LLVMFuzzerTestOneInput:
    7|  3.33k|{
    8|  3.33k|        std::string s(reinterpret_cast<const char*>(data), size);
    9|  3.33k|        std::istringstream is(s);
   10|       |
   11|  3.33k|        std::error_code ec;
   12|  3.33k|        json_stream_cursor reader(is, ec);
   13|  5.31k|        while (!reader.done() && !ec)
  ------------------
  |  Branch (13:16): [True: 3.25k, False: 2.05k]
  |  Branch (13:34): [True: 1.98k, False: 1.27k]
  ------------------
   14|  1.98k|        {
   15|  1.98k|                const auto& event = reader.current();
   16|  1.98k|                std::string s2 = event.get<std::string>(ec);
   17|  1.98k|                if (!ec)
  ------------------
  |  Branch (17:21): [True: 1.97k, False: 3]
  ------------------
   18|  1.97k|                {
   19|  1.97k|                    reader.next(ec);
   20|  1.97k|                }
   21|  1.98k|        }
   22|       |
   23|  3.33k|        return 0;
   24|  3.33k|}

_ZN8jsoncons15make_error_codeENS_9conv_errcE:
  212|      3|{
  213|      3|    return std::error_code(static_cast<int>(result),conv_error_category());
  214|      3|}
_ZN8jsoncons19conv_error_categoryEv:
  205|      3|{
  206|      3|  static detail::conv_error_category_impl instance;
  207|      3|  return instance;
  208|      3|}

_ZN8jsoncons6detail6grisu3EdPcPiS2_:
  294|  1.16k|{
  295|  1.16k|    diy_fp_t w_m, w_p;
  296|  1.16k|    int q = 64, alpha = -59, gamma = -56;
  297|  1.16k|    normalized_boundaries(v, &w_m, &w_p);
  298|  1.16k|    diy_fp_t w = normalize_diy_fp(double2diy_fp(v));
  299|  1.16k|    int mk = k_comp(w_p.e + q, alpha, gamma);
  300|  1.16k|    diy_fp_t c_mk = cached_power(mk);
  301|  1.16k|    diy_fp_t W  = multiply(w,   c_mk);
  302|  1.16k|    diy_fp_t Wp = multiply(w_p, c_mk);
  303|  1.16k|    diy_fp_t Wm = multiply(w_m, c_mk);
  304|  1.16k|    *K = -mk;
  305|  1.16k|    bool result = digit_gen(Wm, W, Wp, buffer, length, K);
  306|  1.16k|    buffer[*length] = 0;
  307|  1.16k|    return result;
  308|  1.16k|}
_ZN8jsoncons6detail21normalized_boundariesEdPNS0_8diy_fp_tES2_:
  189|  1.16k|{
  190|  1.16k|    diy_fp_t v = double2diy_fp(d);
  191|  1.16k|    diy_fp_t pl, mi;
  192|  1.16k|    bool significand_is_zero = v.f == dp_hidden_bit;
  193|  1.16k|    pl.f  = (v.f << 1) + 1; pl.e  = v.e - 1;
  194|  1.16k|    pl = normalize_boundary(pl);
  195|  1.16k|    if (significand_is_zero)
  ------------------
  |  Branch (195:9): [True: 85, False: 1.08k]
  ------------------
  196|     85|    {
  197|     85|        mi.f = (v.f << 2) - 1;
  198|     85|        mi.e = v.e - 2;
  199|     85|    } else
  200|  1.08k|    {
  201|  1.08k|        mi.f = (v.f << 1) - 1;
  202|  1.08k|        mi.e = v.e - 1;
  203|  1.08k|    }
  204|  1.16k|	int x = mi.e - pl.e;
  205|  1.16k|    mi.f <<= x;
  206|  1.16k|    mi.e = pl.e;
  207|  1.16k|    *out_m_plus = pl;
  208|  1.16k|    *out_m_minus = mi;
  209|  1.16k|}
_ZN8jsoncons6detail18normalize_boundaryENS0_8diy_fp_tE:
  172|  1.16k|{
  173|  1.16k|    diy_fp_t res = in;
  174|       |    /* Normalize now */
  175|       |    /* the original number could have been a denormal. */
  176|  12.3k|    while (!(res.f & (dp_hidden_bit << 1)))
  ------------------
  |  Branch (176:12): [True: 11.1k, False: 1.16k]
  ------------------
  177|  11.1k|    {
  178|  11.1k|        res.f <<= 1;
  179|  11.1k|        res.e--;
  180|  11.1k|    }
  181|       |    /* do the final shifts in one go. Don't forget the hidden bit (the '-1') */
  182|  1.16k|    res.f <<= (diy_significand_size - dp_significand_size - 2);
  183|  1.16k|    res.e = res.e - (diy_significand_size - dp_significand_size - 2);
  184|  1.16k|    return res;
  185|  1.16k|}
_ZN8jsoncons6detail16normalize_diy_fpENS0_8diy_fp_tE:
  135|  1.16k|{
  136|  1.16k|    diy_fp_t res = in;
  137|       |    /* Normalize now */
  138|       |    /* the original number could have been a denormal. */
  139|  12.3k|    while (!(res.f & dp_hidden_bit))
  ------------------
  |  Branch (139:12): [True: 11.1k, False: 1.16k]
  ------------------
  140|  11.1k|    {
  141|  11.1k|        res.f <<= 1;
  142|  11.1k|        res.e--;
  143|  11.1k|    }
  144|       |    /* do the final shifts in one go. Don't forget the hidden bit (the '-1') */
  145|  1.16k|    res.f <<= (diy_significand_size - dp_significand_size - 1);
  146|  1.16k|    res.e = res.e - (diy_significand_size - dp_significand_size - 1);
  147|  1.16k|    return res;
  148|  1.16k|}
_ZN8jsoncons6detail13double2diy_fpEd:
  152|  2.33k|{
  153|  2.33k|    uint64_t d64 = double_to_uint64(d);
  154|  2.33k|    int biased_e = (d64 & dp_exponent_mask) >> dp_significand_size;
  155|  2.33k|    uint64_t significand = (d64 & dp_significand_mask);
  156|  2.33k|    diy_fp_t res;
  157|  2.33k|    if (biased_e != 0)
  ------------------
  |  Branch (157:9): [True: 1.58k, False: 752]
  ------------------
  158|  1.58k|    {
  159|  1.58k|        res.f = significand + dp_hidden_bit;
  160|  1.58k|        res.e = biased_e - dp_exponent_bias;
  161|  1.58k|    } 
  162|    752|    else
  163|    752|    {
  164|    752|        res.f = significand;
  165|    752|        res.e = dp_min_exponent + 1;
  166|    752|    }
  167|  2.33k|    return res;
  168|  2.33k|}
_ZN8jsoncons6detail16double_to_uint64Ed:
  121|  2.33k|uint64_t double_to_uint64(double d) {uint64_t d64; std::memcpy(&d64,&d,sizeof(double)); return d64; }
_ZN8jsoncons6detail6k_compEiii:
   83|  1.16k|{
   84|  1.16k|    constexpr double d_1_log2_10 = 0.30102999566398114; //  1 / lg(10)
   85|  1.16k|	int x = alpha - e + 63;
   86|  1.16k|    return static_cast<int>(std::ceil(x * d_1_log2_10));
   87|  1.16k|}
_ZN8jsoncons6detail12cached_powerEi:
   98|  1.16k|{
   99|  1.16k|    diy_fp_t res;
  100|  1.16k|    int index = 343 + k;
  101|  1.16k|    res.f = powers_ten[index];
  102|  1.16k|    res.e = powers_ten_e[index];
  103|  1.16k|    return res;
  104|  1.16k|}
_ZN8jsoncons6detail8multiplyENS0_8diy_fp_tES1_:
   66|  3.49k|{
   67|  3.49k|    uint64_t a, b, c, d, ac, bc, ad, bd, tmp;
   68|  3.49k|    diy_fp_t r; uint64_t M32 = 0xFFFFFFFF;
   69|  3.49k|    a = x.f >> 32; b = x.f & M32;
   70|  3.49k|    c = y.f >> 32; d = y.f & M32;
   71|  3.49k|    ac = a * c; bc = b * c; ad = a * d; bd = b * d;
   72|  3.49k|    tmp = (bd >> 32) + (ad & M32) + (bc & M32);
   73|  3.49k|    tmp += 1U << 31; /// mult_round
   74|  3.49k|    r.f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
   75|  3.49k|    r.e = x.e + y.e + 64;
   76|  3.49k|    return r;
   77|  3.49k|}
_ZN8jsoncons6detail9digit_genENS0_8diy_fp_tES1_S1_PcPiS3_:
  251|  1.16k|{
  252|  1.16k|    const uint32_t TEN2 = 100;
  253|       |
  254|  1.16k|    uint32_t div, p1; uint64_t p2, tmp, unit = 1;
  255|  1.16k|    int d, kappa;
  256|  1.16k|    diy_fp_t one, wp_W, Delta;
  257|  1.16k|    Delta = minus(Wp, Wm); Delta.f += 2 * unit;
  258|  1.16k|    wp_W = minus(Wp, W); wp_W.f += unit;
  259|  1.16k|    one.f = ((uint64_t)1) << -Wp.e; one.e = Wp.e;
  260|  1.16k|    p1 = static_cast<uint32_t>((Wp.f + 1) >> -one.e);
  261|  1.16k|    p2 = (Wp.f + 1) & (one.f - 1);
  262|  1.16k|    *len = 0; kappa = 3; div = TEN2;
  263|  4.07k|    while (kappa > 0)
  ------------------
  |  Branch (263:12): [True: 3.24k, False: 836]
  ------------------
  264|  3.24k|    {
  265|  3.24k|        d = p1 / div;
  266|  3.24k|        if (d || *len) buffer[(*len)++] = (char)('0' + d);
  ------------------
  |  Branch (266:13): [True: 1.81k, False: 1.42k]
  |  Branch (266:18): [True: 75, False: 1.34k]
  ------------------
  267|  3.24k|        p1 %= div; kappa--;
  268|  3.24k|        tmp = (((uint64_t)p1) << -one.e) + p2;
  269|  3.24k|        if (tmp < Delta.f)
  ------------------
  |  Branch (269:13): [True: 330, False: 2.91k]
  ------------------
  270|    330|        {
  271|    330|            *K += kappa;
  272|    330|            return round_weed(buffer, *len, wp_W.f, Delta.f, tmp,
  273|    330|                              ((uint64_t)div) << -one.e, unit);
  274|    330|        }
  275|  2.91k|        div /= 10;
  276|  2.91k|    }
  277|  6.31k|    while (1)
  ------------------
  |  Branch (277:12): [Folded - Ignored]
  ------------------
  278|  6.31k|    {
  279|  6.31k|        p2 *= 10; Delta.f *= 10; unit *= 10;
  280|  6.31k|        d = static_cast<int>(p2 >> -one.e);
  281|  6.31k|        if (d || *len) buffer[(*len)++] = (char)('0' + d);
  ------------------
  |  Branch (281:13): [True: 5.38k, False: 924]
  |  Branch (281:18): [True: 924, False: 0]
  ------------------
  282|  6.31k|        p2 &= one.f - 1; kappa--;
  283|  6.31k|        if (p2 < Delta.f)
  ------------------
  |  Branch (283:13): [True: 836, False: 5.47k]
  ------------------
  284|    836|        {
  285|    836|            *K += kappa;
  286|    836|            return round_weed(buffer, *len, wp_W.f * unit, Delta.f, p2,
  287|    836|                              one.f, unit);
  288|    836|        }
  289|  6.31k|    }
  290|    836|}
_ZN8jsoncons6detail5minusENS0_8diy_fp_tES1_:
   57|  2.33k|{
   58|  2.33k|    assert(x.e == y.e);
   59|      0|    assert(x.f >= y.f);
   60|      0|    diy_fp_t r = { x.f = x.f - y.f, x.e };
   61|  2.33k|    return r;
   62|  2.33k|}
_ZN8jsoncons6detail10round_weedEPcimmmmm:
  231|  1.16k|{
  232|  1.16k|    uint64_t wp_Wup = wp_W - ulp;
  233|  1.16k|    uint64_t wp_Wdown = wp_W + ulp;
  234|  1.54k|    while (rest < wp_Wup &&  /// round1
  ------------------
  |  Branch (234:12): [True: 1.04k, False: 500]
  ------------------
  235|  1.54k|           Delta - rest >= ten_kappa &&
  ------------------
  |  Branch (235:12): [True: 562, False: 483]
  ------------------
  236|  1.54k|           (rest + ten_kappa < wp_Wup || /// closer
  ------------------
  |  Branch (236:13): [True: 269, False: 293]
  ------------------
  237|    562|            wp_Wup - rest >= rest + ten_kappa - wp_Wup))
  ------------------
  |  Branch (237:13): [True: 110, False: 183]
  ------------------
  238|    379|    {
  239|    379|        buffer[len - 1]--; rest += ten_kappa;
  240|    379|    }
  241|  1.16k|    if (rest < wp_Wdown && /// round2
  ------------------
  |  Branch (241:9): [True: 754, False: 412]
  ------------------
  242|  1.16k|        Delta - rest >= ten_kappa &&
  ------------------
  |  Branch (242:9): [True: 191, False: 563]
  ------------------
  243|  1.16k|        (rest + ten_kappa < wp_Wdown ||
  ------------------
  |  Branch (243:10): [True: 0, False: 191]
  ------------------
  244|    191|         wp_Wdown - rest > rest + ten_kappa - wp_Wdown)) return 0;
  ------------------
  |  Branch (244:10): [True: 47, False: 144]
  ------------------
  245|  1.11k|    return 2 * ulp <= rest && rest <= Delta - 4 * ulp; /// weed
  ------------------
  |  Branch (245:12): [True: 1.05k, False: 67]
  |  Branch (245:31): [True: 971, False: 81]
  ------------------
  246|  1.16k|}

_ZN8jsoncons6detail20to_integer_uncheckedIlcEENSt3__19enable_ifIXaasr16extension_traits14integer_limitsIT_EE14is_specializedsr16extension_traits14integer_limitsIS4_EE9is_signedENS0_17to_integer_resultIS4_T0_EEE4typeEPKS6_mRS4_:
  728|    327|{
  729|    327|    static_assert(extension_traits::integer_limits<T>::is_specialized, "Integer type not specialized");
  730|    327|    JSONCONS_ASSERT(length > 0);
  ------------------
  |  |  378|    327|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 327]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  731|       |
  732|    327|    n = 0;
  733|       |
  734|    327|    const CharT* end = s + length; 
  735|    327|    if (*s == '-')
  ------------------
  |  Branch (735:9): [True: 327, False: 0]
  ------------------
  736|    327|    {
  737|    327|        static constexpr T min_value = (extension_traits::integer_limits<T>::lowest)();
  738|    327|        static constexpr T min_value_div_10 = min_value / 10;
  739|    327|        ++s;
  740|  4.90k|        for (; s < end; ++s)
  ------------------
  |  Branch (740:16): [True: 4.68k, False: 223]
  ------------------
  741|  4.68k|        {
  742|  4.68k|            T x = (T)*s - (T)('0');
  743|  4.68k|            if (n < min_value_div_10)
  ------------------
  |  Branch (743:17): [True: 103, False: 4.58k]
  ------------------
  744|    103|            {
  745|    103|                return to_integer_result<T,CharT>(s, to_integer_errc::overflow);
  746|    103|            }
  747|  4.58k|            n = n * 10;
  748|  4.58k|            if (n < min_value + x)
  ------------------
  |  Branch (748:17): [True: 1, False: 4.58k]
  ------------------
  749|      1|            {
  750|      1|                return to_integer_result<T,CharT>(s, to_integer_errc::overflow);
  751|      1|            }
  752|       |
  753|  4.58k|            n -= x;
  754|  4.58k|        }
  755|    327|    }
  756|      0|    else
  757|      0|    {
  758|      0|        static constexpr T max_value = (extension_traits::integer_limits<T>::max)();
  759|      0|        static constexpr T max_value_div_10 = max_value / 10;
  760|      0|        for (; s < end; ++s)
  ------------------
  |  Branch (760:16): [True: 0, False: 0]
  ------------------
  761|      0|        {
  762|      0|            T x = static_cast<T>(*s) - static_cast<T>('0');
  763|      0|            if (n > max_value_div_10)
  ------------------
  |  Branch (763:17): [True: 0, False: 0]
  ------------------
  764|      0|            {
  765|      0|                return to_integer_result<T,CharT>(s, to_integer_errc::overflow);
  766|      0|            }
  767|      0|            n = n * 10;
  768|      0|            if (n > max_value - x)
  ------------------
  |  Branch (768:17): [True: 0, False: 0]
  ------------------
  769|      0|            {
  770|      0|                return to_integer_result<T,CharT>(s, to_integer_errc::overflow);
  771|      0|            }
  772|       |
  773|      0|            n += x;
  774|      0|        }
  775|      0|    }
  776|       |
  777|    223|    return to_integer_result<T,CharT>(s, to_integer_errc());
  778|    327|}
_ZN8jsoncons6detail17to_integer_resultIlcEC2EPKcNS0_15to_integer_errcE:
   87|    327|    {
   88|    327|    }
_ZNK8jsoncons6detail17to_integer_resultIlcEcvbEv:
   95|    327|    {
   96|    327|        return ec == to_integer_errc();
   97|    327|    }
_ZN8jsoncons6detail20to_integer_uncheckedImcEENSt3__19enable_ifIXaasr16extension_traits14integer_limitsIT_EE14is_specializedntsr16extension_traits14integer_limitsIS4_EE9is_signedENS0_17to_integer_resultIS4_T0_EEE4typeEPKS6_mRS4_:
  667|    366|{
  668|    366|    static_assert(extension_traits::integer_limits<T>::is_specialized, "Integer type not specialized");
  669|    366|    JSONCONS_ASSERT(length > 0);
  ------------------
  |  |  378|    366|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 366]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  670|       |
  671|    366|    n = 0;
  672|    366|    const CharT* end = s + length; 
  673|    366|    if (*s == '-')
  ------------------
  |  Branch (673:9): [True: 0, False: 366]
  ------------------
  674|      0|    {
  675|      0|        static constexpr T min_value = (extension_traits::integer_limits<T>::lowest)();
  676|      0|        static constexpr T min_value_div_10 = min_value / 10;
  677|      0|        ++s;
  678|      0|        for (; s < end; ++s)
  ------------------
  |  Branch (678:16): [True: 0, False: 0]
  ------------------
  679|      0|        {
  680|      0|            T x = (T)*s - (T)('0');
  681|      0|            if (n < min_value_div_10)
  ------------------
  |  Branch (681:17): [True: 0, False: 0]
  ------------------
  682|      0|            {
  683|      0|                return to_integer_result<T,CharT>(s, to_integer_errc::overflow);
  684|      0|            }
  685|      0|            n = n * 10;
  686|      0|            if (n < min_value + x)
  ------------------
  |  Branch (686:17): [True: 0, False: 0]
  ------------------
  687|      0|            {
  688|      0|                return to_integer_result<T,CharT>(s, to_integer_errc::overflow);
  689|      0|            }
  690|       |
  691|      0|            n -= x;
  692|      0|        }
  693|      0|    }
  694|    366|    else
  695|    366|    {
  696|    366|        static constexpr T max_value = (extension_traits::integer_limits<T>::max)();
  697|    366|        static constexpr T max_value_div_10 = max_value / 10;
  698|  4.72k|        for (; s < end; ++s)
  ------------------
  |  Branch (698:16): [True: 4.41k, False: 304]
  ------------------
  699|  4.41k|        {
  700|  4.41k|            T x = static_cast<T>(*s) - static_cast<T>('0');
  701|  4.41k|            if (n > max_value_div_10)
  ------------------
  |  Branch (701:17): [True: 61, False: 4.35k]
  ------------------
  702|     61|            {
  703|     61|                return to_integer_result<T,CharT>(s, to_integer_errc::overflow);
  704|     61|            }
  705|  4.35k|            n = n * 10;
  706|  4.35k|            if (n > max_value - x)
  ------------------
  |  Branch (706:17): [True: 1, False: 4.35k]
  ------------------
  707|      1|            {
  708|      1|                return to_integer_result<T,CharT>(s, to_integer_errc::overflow);
  709|      1|            }
  710|       |
  711|  4.35k|            n += x;
  712|  4.35k|        }
  713|    366|    }
  714|       |
  715|    304|    return to_integer_result<T,CharT>(s, to_integer_errc());
  716|    366|}
_ZN8jsoncons6detail17to_integer_resultImcEC2EPKcNS0_15to_integer_errcE:
   87|    366|    {
   88|    366|    }
_ZNK8jsoncons6detail17to_integer_resultImcEcvbEv:
   95|    366|    {
   96|    366|        return ec == to_integer_errc();
   97|    366|    }
_ZNK8jsoncons6detail8chars_toclIcEENSt3__19enable_ifIXsr3std7is_sameIT_cEE5valueEdE4typeEPKS5_m:
 1106|  1.38k|    {
 1107|  1.38k|        CharT *end = nullptr;
 1108|  1.38k|        double val = strtod(s, &end);
 1109|  1.38k|        if (s == end)
  ------------------
  |  Branch (1109:13): [True: 0, False: 1.38k]
  ------------------
 1110|      0|        {
 1111|      0|            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("Convert string to double failed"));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1112|      0|        }
 1113|  1.38k|        return val;
 1114|  1.38k|    }
_ZNK8jsoncons6detail8chars_to17get_decimal_pointEv:
 1099|    494|    {
 1100|    494|        return decimal_point_;
 1101|    494|    }
_ZN8jsoncons6detail8chars_toC2Ev:
 1082|  4.71k|    {
 1083|  4.71k|        struct lconv * lc = localeconv();
 1084|  4.71k|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (1084:13): [True: 4.71k, False: 0]
  |  Branch (1084:30): [True: 4.71k, False: 0]
  ------------------
 1085|  4.71k|        {
 1086|  4.71k|            decimal_point_ = lc->decimal_point[0];    
 1087|  4.71k|        }
 1088|      0|        else
 1089|      0|        {
 1090|      0|            decimal_point_ = '.'; 
 1091|      0|        }
 1092|  4.71k|        buffer_.reserve(100);
 1093|  4.71k|    }

_ZN8jsoncons6detail4spanIKcLm18446744073709551615EEC2Ev:
   53|  4.46k|        {
   54|  4.46k|        }
_ZN8jsoncons6detail4spanIKcLm18446744073709551615EEC2EPS2_m:
   57|  12.7k|        {
   58|  12.7k|        }
_ZNK8jsoncons6detail4spanIKcLm18446744073709551615EE4sizeEv:
  111|  23.5k|        {
  112|  23.5k|            return size_;
  113|  23.5k|        }
_ZNK8jsoncons6detail4spanIKcLm18446744073709551615EE4dataEv:
  106|  12.7k|        {
  107|  12.7k|            return data_;
  108|  12.7k|        }
_ZN8jsoncons6detail4spanIKmLm18446744073709551615EEC2Ev:
   53|  3.33k|        {
   54|  3.33k|        }

_ZNK8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEE6lengthEv:
  119|    259|        {
  120|    259|            return length_;
  121|    259|        }
_ZNK8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEE4dataEv:
  157|    259|        {
  158|    259|            return data_;
  159|    259|        }
_ZN8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEEC2EPKcm:
   48|    439|        {
   49|    439|        }
_ZN8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEEC2IS4_NS2_9allocatorIcEEEERKNS2_12basic_stringIcT_T0_EE:
   60|    166|        {
   61|    166|        }
_ZNK8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEE5beginEv:
   79|    259|        {
   80|    259|            return data_;
   81|    259|        }
_ZNK8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEE3endEv:
   83|    259|        {
   84|    259|            return data_ + length_;
   85|    259|        }

_ZN8jsoncons6detail12from_integerImNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_9enable_ifIXsr16extension_traits10is_integerIT_EE5valueEmE4typeESA_RT0_:
   37|    304|    {
   38|    304|        using char_type = typename Result::value_type;
   39|       |
   40|    304|        char_type buf[255];
   41|    304|        char_type *p = buf;
   42|    304|        const char_type* last = buf+255;
   43|       |
   44|    304|        bool is_negative = value < 0;
   45|       |
   46|    304|        if (value < 0)
  ------------------
  |  Branch (46:13): [True: 0, False: 304]
  ------------------
   47|      0|        {
   48|      0|            do
   49|      0|            {
   50|      0|                *p++ = static_cast<char_type>(48 - (value % 10));
   51|      0|            }
   52|      0|            while ((value /= 10) && (p < last));
  ------------------
  |  Branch (52:20): [True: 0, False: 0]
  |  Branch (52:37): [True: 0, False: 0]
  ------------------
   53|      0|        }
   54|    304|        else
   55|    304|        {
   56|       |
   57|    304|            do
   58|  3.17k|            {
   59|  3.17k|                *p++ = static_cast<char_type>(48 + value % 10);
   60|  3.17k|            }
   61|  3.17k|            while ((value /= 10) && (p < last));
  ------------------
  |  Branch (61:20): [True: 2.86k, False: 304]
  |  Branch (61:37): [True: 2.86k, False: 0]
  ------------------
   62|    304|        }
   63|    304|        JSONCONS_ASSERT(p != last);
  ------------------
  |  |  378|    304|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 304]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   64|       |
   65|    304|        std::size_t count = (p - buf);
   66|    304|        if (is_negative)
  ------------------
  |  Branch (66:13): [True: 0, False: 304]
  ------------------
   67|      0|        {
   68|      0|            result.push_back('-');
   69|      0|            ++count;
   70|      0|        }
   71|  3.47k|        while (--p >= buf)
  ------------------
  |  Branch (71:16): [True: 3.17k, False: 304]
  ------------------
   72|  3.17k|        {
   73|  3.17k|            result.push_back(*p);
   74|  3.17k|        }
   75|       |
   76|    304|        return count;
   77|    304|    }
_ZN8jsoncons6detail12from_integerIlNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_9enable_ifIXsr16extension_traits10is_integerIT_EE5valueEmE4typeESA_RT0_:
   37|    223|    {
   38|    223|        using char_type = typename Result::value_type;
   39|       |
   40|    223|        char_type buf[255];
   41|    223|        char_type *p = buf;
   42|    223|        const char_type* last = buf+255;
   43|       |
   44|    223|        bool is_negative = value < 0;
   45|       |
   46|    223|        if (value < 0)
  ------------------
  |  Branch (46:13): [True: 221, False: 2]
  ------------------
   47|    221|        {
   48|    221|            do
   49|  2.67k|            {
   50|  2.67k|                *p++ = static_cast<char_type>(48 - (value % 10));
   51|  2.67k|            }
   52|  2.67k|            while ((value /= 10) && (p < last));
  ------------------
  |  Branch (52:20): [True: 2.45k, False: 221]
  |  Branch (52:37): [True: 2.45k, False: 0]
  ------------------
   53|    221|        }
   54|      2|        else
   55|      2|        {
   56|       |
   57|      2|            do
   58|      2|            {
   59|      2|                *p++ = static_cast<char_type>(48 + value % 10);
   60|      2|            }
   61|      2|            while ((value /= 10) && (p < last));
  ------------------
  |  Branch (61:20): [True: 0, False: 2]
  |  Branch (61:37): [True: 0, False: 0]
  ------------------
   62|      2|        }
   63|    223|        JSONCONS_ASSERT(p != last);
  ------------------
  |  |  378|    223|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 223]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   64|       |
   65|    223|        std::size_t count = (p - buf);
   66|    223|        if (is_negative)
  ------------------
  |  Branch (66:13): [True: 221, False: 2]
  ------------------
   67|    221|        {
   68|    221|            result.push_back('-');
   69|    221|            ++count;
   70|    221|        }
   71|  2.89k|        while (--p >= buf)
  ------------------
  |  Branch (71:16): [True: 2.67k, False: 223]
  ------------------
   72|  2.67k|        {
   73|  2.67k|            result.push_back(*p);
   74|  2.67k|        }
   75|       |
   76|    223|        return count;
   77|    223|    }
_ZN8jsoncons6detail12write_doubleC2ENS_18float_chars_formatEi:
  472|  1.18k|        {
  473|  1.18k|    #if !defined(JSONCONS_NO_LOCALECONV)
  474|  1.18k|            struct lconv *lc = localeconv();
  475|  1.18k|            if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (475:17): [True: 1.18k, False: 0]
  |  Branch (475:34): [True: 1.18k, False: 0]
  ------------------
  476|  1.18k|            {
  477|  1.18k|                decimal_point_ = lc->decimal_point[0];
  478|  1.18k|            }
  479|  1.18k|    #endif
  480|  1.18k|        }
_ZN8jsoncons6detail12write_doubleclINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEmdRT_:
  487|  1.18k|        {
  488|  1.18k|            std::size_t count = 0;
  489|       |
  490|  1.18k|            char number_buffer[200];
  491|  1.18k|            int length = 0;
  492|       |
  493|  1.18k|            switch (float_format_)
  494|  1.18k|            {
  495|      0|            case float_chars_format::fixed:
  ------------------
  |  Branch (495:13): [True: 0, False: 1.18k]
  ------------------
  496|      0|                {
  497|      0|                    if (precision_ > 0)
  ------------------
  |  Branch (497:25): [True: 0, False: 0]
  ------------------
  498|      0|                    {
  499|      0|                        length = snprintf(number_buffer, sizeof(number_buffer), "%1.*f", precision_, val);
  500|      0|                        if (length < 0)
  ------------------
  |  Branch (500:29): [True: 0, False: 0]
  ------------------
  501|      0|                        {
  502|      0|                            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  503|      0|                        }
  504|      0|                        dump_buffer(number_buffer, length, decimal_point_, result);
  505|      0|                    }
  506|      0|                    else
  507|      0|                    {
  508|      0|                        if (!dtoa_fixed(val, decimal_point_, result))
  ------------------
  |  Branch (508:29): [True: 0, False: 0]
  ------------------
  509|      0|                        {
  510|      0|                            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  511|      0|                        }
  512|      0|                    }
  513|      0|                }
  514|      0|                break;
  515|      0|            case float_chars_format::scientific:
  ------------------
  |  Branch (515:13): [True: 0, False: 1.18k]
  ------------------
  516|      0|                {
  517|      0|                    if (precision_ > 0)
  ------------------
  |  Branch (517:25): [True: 0, False: 0]
  ------------------
  518|      0|                    {
  519|      0|                        length = snprintf(number_buffer, sizeof(number_buffer), "%1.*e", precision_, val);
  520|      0|                        if (length < 0)
  ------------------
  |  Branch (520:29): [True: 0, False: 0]
  ------------------
  521|      0|                        {
  522|      0|                            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  523|      0|                        }
  524|      0|                        dump_buffer(number_buffer, length, decimal_point_, result);
  525|      0|                    }
  526|      0|                    else
  527|      0|                    {
  528|      0|                        if (!dtoa_scientific(val, decimal_point_, result))
  ------------------
  |  Branch (528:29): [True: 0, False: 0]
  ------------------
  529|      0|                        {
  530|      0|                            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  531|      0|                        }
  532|      0|                    }
  533|      0|                }
  534|      0|                break;
  535|  1.18k|            case float_chars_format::general:
  ------------------
  |  Branch (535:13): [True: 1.18k, False: 0]
  ------------------
  536|  1.18k|                {
  537|  1.18k|                    if (precision_ > 0)
  ------------------
  |  Branch (537:25): [True: 0, False: 1.18k]
  ------------------
  538|      0|                    {
  539|      0|                        length = snprintf(number_buffer, sizeof(number_buffer), "%1.*g", precision_, val);
  540|      0|                        if (length < 0)
  ------------------
  |  Branch (540:29): [True: 0, False: 0]
  ------------------
  541|      0|                        {
  542|      0|                            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  543|      0|                        }
  544|      0|                        dump_buffer(number_buffer, length, decimal_point_, result);
  545|      0|                    }
  546|  1.18k|                    else
  547|  1.18k|                    {
  548|  1.18k|                        if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (548:29): [True: 0, False: 1.18k]
  ------------------
  549|      0|                        {
  550|      0|                            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  551|      0|                        }
  552|  1.18k|                    }             
  553|  1.18k|                    break;
  554|  1.18k|                }
  555|  1.18k|                default:
  ------------------
  |  Branch (555:17): [True: 0, False: 1.18k]
  ------------------
  556|      0|                    JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  557|      0|                    break;
  558|  1.18k|            }
  559|  1.18k|            return count;
  560|  1.18k|        }
_ZN8jsoncons6detail11dump_bufferINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvPKcmcRT_:
  238|    195|    {
  239|    195|        const char *sbeg = buffer;
  240|    195|        const char *send = sbeg + length;
  241|       |
  242|    195|        if (sbeg != send)
  ------------------
  |  Branch (242:13): [True: 195, False: 0]
  ------------------
  243|    195|        {
  244|    195|            bool needs_dot = true;
  245|  2.60k|            for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (245:40): [True: 2.41k, False: 195]
  ------------------
  246|  2.41k|            {
  247|  2.41k|                switch (*q)
  248|  2.41k|                {
  249|      7|                case '-':
  ------------------
  |  Branch (249:17): [True: 7, False: 2.40k]
  ------------------
  250|    298|                case '0':
  ------------------
  |  Branch (250:17): [True: 291, False: 2.12k]
  ------------------
  251|    487|                case '1':
  ------------------
  |  Branch (251:17): [True: 189, False: 2.22k]
  ------------------
  252|    735|                case '2':
  ------------------
  |  Branch (252:17): [True: 248, False: 2.16k]
  ------------------
  253|    898|                case '3':
  ------------------
  |  Branch (253:17): [True: 163, False: 2.25k]
  ------------------
  254|  1.11k|                case '4':
  ------------------
  |  Branch (254:17): [True: 213, False: 2.20k]
  ------------------
  255|  1.29k|                case '5':
  ------------------
  |  Branch (255:17): [True: 179, False: 2.23k]
  ------------------
  256|  1.46k|                case '6':
  ------------------
  |  Branch (256:17): [True: 173, False: 2.24k]
  ------------------
  257|  1.60k|                case '7':
  ------------------
  |  Branch (257:17): [True: 144, False: 2.26k]
  ------------------
  258|  1.81k|                case '8':
  ------------------
  |  Branch (258:17): [True: 210, False: 2.20k]
  ------------------
  259|  2.13k|                case '9':
  ------------------
  |  Branch (259:17): [True: 313, False: 2.10k]
  ------------------
  260|  2.17k|                case '+':
  ------------------
  |  Branch (260:17): [True: 48, False: 2.36k]
  ------------------
  261|  2.17k|                    result.push_back(*q);
  262|  2.17k|                    break;
  263|     52|                case 'e':
  ------------------
  |  Branch (263:17): [True: 52, False: 2.36k]
  ------------------
  264|     52|                case 'E':
  ------------------
  |  Branch (264:17): [True: 0, False: 2.41k]
  ------------------
  265|     52|                    result.push_back('e');
  266|     52|                    needs_dot = false;
  267|     52|                    break;
  268|    183|                default:
  ------------------
  |  Branch (268:17): [True: 183, False: 2.23k]
  ------------------
  269|    183|                    if (*q == decimal_point)
  ------------------
  |  Branch (269:25): [True: 183, False: 0]
  ------------------
  270|    183|                    {
  271|    183|                        needs_dot = false;
  272|    183|                        result.push_back('.');
  273|    183|                    }
  274|    183|                    break;
  275|  2.41k|                }
  276|  2.41k|            }
  277|    195|            if (needs_dot)
  ------------------
  |  Branch (277:17): [True: 4, False: 191]
  ------------------
  278|      4|            {
  279|      4|                result.push_back('.');
  280|      4|                result.push_back('0');
  281|      4|            }
  282|    195|        }
  283|    195|    }
_ZN8jsoncons6detail15prettify_stringINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvPKcmiiiRT_:
  166|    971|    {
  167|    971|        int nb_digits = (int)length;
  168|    971|        int offset;
  169|       |        /* v = buffer * 10^k
  170|       |           kk is such that 10^(kk-1) <= v < 10^kk
  171|       |           this way kk gives the position of the decimal point.
  172|       |        */
  173|    971|        int kk = nb_digits + k;
  174|       |
  175|    971|        if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (175:13): [True: 254, False: 717]
  |  Branch (175:32): [True: 72, False: 182]
  ------------------
  176|     72|        {
  177|       |            /* the first digits are already in. Add some 0s and call it a day. */
  178|       |            /* the max_exp is a personal choice. Only 16 digits could possibly be relevant.
  179|       |             * Basically we want to print 12340000000 rather than 1234.0e7 or 1.234e10 */
  180|    234|            for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (180:29): [True: 162, False: 72]
  ------------------
  181|    162|            {
  182|    162|                result.push_back(buffer[i]);
  183|    162|            }
  184|    365|            for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (184:37): [True: 293, False: 72]
  ------------------
  185|    293|            {
  186|    293|                result.push_back('0');
  187|    293|            }
  188|     72|            result.push_back('.');
  189|     72|            result.push_back('0');
  190|     72|        } 
  191|    899|        else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (191:18): [True: 454, False: 445]
  |  Branch (191:28): [True: 272, False: 182]
  ------------------
  192|    272|        {
  193|       |            /* comma number. Just insert a '.' at the correct location. */
  194|  1.32k|            for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (194:29): [True: 1.05k, False: 272]
  ------------------
  195|  1.05k|            {
  196|  1.05k|                result.push_back(buffer[i]);
  197|  1.05k|            }
  198|    272|            result.push_back('.');
  199|  1.84k|            for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (199:30): [True: 1.57k, False: 272]
  ------------------
  200|  1.57k|            {
  201|  1.57k|                result.push_back(buffer[i]);
  202|  1.57k|            }
  203|    272|        } 
  204|    627|        else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (204:18): [True: 218, False: 409]
  |  Branch (204:34): [True: 36, False: 182]
  ------------------
  205|     36|        {
  206|     36|            offset = 2 - kk;
  207|       |
  208|     36|            result.push_back('0');
  209|     36|            result.push_back('.');
  210|     66|            for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (210:29): [True: 30, False: 36]
  ------------------
  211|     30|                result.push_back('0');
  212|    234|            for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (212:29): [True: 198, False: 36]
  ------------------
  213|    198|            {
  214|    198|                result.push_back(buffer[i]);
  215|    198|            }
  216|     36|        } 
  217|    591|        else if (nb_digits == 1)
  ------------------
  |  Branch (217:18): [True: 169, False: 422]
  ------------------
  218|    169|        {
  219|    169|            result.push_back(buffer[0]);
  220|    169|            result.push_back('e');
  221|    169|            fill_exponent(kk - 1, result);
  222|    169|        } 
  223|    422|        else
  224|    422|        {
  225|    422|            result.push_back(buffer[0]);
  226|    422|            result.push_back('.');
  227|  3.15k|            for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (227:29): [True: 2.72k, False: 422]
  ------------------
  228|  2.72k|            {
  229|  2.72k|                result.push_back(buffer[i]);
  230|  2.72k|            }
  231|    422|            result.push_back('e');
  232|    422|            fill_exponent(kk - 1, result);
  233|    422|        }
  234|    971|    }
_ZN8jsoncons6detail13fill_exponentINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEviRT_:
  131|    591|    {
  132|    591|        if (K < 0)
  ------------------
  |  Branch (132:13): [True: 409, False: 182]
  ------------------
  133|    409|        {
  134|    409|            result.push_back('-');
  135|    409|            K = -K;
  136|    409|        }
  137|    182|        else
  138|    182|        {
  139|    182|            result.push_back('+'); // compatibility with sprintf
  140|    182|        }
  141|       |
  142|    591|        if (K < 10)
  ------------------
  |  Branch (142:13): [True: 10, False: 581]
  ------------------
  143|     10|        {
  144|     10|            result.push_back('0'); // compatibility with sprintf
  145|     10|            result.push_back((char)('0' + K));
  146|     10|        }
  147|    581|        else if (K < 100)
  ------------------
  |  Branch (147:18): [True: 83, False: 498]
  ------------------
  148|     83|        {
  149|     83|            result.push_back((char)('0' + K / 10)); K %= 10;
  150|     83|            result.push_back((char)('0' + K));
  151|     83|        }
  152|    498|        else if (K < 1000)
  ------------------
  |  Branch (152:18): [True: 498, False: 0]
  ------------------
  153|    498|        {
  154|    498|            result.push_back((char)('0' + K / 100)); K %= 100;
  155|    498|            result.push_back((char)('0' + K / 10)); K %= 10;
  156|    498|            result.push_back((char)('0' + K));
  157|    498|        }
  158|      0|        else
  159|      0|        {
  160|      0|            jsoncons::detail::from_integer(K, result);
  161|      0|        }
  162|    591|    }
_ZN8jsoncons6detail12dtoa_generalINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEbdcRT_:
  458|  1.18k|    {
  459|  1.18k|        return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  460|  1.18k|    }
_ZN8jsoncons6detail12dtoa_generalINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEbdcRT_NS2_17integral_constantIbLb1EEE:
  353|  1.18k|    {
  354|  1.18k|        if (v == 0)
  ------------------
  |  Branch (354:13): [True: 19, False: 1.16k]
  ------------------
  355|     19|        {
  356|     19|            result.push_back('0');
  357|     19|            result.push_back('.');
  358|     19|            result.push_back('0');
  359|     19|            return true;
  360|     19|        }
  361|       |
  362|  1.16k|        int length = 0;
  363|  1.16k|        int k;
  364|       |
  365|  1.16k|        char buffer[100];
  366|       |
  367|  1.16k|        double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (367:20): [True: 24, False: 1.14k]
  ------------------
  368|  1.16k|        if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (368:13): [True: 971, False: 195]
  ------------------
  369|    971|        {
  370|    971|            if (std::signbit(v))
  ------------------
  |  Branch (370:17): [True: 21, False: 950]
  ------------------
  371|     21|            {
  372|     21|                result.push_back('-');
  373|     21|            }
  374|       |            // min exp: -4 is consistent with sprintf
  375|       |            // max exp: std::numeric_limits<double>::max_digits10
  376|    971|            jsoncons::detail::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  377|    971|            return true;
  378|    971|        }
  379|    195|        else
  380|    195|        {
  381|    195|            return dtoa_general(v, decimal_point, result, std::false_type());
  382|    195|        }
  383|  1.16k|    }
_ZN8jsoncons6detail12dtoa_generalINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEbdcRT_NS2_17integral_constantIbLb0EEE:
  320|    195|    {
  321|    195|        if (val == 0)
  ------------------
  |  Branch (321:13): [True: 0, False: 195]
  ------------------
  322|      0|        {
  323|      0|            result.push_back('0');
  324|      0|            result.push_back('.');
  325|      0|            result.push_back('0');
  326|      0|            return true;
  327|      0|        }
  328|       |
  329|    195|        jsoncons::detail::chars_to to_double_;
  330|       |
  331|    195|        char buffer[100];
  332|    195|        int precision = std::numeric_limits<double>::digits10;
  333|    195|        int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  334|    195|        if (length < 0)
  ------------------
  |  Branch (334:13): [True: 0, False: 195]
  ------------------
  335|      0|        {
  336|      0|            return false;
  337|      0|        }
  338|    195|        if (to_double_(buffer, sizeof(buffer)) != val)
  ------------------
  |  Branch (338:13): [True: 58, False: 137]
  ------------------
  339|     58|        {
  340|     58|            const int precision2 = std::numeric_limits<double>::max_digits10;
  341|     58|            length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  342|     58|            if (length < 0)
  ------------------
  |  Branch (342:17): [True: 0, False: 58]
  ------------------
  343|      0|            {
  344|      0|                return false;
  345|      0|            }
  346|     58|        }
  347|    195|        dump_buffer(buffer, length, decimal_point, result);
  348|    195|        return true;
  349|    195|    }

_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcEENSt3__19allocatorIcEEE9read_nextERNS_18basic_json_visitorIcEERNS3_10error_codeE:
  399|  5.30k|    {
  400|  5.30k|        parser_.restart();
  401|  14.8k|        while (!parser_.stopped())
  ------------------
  |  Branch (401:16): [True: 10.8k, False: 3.92k]
  ------------------
  402|  10.8k|        {
  403|  10.8k|            if (parser_.source_exhausted())
  ------------------
  |  Branch (403:17): [True: 10.8k, False: 36]
  ------------------
  404|  10.8k|            {
  405|  10.8k|                auto s = source_.read_buffer(ec);
  406|  10.8k|                if (ec) return;
  ------------------
  |  Branch (406:21): [True: 15, False: 10.8k]
  ------------------
  407|  10.8k|                if (s.size() > 0)
  ------------------
  |  Branch (407:21): [True: 6.36k, False: 4.46k]
  ------------------
  408|  6.36k|                {
  409|  6.36k|                    parser_.update(s.data(),s.size());
  410|  6.36k|                    if (ec) return;
  ------------------
  |  Branch (410:25): [True: 0, False: 6.36k]
  ------------------
  411|  6.36k|                }
  412|  10.8k|            }
  413|  10.8k|            bool eof = parser_.source_exhausted() && source_.eof();
  ------------------
  |  Branch (413:24): [True: 4.46k, False: 6.39k]
  |  Branch (413:54): [True: 4.46k, False: 0]
  ------------------
  414|  10.8k|            parser_.parse_some(visitor, ec);
  415|  10.8k|            if (ec) return;
  ------------------
  |  Branch (415:17): [True: 1.24k, False: 9.61k]
  ------------------
  416|  9.61k|            if (eof)
  ------------------
  |  Branch (416:17): [True: 3.87k, False: 5.74k]
  ------------------
  417|  3.87k|            {
  418|  3.87k|                if (parser_.enter())
  ------------------
  |  Branch (418:21): [True: 107, False: 3.76k]
  ------------------
  419|    107|                {
  420|    107|                    done_ = true;
  421|    107|                    break;
  422|    107|                }
  423|  3.76k|                else if (!parser_.accept())
  ------------------
  |  Branch (423:26): [True: 13, False: 3.75k]
  ------------------
  424|     13|                {
  425|     13|                    ec = json_errc::unexpected_eof;
  426|     13|                    return;
  427|     13|                }
  428|  3.87k|            }
  429|  9.61k|        }
  430|  5.30k|    }
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcEENSt3__19allocatorIcEEEC1IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES5_EEEEOT_RNS3_10error_codeE:
   94|  3.33k|    {
   95|  3.33k|    }
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcEENSt3__19allocatorIcEEEC1IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES5_EEEENS3_15allocator_arg_tERKS5_OT_RKNS_25basic_json_decode_optionsIcEENS3_8functionIFbNS_9json_errcERKNS_11ser_contextEEEERNS3_10error_codeEPNS3_9enable_ifIXntsr3std16is_constructibleINS_6detail17basic_string_viewIcSA_EESG_EE5valueEvE4typeE:
  133|  3.33k|    {
  134|  3.33k|        if (!done())
  ------------------
  |  Branch (134:13): [True: 3.33k, False: 0]
  ------------------
  135|  3.33k|        {
  136|  3.33k|            next(ec);
  137|  3.33k|        }
  138|  3.33k|    }
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcEENSt3__19allocatorIcEEE10accept_allERKNS_16basic_staj_eventIcEERKNS_11ser_contextE:
  345|  1.98k|    {
  346|  1.98k|        return true;
  347|  1.98k|    }
_ZNK8jsoncons17basic_json_cursorIcNS_13stream_sourceIcEENSt3__19allocatorIcEEE4doneEv:
  227|  8.64k|    {
  228|  8.64k|        return parser_.done() || done_;
  ------------------
  |  Branch (228:16): [True: 1.94k, False: 6.69k]
  |  Branch (228:34): [True: 107, False: 6.58k]
  ------------------
  229|  8.64k|    }
_ZNK8jsoncons17basic_json_cursorIcNS_13stream_sourceIcEENSt3__19allocatorIcEEE7currentEv:
  232|  1.98k|    {
  233|  1.98k|        return cursor_visitor_.event();
  234|  1.98k|    }
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcEENSt3__19allocatorIcEEE4nextERNS3_10error_codeE:
  266|  5.30k|    {
  267|  5.30k|        read_next(ec);
  268|  5.30k|    }
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcEENSt3__19allocatorIcEEE9read_nextERNS3_10error_codeE:
  394|  5.30k|    {
  395|  5.30k|        read_next(cursor_visitor_, ec);
  396|  5.30k|    }

_ZN8jsoncons15make_error_codeENS_9json_errcE:
  137|  1.27k|    {
  138|  1.27k|        return std::error_code(static_cast<int>(result),json_error_category());
  139|  1.27k|    }
_ZN8jsoncons19json_error_categoryEv:
  130|  1.27k|    {
  131|  1.27k|      static json_error_category_impl instance;
  132|  1.27k|      return instance;
  133|  1.27k|    }

_ZN8jsoncons25basic_json_options_commonIcED2Ev:
  137|  6.66k|    virtual ~basic_json_options_common() noexcept = default;
_ZNK8jsoncons25basic_json_decode_optionsIcE15lossless_numberEv:
  381|  1.18k|    {
  382|  1.18k|        return lossless_number_;
  383|  1.18k|    }
_ZNK8jsoncons25basic_json_options_commonIcE17max_nesting_depthEv:
  314|      3|    {
  315|      3|        return max_nesting_depth_;
  316|      3|    }
_ZN8jsoncons25basic_json_decode_optionsIcEC1Ev:
  368|  3.33k|    {
  369|  3.33k|    }
_ZN8jsoncons25basic_json_options_commonIcEC2Ev:
  135|  3.33k|    {}
_ZN8jsoncons20default_json_parsingclENS_9json_errcERKNS_11ser_contextE:
   53|  5.38k|    {
   54|  5.38k|        return ec == json_errc::illegal_comment;
   55|  5.38k|    }
_ZN8jsoncons25basic_json_decode_optionsIcEC1ERKS1_:
  371|  3.33k|    basic_json_decode_options(const basic_json_decode_options&) = default;
_ZN8jsoncons25basic_json_options_commonIcEC2ERKS1_:
  139|  3.33k|    basic_json_options_common(const basic_json_options_common&) = default;
_ZNK8jsoncons25basic_json_options_commonIcE17enable_str_to_nanEv:
  167|  3.33k|    {
  168|  3.33k|        return enable_str_to_nan_;
  169|  3.33k|    }
_ZNK8jsoncons25basic_json_options_commonIcE17enable_str_to_infEv:
  177|  3.33k|    {
  178|  3.33k|        return enable_str_to_inf_;
  179|  3.33k|    }
_ZNK8jsoncons25basic_json_options_commonIcE20enable_str_to_neginfEv:
  187|  3.33k|    {
  188|  3.33k|        return enable_str_to_neginf_ || enable_str_to_inf_;
  ------------------
  |  Branch (188:16): [True: 0, False: 3.33k]
  |  Branch (188:41): [True: 0, False: 3.33k]
  ------------------
  189|  3.33k|    }

_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEED2Ev:
  205|  3.33k|    {
  206|  3.33k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE7restartEv:
  471|  5.30k|    {
  472|  5.30k|        more_ = true;
  473|  5.30k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE7stoppedEv:
  230|  14.8k|    {
  231|  14.8k|        return !more_;
  232|  14.8k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE16source_exhaustedEv:
  200|  21.7k|    {
  201|  21.7k|        return input_ptr_ == end_input_;
  202|  21.7k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE6updateEPKcm:
  515|  6.36k|    {
  516|  6.36k|        begin_input_ = data;
  517|  6.36k|        end_input_ = data + length;
  518|  6.36k|        input_ptr_ = begin_input_;
  519|  6.36k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10parse_someERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  532|  10.8k|    {
  533|  10.8k|        parse_some_(visitor, ec);
  534|  10.8k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11parse_some_ERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  555|  10.8k|    {
  556|  10.8k|        if (state_ == json_parse_state::accept)
  ------------------
  |  Branch (556:13): [True: 1.94k, False: 8.91k]
  ------------------
  557|  1.94k|        {
  558|  1.94k|            visitor.flush();
  559|  1.94k|            done_ = true;
  560|  1.94k|            state_ = json_parse_state::done;
  561|  1.94k|            more_ = false;
  562|  1.94k|            return;
  563|  1.94k|        }
  564|  8.91k|        const char_type* local_input_end = end_input_;
  565|       |
  566|  8.91k|        if (input_ptr_ == local_input_end && more_)
  ------------------
  |  Branch (566:13): [True: 2.52k, False: 6.38k]
  |  Branch (566:46): [True: 2.52k, False: 0]
  ------------------
  567|  2.52k|        {
  568|  2.52k|            switch (state_)
  569|  2.52k|            {
  570|      3|                case json_parse_state::zero:  
  ------------------
  |  Branch (570:17): [True: 3, False: 2.52k]
  ------------------
  571|    649|                case json_parse_state::integer:
  ------------------
  |  Branch (571:17): [True: 646, False: 1.87k]
  ------------------
  572|    649|                    end_integer_value(visitor, ec);
  573|    649|                    if (ec) return;
  ------------------
  |  Branch (573:25): [True: 0, False: 649]
  ------------------
  574|    649|                    break;
  575|    649|                case json_parse_state::fraction2:
  ------------------
  |  Branch (575:17): [True: 448, False: 2.07k]
  ------------------
  576|  1.16k|                case json_parse_state::exp3:
  ------------------
  |  Branch (576:17): [True: 715, False: 1.81k]
  ------------------
  577|  1.16k|                    end_fraction_value(visitor, ec);
  578|  1.16k|                    if (ec) return;
  ------------------
  |  Branch (578:25): [True: 0, False: 1.16k]
  ------------------
  579|  1.16k|                    break;
  580|  1.16k|                case json_parse_state::accept:
  ------------------
  |  Branch (580:17): [True: 0, False: 2.52k]
  ------------------
  581|      0|                    visitor.flush();
  582|      0|                    done_ = true;
  583|      0|                    state_ = json_parse_state::done;
  584|      0|                    more_ = false;
  585|      0|                    break;
  586|     80|                case json_parse_state::start:
  ------------------
  |  Branch (586:17): [True: 80, False: 2.44k]
  ------------------
  587|     80|                case json_parse_state::done:
  ------------------
  |  Branch (587:17): [True: 0, False: 2.52k]
  ------------------
  588|     80|                    more_ = false;
  589|     80|                    break;
  590|     44|                case json_parse_state::cr:
  ------------------
  |  Branch (590:17): [True: 44, False: 2.48k]
  ------------------
  591|     44|                    state_ = pop_state();
  592|     44|                    break;
  593|    589|                default:
  ------------------
  |  Branch (593:17): [True: 589, False: 1.93k]
  ------------------
  594|    589|                    err_handler_(json_errc::unexpected_eof, *this);
  595|    589|                    ec = json_errc::unexpected_eof;
  596|    589|                    more_ = false;
  597|    589|                    return;
  598|  2.52k|            }
  599|  2.52k|        }
  600|       |
  601|  2.61M|        while ((input_ptr_ < local_input_end) && more_)
  ------------------
  |  Branch (601:16): [True: 2.60M, False: 7.62k]
  |  Branch (601:50): [True: 2.60M, False: 39]
  ------------------
  602|  2.60M|        {
  603|  2.60M|            switch (state_)
  604|  2.60M|            {
  605|      2|                case json_parse_state::accept:
  ------------------
  |  Branch (605:17): [True: 2, False: 2.60M]
  ------------------
  606|      2|                    visitor.flush();
  607|      2|                    done_ = true;
  608|      2|                    state_ = json_parse_state::done;
  609|      2|                    more_ = false;
  610|      2|                    break;
  611|  18.9k|                case json_parse_state::cr:
  ------------------
  |  Branch (611:17): [True: 18.9k, False: 2.58M]
  ------------------
  612|  18.9k|                    ++line_;
  613|  18.9k|                    mark_position_ = position_;
  614|  18.9k|                    switch (*input_ptr_)
  615|  18.9k|                    {
  616|  1.33k|                        case '\n':
  ------------------
  |  Branch (616:25): [True: 1.33k, False: 17.6k]
  ------------------
  617|  1.33k|                            ++input_ptr_;
  618|  1.33k|                            ++position_;
  619|  1.33k|                            state_ = pop_state();
  620|  1.33k|                            break;
  621|  17.6k|                        default:
  ------------------
  |  Branch (621:25): [True: 17.6k, False: 1.33k]
  ------------------
  622|  17.6k|                            state_ = pop_state();
  623|  17.6k|                            break;
  624|  18.9k|                    }
  625|  18.9k|                    break;
  626|  21.5k|                case json_parse_state::start: 
  ------------------
  |  Branch (626:17): [True: 21.5k, False: 2.58M]
  ------------------
  627|  21.5k|                    {
  628|  21.5k|                        switch (*input_ptr_)
  629|  21.5k|                        {
  630|  1.34k|                            JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   26|     42|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (26:9): [True: 23, False: 21.5k]
  |  |  |  Branch (26:19): [True: 3, False: 21.5k]
  |  |  |  Branch (26:29): [True: 2, False: 21.5k]
  |  |  |  Branch (26:39): [True: 2, False: 21.5k]
  |  |  |  Branch (26:49): [True: 2, False: 21.5k]
  |  |  |  Branch (26:59): [True: 1, False: 21.5k]
  |  |  |  Branch (26:69): [True: 3, False: 21.5k]
  |  |  |  Branch (26:79): [True: 2, False: 21.5k]
  |  |  |  Branch (26:89): [True: 2, False: 21.5k]
  |  |  |  Branch (26:99): [True: 2, False: 21.5k]
  |  |  ------------------
  |  |   27|     53|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (27:9): [True: 1, False: 21.5k]
  |  |  |  Branch (27:19): [True: 1, False: 21.5k]
  |  |  |  Branch (27:29): [True: 1, False: 21.5k]
  |  |  |  Branch (27:39): [True: 2, False: 21.5k]
  |  |  |  Branch (27:49): [True: 1, False: 21.5k]
  |  |  |  Branch (27:59): [True: 1, False: 21.5k]
  |  |  |  Branch (27:69): [True: 1, False: 21.5k]
  |  |  |  Branch (27:79): [True: 1, False: 21.5k]
  |  |  |  Branch (27:89): [True: 1, False: 21.5k]
  |  |  |  Branch (27:99): [True: 1, False: 21.5k]
  |  |  ------------------
  |  |   28|     64|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (28:9): [True: 2, False: 21.5k]
  |  |  |  Branch (28:19): [True: 1, False: 21.5k]
  |  |  |  Branch (28:29): [True: 1, False: 21.5k]
  |  |  |  Branch (28:39): [True: 1, False: 21.5k]
  |  |  |  Branch (28:49): [True: 1, False: 21.5k]
  |  |  |  Branch (28:59): [True: 2, False: 21.5k]
  |  |  |  Branch (28:69): [True: 1, False: 21.5k]
  |  |  |  Branch (28:79): [True: 1, False: 21.5k]
  |  |  ------------------
  ------------------
  631|  1.34k|                                more_ = err_handler_(json_errc::illegal_control_character, *this);
  632|  1.34k|                                if (!more_)
  ------------------
  |  Branch (632:37): [True: 64, False: 0]
  ------------------
  633|     64|                                {
  634|     64|                                    ec = json_errc::illegal_control_character;
  635|     64|                                    return;
  636|     64|                                }
  637|      0|                                break;
  638|  3.28k|                            case '\r': 
  ------------------
  |  Branch (638:29): [True: 3.28k, False: 18.2k]
  ------------------
  639|  3.28k|                                push_state(state_);
  640|  3.28k|                                ++input_ptr_;
  641|  3.28k|                                ++position_;
  642|  3.28k|                                state_ = json_parse_state::cr;
  643|  3.28k|                                break; 
  644|  4.24k|                            case '\n': 
  ------------------
  |  Branch (644:29): [True: 4.24k, False: 17.2k]
  ------------------
  645|  4.24k|                                ++input_ptr_;
  646|  4.24k|                                ++line_;
  647|  4.24k|                                ++position_;
  648|  4.24k|                                mark_position_ = position_;
  649|  4.24k|                                break;   
  650|  6.75k|                            case ' ':case '\t':
  ------------------
  |  Branch (650:29): [True: 1.06k, False: 20.4k]
  |  Branch (650:38): [True: 5.69k, False: 15.8k]
  ------------------
  651|  6.75k|                                skip_space();
  652|  6.75k|                                break;
  653|  4.13k|                            case '/': 
  ------------------
  |  Branch (653:29): [True: 4.13k, False: 17.4k]
  ------------------
  654|  4.13k|                                ++input_ptr_;
  655|  4.13k|                                ++position_;
  656|  4.13k|                                push_state(state_);
  657|  4.13k|                                state_ = json_parse_state::slash;
  658|  4.13k|                                break;
  659|      2|                            case '{':
  ------------------
  |  Branch (659:29): [True: 2, False: 21.5k]
  ------------------
  660|      2|                                saved_position_ = position_;
  661|      2|                                ++input_ptr_;
  662|      2|                                ++position_;
  663|      2|                                begin_object(visitor, ec);
  664|      2|                                if (ec) return;
  ------------------
  |  Branch (664:37): [True: 0, False: 2]
  ------------------
  665|      2|                                break;
  666|      2|                            case '[':
  ------------------
  |  Branch (666:29): [True: 1, False: 21.5k]
  ------------------
  667|      1|                                saved_position_ = position_;
  668|      1|                                ++input_ptr_;
  669|      1|                                ++position_;
  670|      1|                                begin_array(visitor, ec);
  671|      1|                                if (ec) return;
  ------------------
  |  Branch (671:37): [True: 0, False: 1]
  ------------------
  672|      1|                                break;
  673|    762|                            case '\"':
  ------------------
  |  Branch (673:29): [True: 762, False: 20.7k]
  ------------------
  674|    762|                                state_ = json_parse_state::string;
  675|    762|                                saved_position_ = position_;
  676|    762|                                ++input_ptr_;
  677|    762|                                ++position_;
  678|    762|                                string_buffer_.clear();
  679|    762|                                parse_string(visitor, ec);
  680|    762|                                if (ec) return;
  ------------------
  |  Branch (680:37): [True: 171, False: 591]
  ------------------
  681|    591|                                break;
  682|    591|                            case '-':
  ------------------
  |  Branch (682:29): [True: 361, False: 21.1k]
  ------------------
  683|    361|                                string_buffer_.clear();
  684|    361|                                string_buffer_.push_back('-');
  685|    361|                                saved_position_ = position_;
  686|    361|                                ++input_ptr_;
  687|    361|                                ++position_;
  688|    361|                                state_ = json_parse_state::minus;
  689|    361|                                parse_number(visitor, ec);
  690|    361|                                if (ec) {return;}
  ------------------
  |  Branch (690:37): [True: 4, False: 357]
  ------------------
  691|    357|                                break;
  692|    357|                            case '0': 
  ------------------
  |  Branch (692:29): [True: 74, False: 21.4k]
  ------------------
  693|     74|                                string_buffer_.clear();
  694|     74|                                string_buffer_.push_back(static_cast<char>(*input_ptr_));
  695|     74|                                state_ = json_parse_state::zero;
  696|     74|                                saved_position_ = position_;
  697|     74|                                ++input_ptr_;
  698|     74|                                ++position_;
  699|     74|                                parse_number(visitor, ec);
  700|     74|                                if (ec) {return;}
  ------------------
  |  Branch (700:37): [True: 17, False: 57]
  ------------------
  701|     57|                                break;
  702|  1.50k|                            case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (702:29): [True: 245, False: 21.2k]
  |  Branch (702:38): [True: 209, False: 21.3k]
  |  Branch (702:47): [True: 102, False: 21.4k]
  |  Branch (702:56): [True: 144, False: 21.4k]
  |  Branch (702:65): [True: 86, False: 21.4k]
  |  Branch (702:74): [True: 100, False: 21.4k]
  |  Branch (702:83): [True: 126, False: 21.4k]
  |  Branch (702:92): [True: 200, False: 21.3k]
  |  Branch (702:102): [True: 297, False: 21.2k]
  ------------------
  703|  1.50k|                                string_buffer_.clear();
  704|  1.50k|                                string_buffer_.push_back(static_cast<char>(*input_ptr_));
  705|  1.50k|                                saved_position_ = position_;
  706|  1.50k|                                ++input_ptr_;
  707|  1.50k|                                ++position_;
  708|  1.50k|                                state_ = json_parse_state::integer;
  709|  1.50k|                                parse_number(visitor, ec);
  710|  1.50k|                                if (ec) {return;}
  ------------------
  |  Branch (710:37): [True: 29, False: 1.48k]
  ------------------
  711|  1.48k|                                break;
  712|  1.48k|                            case 'n':
  ------------------
  |  Branch (712:29): [True: 78, False: 21.4k]
  ------------------
  713|     78|                                parse_null(visitor, ec);
  714|     78|                                if (ec) {return;}
  ------------------
  |  Branch (714:37): [True: 39, False: 39]
  ------------------
  715|     39|                                break;
  716|     83|                            case 't':
  ------------------
  |  Branch (716:29): [True: 83, False: 21.4k]
  ------------------
  717|     83|                                parse_true(visitor, ec);
  718|     83|                                if (ec) {return;}
  ------------------
  |  Branch (718:37): [True: 47, False: 36]
  ------------------
  719|     36|                                break;
  720|     95|                            case 'f':
  ------------------
  |  Branch (720:29): [True: 95, False: 21.4k]
  ------------------
  721|     95|                                parse_false(visitor, ec);
  722|     95|                                if (ec) {return;}
  ------------------
  |  Branch (722:37): [True: 44, False: 51]
  ------------------
  723|     51|                                break;
  724|     51|                            case '}':
  ------------------
  |  Branch (724:29): [True: 1, False: 21.5k]
  ------------------
  725|      1|                                err_handler_(json_errc::unexpected_rbrace, *this);
  726|      1|                                ec = json_errc::unexpected_rbrace;
  727|      1|                                more_ = false;
  728|      1|                                return;
  729|      1|                            case ']':
  ------------------
  |  Branch (729:29): [True: 1, False: 21.5k]
  ------------------
  730|      1|                                err_handler_(json_errc::unexpected_rbracket, *this);
  731|      1|                                ec = json_errc::unexpected_rbracket;
  732|      1|                                more_ = false;
  733|      1|                                return;
  734|     89|                            default:
  ------------------
  |  Branch (734:29): [True: 89, False: 21.4k]
  ------------------
  735|     89|                                err_handler_(json_errc::syntax_error, *this);
  736|     89|                                ec = json_errc::syntax_error;
  737|     89|                                more_ = false;
  738|     89|                                return;
  739|  21.5k|                        }
  740|  21.5k|                    }
  741|  21.0k|                    break;
  742|       |
  743|  21.0k|                case json_parse_state::expect_comma_or_end: 
  ------------------
  |  Branch (743:17): [True: 14, False: 2.60M]
  ------------------
  744|     14|                    {
  745|     14|                        switch (*input_ptr_)
  746|     14|                        {
  747|      0|                            JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   26|      0|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (26:9): [True: 0, False: 14]
  |  |  |  Branch (26:19): [True: 0, False: 14]
  |  |  |  Branch (26:29): [True: 0, False: 14]
  |  |  |  Branch (26:39): [True: 0, False: 14]
  |  |  |  Branch (26:49): [True: 0, False: 14]
  |  |  |  Branch (26:59): [True: 0, False: 14]
  |  |  |  Branch (26:69): [True: 0, False: 14]
  |  |  |  Branch (26:79): [True: 0, False: 14]
  |  |  |  Branch (26:89): [True: 0, False: 14]
  |  |  |  Branch (26:99): [True: 0, False: 14]
  |  |  ------------------
  |  |   27|      0|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (27:9): [True: 0, False: 14]
  |  |  |  Branch (27:19): [True: 0, False: 14]
  |  |  |  Branch (27:29): [True: 0, False: 14]
  |  |  |  Branch (27:39): [True: 0, False: 14]
  |  |  |  Branch (27:49): [True: 0, False: 14]
  |  |  |  Branch (27:59): [True: 0, False: 14]
  |  |  |  Branch (27:69): [True: 0, False: 14]
  |  |  |  Branch (27:79): [True: 0, False: 14]
  |  |  |  Branch (27:89): [True: 0, False: 14]
  |  |  |  Branch (27:99): [True: 0, False: 14]
  |  |  ------------------
  |  |   28|      0|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (28:9): [True: 0, False: 14]
  |  |  |  Branch (28:19): [True: 0, False: 14]
  |  |  |  Branch (28:29): [True: 0, False: 14]
  |  |  |  Branch (28:39): [True: 0, False: 14]
  |  |  |  Branch (28:49): [True: 0, False: 14]
  |  |  |  Branch (28:59): [True: 0, False: 14]
  |  |  |  Branch (28:69): [True: 0, False: 14]
  |  |  |  Branch (28:79): [True: 0, False: 14]
  |  |  ------------------
  ------------------
  748|      0|                                more_ = err_handler_(json_errc::illegal_control_character, *this);
  749|      0|                                if (!more_)
  ------------------
  |  Branch (749:37): [True: 0, False: 0]
  ------------------
  750|      0|                                {
  751|      0|                                    ec = json_errc::illegal_control_character;
  752|      0|                                    return;
  753|      0|                                }
  754|      0|                                ++input_ptr_;
  755|      0|                                ++position_;
  756|      0|                                break;
  757|      0|                            case '\r': 
  ------------------
  |  Branch (757:29): [True: 0, False: 14]
  ------------------
  758|      0|                                ++input_ptr_;
  759|      0|                                ++position_;
  760|      0|                                push_state(state_);
  761|      0|                                state_ = json_parse_state::cr;
  762|      0|                                break; 
  763|      0|                            case '\n': 
  ------------------
  |  Branch (763:29): [True: 0, False: 14]
  ------------------
  764|      0|                                ++input_ptr_;
  765|      0|                                ++line_;
  766|      0|                                ++position_;
  767|      0|                                mark_position_ = position_;
  768|      0|                                break;   
  769|      0|                            case ' ':case '\t':
  ------------------
  |  Branch (769:29): [True: 0, False: 14]
  |  Branch (769:38): [True: 0, False: 14]
  ------------------
  770|      0|                                skip_space();
  771|      0|                                break;
  772|      0|                            case '/':
  ------------------
  |  Branch (772:29): [True: 0, False: 14]
  ------------------
  773|      0|                                ++input_ptr_;
  774|      0|                                ++position_;
  775|      0|                                push_state(state_); 
  776|      0|                                state_ = json_parse_state::slash;
  777|      0|                                break;
  778|      7|                            case '}':
  ------------------
  |  Branch (778:29): [True: 7, False: 7]
  ------------------
  779|      7|                                saved_position_ = position_;
  780|      7|                                ++input_ptr_;
  781|      7|                                ++position_;
  782|      7|                                end_object(visitor, ec);
  783|      7|                                if (ec) return;
  ------------------
  |  Branch (783:37): [True: 7, False: 0]
  ------------------
  784|      0|                                break;
  785|      7|                            case ']':
  ------------------
  |  Branch (785:29): [True: 7, False: 7]
  ------------------
  786|      7|                                saved_position_ = position_;
  787|      7|                                ++input_ptr_;
  788|      7|                                ++position_;
  789|      7|                                end_array(visitor, ec);
  790|      7|                                if (ec) return;
  ------------------
  |  Branch (790:37): [True: 7, False: 0]
  ------------------
  791|      0|                                break;
  792|      0|                            case ',':
  ------------------
  |  Branch (792:29): [True: 0, False: 14]
  ------------------
  793|      0|                                begin_member_or_element(ec);
  794|      0|                                if (ec) return;
  ------------------
  |  Branch (794:37): [True: 0, False: 0]
  ------------------
  795|      0|                                ++input_ptr_;
  796|      0|                                ++position_;
  797|      0|                                break;
  798|      0|                            default:
  ------------------
  |  Branch (798:29): [True: 0, False: 14]
  ------------------
  799|      0|                                if (parent() == json_parse_state::array)
  ------------------
  |  Branch (799:37): [True: 0, False: 0]
  ------------------
  800|      0|                                {
  801|      0|                                    more_ = err_handler_(json_errc::expected_comma_or_rbracket, *this);
  802|      0|                                    if (!more_)
  ------------------
  |  Branch (802:41): [True: 0, False: 0]
  ------------------
  803|      0|                                    {
  804|      0|                                        ec = json_errc::expected_comma_or_rbracket;
  805|      0|                                        return;
  806|      0|                                    }
  807|      0|                                }
  808|      0|                                else if (parent() == json_parse_state::object)
  ------------------
  |  Branch (808:42): [True: 0, False: 0]
  ------------------
  809|      0|                                {
  810|      0|                                    more_ = err_handler_(json_errc::expected_comma_or_rbrace, *this);
  811|      0|                                    if (!more_)
  ------------------
  |  Branch (811:41): [True: 0, False: 0]
  ------------------
  812|      0|                                    {
  813|      0|                                        ec = json_errc::expected_comma_or_rbrace;
  814|      0|                                        return;
  815|      0|                                    }
  816|      0|                                }
  817|      0|                                ++input_ptr_;
  818|      0|                                ++position_;
  819|      0|                                break;
  820|     14|                        }
  821|     14|                    }
  822|      0|                    break;
  823|      0|                case json_parse_state::expect_member_name_or_end: 
  ------------------
  |  Branch (823:17): [True: 0, False: 2.60M]
  ------------------
  824|      0|                    {
  825|      0|                        switch (*input_ptr_)
  826|      0|                        {
  827|      0|                            JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   26|      0|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (26:9): [True: 0, False: 0]
  |  |  |  Branch (26:19): [True: 0, False: 0]
  |  |  |  Branch (26:29): [True: 0, False: 0]
  |  |  |  Branch (26:39): [True: 0, False: 0]
  |  |  |  Branch (26:49): [True: 0, False: 0]
  |  |  |  Branch (26:59): [True: 0, False: 0]
  |  |  |  Branch (26:69): [True: 0, False: 0]
  |  |  |  Branch (26:79): [True: 0, False: 0]
  |  |  |  Branch (26:89): [True: 0, False: 0]
  |  |  |  Branch (26:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   27|      0|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (27:9): [True: 0, False: 0]
  |  |  |  Branch (27:19): [True: 0, False: 0]
  |  |  |  Branch (27:29): [True: 0, False: 0]
  |  |  |  Branch (27:39): [True: 0, False: 0]
  |  |  |  Branch (27:49): [True: 0, False: 0]
  |  |  |  Branch (27:59): [True: 0, False: 0]
  |  |  |  Branch (27:69): [True: 0, False: 0]
  |  |  |  Branch (27:79): [True: 0, False: 0]
  |  |  |  Branch (27:89): [True: 0, False: 0]
  |  |  |  Branch (27:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   28|      0|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (28:9): [True: 0, False: 0]
  |  |  |  Branch (28:19): [True: 0, False: 0]
  |  |  |  Branch (28:29): [True: 0, False: 0]
  |  |  |  Branch (28:39): [True: 0, False: 0]
  |  |  |  Branch (28:49): [True: 0, False: 0]
  |  |  |  Branch (28:59): [True: 0, False: 0]
  |  |  |  Branch (28:69): [True: 0, False: 0]
  |  |  |  Branch (28:79): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  828|      0|                                more_ = err_handler_(json_errc::illegal_control_character, *this);
  829|      0|                                if (!more_)
  ------------------
  |  Branch (829:37): [True: 0, False: 0]
  ------------------
  830|      0|                                {
  831|      0|                                    ec = json_errc::illegal_control_character;
  832|      0|                                    return;
  833|      0|                                }
  834|      0|                                ++input_ptr_;
  835|      0|                                ++position_;
  836|      0|                                break;
  837|      0|                            case '\r': 
  ------------------
  |  Branch (837:29): [True: 0, False: 0]
  ------------------
  838|      0|                                ++input_ptr_;
  839|      0|                                ++position_;
  840|      0|                                push_state(state_);
  841|      0|                                state_ = json_parse_state::cr;
  842|      0|                                break; 
  843|      0|                            case '\n': 
  ------------------
  |  Branch (843:29): [True: 0, False: 0]
  ------------------
  844|      0|                                ++input_ptr_;
  845|      0|                                ++line_;
  846|      0|                                ++position_;
  847|      0|                                mark_position_ = position_;
  848|      0|                                break;   
  849|      0|                            case ' ':case '\t':
  ------------------
  |  Branch (849:29): [True: 0, False: 0]
  |  Branch (849:38): [True: 0, False: 0]
  ------------------
  850|      0|                                skip_space();
  851|      0|                                break;
  852|      0|                            case '/':
  ------------------
  |  Branch (852:29): [True: 0, False: 0]
  ------------------
  853|      0|                                ++input_ptr_;
  854|      0|                                ++position_;
  855|      0|                                push_state(state_); 
  856|      0|                                state_ = json_parse_state::slash;
  857|      0|                                break;
  858|      0|                            case '}':
  ------------------
  |  Branch (858:29): [True: 0, False: 0]
  ------------------
  859|      0|                                saved_position_ = position_;
  860|      0|                                ++input_ptr_;
  861|      0|                                ++position_;
  862|      0|                                end_object(visitor, ec);
  863|      0|                                if (ec) return;
  ------------------
  |  Branch (863:37): [True: 0, False: 0]
  ------------------
  864|      0|                                break;
  865|      0|                            case '\"':
  ------------------
  |  Branch (865:29): [True: 0, False: 0]
  ------------------
  866|      0|                                saved_position_ = position_;
  867|      0|                                ++input_ptr_;
  868|      0|                                ++position_;
  869|      0|                                push_state(json_parse_state::member_name);
  870|      0|                                state_ = json_parse_state::string;
  871|      0|                                string_buffer_.clear();
  872|      0|                                parse_string(visitor, ec);
  873|      0|                                if (ec) return;
  ------------------
  |  Branch (873:37): [True: 0, False: 0]
  ------------------
  874|      0|                                break;
  875|      0|                            case '\'':
  ------------------
  |  Branch (875:29): [True: 0, False: 0]
  ------------------
  876|      0|                                more_ = err_handler_(json_errc::single_quote, *this);
  877|      0|                                if (!more_)
  ------------------
  |  Branch (877:37): [True: 0, False: 0]
  ------------------
  878|      0|                                {
  879|      0|                                    ec = json_errc::single_quote;
  880|      0|                                    return;
  881|      0|                                }
  882|      0|                                ++input_ptr_;
  883|      0|                                ++position_;
  884|      0|                                break;
  885|      0|                            default:
  ------------------
  |  Branch (885:29): [True: 0, False: 0]
  ------------------
  886|      0|                                more_ = err_handler_(json_errc::expected_key, *this);
  887|      0|                                if (!more_)
  ------------------
  |  Branch (887:37): [True: 0, False: 0]
  ------------------
  888|      0|                                {
  889|      0|                                    ec = json_errc::expected_key;
  890|      0|                                    return;
  891|      0|                                }
  892|      0|                                ++input_ptr_;
  893|      0|                                ++position_;
  894|      0|                                break;
  895|      0|                        }
  896|      0|                    }
  897|      0|                    break;
  898|      0|                case json_parse_state::expect_member_name: 
  ------------------
  |  Branch (898:17): [True: 0, False: 2.60M]
  ------------------
  899|      0|                    {
  900|      0|                        switch (*input_ptr_)
  901|      0|                        {
  902|      0|                            JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   26|      0|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (26:9): [True: 0, False: 0]
  |  |  |  Branch (26:19): [True: 0, False: 0]
  |  |  |  Branch (26:29): [True: 0, False: 0]
  |  |  |  Branch (26:39): [True: 0, False: 0]
  |  |  |  Branch (26:49): [True: 0, False: 0]
  |  |  |  Branch (26:59): [True: 0, False: 0]
  |  |  |  Branch (26:69): [True: 0, False: 0]
  |  |  |  Branch (26:79): [True: 0, False: 0]
  |  |  |  Branch (26:89): [True: 0, False: 0]
  |  |  |  Branch (26:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   27|      0|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (27:9): [True: 0, False: 0]
  |  |  |  Branch (27:19): [True: 0, False: 0]
  |  |  |  Branch (27:29): [True: 0, False: 0]
  |  |  |  Branch (27:39): [True: 0, False: 0]
  |  |  |  Branch (27:49): [True: 0, False: 0]
  |  |  |  Branch (27:59): [True: 0, False: 0]
  |  |  |  Branch (27:69): [True: 0, False: 0]
  |  |  |  Branch (27:79): [True: 0, False: 0]
  |  |  |  Branch (27:89): [True: 0, False: 0]
  |  |  |  Branch (27:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   28|      0|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (28:9): [True: 0, False: 0]
  |  |  |  Branch (28:19): [True: 0, False: 0]
  |  |  |  Branch (28:29): [True: 0, False: 0]
  |  |  |  Branch (28:39): [True: 0, False: 0]
  |  |  |  Branch (28:49): [True: 0, False: 0]
  |  |  |  Branch (28:59): [True: 0, False: 0]
  |  |  |  Branch (28:69): [True: 0, False: 0]
  |  |  |  Branch (28:79): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  903|      0|                                more_ = err_handler_(json_errc::illegal_control_character, *this);
  904|      0|                                if (!more_)
  ------------------
  |  Branch (904:37): [True: 0, False: 0]
  ------------------
  905|      0|                                {
  906|      0|                                    ec = json_errc::illegal_control_character;
  907|      0|                                    return;
  908|      0|                                }
  909|      0|                                ++input_ptr_;
  910|      0|                                ++position_;
  911|      0|                                break;
  912|      0|                            case '\r': 
  ------------------
  |  Branch (912:29): [True: 0, False: 0]
  ------------------
  913|      0|                                ++input_ptr_;
  914|      0|                                ++position_;
  915|      0|                                push_state(state_);
  916|      0|                                state_ = json_parse_state::cr;
  917|      0|                                break; 
  918|      0|                            case '\n': 
  ------------------
  |  Branch (918:29): [True: 0, False: 0]
  ------------------
  919|      0|                                ++input_ptr_;
  920|      0|                                ++line_;
  921|      0|                                ++position_;
  922|      0|                                mark_position_ = position_;
  923|      0|                                break;   
  924|      0|                            case ' ':case '\t':
  ------------------
  |  Branch (924:29): [True: 0, False: 0]
  |  Branch (924:38): [True: 0, False: 0]
  ------------------
  925|      0|                                skip_space();
  926|      0|                                break;
  927|      0|                            case '/': 
  ------------------
  |  Branch (927:29): [True: 0, False: 0]
  ------------------
  928|      0|                                ++input_ptr_;
  929|      0|                                ++position_;
  930|      0|                                push_state(state_);
  931|      0|                                state_ = json_parse_state::slash;
  932|      0|                                break;
  933|      0|                            case '\"':
  ------------------
  |  Branch (933:29): [True: 0, False: 0]
  ------------------
  934|      0|                                saved_position_ = position_;
  935|      0|                                ++input_ptr_;
  936|      0|                                ++position_;
  937|      0|                                push_state(json_parse_state::member_name);
  938|      0|                                state_ = json_parse_state::string;
  939|      0|                                string_buffer_.clear();
  940|      0|                                parse_string(visitor, ec);
  941|      0|                                if (ec) return;
  ------------------
  |  Branch (941:37): [True: 0, False: 0]
  ------------------
  942|      0|                                break;
  943|      0|                            case '}':
  ------------------
  |  Branch (943:29): [True: 0, False: 0]
  ------------------
  944|      0|                                more_ = err_handler_(json_errc::extra_comma, *this);
  945|      0|                                if (!more_)
  ------------------
  |  Branch (945:37): [True: 0, False: 0]
  ------------------
  946|      0|                                {
  947|      0|                                    ec = json_errc::extra_comma;
  948|      0|                                    return;
  949|      0|                                }
  950|      0|                                saved_position_ = position_;
  951|      0|                                ++input_ptr_;
  952|      0|                                ++position_;
  953|      0|                                end_object(visitor, ec);  // Recover
  954|      0|                                if (ec) return;
  ------------------
  |  Branch (954:37): [True: 0, False: 0]
  ------------------
  955|      0|                                break;
  956|      0|                            case '\'':
  ------------------
  |  Branch (956:29): [True: 0, False: 0]
  ------------------
  957|      0|                                more_ = err_handler_(json_errc::single_quote, *this);
  958|      0|                                if (!more_)
  ------------------
  |  Branch (958:37): [True: 0, False: 0]
  ------------------
  959|      0|                                {
  960|      0|                                    ec = json_errc::single_quote;
  961|      0|                                    return;
  962|      0|                                }
  963|      0|                                ++input_ptr_;
  964|      0|                                ++position_;
  965|      0|                                break;
  966|      0|                            default:
  ------------------
  |  Branch (966:29): [True: 0, False: 0]
  ------------------
  967|      0|                                more_ = err_handler_(json_errc::expected_key, *this);
  968|      0|                                if (!more_)
  ------------------
  |  Branch (968:37): [True: 0, False: 0]
  ------------------
  969|      0|                                {
  970|      0|                                    ec = json_errc::expected_key;
  971|      0|                                    return;
  972|      0|                                }
  973|      0|                                ++input_ptr_;
  974|      0|                                ++position_;
  975|      0|                                break;
  976|      0|                        }
  977|      0|                    }
  978|      0|                    break;
  979|      0|                case json_parse_state::expect_colon: 
  ------------------
  |  Branch (979:17): [True: 0, False: 2.60M]
  ------------------
  980|      0|                    {
  981|      0|                        switch (*input_ptr_)
  982|      0|                        {
  983|      0|                            JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   26|      0|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (26:9): [True: 0, False: 0]
  |  |  |  Branch (26:19): [True: 0, False: 0]
  |  |  |  Branch (26:29): [True: 0, False: 0]
  |  |  |  Branch (26:39): [True: 0, False: 0]
  |  |  |  Branch (26:49): [True: 0, False: 0]
  |  |  |  Branch (26:59): [True: 0, False: 0]
  |  |  |  Branch (26:69): [True: 0, False: 0]
  |  |  |  Branch (26:79): [True: 0, False: 0]
  |  |  |  Branch (26:89): [True: 0, False: 0]
  |  |  |  Branch (26:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   27|      0|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (27:9): [True: 0, False: 0]
  |  |  |  Branch (27:19): [True: 0, False: 0]
  |  |  |  Branch (27:29): [True: 0, False: 0]
  |  |  |  Branch (27:39): [True: 0, False: 0]
  |  |  |  Branch (27:49): [True: 0, False: 0]
  |  |  |  Branch (27:59): [True: 0, False: 0]
  |  |  |  Branch (27:69): [True: 0, False: 0]
  |  |  |  Branch (27:79): [True: 0, False: 0]
  |  |  |  Branch (27:89): [True: 0, False: 0]
  |  |  |  Branch (27:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   28|      0|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (28:9): [True: 0, False: 0]
  |  |  |  Branch (28:19): [True: 0, False: 0]
  |  |  |  Branch (28:29): [True: 0, False: 0]
  |  |  |  Branch (28:39): [True: 0, False: 0]
  |  |  |  Branch (28:49): [True: 0, False: 0]
  |  |  |  Branch (28:59): [True: 0, False: 0]
  |  |  |  Branch (28:69): [True: 0, False: 0]
  |  |  |  Branch (28:79): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  984|      0|                                more_ = err_handler_(json_errc::illegal_control_character, *this);
  985|      0|                                if (!more_)
  ------------------
  |  Branch (985:37): [True: 0, False: 0]
  ------------------
  986|      0|                                {
  987|      0|                                    ec = json_errc::illegal_control_character;
  988|      0|                                    return;
  989|      0|                                }
  990|      0|                                ++input_ptr_;
  991|      0|                                ++position_;
  992|      0|                                break;
  993|      0|                            case '\r': 
  ------------------
  |  Branch (993:29): [True: 0, False: 0]
  ------------------
  994|      0|                                push_state(state_);
  995|      0|                                state_ = json_parse_state::cr;
  996|      0|                                ++input_ptr_;
  997|      0|                                ++position_;
  998|      0|                                break; 
  999|      0|                            case '\n': 
  ------------------
  |  Branch (999:29): [True: 0, False: 0]
  ------------------
 1000|      0|                                ++input_ptr_;
 1001|      0|                                ++line_;
 1002|      0|                                ++position_;
 1003|      0|                                mark_position_ = position_;
 1004|      0|                                break;   
 1005|      0|                            case ' ':case '\t':
  ------------------
  |  Branch (1005:29): [True: 0, False: 0]
  |  Branch (1005:38): [True: 0, False: 0]
  ------------------
 1006|      0|                                skip_space();
 1007|      0|                                break;
 1008|      0|                            case '/': 
  ------------------
  |  Branch (1008:29): [True: 0, False: 0]
  ------------------
 1009|      0|                                push_state(state_);
 1010|      0|                                state_ = json_parse_state::slash;
 1011|      0|                                ++input_ptr_;
 1012|      0|                                ++position_;
 1013|      0|                                break;
 1014|      0|                            case ':':
  ------------------
  |  Branch (1014:29): [True: 0, False: 0]
  ------------------
 1015|      0|                                state_ = json_parse_state::expect_value;
 1016|      0|                                ++input_ptr_;
 1017|      0|                                ++position_;
 1018|      0|                                break;
 1019|      0|                            default:
  ------------------
  |  Branch (1019:29): [True: 0, False: 0]
  ------------------
 1020|      0|                                more_ = err_handler_(json_errc::expected_colon, *this);
 1021|      0|                                if (!more_)
  ------------------
  |  Branch (1021:37): [True: 0, False: 0]
  ------------------
 1022|      0|                                {
 1023|      0|                                    ec = json_errc::expected_colon;
 1024|      0|                                    return;
 1025|      0|                                }
 1026|      0|                                ++input_ptr_;
 1027|      0|                                ++position_;
 1028|      0|                                break;
 1029|      0|                        }
 1030|      0|                    }
 1031|      0|                    break;
 1032|       |
 1033|      0|                    case json_parse_state::expect_value: 
  ------------------
  |  Branch (1033:21): [True: 0, False: 2.60M]
  ------------------
 1034|      0|                    {
 1035|      0|                        switch (*input_ptr_)
 1036|      0|                        {
 1037|      0|                            JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   26|      0|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (26:9): [True: 0, False: 0]
  |  |  |  Branch (26:19): [True: 0, False: 0]
  |  |  |  Branch (26:29): [True: 0, False: 0]
  |  |  |  Branch (26:39): [True: 0, False: 0]
  |  |  |  Branch (26:49): [True: 0, False: 0]
  |  |  |  Branch (26:59): [True: 0, False: 0]
  |  |  |  Branch (26:69): [True: 0, False: 0]
  |  |  |  Branch (26:79): [True: 0, False: 0]
  |  |  |  Branch (26:89): [True: 0, False: 0]
  |  |  |  Branch (26:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   27|      0|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (27:9): [True: 0, False: 0]
  |  |  |  Branch (27:19): [True: 0, False: 0]
  |  |  |  Branch (27:29): [True: 0, False: 0]
  |  |  |  Branch (27:39): [True: 0, False: 0]
  |  |  |  Branch (27:49): [True: 0, False: 0]
  |  |  |  Branch (27:59): [True: 0, False: 0]
  |  |  |  Branch (27:69): [True: 0, False: 0]
  |  |  |  Branch (27:79): [True: 0, False: 0]
  |  |  |  Branch (27:89): [True: 0, False: 0]
  |  |  |  Branch (27:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   28|      0|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (28:9): [True: 0, False: 0]
  |  |  |  Branch (28:19): [True: 0, False: 0]
  |  |  |  Branch (28:29): [True: 0, False: 0]
  |  |  |  Branch (28:39): [True: 0, False: 0]
  |  |  |  Branch (28:49): [True: 0, False: 0]
  |  |  |  Branch (28:59): [True: 0, False: 0]
  |  |  |  Branch (28:69): [True: 0, False: 0]
  |  |  |  Branch (28:79): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1038|      0|                                more_ = err_handler_(json_errc::illegal_control_character, *this);
 1039|      0|                                if (!more_)
  ------------------
  |  Branch (1039:37): [True: 0, False: 0]
  ------------------
 1040|      0|                                {
 1041|      0|                                    ec = json_errc::illegal_control_character;
 1042|      0|                                    return;
 1043|      0|                                }
 1044|      0|                                ++input_ptr_;
 1045|      0|                                ++position_;
 1046|      0|                                break;
 1047|      0|                            case '\r': 
  ------------------
  |  Branch (1047:29): [True: 0, False: 0]
  ------------------
 1048|      0|                                push_state(state_);
 1049|      0|                                ++input_ptr_;
 1050|      0|                                ++position_;
 1051|      0|                                state_ = json_parse_state::cr;
 1052|      0|                                break; 
 1053|      0|                            case '\n': 
  ------------------
  |  Branch (1053:29): [True: 0, False: 0]
  ------------------
 1054|      0|                                ++input_ptr_;
 1055|      0|                                ++line_;
 1056|      0|                                ++position_;
 1057|      0|                                mark_position_ = position_;
 1058|      0|                                break;   
 1059|      0|                            case ' ':case '\t':
  ------------------
  |  Branch (1059:29): [True: 0, False: 0]
  |  Branch (1059:38): [True: 0, False: 0]
  ------------------
 1060|      0|                                skip_space();
 1061|      0|                                break;
 1062|      0|                            case '/': 
  ------------------
  |  Branch (1062:29): [True: 0, False: 0]
  ------------------
 1063|      0|                                push_state(state_);
 1064|      0|                                ++input_ptr_;
 1065|      0|                                ++position_;
 1066|      0|                                state_ = json_parse_state::slash;
 1067|      0|                                break;
 1068|      0|                            case '{':
  ------------------
  |  Branch (1068:29): [True: 0, False: 0]
  ------------------
 1069|      0|                                saved_position_ = position_;
 1070|      0|                                ++input_ptr_;
 1071|      0|                                ++position_;
 1072|      0|                                begin_object(visitor, ec);
 1073|      0|                                if (ec) return;
  ------------------
  |  Branch (1073:37): [True: 0, False: 0]
  ------------------
 1074|      0|                                break;
 1075|      0|                            case '[':
  ------------------
  |  Branch (1075:29): [True: 0, False: 0]
  ------------------
 1076|      0|                                saved_position_ = position_;
 1077|      0|                                ++input_ptr_;
 1078|      0|                                ++position_;
 1079|      0|                                begin_array(visitor, ec);
 1080|      0|                                if (ec) return;
  ------------------
  |  Branch (1080:37): [True: 0, False: 0]
  ------------------
 1081|      0|                                break;
 1082|      0|                            case '\"':
  ------------------
  |  Branch (1082:29): [True: 0, False: 0]
  ------------------
 1083|      0|                                saved_position_ = position_;
 1084|      0|                                ++input_ptr_;
 1085|      0|                                ++position_;
 1086|      0|                                state_ = json_parse_state::string;
 1087|      0|                                string_buffer_.clear();
 1088|      0|                                parse_string(visitor, ec);
 1089|      0|                                if (ec) return;
  ------------------
  |  Branch (1089:37): [True: 0, False: 0]
  ------------------
 1090|      0|                                break;
 1091|      0|                            case '-':
  ------------------
  |  Branch (1091:29): [True: 0, False: 0]
  ------------------
 1092|      0|                                string_buffer_.clear();
 1093|      0|                                string_buffer_.push_back('-');
 1094|      0|                                saved_position_ = position_;
 1095|      0|                                ++input_ptr_;
 1096|      0|                                ++position_;
 1097|      0|                                state_ = json_parse_state::minus;
 1098|      0|                                parse_number(visitor, ec);
 1099|      0|                                if (ec) {return;}
  ------------------
  |  Branch (1099:37): [True: 0, False: 0]
  ------------------
 1100|      0|                                break;
 1101|      0|                            case '0': 
  ------------------
  |  Branch (1101:29): [True: 0, False: 0]
  ------------------
 1102|      0|                                string_buffer_.clear();
 1103|      0|                                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 1104|      0|                                saved_position_ = position_;
 1105|      0|                                ++input_ptr_;
 1106|      0|                                ++position_;
 1107|      0|                                state_ = json_parse_state::zero;
 1108|      0|                                parse_number(visitor, ec);
 1109|      0|                                if (ec) {return;}
  ------------------
  |  Branch (1109:37): [True: 0, False: 0]
  ------------------
 1110|      0|                                break;
 1111|      0|                            case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (1111:29): [True: 0, False: 0]
  |  Branch (1111:38): [True: 0, False: 0]
  |  Branch (1111:47): [True: 0, False: 0]
  |  Branch (1111:56): [True: 0, False: 0]
  |  Branch (1111:65): [True: 0, False: 0]
  |  Branch (1111:74): [True: 0, False: 0]
  |  Branch (1111:83): [True: 0, False: 0]
  |  Branch (1111:92): [True: 0, False: 0]
  |  Branch (1111:102): [True: 0, False: 0]
  ------------------
 1112|      0|                                string_buffer_.clear();
 1113|      0|                                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 1114|      0|                                saved_position_ = position_;
 1115|      0|                                ++input_ptr_;
 1116|      0|                                ++position_;
 1117|      0|                                state_ = json_parse_state::integer;
 1118|      0|                                parse_number(visitor, ec);
 1119|      0|                                if (ec) {return;}
  ------------------
  |  Branch (1119:37): [True: 0, False: 0]
  ------------------
 1120|      0|                                break;
 1121|      0|                            case 'n':
  ------------------
  |  Branch (1121:29): [True: 0, False: 0]
  ------------------
 1122|      0|                                parse_null(visitor, ec);
 1123|      0|                                if (ec) {return;}
  ------------------
  |  Branch (1123:37): [True: 0, False: 0]
  ------------------
 1124|      0|                                break;
 1125|      0|                            case 't':
  ------------------
  |  Branch (1125:29): [True: 0, False: 0]
  ------------------
 1126|      0|                                parse_true(visitor, ec);
 1127|      0|                                if (ec) {return;}
  ------------------
  |  Branch (1127:37): [True: 0, False: 0]
  ------------------
 1128|      0|                                break;
 1129|      0|                            case 'f':
  ------------------
  |  Branch (1129:29): [True: 0, False: 0]
  ------------------
 1130|      0|                                parse_false(visitor, ec);
 1131|      0|                                if (ec) {return;}
  ------------------
  |  Branch (1131:37): [True: 0, False: 0]
  ------------------
 1132|      0|                                break;
 1133|      0|                            case ']':
  ------------------
  |  Branch (1133:29): [True: 0, False: 0]
  ------------------
 1134|      0|                                saved_position_ = position_;
 1135|      0|                                ++input_ptr_;
 1136|      0|                                ++position_;
 1137|      0|                                if (parent() == json_parse_state::array)
  ------------------
  |  Branch (1137:37): [True: 0, False: 0]
  ------------------
 1138|      0|                                {
 1139|      0|                                    more_ = err_handler_(json_errc::extra_comma, *this);
 1140|      0|                                    if (!more_)
  ------------------
  |  Branch (1140:41): [True: 0, False: 0]
  ------------------
 1141|      0|                                    {
 1142|      0|                                        ec = json_errc::extra_comma;
 1143|      0|                                        return;
 1144|      0|                                    }
 1145|      0|                                    end_array(visitor, ec);  // Recover
 1146|      0|                                    if (ec) return;
  ------------------
  |  Branch (1146:41): [True: 0, False: 0]
  ------------------
 1147|      0|                                }
 1148|      0|                                else
 1149|      0|                                {
 1150|      0|                                    more_ = err_handler_(json_errc::expected_value, *this);
 1151|      0|                                    if (!more_)
  ------------------
  |  Branch (1151:41): [True: 0, False: 0]
  ------------------
 1152|      0|                                    {
 1153|      0|                                        ec = json_errc::expected_value;
 1154|      0|                                        return;
 1155|      0|                                    }
 1156|      0|                                }
 1157|      0|                                break;
 1158|      0|                            case '\'':
  ------------------
  |  Branch (1158:29): [True: 0, False: 0]
  ------------------
 1159|      0|                                more_ = err_handler_(json_errc::single_quote, *this);
 1160|      0|                                if (!more_)
  ------------------
  |  Branch (1160:37): [True: 0, False: 0]
  ------------------
 1161|      0|                                {
 1162|      0|                                    ec = json_errc::single_quote;
 1163|      0|                                    return;
 1164|      0|                                }
 1165|      0|                                ++input_ptr_;
 1166|      0|                                ++position_;
 1167|      0|                                break;
 1168|      0|                            default:
  ------------------
  |  Branch (1168:29): [True: 0, False: 0]
  ------------------
 1169|      0|                                more_ = err_handler_(json_errc::expected_value, *this);
 1170|      0|                                if (!more_)
  ------------------
  |  Branch (1170:37): [True: 0, False: 0]
  ------------------
 1171|      0|                                {
 1172|      0|                                    ec = json_errc::expected_value;
 1173|      0|                                    return;
 1174|      0|                                }
 1175|      0|                                ++input_ptr_;
 1176|      0|                                ++position_;
 1177|      0|                                break;
 1178|      0|                        }
 1179|      0|                    }
 1180|      0|                    break;
 1181|      0|                    case json_parse_state::expect_value_or_end: 
  ------------------
  |  Branch (1181:21): [True: 0, False: 2.60M]
  ------------------
 1182|      0|                    {
 1183|      0|                        switch (*input_ptr_)
 1184|      0|                        {
 1185|      0|                            JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   26|      0|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (26:9): [True: 0, False: 0]
  |  |  |  Branch (26:19): [True: 0, False: 0]
  |  |  |  Branch (26:29): [True: 0, False: 0]
  |  |  |  Branch (26:39): [True: 0, False: 0]
  |  |  |  Branch (26:49): [True: 0, False: 0]
  |  |  |  Branch (26:59): [True: 0, False: 0]
  |  |  |  Branch (26:69): [True: 0, False: 0]
  |  |  |  Branch (26:79): [True: 0, False: 0]
  |  |  |  Branch (26:89): [True: 0, False: 0]
  |  |  |  Branch (26:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   27|      0|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (27:9): [True: 0, False: 0]
  |  |  |  Branch (27:19): [True: 0, False: 0]
  |  |  |  Branch (27:29): [True: 0, False: 0]
  |  |  |  Branch (27:39): [True: 0, False: 0]
  |  |  |  Branch (27:49): [True: 0, False: 0]
  |  |  |  Branch (27:59): [True: 0, False: 0]
  |  |  |  Branch (27:69): [True: 0, False: 0]
  |  |  |  Branch (27:79): [True: 0, False: 0]
  |  |  |  Branch (27:89): [True: 0, False: 0]
  |  |  |  Branch (27:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   28|      0|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (28:9): [True: 0, False: 0]
  |  |  |  Branch (28:19): [True: 0, False: 0]
  |  |  |  Branch (28:29): [True: 0, False: 0]
  |  |  |  Branch (28:39): [True: 0, False: 0]
  |  |  |  Branch (28:49): [True: 0, False: 0]
  |  |  |  Branch (28:59): [True: 0, False: 0]
  |  |  |  Branch (28:69): [True: 0, False: 0]
  |  |  |  Branch (28:79): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1186|      0|                                more_ = err_handler_(json_errc::illegal_control_character, *this);
 1187|      0|                                if (!more_)
  ------------------
  |  Branch (1187:37): [True: 0, False: 0]
  ------------------
 1188|      0|                                {
 1189|      0|                                    ec = json_errc::illegal_control_character;
 1190|      0|                                    return;
 1191|      0|                                }
 1192|      0|                                ++input_ptr_;
 1193|      0|                                ++position_;
 1194|      0|                                break;
 1195|      0|                            case '\r': 
  ------------------
  |  Branch (1195:29): [True: 0, False: 0]
  ------------------
 1196|      0|                                ++input_ptr_;
 1197|      0|                                ++position_;
 1198|      0|                                push_state(state_);
 1199|      0|                                state_ = json_parse_state::cr;
 1200|      0|                                break; 
 1201|      0|                            case '\n': 
  ------------------
  |  Branch (1201:29): [True: 0, False: 0]
  ------------------
 1202|      0|                                ++input_ptr_;
 1203|      0|                                ++line_;
 1204|      0|                                ++position_;
 1205|      0|                                mark_position_ = position_;
 1206|      0|                                break;   
 1207|      0|                            case ' ':case '\t':
  ------------------
  |  Branch (1207:29): [True: 0, False: 0]
  |  Branch (1207:38): [True: 0, False: 0]
  ------------------
 1208|      0|                                skip_space();
 1209|      0|                                break;
 1210|      0|                            case '/': 
  ------------------
  |  Branch (1210:29): [True: 0, False: 0]
  ------------------
 1211|      0|                                ++input_ptr_;
 1212|      0|                                ++position_;
 1213|      0|                                push_state(state_);
 1214|      0|                                state_ = json_parse_state::slash;
 1215|      0|                                break;
 1216|      0|                            case '{':
  ------------------
  |  Branch (1216:29): [True: 0, False: 0]
  ------------------
 1217|      0|                                saved_position_ = position_;
 1218|      0|                                ++input_ptr_;
 1219|      0|                                ++position_;
 1220|      0|                                begin_object(visitor, ec);
 1221|      0|                                if (ec) return;
  ------------------
  |  Branch (1221:37): [True: 0, False: 0]
  ------------------
 1222|      0|                                break;
 1223|      0|                            case '[':
  ------------------
  |  Branch (1223:29): [True: 0, False: 0]
  ------------------
 1224|      0|                                saved_position_ = position_;
 1225|      0|                                ++input_ptr_;
 1226|      0|                                ++position_;
 1227|      0|                                begin_array(visitor, ec);
 1228|      0|                                if (ec) return;
  ------------------
  |  Branch (1228:37): [True: 0, False: 0]
  ------------------
 1229|      0|                                break;
 1230|      0|                            case ']':
  ------------------
  |  Branch (1230:29): [True: 0, False: 0]
  ------------------
 1231|      0|                                saved_position_ = position_;
 1232|      0|                                ++input_ptr_;
 1233|      0|                                ++position_;
 1234|      0|                                end_array(visitor, ec);
 1235|      0|                                if (ec) return;
  ------------------
  |  Branch (1235:37): [True: 0, False: 0]
  ------------------
 1236|      0|                                break;
 1237|      0|                            case '\"':
  ------------------
  |  Branch (1237:29): [True: 0, False: 0]
  ------------------
 1238|      0|                                saved_position_ = position_;
 1239|      0|                                ++input_ptr_;
 1240|      0|                                ++position_;
 1241|      0|                                state_ = json_parse_state::string;
 1242|      0|                                string_buffer_.clear();
 1243|      0|                                parse_string(visitor, ec);
 1244|      0|                                if (ec) return;
  ------------------
  |  Branch (1244:37): [True: 0, False: 0]
  ------------------
 1245|      0|                                break;
 1246|      0|                            case '-':
  ------------------
  |  Branch (1246:29): [True: 0, False: 0]
  ------------------
 1247|      0|                                string_buffer_.clear();
 1248|      0|                                string_buffer_.push_back('-');
 1249|      0|                                saved_position_ = position_;
 1250|      0|                                ++input_ptr_;
 1251|      0|                                ++position_;
 1252|      0|                                state_ = json_parse_state::minus;
 1253|      0|                                parse_number(visitor, ec);
 1254|      0|                                if (ec) {return;}
  ------------------
  |  Branch (1254:37): [True: 0, False: 0]
  ------------------
 1255|      0|                                break;
 1256|      0|                            case '0': 
  ------------------
  |  Branch (1256:29): [True: 0, False: 0]
  ------------------
 1257|      0|                                string_buffer_.clear();
 1258|      0|                                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 1259|      0|                                saved_position_ = position_;
 1260|      0|                                ++input_ptr_;
 1261|      0|                                ++position_;
 1262|      0|                                state_ = json_parse_state::zero;
 1263|      0|                                parse_number(visitor, ec);
 1264|      0|                                if (ec) {return;}
  ------------------
  |  Branch (1264:37): [True: 0, False: 0]
  ------------------
 1265|      0|                                break;
 1266|      0|                            case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (1266:29): [True: 0, False: 0]
  |  Branch (1266:38): [True: 0, False: 0]
  |  Branch (1266:47): [True: 0, False: 0]
  |  Branch (1266:56): [True: 0, False: 0]
  |  Branch (1266:65): [True: 0, False: 0]
  |  Branch (1266:74): [True: 0, False: 0]
  |  Branch (1266:83): [True: 0, False: 0]
  |  Branch (1266:92): [True: 0, False: 0]
  |  Branch (1266:102): [True: 0, False: 0]
  ------------------
 1267|      0|                                string_buffer_.clear();
 1268|      0|                                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 1269|      0|                                saved_position_ = position_;
 1270|      0|                                ++input_ptr_;
 1271|      0|                                ++position_;
 1272|      0|                                state_ = json_parse_state::integer;
 1273|      0|                                parse_number(visitor, ec);
 1274|      0|                                if (ec) {return;}
  ------------------
  |  Branch (1274:37): [True: 0, False: 0]
  ------------------
 1275|      0|                                break;
 1276|      0|                            case 'n':
  ------------------
  |  Branch (1276:29): [True: 0, False: 0]
  ------------------
 1277|      0|                                parse_null(visitor, ec);
 1278|      0|                                if (ec) {return;}
  ------------------
  |  Branch (1278:37): [True: 0, False: 0]
  ------------------
 1279|      0|                                break;
 1280|      0|                            case 't':
  ------------------
  |  Branch (1280:29): [True: 0, False: 0]
  ------------------
 1281|      0|                                parse_true(visitor, ec);
 1282|      0|                                if (ec) {return;}
  ------------------
  |  Branch (1282:37): [True: 0, False: 0]
  ------------------
 1283|      0|                                break;
 1284|      0|                            case 'f':
  ------------------
  |  Branch (1284:29): [True: 0, False: 0]
  ------------------
 1285|      0|                                parse_false(visitor, ec);
 1286|      0|                                if (ec) {return;}
  ------------------
  |  Branch (1286:37): [True: 0, False: 0]
  ------------------
 1287|      0|                                break;
 1288|      0|                            case '\'':
  ------------------
  |  Branch (1288:29): [True: 0, False: 0]
  ------------------
 1289|      0|                                more_ = err_handler_(json_errc::single_quote, *this);
 1290|      0|                                if (!more_)
  ------------------
  |  Branch (1290:37): [True: 0, False: 0]
  ------------------
 1291|      0|                                {
 1292|      0|                                    ec = json_errc::single_quote;
 1293|      0|                                    return;
 1294|      0|                                }
 1295|      0|                                ++input_ptr_;
 1296|      0|                                ++position_;
 1297|      0|                                break;
 1298|      0|                            default:
  ------------------
  |  Branch (1298:29): [True: 0, False: 0]
  ------------------
 1299|      0|                                more_ = err_handler_(json_errc::expected_value, *this);
 1300|      0|                                if (!more_)
  ------------------
  |  Branch (1300:37): [True: 0, False: 0]
  ------------------
 1301|      0|                                {
 1302|      0|                                    ec = json_errc::expected_value;
 1303|      0|                                    return;
 1304|      0|                                }
 1305|      0|                                ++input_ptr_;
 1306|      0|                                ++position_;
 1307|      0|                                break;
 1308|      0|                            }
 1309|      0|                        }
 1310|      0|                    break;
 1311|   518k|                case json_parse_state::string: 
  ------------------
  |  Branch (1311:17): [True: 518k, False: 2.08M]
  ------------------
 1312|   518k|                case json_parse_state::escape: 
  ------------------
  |  Branch (1312:17): [True: 125, False: 2.60M]
  ------------------
 1313|   518k|                case json_parse_state::escape_u1: 
  ------------------
  |  Branch (1313:17): [True: 125, False: 2.60M]
  ------------------
 1314|   518k|                case json_parse_state::escape_u2: 
  ------------------
  |  Branch (1314:17): [True: 125, False: 2.60M]
  ------------------
 1315|   518k|                case json_parse_state::escape_u3: 
  ------------------
  |  Branch (1315:17): [True: 126, False: 2.60M]
  ------------------
 1316|   518k|                case json_parse_state::escape_u4: 
  ------------------
  |  Branch (1316:17): [True: 125, False: 2.60M]
  ------------------
 1317|   518k|                case json_parse_state::escape_expect_surrogate_pair1: 
  ------------------
  |  Branch (1317:17): [True: 156, False: 2.60M]
  ------------------
 1318|   518k|                case json_parse_state::escape_expect_surrogate_pair2: 
  ------------------
  |  Branch (1318:17): [True: 125, False: 2.60M]
  ------------------
 1319|   519k|                case json_parse_state::escape_u5: 
  ------------------
  |  Branch (1319:17): [True: 132, False: 2.60M]
  ------------------
 1320|   519k|                case json_parse_state::escape_u6: 
  ------------------
  |  Branch (1320:17): [True: 125, False: 2.60M]
  ------------------
 1321|   519k|                case json_parse_state::escape_u7: 
  ------------------
  |  Branch (1321:17): [True: 125, False: 2.60M]
  ------------------
 1322|   519k|                case json_parse_state::escape_u8: 
  ------------------
  |  Branch (1322:17): [True: 125, False: 2.60M]
  ------------------
 1323|   519k|                    parse_string(visitor, ec);
 1324|   519k|                    if (ec) return;
  ------------------
  |  Branch (1324:25): [True: 21, False: 519k]
  ------------------
 1325|   519k|                    break;
 1326|   519k|                case json_parse_state::minus:
  ------------------
  |  Branch (1326:17): [True: 1, False: 2.60M]
  ------------------
 1327|      2|                case json_parse_state::zero:  
  ------------------
  |  Branch (1327:17): [True: 1, False: 2.60M]
  ------------------
 1328|    646|                case json_parse_state::integer: 
  ------------------
  |  Branch (1328:17): [True: 644, False: 2.60M]
  ------------------
 1329|    647|                case json_parse_state::fraction1: 
  ------------------
  |  Branch (1329:17): [True: 1, False: 2.60M]
  ------------------
 1330|    792|                case json_parse_state::fraction2: 
  ------------------
  |  Branch (1330:17): [True: 145, False: 2.60M]
  ------------------
 1331|    796|                case json_parse_state::exp1: 
  ------------------
  |  Branch (1331:17): [True: 4, False: 2.60M]
  ------------------
 1332|    797|                case json_parse_state::exp2:  
  ------------------
  |  Branch (1332:17): [True: 1, False: 2.60M]
  ------------------
 1333|    983|                case json_parse_state::exp3: 
  ------------------
  |  Branch (1333:17): [True: 186, False: 2.60M]
  ------------------
 1334|    983|                    parse_number(visitor, ec);  
 1335|    983|                    if (ec) return;
  ------------------
  |  Branch (1335:25): [True: 3, False: 980]
  ------------------
 1336|    980|                    break;
 1337|    980|                case json_parse_state::t: 
  ------------------
  |  Branch (1337:17): [True: 34, False: 2.60M]
  ------------------
 1338|     34|                    switch (*input_ptr_)
 1339|     34|                    {
 1340|     24|                        case 'r':
  ------------------
  |  Branch (1340:25): [True: 24, False: 10]
  ------------------
 1341|     24|                            ++input_ptr_;
 1342|     24|                            ++position_;
 1343|     24|                            state_ = json_parse_state::tr;
 1344|     24|                            break;
 1345|     10|                        default:
  ------------------
  |  Branch (1345:25): [True: 10, False: 24]
  ------------------
 1346|     10|                            err_handler_(json_errc::invalid_value, *this);
 1347|     10|                            ec = json_errc::invalid_value;
 1348|     10|                            more_ = false;
 1349|     10|                            return;
 1350|     34|                    }
 1351|     24|                    break;
 1352|     24|                case json_parse_state::tr: 
  ------------------
  |  Branch (1352:17): [True: 23, False: 2.60M]
  ------------------
 1353|     23|                    switch (*input_ptr_)
 1354|     23|                    {
 1355|     12|                        case 'u':
  ------------------
  |  Branch (1355:25): [True: 12, False: 11]
  ------------------
 1356|     12|                            state_ = json_parse_state::tru;
 1357|     12|                            break;
 1358|     11|                        default:
  ------------------
  |  Branch (1358:25): [True: 11, False: 12]
  ------------------
 1359|     11|                            err_handler_(json_errc::invalid_value, *this);
 1360|     11|                            ec = json_errc::invalid_value;
 1361|     11|                            more_ = false;
 1362|     11|                            return;
 1363|     23|                    }
 1364|     12|                    ++input_ptr_;
 1365|     12|                    ++position_;
 1366|     12|                    break;
 1367|     11|                case json_parse_state::tru: 
  ------------------
  |  Branch (1367:17): [True: 11, False: 2.60M]
  ------------------
 1368|     11|                    switch (*input_ptr_)
 1369|     11|                    {
 1370|      1|                        case 'e':
  ------------------
  |  Branch (1370:25): [True: 1, False: 10]
  ------------------
 1371|      1|                            ++input_ptr_;
 1372|      1|                            ++position_;
 1373|      1|                            more_ = visitor.bool_value(true,  semantic_tag::none, *this, ec);
 1374|      1|                            if (parent() == json_parse_state::root)
  ------------------
  |  Branch (1374:33): [True: 1, False: 0]
  ------------------
 1375|      1|                            {
 1376|      1|                                state_ = json_parse_state::accept;
 1377|      1|                            }
 1378|      0|                            else
 1379|      0|                            {
 1380|      0|                                state_ = json_parse_state::expect_comma_or_end;
 1381|      0|                            }
 1382|      1|                            break;
 1383|     10|                        default:
  ------------------
  |  Branch (1383:25): [True: 10, False: 1]
  ------------------
 1384|     10|                            err_handler_(json_errc::invalid_value, *this);
 1385|     10|                            ec = json_errc::invalid_value;
 1386|     10|                            more_ = false;
 1387|     10|                            return;
 1388|     11|                    }
 1389|      1|                    break;
 1390|     49|                case json_parse_state::f: 
  ------------------
  |  Branch (1390:17): [True: 49, False: 2.60M]
  ------------------
 1391|     49|                    switch (*input_ptr_)
 1392|     49|                    {
 1393|     37|                        case 'a':
  ------------------
  |  Branch (1393:25): [True: 37, False: 12]
  ------------------
 1394|     37|                            ++input_ptr_;
 1395|     37|                            ++position_;
 1396|     37|                            state_ = json_parse_state::fa;
 1397|     37|                            break;
 1398|     12|                        default:
  ------------------
  |  Branch (1398:25): [True: 12, False: 37]
  ------------------
 1399|     12|                            err_handler_(json_errc::invalid_value, *this);
 1400|     12|                            ec = json_errc::invalid_value;
 1401|     12|                            more_ = false;
 1402|     12|                            return;
 1403|     49|                    }
 1404|     37|                    break;
 1405|     37|                case json_parse_state::fa: 
  ------------------
  |  Branch (1405:17): [True: 36, False: 2.60M]
  ------------------
 1406|     36|                    switch (*input_ptr_)
 1407|     36|                    {
 1408|     24|                        case 'l':
  ------------------
  |  Branch (1408:25): [True: 24, False: 12]
  ------------------
 1409|     24|                            state_ = json_parse_state::fal;
 1410|     24|                            break;
 1411|     12|                        default:
  ------------------
  |  Branch (1411:25): [True: 12, False: 24]
  ------------------
 1412|     12|                            err_handler_(json_errc::invalid_value, *this);
 1413|     12|                            ec = json_errc::invalid_value;
 1414|     12|                            more_ = false;
 1415|     12|                            return;
 1416|     36|                    }
 1417|     24|                    ++input_ptr_;
 1418|     24|                    ++position_;
 1419|     24|                    break;
 1420|     23|                case json_parse_state::fal: 
  ------------------
  |  Branch (1420:17): [True: 23, False: 2.60M]
  ------------------
 1421|     23|                    switch (*input_ptr_)
 1422|     23|                    {
 1423|     13|                        case 's':
  ------------------
  |  Branch (1423:25): [True: 13, False: 10]
  ------------------
 1424|     13|                            state_ = json_parse_state::fals;
 1425|     13|                            break;
 1426|     10|                        default:
  ------------------
  |  Branch (1426:25): [True: 10, False: 13]
  ------------------
 1427|     10|                            err_handler_(json_errc::invalid_value, *this);
 1428|     10|                            ec = json_errc::invalid_value;
 1429|     10|                            more_ = false;
 1430|     10|                            return;
 1431|     23|                    }
 1432|     13|                    ++input_ptr_;
 1433|     13|                    ++position_;
 1434|     13|                    break;
 1435|     12|                case json_parse_state::fals: 
  ------------------
  |  Branch (1435:17): [True: 12, False: 2.60M]
  ------------------
 1436|     12|                    switch (*input_ptr_)
 1437|     12|                    {
 1438|      1|                        case 'e':
  ------------------
  |  Branch (1438:25): [True: 1, False: 11]
  ------------------
 1439|      1|                            ++input_ptr_;
 1440|      1|                            ++position_;
 1441|      1|                            more_ = visitor.bool_value(false, semantic_tag::none, *this, ec);
 1442|      1|                            if (parent() == json_parse_state::root)
  ------------------
  |  Branch (1442:33): [True: 1, False: 0]
  ------------------
 1443|      1|                            {
 1444|      1|                                state_ = json_parse_state::accept;
 1445|      1|                            }
 1446|      0|                            else
 1447|      0|                            {
 1448|      0|                                state_ = json_parse_state::expect_comma_or_end;
 1449|      0|                            }
 1450|      1|                            break;
 1451|     11|                        default:
  ------------------
  |  Branch (1451:25): [True: 11, False: 1]
  ------------------
 1452|     11|                            err_handler_(json_errc::invalid_value, *this);
 1453|     11|                            ec = json_errc::invalid_value;
 1454|     11|                            more_ = false;
 1455|     11|                            return;
 1456|     12|                    }
 1457|      1|                    break;
 1458|     37|                case json_parse_state::n: 
  ------------------
  |  Branch (1458:17): [True: 37, False: 2.60M]
  ------------------
 1459|     37|                    switch (*input_ptr_)
 1460|     37|                    {
 1461|     25|                        case 'u':
  ------------------
  |  Branch (1461:25): [True: 25, False: 12]
  ------------------
 1462|     25|                            ++input_ptr_;
 1463|     25|                            ++position_;
 1464|     25|                            state_ = json_parse_state::nu;
 1465|     25|                            break;
 1466|     12|                        default:
  ------------------
  |  Branch (1466:25): [True: 12, False: 25]
  ------------------
 1467|     12|                            err_handler_(json_errc::invalid_value, *this);
 1468|     12|                            ec = json_errc::invalid_value;
 1469|     12|                            more_ = false;
 1470|     12|                            return;
 1471|     37|                    }
 1472|     25|                    break;
 1473|     25|                case json_parse_state::nu: 
  ------------------
  |  Branch (1473:17): [True: 24, False: 2.60M]
  ------------------
 1474|     24|                    switch (*input_ptr_)
 1475|     24|                    {
 1476|     13|                        case 'l':
  ------------------
  |  Branch (1476:25): [True: 13, False: 11]
  ------------------
 1477|     13|                            state_ = json_parse_state::nul;
 1478|     13|                            break;
 1479|     11|                        default:
  ------------------
  |  Branch (1479:25): [True: 11, False: 13]
  ------------------
 1480|     11|                            err_handler_(json_errc::invalid_value, *this);
 1481|     11|                            ec = json_errc::invalid_value;
 1482|     11|                            more_ = false;
 1483|     11|                            return;
 1484|     24|                    }
 1485|     13|                    ++input_ptr_;
 1486|     13|                    ++position_;
 1487|     13|                    break;
 1488|     12|                case json_parse_state::nul: 
  ------------------
  |  Branch (1488:17): [True: 12, False: 2.60M]
  ------------------
 1489|     12|                    ++position_;
 1490|     12|                    switch (*input_ptr_)
 1491|     12|                    {
 1492|      1|                    case 'l':
  ------------------
  |  Branch (1492:21): [True: 1, False: 11]
  ------------------
 1493|      1|                        more_ = visitor.null_value(semantic_tag::none, *this, ec);
 1494|      1|                        if (parent() == json_parse_state::root)
  ------------------
  |  Branch (1494:29): [True: 1, False: 0]
  ------------------
 1495|      1|                        {
 1496|      1|                            state_ = json_parse_state::accept;
 1497|      1|                        }
 1498|      0|                        else
 1499|      0|                        {
 1500|      0|                            state_ = json_parse_state::expect_comma_or_end;
 1501|      0|                        }
 1502|      1|                        break;
 1503|     11|                    default:
  ------------------
  |  Branch (1503:21): [True: 11, False: 1]
  ------------------
 1504|     11|                        err_handler_(json_errc::invalid_value, *this);
 1505|     11|                        ec = json_errc::invalid_value;
 1506|     11|                        more_ = false;
 1507|     11|                        return;
 1508|     12|                    }
 1509|      1|                    ++input_ptr_;
 1510|      1|                    break;
 1511|  4.13k|                case json_parse_state::slash: 
  ------------------
  |  Branch (1511:17): [True: 4.13k, False: 2.60M]
  ------------------
 1512|  4.13k|                {
 1513|  4.13k|                    switch (*input_ptr_)
 1514|  4.13k|                    {
 1515|    341|                    case '*':
  ------------------
  |  Branch (1515:21): [True: 341, False: 3.79k]
  ------------------
 1516|    341|                        state_ = json_parse_state::slash_star;
 1517|    341|                        more_ = err_handler_(json_errc::illegal_comment, *this);
 1518|    341|                        if (!more_)
  ------------------
  |  Branch (1518:29): [True: 0, False: 341]
  ------------------
 1519|      0|                        {
 1520|      0|                            ec = json_errc::illegal_comment;
 1521|      0|                            return;
 1522|      0|                        }
 1523|    341|                        break;
 1524|  3.79k|                    case '/':
  ------------------
  |  Branch (1524:21): [True: 3.79k, False: 342]
  ------------------
 1525|  3.79k|                        state_ = json_parse_state::slash_slash;
 1526|  3.79k|                        more_ = err_handler_(json_errc::illegal_comment, *this);
 1527|  3.79k|                        if (!more_)
  ------------------
  |  Branch (1527:29): [True: 0, False: 3.79k]
  ------------------
 1528|      0|                        {
 1529|      0|                            ec = json_errc::illegal_comment;
 1530|      0|                            return;
 1531|      0|                        }
 1532|  3.79k|                        break;
 1533|  3.79k|                    default:    
  ------------------
  |  Branch (1533:21): [True: 1, False: 4.13k]
  ------------------
 1534|      1|                        more_ = err_handler_(json_errc::syntax_error, *this);
 1535|      1|                        if (!more_)
  ------------------
  |  Branch (1535:29): [True: 1, False: 0]
  ------------------
 1536|      1|                        {
 1537|      1|                            ec = json_errc::syntax_error;
 1538|      1|                            return;
 1539|      1|                        }
 1540|      0|                        break;
 1541|  4.13k|                    }
 1542|  4.13k|                    ++input_ptr_;
 1543|  4.13k|                    ++position_;
 1544|  4.13k|                    break;
 1545|  4.13k|                }
 1546|  1.31M|                case json_parse_state::slash_star:  
  ------------------
  |  Branch (1546:17): [True: 1.31M, False: 1.28M]
  ------------------
 1547|  1.31M|                {
 1548|  1.31M|                    switch (*input_ptr_)
 1549|  1.31M|                    {
 1550|  13.0k|                        case '\r':
  ------------------
  |  Branch (1550:25): [True: 13.0k, False: 1.30M]
  ------------------
 1551|  13.0k|                            push_state(state_);
 1552|  13.0k|                            ++input_ptr_;
 1553|  13.0k|                            ++position_;
 1554|  13.0k|                            state_ = json_parse_state::cr;
 1555|  13.0k|                            break;
 1556|  16.1k|                        case '\n':
  ------------------
  |  Branch (1556:25): [True: 16.1k, False: 1.30M]
  ------------------
 1557|  16.1k|                            ++input_ptr_;
 1558|  16.1k|                            ++line_;
 1559|  16.1k|                            ++position_;
 1560|  16.1k|                            mark_position_ = position_;
 1561|  16.1k|                            break;
 1562|  1.42k|                        case '*':
  ------------------
  |  Branch (1562:25): [True: 1.42k, False: 1.31M]
  ------------------
 1563|  1.42k|                            ++input_ptr_;
 1564|  1.42k|                            ++position_;
 1565|  1.42k|                            state_ = json_parse_state::slash_star_star;
 1566|  1.42k|                            break;
 1567|  1.28M|                        default:
  ------------------
  |  Branch (1567:25): [True: 1.28M, False: 30.6k]
  ------------------
 1568|  1.28M|                            ++input_ptr_;
 1569|  1.28M|                            ++position_;
 1570|  1.28M|                            break;
 1571|  1.31M|                    }
 1572|  1.31M|                    break;
 1573|  1.31M|                }
 1574|  1.31M|                case json_parse_state::slash_slash: 
  ------------------
  |  Branch (1574:17): [True: 722k, False: 1.88M]
  ------------------
 1575|   722k|                {
 1576|   722k|                    switch (*input_ptr_)
 1577|   722k|                    {
 1578|  1.50k|                    case '\r':
  ------------------
  |  Branch (1578:21): [True: 1.50k, False: 721k]
  ------------------
 1579|  3.77k|                    case '\n':
  ------------------
  |  Branch (1579:21): [True: 2.26k, False: 720k]
  ------------------
 1580|  3.77k|                        state_ = pop_state();
 1581|  3.77k|                        break;
 1582|   718k|                    default:
  ------------------
  |  Branch (1582:21): [True: 718k, False: 3.77k]
  ------------------
 1583|   718k|                        ++input_ptr_;
 1584|   718k|                        ++position_;
 1585|   722k|                    }
 1586|   722k|                    break;
 1587|   722k|                }
 1588|   722k|                case json_parse_state::slash_star_star: 
  ------------------
  |  Branch (1588:17): [True: 1.41k, False: 2.60M]
  ------------------
 1589|  1.41k|                {
 1590|  1.41k|                    switch (*input_ptr_)
 1591|  1.41k|                    {
 1592|    273|                    case '/':
  ------------------
  |  Branch (1592:21): [True: 273, False: 1.14k]
  ------------------
 1593|    273|                        state_ = pop_state();
 1594|    273|                        break;
 1595|  1.14k|                    default:    
  ------------------
  |  Branch (1595:21): [True: 1.14k, False: 273]
  ------------------
 1596|  1.14k|                        state_ = json_parse_state::slash_star;
 1597|  1.14k|                        break;
 1598|  1.41k|                    }
 1599|  1.41k|                    ++input_ptr_;
 1600|  1.41k|                    ++position_;
 1601|  1.41k|                    break;
 1602|  1.41k|                }
 1603|      0|                default:
  ------------------
  |  Branch (1603:17): [True: 0, False: 2.60M]
  ------------------
 1604|      0|                    JSONCONS_ASSERT(false);
  ------------------
  |  |  378|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [Folded - Ignored]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1605|      0|                    break;
 1606|  2.60M|            }
 1607|  2.60M|        }
 1608|  8.32k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE17end_integer_valueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2641|    693|    {
 2642|    693|        if (string_buffer_[0] == '-')
  ------------------
  |  Branch (2642:13): [True: 327, False: 366]
  ------------------
 2643|    327|        {
 2644|    327|            end_negative_value(visitor, ec);
 2645|    327|        }
 2646|    366|        else
 2647|    366|        {
 2648|    366|            end_positive_value(visitor, ec);
 2649|    366|        }
 2650|    693|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE18end_negative_valueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2653|    327|    {
 2654|    327|        int64_t val;
 2655|    327|        auto result = jsoncons::detail::to_integer_unchecked(string_buffer_.data(), string_buffer_.length(), val);
 2656|    327|        if (result)
  ------------------
  |  Branch (2656:13): [True: 223, False: 104]
  ------------------
 2657|    223|        {
 2658|    223|            more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);
 2659|    223|        }
 2660|    104|        else // Must be overflow
 2661|    104|        {
 2662|    104|            more_ = visitor.string_value(string_buffer_, semantic_tag::bigint, *this, ec);
 2663|    104|        }
 2664|    327|        after_value(ec);
 2665|    327|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11after_valueERNS1_10error_codeE:
 2791|  1.87k|    {
 2792|  1.87k|        switch (parent())
 2793|  1.87k|        {
 2794|      0|        case json_parse_state::array:
  ------------------
  |  Branch (2794:9): [True: 0, False: 1.87k]
  ------------------
 2795|      0|        case json_parse_state::object:
  ------------------
  |  Branch (2795:9): [True: 0, False: 1.87k]
  ------------------
 2796|      0|            state_ = json_parse_state::expect_comma_or_end;
 2797|      0|            break;
 2798|  1.87k|        case json_parse_state::root:
  ------------------
  |  Branch (2798:9): [True: 1.87k, False: 0]
  ------------------
 2799|  1.87k|            state_ = json_parse_state::accept;
 2800|  1.87k|            break;
 2801|      0|        default:
  ------------------
  |  Branch (2801:9): [True: 0, False: 1.87k]
  ------------------
 2802|      0|            more_ = err_handler_(json_errc::syntax_error, *this);
 2803|      0|            if (!more_)
  ------------------
  |  Branch (2803:17): [True: 0, False: 0]
  ------------------
 2804|      0|            {
 2805|      0|                ec = json_errc::syntax_error;
 2806|      0|                return;
 2807|      0|            }
 2808|      0|            break;
 2809|  1.87k|        }
 2810|  1.87k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE18end_positive_valueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2668|    366|    {
 2669|    366|        uint64_t val;
 2670|    366|        auto result = jsoncons::detail::to_integer_unchecked(string_buffer_.data(), string_buffer_.length(), val);
 2671|    366|        if (result)
  ------------------
  |  Branch (2671:13): [True: 304, False: 62]
  ------------------
 2672|    304|        {
 2673|    304|            more_ = visitor.uint64_value(val, semantic_tag::none, *this, ec);
 2674|    304|        }
 2675|     62|        else // Must be overflow
 2676|     62|        {
 2677|     62|            more_ = visitor.string_value(string_buffer_, semantic_tag::bigint, *this, ec);
 2678|     62|        }
 2679|    366|        after_value(ec);
 2680|    366|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE18end_fraction_valueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2683|  1.18k|    {
 2684|  1.18k|        JSONCONS_TRY
  ------------------
  |  |  239|  1.18k|    #define JSONCONS_TRY try
  ------------------
 2685|  1.18k|        {
 2686|  1.18k|            if (options_.lossless_number())
  ------------------
  |  Branch (2686:17): [True: 0, False: 1.18k]
  ------------------
 2687|      0|            {
 2688|      0|                more_ = visitor.string_value(string_buffer_, semantic_tag::bigdec, *this, ec);
 2689|      0|            }
 2690|  1.18k|            else
 2691|  1.18k|            {
 2692|  1.18k|                double d = to_double_(string_buffer_.c_str(), string_buffer_.length());
 2693|  1.18k|                more_ = visitor.double_value(d, semantic_tag::none, *this, ec);
 2694|  1.18k|            }
 2695|  1.18k|        }
 2696|  1.18k|        JSONCONS_CATCH(...)
 2697|  1.18k|        {
 2698|      0|            more_ = err_handler_(json_errc::invalid_number, *this);
 2699|      0|            if (!more_)
  ------------------
  |  Branch (2699:17): [True: 0, False: 0]
  ------------------
 2700|      0|            {
 2701|      0|                ec = json_errc::invalid_number;
 2702|      0|                return;
 2703|      0|            }
 2704|      0|            more_ = visitor.null_value(semantic_tag::none, *this, ec); // recovery
 2705|      0|        }
 2706|       |
 2707|  1.18k|        after_value(ec);
 2708|  1.18k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE9pop_stateEv:
 2818|  23.0k|    {
 2819|  23.0k|        JSONCONS_ASSERT(!state_stack_.empty())
  ------------------
  |  |  378|  23.0k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 23.0k]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 2820|  23.0k|        json_parse_state state = state_stack_.back();
 2821|  23.0k|        state_stack_.pop_back();
 2822|  23.0k|        return state;
 2823|  23.0k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10push_stateENS_16json_parse_stateE:
 2813|  26.5k|    {
 2814|  26.5k|        state_stack_.push_back(state);
 2815|  26.5k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10skip_spaceEv:
  260|  6.77k|    {
  261|  6.77k|        const char_type* local_input_end = end_input_;
  262|  1.19M|        while (input_ptr_ != local_input_end) 
  ------------------
  |  Branch (262:16): [True: 1.19M, False: 122]
  ------------------
  263|  1.19M|        {
  264|  1.19M|            switch (*input_ptr_)
  265|  1.19M|            {
  266|  1.17M|                case ' ':
  ------------------
  |  Branch (266:17): [True: 1.17M, False: 20.9k]
  ------------------
  267|  1.18M|                case '\t':
  ------------------
  |  Branch (267:17): [True: 14.3k, False: 1.17M]
  ------------------
  268|  1.18M|                    ++input_ptr_;
  269|  1.18M|                    ++position_;
  270|  1.18M|                    break;
  271|  2.72k|                case '\r': 
  ------------------
  |  Branch (271:17): [True: 2.72k, False: 1.18M]
  ------------------
  272|  2.72k|                    push_state(state_);
  273|  2.72k|                    ++input_ptr_;
  274|  2.72k|                    ++position_;
  275|  2.72k|                    state_ = json_parse_state::cr;
  276|  2.72k|                    return; 
  277|  2.61k|                case '\n': 
  ------------------
  |  Branch (277:17): [True: 2.61k, False: 1.18M]
  ------------------
  278|  2.61k|                    ++input_ptr_;
  279|  2.61k|                    ++line_;
  280|  2.61k|                    ++position_;
  281|  2.61k|                    mark_position_ = position_;
  282|  2.61k|                    return;   
  283|  1.31k|                default:
  ------------------
  |  Branch (283:17): [True: 1.31k, False: 1.18M]
  ------------------
  284|  1.31k|                    return;
  285|  1.19M|            }
  286|  1.19M|        }
  287|  6.77k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE12begin_objectERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  332|      2|    {
  333|      2|        if (JSONCONS_UNLIKELY(++nesting_depth_ > options_.max_nesting_depth()))
  ------------------
  |  |   45|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  334|      0|        {
  335|      0|            more_ = err_handler_(json_errc::max_nesting_depth_exceeded, *this);
  336|      0|            if (!more_)
  ------------------
  |  Branch (336:17): [True: 0, False: 0]
  ------------------
  337|      0|            {
  338|      0|                ec = json_errc::max_nesting_depth_exceeded;
  339|      0|                return;
  340|      0|            }
  341|      0|        } 
  342|       |
  343|      2|        push_state(json_parse_state::object);
  344|      2|        state_ = json_parse_state::expect_member_name_or_end;
  345|      2|        more_ = visitor.begin_object(semantic_tag::none, *this, ec);
  346|      2|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11begin_arrayERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  389|      1|    {
  390|      1|        if (++nesting_depth_ > options_.max_nesting_depth())
  ------------------
  |  Branch (390:13): [True: 0, False: 1]
  ------------------
  391|      0|        {
  392|      0|            more_ = err_handler_(json_errc::max_nesting_depth_exceeded, *this);
  393|      0|            if (!more_)
  ------------------
  |  Branch (393:17): [True: 0, False: 0]
  ------------------
  394|      0|            {
  395|      0|                ec = json_errc::max_nesting_depth_exceeded;
  396|      0|                return;
  397|      0|            }
  398|      0|        }
  399|       |
  400|      1|        push_state(json_parse_state::array);
  401|      1|        state_ = json_parse_state::expect_value_or_end;
  402|      1|        more_ = visitor.begin_array(semantic_tag::none, *this, ec);
  403|      1|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE12parse_stringERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2125|   520k|    {
 2126|   520k|        const char_type* local_input_end = end_input_;
 2127|   520k|        const char_type* sb = input_ptr_;
 2128|       |
 2129|   520k|        switch (state_)
 2130|   520k|        {
 2131|   518k|            case json_parse_state::string:
  ------------------
  |  Branch (2131:13): [True: 518k, False: 1.41k]
  ------------------
 2132|   518k|                goto string_u1;
 2133|    125|            case json_parse_state::escape:
  ------------------
  |  Branch (2133:13): [True: 125, False: 520k]
  ------------------
 2134|    125|                goto escape;
 2135|    125|            case json_parse_state::escape_u1:
  ------------------
  |  Branch (2135:13): [True: 125, False: 520k]
  ------------------
 2136|    125|                goto escape_u1;
 2137|    125|            case json_parse_state::escape_u2:
  ------------------
  |  Branch (2137:13): [True: 125, False: 520k]
  ------------------
 2138|    125|                goto escape_u2;
 2139|    126|            case json_parse_state::escape_u3:
  ------------------
  |  Branch (2139:13): [True: 126, False: 520k]
  ------------------
 2140|    126|                goto escape_u3;
 2141|    125|            case json_parse_state::escape_u4:
  ------------------
  |  Branch (2141:13): [True: 125, False: 520k]
  ------------------
 2142|    125|                goto escape_u4;
 2143|    156|            case json_parse_state::escape_expect_surrogate_pair1:
  ------------------
  |  Branch (2143:13): [True: 156, False: 520k]
  ------------------
 2144|    156|                goto escape_expect_surrogate_pair1;
 2145|    125|            case json_parse_state::escape_expect_surrogate_pair2:
  ------------------
  |  Branch (2145:13): [True: 125, False: 520k]
  ------------------
 2146|    125|                goto escape_expect_surrogate_pair2;
 2147|    132|            case json_parse_state::escape_u5:
  ------------------
  |  Branch (2147:13): [True: 132, False: 520k]
  ------------------
 2148|    132|                goto escape_u5;
 2149|    125|            case json_parse_state::escape_u6:
  ------------------
  |  Branch (2149:13): [True: 125, False: 520k]
  ------------------
 2150|    125|                goto escape_u6;
 2151|    125|            case json_parse_state::escape_u7:
  ------------------
  |  Branch (2151:13): [True: 125, False: 520k]
  ------------------
 2152|    125|                goto escape_u7;
 2153|    125|            case json_parse_state::escape_u8:
  ------------------
  |  Branch (2153:13): [True: 125, False: 520k]
  ------------------
 2154|    125|                goto escape_u8;
 2155|      0|            default:
  ------------------
  |  Branch (2155:13): [True: 0, False: 520k]
  ------------------
 2156|      0|                JSONCONS_UNREACHABLE();               
  ------------------
  |  |   46|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 2157|   520k|        }
 2158|       |
 2159|  3.40M|string_u1:
 2160|  19.0M|        while (input_ptr_ < local_input_end)
  ------------------
  |  Branch (2160:16): [True: 19.0M, False: 599]
  ------------------
 2161|  19.0M|        {
 2162|  19.0M|            switch (*input_ptr_)
 2163|  19.0M|            {
 2164|    506|                JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   26|     12|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (26:9): [True: 2, False: 19.0M]
  |  |  |  Branch (26:19): [True: 2, False: 19.0M]
  |  |  |  Branch (26:29): [True: 1, False: 19.0M]
  |  |  |  Branch (26:39): [True: 1, False: 19.0M]
  |  |  |  Branch (26:49): [True: 1, False: 19.0M]
  |  |  |  Branch (26:59): [True: 1, False: 19.0M]
  |  |  |  Branch (26:69): [True: 1, False: 19.0M]
  |  |  |  Branch (26:79): [True: 1, False: 19.0M]
  |  |  |  Branch (26:89): [True: 1, False: 19.0M]
  |  |  |  Branch (26:99): [True: 1, False: 19.0M]
  |  |  ------------------
  |  |   27|     23|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (27:9): [True: 1, False: 19.0M]
  |  |  |  Branch (27:19): [True: 1, False: 19.0M]
  |  |  |  Branch (27:29): [True: 1, False: 19.0M]
  |  |  |  Branch (27:39): [True: 1, False: 19.0M]
  |  |  |  Branch (27:49): [True: 1, False: 19.0M]
  |  |  |  Branch (27:59): [True: 1, False: 19.0M]
  |  |  |  Branch (27:69): [True: 1, False: 19.0M]
  |  |  |  Branch (27:79): [True: 1, False: 19.0M]
  |  |  |  Branch (27:89): [True: 2, False: 19.0M]
  |  |  |  Branch (27:99): [True: 1, False: 19.0M]
  |  |  ------------------
  |  |   28|     33|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (28:9): [True: 1, False: 19.0M]
  |  |  |  Branch (28:19): [True: 1, False: 19.0M]
  |  |  |  Branch (28:29): [True: 1, False: 19.0M]
  |  |  |  Branch (28:39): [True: 1, False: 19.0M]
  |  |  |  Branch (28:49): [True: 1, False: 19.0M]
  |  |  |  Branch (28:59): [True: 1, False: 19.0M]
  |  |  |  Branch (28:69): [True: 2, False: 19.0M]
  |  |  |  Branch (28:79): [True: 1, False: 19.0M]
  |  |  ------------------
  ------------------
 2165|    506|                {
 2166|    506|                    position_ += (input_ptr_ - sb + 1);
 2167|    506|                    more_ = err_handler_(json_errc::illegal_control_character, *this);
 2168|    506|                    if (!more_)
  ------------------
  |  Branch (2168:25): [True: 33, False: 0]
  ------------------
 2169|     33|                    {
 2170|     33|                        ec = json_errc::illegal_control_character;
 2171|     33|                        state_ = json_parse_state::string;
 2172|     33|                        return;
 2173|     33|                    }
 2174|       |                    // recovery - skip
 2175|      0|                    string_buffer_.append(sb,input_ptr_-sb);
 2176|      0|                    ++input_ptr_;
 2177|      0|                    state_ = json_parse_state::string;
 2178|      0|                    return;
 2179|    506|                }
 2180|      1|                case '\r':
  ------------------
  |  Branch (2180:17): [True: 1, False: 19.0M]
  ------------------
 2181|      1|                {
 2182|      1|                    position_ += (input_ptr_ - sb + 1);
 2183|      1|                    more_ = err_handler_(json_errc::illegal_character_in_string, *this);
 2184|      1|                    if (!more_)
  ------------------
  |  Branch (2184:25): [True: 1, False: 0]
  ------------------
 2185|      1|                    {
 2186|      1|                        ec = json_errc::illegal_character_in_string;
 2187|      1|                        state_ = json_parse_state::string;
 2188|      1|                        return;
 2189|      1|                    }
 2190|       |                    // recovery - keep
 2191|      0|                    string_buffer_.append(sb, input_ptr_ - sb + 1);
 2192|      0|                    ++input_ptr_;
 2193|      0|                    push_state(state_);
 2194|      0|                    state_ = json_parse_state::cr;
 2195|      0|                    return;
 2196|      1|                }
 2197|      1|                case '\n':
  ------------------
  |  Branch (2197:17): [True: 1, False: 19.0M]
  ------------------
 2198|      1|                {
 2199|      1|                    ++line_;
 2200|      1|                    ++position_;
 2201|      1|                    mark_position_ = position_;
 2202|      1|                    more_ = err_handler_(json_errc::illegal_character_in_string, *this);
 2203|      1|                    if (!more_)
  ------------------
  |  Branch (2203:25): [True: 1, False: 0]
  ------------------
 2204|      1|                    {
 2205|      1|                        ec = json_errc::illegal_character_in_string;
 2206|      1|                        state_ = json_parse_state::string;
 2207|      1|                        return;
 2208|      1|                    }
 2209|       |                    // recovery - keep
 2210|      0|                    string_buffer_.append(sb, input_ptr_ - sb + 1);
 2211|      0|                    ++input_ptr_;
 2212|      0|                    return;
 2213|      1|                }
 2214|      1|                case '\t':
  ------------------
  |  Branch (2214:17): [True: 1, False: 19.0M]
  ------------------
 2215|      1|                {
 2216|      1|                    position_ += (input_ptr_ - sb + 1);
 2217|      1|                    more_ = err_handler_(json_errc::illegal_character_in_string, *this);
 2218|      1|                    if (!more_)
  ------------------
  |  Branch (2218:25): [True: 1, False: 0]
  ------------------
 2219|      1|                    {
 2220|      1|                        ec = json_errc::illegal_character_in_string;
 2221|      1|                        state_ = json_parse_state::string;
 2222|      1|                        return;
 2223|      1|                    }
 2224|       |                    // recovery - keep
 2225|      0|                    string_buffer_.append(sb, input_ptr_ - sb + 1);
 2226|      0|                    ++input_ptr_;
 2227|      0|                    state_ = json_parse_state::string;
 2228|      0|                    return;
 2229|      1|                }
 2230|  3.40M|                case '\\': 
  ------------------
  |  Branch (2230:17): [True: 3.40M, False: 15.6M]
  ------------------
 2231|  3.40M|                {
 2232|  3.40M|                    string_buffer_.append(sb,input_ptr_-sb);
 2233|  3.40M|                    position_ += (input_ptr_ - sb + 1);
 2234|  3.40M|                    ++input_ptr_;
 2235|  3.40M|                    goto escape;
 2236|      1|                }
 2237|    180|                case '\"':
  ------------------
  |  Branch (2237:17): [True: 180, False: 19.0M]
  ------------------
 2238|    180|                {
 2239|    180|                    position_ += (input_ptr_ - sb + 1);
 2240|    180|                    if (string_buffer_.length() == 0)
  ------------------
  |  Branch (2240:25): [True: 137, False: 43]
  ------------------
 2241|    137|                    {
 2242|    137|                        end_string_value(sb,input_ptr_-sb, visitor, ec);
 2243|    137|                        if (ec) {return;}
  ------------------
  |  Branch (2243:29): [True: 61, False: 76]
  ------------------
 2244|    137|                    }
 2245|     43|                    else
 2246|     43|                    {
 2247|     43|                        string_buffer_.append(sb,input_ptr_-sb);
 2248|     43|                        end_string_value(string_buffer_.data(),string_buffer_.length(), visitor, ec);
 2249|     43|                        if (ec) {return;}
  ------------------
  |  Branch (2249:29): [True: 26, False: 17]
  ------------------
 2250|     43|                    }
 2251|     93|                    ++input_ptr_;
 2252|     93|                    return;
 2253|    180|                }
 2254|  15.6M|            default:
  ------------------
  |  Branch (2254:13): [True: 15.6M, False: 3.40M]
  ------------------
 2255|  15.6M|                break;
 2256|  19.0M|            }
 2257|  15.6M|            ++input_ptr_;
 2258|  15.6M|        }
 2259|       |
 2260|       |        // Buffer exhausted               
 2261|    599|        {
 2262|    599|            string_buffer_.append(sb,input_ptr_-sb);
 2263|    599|            position_ += (input_ptr_ - sb);
 2264|    599|            state_ = json_parse_state::string;
 2265|    599|            return;
 2266|  3.40M|        }
 2267|       |
 2268|  3.40M|escape:
 2269|  3.40M|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|  3.40M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 141, False: 3.40M]
  |  |  ------------------
  ------------------
 2270|    141|        {
 2271|    141|            state_ = json_parse_state::escape;
 2272|    141|            return;
 2273|    141|        }
 2274|  3.40M|        switch (*input_ptr_)
 2275|  3.40M|        {
 2276|   815k|        case '\"':
  ------------------
  |  Branch (2276:9): [True: 815k, False: 2.59M]
  ------------------
 2277|   815k|            string_buffer_.push_back('\"');
 2278|   815k|            sb = ++input_ptr_;
 2279|   815k|            ++position_;
 2280|   815k|            goto string_u1;
 2281|  1.41M|        case '\\': 
  ------------------
  |  Branch (2281:9): [True: 1.41M, False: 1.98M]
  ------------------
 2282|  1.41M|            string_buffer_.push_back('\\');
 2283|  1.41M|            sb = ++input_ptr_;
 2284|  1.41M|            ++position_;
 2285|  1.41M|            goto string_u1;
 2286|    219|        case '/':
  ------------------
  |  Branch (2286:9): [True: 219, False: 3.40M]
  ------------------
 2287|    219|            string_buffer_.push_back('/');
 2288|    219|            sb = ++input_ptr_;
 2289|    219|            ++position_;
 2290|    219|            goto string_u1;
 2291|    289|        case 'b':
  ------------------
  |  Branch (2291:9): [True: 289, False: 3.40M]
  ------------------
 2292|    289|            string_buffer_.push_back('\b');
 2293|    289|            sb = ++input_ptr_;
 2294|    289|            ++position_;
 2295|    289|            goto string_u1;
 2296|    209|        case 'f':
  ------------------
  |  Branch (2296:9): [True: 209, False: 3.40M]
  ------------------
 2297|    209|            string_buffer_.push_back('\f');
 2298|    209|            sb = ++input_ptr_;
 2299|    209|            ++position_;
 2300|    209|            goto string_u1;
 2301|  2.68k|        case 'n':
  ------------------
  |  Branch (2301:9): [True: 2.68k, False: 3.40M]
  ------------------
 2302|  2.68k|            string_buffer_.push_back('\n');
 2303|  2.68k|            sb = ++input_ptr_;
 2304|  2.68k|            ++position_;
 2305|  2.68k|            goto string_u1;
 2306|    361|        case 'r':
  ------------------
  |  Branch (2306:9): [True: 361, False: 3.40M]
  ------------------
 2307|    361|            string_buffer_.push_back('\r');
 2308|    361|            sb = ++input_ptr_;
 2309|    361|            ++position_;
 2310|    361|            goto string_u1;
 2311|  1.38k|        case 't':
  ------------------
  |  Branch (2311:9): [True: 1.38k, False: 3.40M]
  ------------------
 2312|  1.38k|            string_buffer_.push_back('\t');
 2313|  1.38k|            sb = ++input_ptr_;
 2314|  1.38k|            ++position_;
 2315|  1.38k|            goto string_u1;
 2316|  1.16M|        case 'u':
  ------------------
  |  Branch (2316:9): [True: 1.16M, False: 2.23M]
  ------------------
 2317|  1.16M|             cp_ = 0;
 2318|  1.16M|             ++input_ptr_;
 2319|  1.16M|             ++position_;
 2320|  1.16M|             goto escape_u1;
 2321|      2|        default:    
  ------------------
  |  Branch (2321:9): [True: 2, False: 3.40M]
  ------------------
 2322|      2|            err_handler_(json_errc::illegal_escaped_character, *this);
 2323|      2|            ec = json_errc::illegal_escaped_character;
 2324|      2|            more_ = false;
 2325|      2|            state_ = json_parse_state::escape;
 2326|      2|            return;
 2327|  3.40M|        }
 2328|       |
 2329|  1.16M|escape_u1:
 2330|  1.16M|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|  1.16M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 141, False: 1.16M]
  |  |  ------------------
  ------------------
 2331|    141|        {
 2332|    141|            state_ = json_parse_state::escape_u1;
 2333|    141|            return;
 2334|    141|        }
 2335|  1.16M|        {
 2336|  1.16M|            cp_ = append_to_codepoint(0, *input_ptr_, ec);
 2337|  1.16M|            if (ec)
  ------------------
  |  Branch (2337:17): [True: 34, False: 1.16M]
  ------------------
 2338|     34|            {
 2339|     34|                state_ = json_parse_state::escape_u1;
 2340|     34|                return;
 2341|     34|            }
 2342|  1.16M|            ++input_ptr_;
 2343|  1.16M|            ++position_;
 2344|  1.16M|            goto escape_u2;
 2345|  1.16M|        }
 2346|       |
 2347|  1.16M|escape_u2:
 2348|  1.16M|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|  1.16M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 152, False: 1.16M]
  |  |  ------------------
  ------------------
 2349|    152|        {
 2350|    152|            state_ = json_parse_state::escape_u2;
 2351|    152|            return;
 2352|    152|        }
 2353|  1.16M|        {
 2354|  1.16M|            cp_ = append_to_codepoint(cp_, *input_ptr_, ec);
 2355|  1.16M|            if (ec)
  ------------------
  |  Branch (2355:17): [True: 2, False: 1.16M]
  ------------------
 2356|      2|            {
 2357|      2|                state_ = json_parse_state::escape_u2;
 2358|      2|                return;
 2359|      2|            }
 2360|  1.16M|            ++input_ptr_;
 2361|  1.16M|            ++position_;
 2362|  1.16M|            goto escape_u3;
 2363|  1.16M|        }
 2364|       |
 2365|  1.16M|escape_u3:
 2366|  1.16M|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|  1.16M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 149, False: 1.16M]
  |  |  ------------------
  ------------------
 2367|    149|        {
 2368|    149|            state_ = json_parse_state::escape_u3;
 2369|    149|            return;
 2370|    149|        }
 2371|  1.16M|        {
 2372|  1.16M|            cp_ = append_to_codepoint(cp_, *input_ptr_, ec);
 2373|  1.16M|            if (ec)
  ------------------
  |  Branch (2373:17): [True: 2, False: 1.16M]
  ------------------
 2374|      2|            {
 2375|      2|                state_ = json_parse_state::escape_u3;
 2376|      2|                return;
 2377|      2|            }
 2378|  1.16M|            ++input_ptr_;
 2379|  1.16M|            ++position_;
 2380|  1.16M|            goto escape_u4;
 2381|  1.16M|        }
 2382|       |
 2383|  1.16M|escape_u4:
 2384|  1.16M|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|  1.16M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 148, False: 1.16M]
  |  |  ------------------
  ------------------
 2385|    148|        {
 2386|    148|            state_ = json_parse_state::escape_u4;
 2387|    148|            return;
 2388|    148|        }
 2389|  1.16M|        {
 2390|  1.16M|            cp_ = append_to_codepoint(cp_, *input_ptr_, ec);
 2391|  1.16M|            if (ec)
  ------------------
  |  Branch (2391:17): [True: 1, False: 1.16M]
  ------------------
 2392|      1|            {
 2393|      1|                state_ = json_parse_state::escape_u4;
 2394|      1|                return;
 2395|      1|            }
 2396|  1.16M|            if (unicode_traits::is_high_surrogate(cp_))
  ------------------
  |  Branch (2396:17): [True: 651k, False: 517k]
  ------------------
 2397|   651k|            {
 2398|   651k|                ++input_ptr_;
 2399|   651k|                ++position_;
 2400|   651k|                goto escape_expect_surrogate_pair1;
 2401|   651k|            }
 2402|   517k|            else
 2403|   517k|            {
 2404|   517k|                unicode_traits::convert(&cp_, 1, string_buffer_);
 2405|   517k|                sb = ++input_ptr_;
 2406|   517k|                ++position_;
 2407|   517k|                state_ = json_parse_state::string;
 2408|   517k|                return;
 2409|   517k|            }
 2410|  1.16M|        }
 2411|       |
 2412|   651k|escape_expect_surrogate_pair1:
 2413|   651k|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|   651k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 187, False: 651k]
  |  |  ------------------
  ------------------
 2414|    187|        {
 2415|    187|            state_ = json_parse_state::escape_expect_surrogate_pair1;
 2416|    187|            return;
 2417|    187|        }
 2418|   651k|        {
 2419|   651k|            switch (*input_ptr_)
 2420|   651k|            {
 2421|   650k|            case '\\': 
  ------------------
  |  Branch (2421:13): [True: 650k, False: 10]
  ------------------
 2422|   650k|                cp2_ = 0;
 2423|   650k|                ++input_ptr_;
 2424|   650k|                ++position_;
 2425|   650k|                goto escape_expect_surrogate_pair2;
 2426|     10|            default:
  ------------------
  |  Branch (2426:13): [True: 10, False: 650k]
  ------------------
 2427|     10|                err_handler_(json_errc::expected_codepoint_surrogate_pair, *this);
 2428|     10|                ec = json_errc::expected_codepoint_surrogate_pair;
 2429|     10|                more_ = false;
 2430|     10|                state_ = json_parse_state::escape_expect_surrogate_pair1;
 2431|     10|                return;
 2432|   651k|            }
 2433|   651k|        }
 2434|       |
 2435|   651k|escape_expect_surrogate_pair2:
 2436|   651k|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|   651k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 145, False: 650k]
  |  |  ------------------
  ------------------
 2437|    145|        {
 2438|    145|            state_ = json_parse_state::escape_expect_surrogate_pair2;
 2439|    145|            return;
 2440|    145|        }
 2441|   650k|        {
 2442|   650k|            switch (*input_ptr_)
 2443|   650k|            {
 2444|   650k|            case 'u':
  ------------------
  |  Branch (2444:13): [True: 650k, False: 13]
  ------------------
 2445|   650k|                ++input_ptr_;
 2446|   650k|                ++position_;
 2447|   650k|                goto escape_u5;
 2448|     13|            default:
  ------------------
  |  Branch (2448:13): [True: 13, False: 650k]
  ------------------
 2449|     13|                err_handler_(json_errc::expected_codepoint_surrogate_pair, *this);
 2450|     13|                ec = json_errc::expected_codepoint_surrogate_pair;
 2451|     13|                more_ = false;
 2452|     13|                state_ = json_parse_state::escape_expect_surrogate_pair2;
 2453|     13|                return;
 2454|   650k|            }
 2455|   650k|        }
 2456|       |
 2457|   651k|escape_u5:
 2458|   651k|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|   651k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 151, False: 650k]
  |  |  ------------------
  ------------------
 2459|    151|        {
 2460|    151|            state_ = json_parse_state::escape_u5;
 2461|    151|            return;
 2462|    151|        }
 2463|   650k|        {
 2464|   650k|            cp2_ = append_to_codepoint(0, *input_ptr_, ec);
 2465|   650k|            if (ec)
  ------------------
  |  Branch (2465:17): [True: 1, False: 650k]
  ------------------
 2466|      1|            {
 2467|      1|                state_ = json_parse_state::escape_u5;
 2468|      1|                return;
 2469|      1|            }
 2470|   650k|        }
 2471|   650k|        ++input_ptr_;
 2472|   650k|        ++position_;
 2473|   650k|        goto escape_u6;
 2474|       |
 2475|   651k|escape_u6:
 2476|   651k|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|   651k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 145, False: 650k]
  |  |  ------------------
  ------------------
 2477|    145|        {
 2478|    145|            state_ = json_parse_state::escape_u6;
 2479|    145|            return;
 2480|    145|        }
 2481|   650k|        {
 2482|   650k|            cp2_ = append_to_codepoint(cp2_, *input_ptr_, ec);
 2483|   650k|            if (ec)
  ------------------
  |  Branch (2483:17): [True: 1, False: 650k]
  ------------------
 2484|      1|            {
 2485|      1|                state_ = json_parse_state::escape_u6;
 2486|      1|                return;
 2487|      1|            }
 2488|   650k|            ++input_ptr_;
 2489|   650k|            ++position_;
 2490|   650k|            goto escape_u7;
 2491|   650k|        }
 2492|       |
 2493|   651k|escape_u7:
 2494|   651k|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|   651k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 146, False: 650k]
  |  |  ------------------
  ------------------
 2495|    146|        {
 2496|    146|            state_ = json_parse_state::escape_u7;
 2497|    146|            return;
 2498|    146|        }
 2499|   650k|        {
 2500|   650k|            cp2_ = append_to_codepoint(cp2_, *input_ptr_, ec);
 2501|   650k|            if (ec)
  ------------------
  |  Branch (2501:17): [True: 2, False: 650k]
  ------------------
 2502|      2|            {
 2503|      2|                state_ = json_parse_state::escape_u7;
 2504|      2|                return;
 2505|      2|            }
 2506|   650k|            ++input_ptr_;
 2507|   650k|            ++position_;
 2508|   650k|            goto escape_u8;
 2509|   650k|        }
 2510|       |
 2511|   651k|escape_u8:
 2512|   651k|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|   651k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 144, False: 650k]
  |  |  ------------------
  ------------------
 2513|    144|        {
 2514|    144|            state_ = json_parse_state::escape_u8;
 2515|    144|            return;
 2516|    144|        }
 2517|   650k|        {
 2518|   650k|            cp2_ = append_to_codepoint(cp2_, *input_ptr_, ec);
 2519|   650k|            if (ec)
  ------------------
  |  Branch (2519:17): [True: 1, False: 650k]
  ------------------
 2520|      1|            {
 2521|      1|                state_ = json_parse_state::escape_u8;
 2522|      1|                return;
 2523|      1|            }
 2524|   650k|            uint32_t cp = 0x10000 + ((cp_ & 0x3FF) << 10) + (cp2_ & 0x3FF);
 2525|   650k|            unicode_traits::convert(&cp, 1, string_buffer_);
 2526|   650k|            sb = ++input_ptr_;
 2527|   650k|            ++position_;
 2528|   650k|            goto string_u1;
 2529|   650k|        }
 2530|       |
 2531|      0|        JSONCONS_UNREACHABLE();               
  ------------------
  |  |   46|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 2532|   650k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE16end_string_valueEPKcmRNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2711|    180|    {
 2712|    180|        string_view_type sv(s, length);
 2713|    180|        auto result = unicode_traits::validate(s, length);
 2714|    180|        if (result.ec != unicode_traits::conv_errc())
  ------------------
  |  Branch (2714:13): [True: 87, False: 93]
  ------------------
 2715|     87|        {
 2716|     87|            translate_conv_errc(result.ec,ec);
 2717|     87|            position_ += (result.ptr - s);
 2718|     87|            return;
 2719|     87|        }
 2720|     93|        switch (parent())
 2721|     93|        {
 2722|      0|        case json_parse_state::member_name:
  ------------------
  |  Branch (2722:9): [True: 0, False: 93]
  ------------------
 2723|      0|            more_ = visitor.key(sv, *this, ec);
 2724|      0|            pop_state();
 2725|      0|            state_ = json_parse_state::expect_colon;
 2726|      0|            break;
 2727|      0|        case json_parse_state::object:
  ------------------
  |  Branch (2727:9): [True: 0, False: 93]
  ------------------
 2728|      0|        case json_parse_state::array:
  ------------------
  |  Branch (2728:9): [True: 0, False: 93]
  ------------------
 2729|      0|        {
 2730|      0|            auto it = std::find_if(string_double_map_.begin(), string_double_map_.end(), string_maps_to_double{ sv });
 2731|      0|            if (it != string_double_map_.end())
  ------------------
  |  Branch (2731:17): [True: 0, False: 0]
  ------------------
 2732|      0|            {
 2733|      0|                more_ = visitor.double_value(it->second, semantic_tag::none, *this, ec);
 2734|      0|            }
 2735|      0|            else
 2736|      0|            {
 2737|      0|                more_ = visitor.string_value(sv, semantic_tag::none, *this, ec);
 2738|      0|            }
 2739|      0|            state_ = json_parse_state::expect_comma_or_end;
 2740|      0|            break;
 2741|      0|        }
 2742|     93|        case json_parse_state::root:
  ------------------
  |  Branch (2742:9): [True: 93, False: 0]
  ------------------
 2743|     93|        {
 2744|     93|            auto it = std::find_if(string_double_map_.begin(),string_double_map_.end(),string_maps_to_double{sv});
 2745|     93|            if (it != string_double_map_.end())
  ------------------
  |  Branch (2745:17): [True: 0, False: 93]
  ------------------
 2746|      0|            {
 2747|      0|                more_ = visitor.double_value(it->second, semantic_tag::none, *this, ec);
 2748|      0|            }
 2749|     93|            else
 2750|     93|            {
 2751|     93|                more_ = visitor.string_value(sv, semantic_tag::none, *this, ec);
 2752|     93|            }
 2753|     93|            state_ = json_parse_state::accept;
 2754|     93|            break;
 2755|      0|        }
 2756|      0|        default:
  ------------------
  |  Branch (2756:9): [True: 0, False: 93]
  ------------------
 2757|      0|            more_ = err_handler_(json_errc::syntax_error, *this);
 2758|      0|            if (!more_)
  ------------------
  |  Branch (2758:17): [True: 0, False: 0]
  ------------------
 2759|      0|            {
 2760|      0|                ec = json_errc::syntax_error;
 2761|      0|                return;
 2762|      0|            }
 2763|      0|            break;
 2764|     93|        }
 2765|     93|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE19translate_conv_errcENS_14unicode_traits9conv_errcERNS1_10error_codeE:
 2535|     87|    {
 2536|     87|        switch (result)
 2537|     87|        {
 2538|      0|        case unicode_traits::conv_errc():
  ------------------
  |  Branch (2538:9): [True: 0, False: 87]
  ------------------
 2539|      0|            break;
 2540|     27|        case unicode_traits::conv_errc::over_long_utf8_sequence:
  ------------------
  |  Branch (2540:9): [True: 27, False: 60]
  ------------------
 2541|     27|            more_ = err_handler_(json_errc::over_long_utf8_sequence, *this);
 2542|     27|            if (!more_)
  ------------------
  |  Branch (2542:17): [True: 27, False: 0]
  ------------------
 2543|     27|            {
 2544|     27|                ec = json_errc::over_long_utf8_sequence;
 2545|     27|                return;
 2546|     27|            }
 2547|      0|            break;
 2548|      0|        case unicode_traits::conv_errc::unpaired_high_surrogate:
  ------------------
  |  Branch (2548:9): [True: 0, False: 87]
  ------------------
 2549|      0|            more_ = err_handler_(json_errc::unpaired_high_surrogate, *this);
 2550|      0|            if (!more_)
  ------------------
  |  Branch (2550:17): [True: 0, False: 0]
  ------------------
 2551|      0|            {
 2552|      0|                ec = json_errc::unpaired_high_surrogate;
 2553|      0|                return;
 2554|      0|            }
 2555|      0|            break;
 2556|     25|        case unicode_traits::conv_errc::expected_continuation_byte:
  ------------------
  |  Branch (2556:9): [True: 25, False: 62]
  ------------------
 2557|     25|            more_ = err_handler_(json_errc::expected_continuation_byte, *this);
 2558|     25|            if (!more_)
  ------------------
  |  Branch (2558:17): [True: 25, False: 0]
  ------------------
 2559|     25|            {
 2560|     25|                ec = json_errc::expected_continuation_byte;
 2561|     25|                return;
 2562|     25|            }
 2563|      0|            break;
 2564|      0|        case unicode_traits::conv_errc::illegal_surrogate_value:
  ------------------
  |  Branch (2564:9): [True: 0, False: 87]
  ------------------
 2565|      0|            more_ = err_handler_(json_errc::illegal_surrogate_value, *this);
 2566|      0|            if (!more_)
  ------------------
  |  Branch (2566:17): [True: 0, False: 0]
  ------------------
 2567|      0|            {
 2568|      0|                ec = json_errc::illegal_surrogate_value;
 2569|      0|                return;
 2570|      0|            }
 2571|      0|            break;
 2572|     35|        default:
  ------------------
  |  Branch (2572:9): [True: 35, False: 52]
  ------------------
 2573|     35|            more_ = err_handler_(json_errc::illegal_codepoint, *this);
 2574|     35|            if (!more_)
  ------------------
  |  Branch (2574:17): [True: 35, False: 0]
  ------------------
 2575|     35|            {
 2576|     35|                ec = json_errc::illegal_codepoint;
 2577|     35|                return;
 2578|     35|            }
 2579|      0|            break;
 2580|     87|        }
 2581|     87|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE19append_to_codepointEjiRNS1_10error_codeE:
 2826|  7.27M|    {
 2827|  7.27M|        cp *= 16;
 2828|  7.27M|        if (c >= '0'  &&  c <= '9')
  ------------------
  |  Branch (2828:13): [True: 7.27M, False: 22]
  |  Branch (2828:27): [True: 2.01M, False: 5.26M]
  ------------------
 2829|  2.01M|        {
 2830|  2.01M|            cp += c - '0';
 2831|  2.01M|        }
 2832|  5.26M|        else if (c >= 'a'  &&  c <= 'f')
  ------------------
  |  Branch (2832:18): [True: 1.00M, False: 4.26M]
  |  Branch (2832:32): [True: 1.00M, False: 7]
  ------------------
 2833|  1.00M|        {
 2834|  1.00M|            cp += c - 'a' + 10;
 2835|  1.00M|        }
 2836|  4.26M|        else if (c >= 'A'  &&  c <= 'F')
  ------------------
  |  Branch (2836:18): [True: 4.26M, False: 27]
  |  Branch (2836:32): [True: 4.26M, False: 17]
  ------------------
 2837|  4.26M|        {
 2838|  4.26M|            cp += c - 'A' + 10;
 2839|  4.26M|        }
 2840|     44|        else
 2841|     44|        {
 2842|     44|            more_ = err_handler_(json_errc::invalid_unicode_escape_sequence, *this);
 2843|     44|            if (!more_)
  ------------------
  |  Branch (2843:17): [True: 44, False: 0]
  ------------------
 2844|     44|            {
 2845|     44|                ec = json_errc::invalid_unicode_escape_sequence;
 2846|     44|                return cp;
 2847|     44|            }
 2848|     44|        }
 2849|  7.27M|        return cp;
 2850|  7.27M|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE12parse_numberERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1716|  2.92k|    {
 1717|  2.92k|        const char_type* local_input_end = end_input_;
 1718|       |
 1719|  2.92k|        switch (state_)
 1720|  2.92k|        {
 1721|    362|            case json_parse_state::minus:
  ------------------
  |  Branch (1721:13): [True: 362, False: 2.56k]
  ------------------
 1722|    362|                goto minus_sign;
 1723|     75|            case json_parse_state::zero:
  ------------------
  |  Branch (1723:13): [True: 75, False: 2.85k]
  ------------------
 1724|     75|                goto zero;
 1725|  2.15k|            case json_parse_state::integer:
  ------------------
  |  Branch (1725:13): [True: 2.15k, False: 774]
  ------------------
 1726|  2.15k|                goto integer;
 1727|      1|            case json_parse_state::fraction1:
  ------------------
  |  Branch (1727:13): [True: 1, False: 2.92k]
  ------------------
 1728|      1|                goto fraction1;
 1729|    145|            case json_parse_state::fraction2:
  ------------------
  |  Branch (1729:13): [True: 145, False: 2.78k]
  ------------------
 1730|    145|                goto fraction2;
 1731|      4|            case json_parse_state::exp1:
  ------------------
  |  Branch (1731:13): [True: 4, False: 2.92k]
  ------------------
 1732|      4|                goto exp1;
 1733|      1|            case json_parse_state::exp2:
  ------------------
  |  Branch (1733:13): [True: 1, False: 2.92k]
  ------------------
 1734|      1|                goto exp2;
 1735|    186|            case json_parse_state::exp3:
  ------------------
  |  Branch (1735:13): [True: 186, False: 2.74k]
  ------------------
 1736|    186|                goto exp3;
 1737|      0|            default:
  ------------------
  |  Branch (1737:13): [True: 0, False: 2.92k]
  ------------------
 1738|      0|                JSONCONS_UNREACHABLE();               
  ------------------
  |  |   46|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1739|  2.92k|        }
 1740|    362|minus_sign:
 1741|    362|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|    362|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 3, False: 359]
  |  |  ------------------
  ------------------
 1742|      3|        {
 1743|      3|            state_ = json_parse_state::minus;
 1744|      3|            return;
 1745|      3|        }
 1746|    359|        switch (*input_ptr_)
 1747|    359|        {
 1748|      4|            case '0': 
  ------------------
  |  Branch (1748:13): [True: 4, False: 355]
  ------------------
 1749|      4|                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 1750|      4|                ++input_ptr_;
 1751|      4|                ++position_;
 1752|      4|                goto zero;
 1753|    353|            case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (1753:13): [True: 19, False: 340]
  |  Branch (1753:22): [True: 29, False: 330]
  |  Branch (1753:31): [True: 13, False: 346]
  |  Branch (1753:40): [True: 15, False: 344]
  |  Branch (1753:49): [True: 25, False: 334]
  |  Branch (1753:58): [True: 6, False: 353]
  |  Branch (1753:67): [True: 14, False: 345]
  |  Branch (1753:76): [True: 50, False: 309]
  |  Branch (1753:86): [True: 182, False: 177]
  ------------------
 1754|    353|                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 1755|    353|                ++input_ptr_;
 1756|    353|                ++position_;
 1757|    353|                goto integer;
 1758|      2|            default:
  ------------------
  |  Branch (1758:13): [True: 2, False: 357]
  ------------------
 1759|      2|                err_handler_(json_errc::invalid_number, *this);
 1760|      2|                ec = json_errc::expected_value;
 1761|      2|                more_ = false;
 1762|      2|                return;
 1763|    359|        }
 1764|     79|zero:
 1765|     79|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|     79|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 4, False: 75]
  |  |  ------------------
  ------------------
 1766|      4|        {
 1767|      4|            state_ = json_parse_state::zero;
 1768|      4|            return;
 1769|      4|        }
 1770|     75|        switch (*input_ptr_)
 1771|     75|        {
 1772|      1|            case '\r': 
  ------------------
  |  Branch (1772:13): [True: 1, False: 74]
  ------------------
 1773|      1|                end_integer_value(visitor, ec);
 1774|      1|                if (ec) return;
  ------------------
  |  Branch (1774:21): [True: 0, False: 1]
  ------------------
 1775|      1|                ++input_ptr_;
 1776|      1|                ++position_;
 1777|      1|                push_state(state_);
 1778|      1|                state_ = json_parse_state::cr;
 1779|      1|                return; 
 1780|      1|            case '\n': 
  ------------------
  |  Branch (1780:13): [True: 1, False: 74]
  ------------------
 1781|      1|                end_integer_value(visitor, ec);
 1782|      1|                if (ec) return;
  ------------------
  |  Branch (1782:21): [True: 0, False: 1]
  ------------------
 1783|      1|                ++input_ptr_;
 1784|      1|                ++line_;
 1785|      1|                ++position_;
 1786|      1|                mark_position_ = position_;
 1787|      1|                return;   
 1788|      3|            case ' ':case '\t':
  ------------------
  |  Branch (1788:13): [True: 2, False: 73]
  |  Branch (1788:22): [True: 1, False: 74]
  ------------------
 1789|      3|                end_integer_value(visitor, ec);
 1790|      3|                if (ec) return;
  ------------------
  |  Branch (1790:21): [True: 0, False: 3]
  ------------------
 1791|      3|                skip_space();
 1792|      3|                return;
 1793|      1|            case '/': 
  ------------------
  |  Branch (1793:13): [True: 1, False: 74]
  ------------------
 1794|      1|                end_integer_value(visitor, ec);
 1795|      1|                if (ec) return;
  ------------------
  |  Branch (1795:21): [True: 0, False: 1]
  ------------------
 1796|      1|                ++input_ptr_;
 1797|      1|                ++position_;
 1798|      1|                push_state(state_);
 1799|      1|                state_ = json_parse_state::slash;
 1800|      1|                return;
 1801|      2|            case '}':
  ------------------
  |  Branch (1801:13): [True: 2, False: 73]
  ------------------
 1802|      3|            case ']':
  ------------------
  |  Branch (1802:13): [True: 1, False: 74]
  ------------------
 1803|      3|                end_integer_value(visitor, ec);
 1804|      3|                if (ec) return;
  ------------------
  |  Branch (1804:21): [True: 0, False: 3]
  ------------------
 1805|      3|                state_ = json_parse_state::expect_comma_or_end;
 1806|      3|                return;
 1807|     35|            case '.':
  ------------------
  |  Branch (1807:13): [True: 35, False: 40]
  ------------------
 1808|     35|                string_buffer_.push_back(to_double_.get_decimal_point());
 1809|     35|                ++input_ptr_;
 1810|     35|                ++position_;
 1811|     35|                goto fraction1;
 1812|     17|            case 'e':case 'E':
  ------------------
  |  Branch (1812:13): [True: 10, False: 65]
  |  Branch (1812:22): [True: 7, False: 68]
  ------------------
 1813|     17|                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 1814|     17|                ++input_ptr_;
 1815|     17|                ++position_;
 1816|     17|                goto exp1;
 1817|      1|            case ',':
  ------------------
  |  Branch (1817:13): [True: 1, False: 74]
  ------------------
 1818|      1|                end_integer_value(visitor, ec);
 1819|      1|                if (ec) return;
  ------------------
  |  Branch (1819:21): [True: 0, False: 1]
  ------------------
 1820|      1|                begin_member_or_element(ec);
 1821|      1|                if (ec) return;
  ------------------
  |  Branch (1821:21): [True: 0, False: 1]
  ------------------
 1822|      1|                ++input_ptr_;
 1823|      1|                ++position_;
 1824|      1|                return;
 1825|     10|            case '0': case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (1825:13): [True: 1, False: 74]
  |  Branch (1825:23): [True: 1, False: 74]
  |  Branch (1825:32): [True: 1, False: 74]
  |  Branch (1825:41): [True: 1, False: 74]
  |  Branch (1825:50): [True: 1, False: 74]
  |  Branch (1825:59): [True: 1, False: 74]
  |  Branch (1825:68): [True: 1, False: 74]
  |  Branch (1825:77): [True: 1, False: 74]
  |  Branch (1825:86): [True: 1, False: 74]
  |  Branch (1825:96): [True: 1, False: 74]
  ------------------
 1826|     10|                err_handler_(json_errc::leading_zero, *this);
 1827|     10|                ec = json_errc::leading_zero;
 1828|     10|                more_ = false;
 1829|     10|                state_ = json_parse_state::zero;
 1830|     10|                return;
 1831|      3|            default:
  ------------------
  |  Branch (1831:13): [True: 3, False: 72]
  ------------------
 1832|      3|                err_handler_(json_errc::invalid_number, *this);
 1833|      3|                ec = json_errc::invalid_number;
 1834|      3|                more_ = false;
 1835|      3|                state_ = json_parse_state::zero;
 1836|      3|                return;
 1837|     75|        }
 1838|  11.2M|integer:
 1839|  11.2M|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|  11.2M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 1.29k, False: 11.2M]
  |  |  ------------------
  ------------------
 1840|  1.29k|        {
 1841|  1.29k|            state_ = json_parse_state::integer;
 1842|  1.29k|            return;
 1843|  1.29k|        }
 1844|  11.2M|        switch (*input_ptr_)
 1845|  11.2M|        {
 1846|      3|            case '\r': 
  ------------------
  |  Branch (1846:13): [True: 3, False: 11.2M]
  ------------------
 1847|      3|                end_integer_value(visitor, ec);
 1848|      3|                if (ec) return;
  ------------------
  |  Branch (1848:21): [True: 0, False: 3]
  ------------------
 1849|      3|                push_state(state_);
 1850|      3|                ++input_ptr_;
 1851|      3|                ++position_;
 1852|      3|                state_ = json_parse_state::cr;
 1853|      3|                return; 
 1854|      2|            case '\n': 
  ------------------
  |  Branch (1854:13): [True: 2, False: 11.2M]
  ------------------
 1855|      2|                end_integer_value(visitor, ec);
 1856|      2|                if (ec) return;
  ------------------
  |  Branch (1856:21): [True: 0, False: 2]
  ------------------
 1857|      2|                ++input_ptr_;
 1858|      2|                ++line_;
 1859|      2|                ++position_;
 1860|      2|                mark_position_ = position_;
 1861|      2|                return;   
 1862|     14|            case ' ':case '\t':
  ------------------
  |  Branch (1862:13): [True: 8, False: 11.2M]
  |  Branch (1862:22): [True: 6, False: 11.2M]
  ------------------
 1863|     14|                end_integer_value(visitor, ec);
 1864|     14|                if (ec) return;
  ------------------
  |  Branch (1864:21): [True: 0, False: 14]
  ------------------
 1865|     14|                skip_space();
 1866|     14|                return;
 1867|      6|            case '/': 
  ------------------
  |  Branch (1867:13): [True: 6, False: 11.2M]
  ------------------
 1868|      6|                end_integer_value(visitor, ec);
 1869|      6|                if (ec) return;
  ------------------
  |  Branch (1869:21): [True: 0, False: 6]
  ------------------
 1870|      6|                push_state(state_);
 1871|      6|                ++input_ptr_;
 1872|      6|                ++position_;
 1873|      6|                state_ = json_parse_state::slash;
 1874|      6|                return;
 1875|      3|            case '}':
  ------------------
  |  Branch (1875:13): [True: 3, False: 11.2M]
  ------------------
 1876|      7|            case ']':
  ------------------
  |  Branch (1876:13): [True: 4, False: 11.2M]
  ------------------
 1877|      7|                end_integer_value(visitor, ec);
 1878|      7|                if (ec) return;
  ------------------
  |  Branch (1878:21): [True: 0, False: 7]
  ------------------
 1879|      7|                state_ = json_parse_state::expect_comma_or_end;
 1880|      7|                return;
 1881|  11.2M|            case '0': case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (1881:13): [True: 10.9M, False: 334k]
  |  Branch (1881:23): [True: 74.9k, False: 11.2M]
  |  Branch (1881:32): [True: 10.4k, False: 11.2M]
  |  Branch (1881:41): [True: 7.78k, False: 11.2M]
  |  Branch (1881:50): [True: 14.4k, False: 11.2M]
  |  Branch (1881:59): [True: 9.43k, False: 11.2M]
  |  Branch (1881:68): [True: 10.2k, False: 11.2M]
  |  Branch (1881:77): [True: 149k, False: 11.1M]
  |  Branch (1881:86): [True: 45.3k, False: 11.2M]
  |  Branch (1881:96): [True: 10.6k, False: 11.2M]
  ------------------
 1882|  11.2M|                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 1883|  11.2M|                ++input_ptr_;
 1884|  11.2M|                ++position_;
 1885|  11.2M|                goto integer;
 1886|    459|            case '.':
  ------------------
  |  Branch (1886:13): [True: 459, False: 11.2M]
  ------------------
 1887|    459|                string_buffer_.push_back(to_double_.get_decimal_point());
 1888|    459|                ++input_ptr_;
 1889|    459|                ++position_;
 1890|    459|                goto fraction1;
 1891|    717|            case 'e':case 'E':
  ------------------
  |  Branch (1891:13): [True: 430, False: 11.2M]
  |  Branch (1891:22): [True: 287, False: 11.2M]
  ------------------
 1892|    717|                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 1893|    717|                ++input_ptr_;
 1894|    717|                ++position_;
 1895|    717|                goto exp1;
 1896|      2|            case ',':
  ------------------
  |  Branch (1896:13): [True: 2, False: 11.2M]
  ------------------
 1897|      2|                end_integer_value(visitor, ec);
 1898|      2|                if (ec) return;
  ------------------
  |  Branch (1898:21): [True: 0, False: 2]
  ------------------
 1899|      2|                begin_member_or_element(ec);
 1900|      2|                if (ec) return;
  ------------------
  |  Branch (1900:21): [True: 0, False: 2]
  ------------------
 1901|      2|                ++input_ptr_;
 1902|      2|                ++position_;
 1903|      2|                return;
 1904|      6|            default:
  ------------------
  |  Branch (1904:13): [True: 6, False: 11.2M]
  ------------------
 1905|      6|                err_handler_(json_errc::invalid_number, *this);
 1906|      6|                ec = json_errc::invalid_number;
 1907|      6|                more_ = false;
 1908|      6|                state_ = json_parse_state::integer;
 1909|      6|                return;
 1910|  11.2M|        }
 1911|    495|fraction1:
 1912|    495|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|    495|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 4, False: 491]
  |  |  ------------------
  ------------------
 1913|      4|        {
 1914|      4|            state_ = json_parse_state::fraction1;
 1915|      4|            return;
 1916|      4|        }
 1917|    491|        switch (*input_ptr_)
 1918|    491|        {
 1919|    477|            case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (1919:13): [True: 127, False: 364]
  |  Branch (1919:22): [True: 63, False: 428]
  |  Branch (1919:31): [True: 34, False: 457]
  |  Branch (1919:40): [True: 25, False: 466]
  |  Branch (1919:49): [True: 45, False: 446]
  |  Branch (1919:58): [True: 18, False: 473]
  |  Branch (1919:67): [True: 25, False: 466]
  |  Branch (1919:76): [True: 28, False: 463]
  |  Branch (1919:85): [True: 44, False: 447]
  |  Branch (1919:95): [True: 68, False: 423]
  ------------------
 1920|    477|                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 1921|    477|                ++input_ptr_;
 1922|    477|                ++position_;
 1923|    477|                goto fraction2;
 1924|     14|            default:
  ------------------
  |  Branch (1924:13): [True: 14, False: 477]
  ------------------
 1925|     14|                err_handler_(json_errc::invalid_number, *this);
 1926|     14|                ec = json_errc::invalid_number;
 1927|     14|                more_ = false;
 1928|     14|                state_ = json_parse_state::fraction1;
 1929|     14|                return;
 1930|    491|        }
 1931|  2.34M|fraction2:
 1932|  2.34M|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|  2.34M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 593, False: 2.34M]
  |  |  ------------------
  ------------------
 1933|    593|        {
 1934|    593|            state_ = json_parse_state::fraction2;
 1935|    593|            return;
 1936|    593|        }
 1937|  2.34M|        switch (*input_ptr_)
 1938|  2.34M|        {
 1939|      1|            case '\r': 
  ------------------
  |  Branch (1939:13): [True: 1, False: 2.34M]
  ------------------
 1940|      1|                end_fraction_value(visitor, ec);
 1941|      1|                if (ec) return;
  ------------------
  |  Branch (1941:21): [True: 0, False: 1]
  ------------------
 1942|      1|                push_state(state_);
 1943|      1|                ++input_ptr_;
 1944|      1|                ++position_;
 1945|      1|                state_ = json_parse_state::cr;
 1946|      1|                return; 
 1947|      1|            case '\n': 
  ------------------
  |  Branch (1947:13): [True: 1, False: 2.34M]
  ------------------
 1948|      1|                end_fraction_value(visitor, ec);
 1949|      1|                if (ec) return;
  ------------------
  |  Branch (1949:21): [True: 0, False: 1]
  ------------------
 1950|      1|                ++input_ptr_;
 1951|      1|                ++line_;
 1952|      1|                ++position_;
 1953|      1|                mark_position_ = position_;
 1954|      1|                return;   
 1955|      3|            case ' ':case '\t':
  ------------------
  |  Branch (1955:13): [True: 2, False: 2.34M]
  |  Branch (1955:22): [True: 1, False: 2.34M]
  ------------------
 1956|      3|                end_fraction_value(visitor, ec);
 1957|      3|                if (ec) return;
  ------------------
  |  Branch (1957:21): [True: 0, False: 3]
  ------------------
 1958|      3|                skip_space();
 1959|      3|                return;
 1960|      4|            case '/': 
  ------------------
  |  Branch (1960:13): [True: 4, False: 2.34M]
  ------------------
 1961|      4|                end_fraction_value(visitor, ec);
 1962|      4|                if (ec) return;
  ------------------
  |  Branch (1962:21): [True: 0, False: 4]
  ------------------
 1963|      4|                push_state(state_);
 1964|      4|                ++input_ptr_;
 1965|      4|                ++position_;
 1966|      4|                state_ = json_parse_state::slash;
 1967|      4|                return;
 1968|      1|            case '}':
  ------------------
  |  Branch (1968:13): [True: 1, False: 2.34M]
  ------------------
 1969|      1|                end_fraction_value(visitor, ec);
 1970|      1|                if (ec) return;
  ------------------
  |  Branch (1970:21): [True: 0, False: 1]
  ------------------
 1971|      1|                state_ = json_parse_state::expect_comma_or_end;
 1972|      1|                return;
 1973|      1|            case ']':
  ------------------
  |  Branch (1973:13): [True: 1, False: 2.34M]
  ------------------
 1974|      1|                end_fraction_value(visitor, ec);
 1975|      1|                if (ec) return;
  ------------------
  |  Branch (1975:21): [True: 0, False: 1]
  ------------------
 1976|      1|                state_ = json_parse_state::expect_comma_or_end;
 1977|      1|                return;
 1978|      1|            case ',':
  ------------------
  |  Branch (1978:13): [True: 1, False: 2.34M]
  ------------------
 1979|      1|                end_fraction_value(visitor, ec);
 1980|      1|                if (ec) return;
  ------------------
  |  Branch (1980:21): [True: 0, False: 1]
  ------------------
 1981|      1|                begin_member_or_element(ec);
 1982|      1|                if (ec) return;
  ------------------
  |  Branch (1982:21): [True: 0, False: 1]
  ------------------
 1983|      1|                ++input_ptr_;
 1984|      1|                ++position_;
 1985|      1|                return;
 1986|  2.34M|            case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (1986:13): [True: 2.32M, False: 19.3k]
  |  Branch (1986:22): [True: 2.60k, False: 2.34M]
  |  Branch (1986:31): [True: 1.55k, False: 2.34M]
  |  Branch (1986:40): [True: 879, False: 2.34M]
  |  Branch (1986:49): [True: 4.44k, False: 2.34M]
  |  Branch (1986:58): [True: 1.19k, False: 2.34M]
  |  Branch (1986:67): [True: 1.10k, False: 2.34M]
  |  Branch (1986:76): [True: 2.99k, False: 2.34M]
  |  Branch (1986:85): [True: 1.25k, False: 2.34M]
  |  Branch (1986:95): [True: 3.30k, False: 2.34M]
  ------------------
 1987|  2.34M|                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 1988|  2.34M|                ++input_ptr_;
 1989|  2.34M|                ++position_;
 1990|  2.34M|                goto fraction2;
 1991|     15|            case 'e':case 'E':
  ------------------
  |  Branch (1991:13): [True: 7, False: 2.34M]
  |  Branch (1991:22): [True: 8, False: 2.34M]
  ------------------
 1992|     15|                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 1993|     15|                ++input_ptr_;
 1994|     15|                ++position_;
 1995|     15|                goto exp1;
 1996|      2|            default:
  ------------------
  |  Branch (1996:13): [True: 2, False: 2.34M]
  ------------------
 1997|      2|                err_handler_(json_errc::invalid_number, *this);
 1998|      2|                ec = json_errc::invalid_number;
 1999|      2|                more_ = false;
 2000|      2|                state_ = json_parse_state::fraction2;
 2001|      2|                return;
 2002|  2.34M|        }
 2003|    753|exp1:
 2004|    753|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|    753|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 10, False: 743]
  |  |  ------------------
  ------------------
 2005|     10|        {
 2006|     10|            state_ = json_parse_state::exp1;
 2007|     10|            return;
 2008|     10|        }
 2009|    743|        switch (*input_ptr_)
 2010|    743|        {
 2011|      1|            case '+':
  ------------------
  |  Branch (2011:13): [True: 1, False: 742]
  ------------------
 2012|      1|                ++input_ptr_;
 2013|      1|                ++position_;
 2014|      1|                goto exp2;
 2015|    444|            case '-':
  ------------------
  |  Branch (2015:13): [True: 444, False: 299]
  ------------------
 2016|    444|                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 2017|    444|                ++input_ptr_;
 2018|    444|                ++position_;
 2019|    444|                goto exp2;
 2020|    294|            case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (2020:13): [True: 23, False: 720]
  |  Branch (2020:22): [True: 31, False: 712]
  |  Branch (2020:31): [True: 69, False: 674]
  |  Branch (2020:40): [True: 23, False: 720]
  |  Branch (2020:49): [True: 23, False: 720]
  |  Branch (2020:58): [True: 24, False: 719]
  |  Branch (2020:67): [True: 22, False: 721]
  |  Branch (2020:76): [True: 26, False: 717]
  |  Branch (2020:85): [True: 14, False: 729]
  |  Branch (2020:95): [True: 39, False: 704]
  ------------------
 2021|    294|                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 2022|    294|                ++input_ptr_;
 2023|    294|                ++position_;
 2024|    294|                goto exp3;
 2025|      4|            default:
  ------------------
  |  Branch (2025:13): [True: 4, False: 739]
  ------------------
 2026|      4|                err_handler_(json_errc::invalid_number, *this);
 2027|      4|                ec = json_errc::expected_value;
 2028|      4|                more_ = false;
 2029|      4|                state_ = json_parse_state::exp1;
 2030|      4|                return;
 2031|    743|        }
 2032|    446|exp2:
 2033|    446|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|    446|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 3, False: 443]
  |  |  ------------------
  ------------------
 2034|      3|        {
 2035|      3|            state_ = json_parse_state::exp2;
 2036|      3|            return;
 2037|      3|        }
 2038|    443|        switch (*input_ptr_)
 2039|    443|        {
 2040|    433|            case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (2040:13): [True: 1, False: 442]
  |  Branch (2040:22): [True: 6, False: 437]
  |  Branch (2040:31): [True: 16, False: 427]
  |  Branch (2040:40): [True: 386, False: 57]
  |  Branch (2040:49): [True: 4, False: 439]
  |  Branch (2040:58): [True: 7, False: 436]
  |  Branch (2040:67): [True: 4, False: 439]
  |  Branch (2040:76): [True: 1, False: 442]
  |  Branch (2040:85): [True: 4, False: 439]
  |  Branch (2040:95): [True: 4, False: 439]
  ------------------
 2041|    433|                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 2042|    433|                ++input_ptr_;
 2043|    433|                ++position_;
 2044|    433|                goto exp3;
 2045|     10|            default:
  ------------------
  |  Branch (2045:13): [True: 10, False: 433]
  ------------------
 2046|     10|                err_handler_(json_errc::invalid_number, *this);
 2047|     10|                ec = json_errc::expected_value;
 2048|     10|                more_ = false;
 2049|     10|                state_ = json_parse_state::exp2;
 2050|     10|                return;
 2051|    443|        }
 2052|       |        
 2053|  2.98M|exp3:
 2054|  2.98M|        if (JSONCONS_UNLIKELY(input_ptr_ >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   45|  2.98M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 901, False: 2.98M]
  |  |  ------------------
  ------------------
 2055|    901|        {
 2056|    901|            state_ = json_parse_state::exp3;
 2057|    901|            return;
 2058|    901|        }
 2059|  2.98M|        switch (*input_ptr_)
 2060|  2.98M|        {
 2061|      1|            case '\r': 
  ------------------
  |  Branch (2061:13): [True: 1, False: 2.98M]
  ------------------
 2062|      1|                end_fraction_value(visitor, ec);
 2063|      1|                if (ec) return;
  ------------------
  |  Branch (2063:21): [True: 0, False: 1]
  ------------------
 2064|      1|                ++input_ptr_;
 2065|      1|                ++position_;
 2066|      1|                push_state(state_);
 2067|      1|                state_ = json_parse_state::cr;
 2068|      1|                return; 
 2069|      1|            case '\n': 
  ------------------
  |  Branch (2069:13): [True: 1, False: 2.98M]
  ------------------
 2070|      1|                end_fraction_value(visitor, ec);
 2071|      1|                if (ec) return;
  ------------------
  |  Branch (2071:21): [True: 0, False: 1]
  ------------------
 2072|      1|                ++input_ptr_;
 2073|      1|                ++line_;
 2074|      1|                ++position_;
 2075|      1|                mark_position_ = position_;
 2076|      1|                return;   
 2077|      2|            case ' ':case '\t':
  ------------------
  |  Branch (2077:13): [True: 1, False: 2.98M]
  |  Branch (2077:22): [True: 1, False: 2.98M]
  ------------------
 2078|      2|                end_fraction_value(visitor, ec);
 2079|      2|                if (ec) return;
  ------------------
  |  Branch (2079:21): [True: 0, False: 2]
  ------------------
 2080|      2|                skip_space();
 2081|      2|                return;
 2082|      3|            case '/': 
  ------------------
  |  Branch (2082:13): [True: 3, False: 2.98M]
  ------------------
 2083|      3|                end_fraction_value(visitor, ec);
 2084|      3|                if (ec) return;
  ------------------
  |  Branch (2084:21): [True: 0, False: 3]
  ------------------
 2085|      3|                push_state(state_);
 2086|      3|                ++input_ptr_;
 2087|      3|                ++position_;
 2088|      3|                state_ = json_parse_state::slash;
 2089|      3|                return;
 2090|      1|            case '}':
  ------------------
  |  Branch (2090:13): [True: 1, False: 2.98M]
  ------------------
 2091|      1|                end_fraction_value(visitor, ec);
 2092|      1|                if (ec) return;
  ------------------
  |  Branch (2092:21): [True: 0, False: 1]
  ------------------
 2093|      1|                state_ = json_parse_state::expect_comma_or_end;
 2094|      1|                return;
 2095|      1|            case ']':
  ------------------
  |  Branch (2095:13): [True: 1, False: 2.98M]
  ------------------
 2096|      1|                end_fraction_value(visitor, ec);
 2097|      1|                if (ec) return;
  ------------------
  |  Branch (2097:21): [True: 0, False: 1]
  ------------------
 2098|      1|                state_ = json_parse_state::expect_comma_or_end;
 2099|      1|                return;
 2100|      1|            case ',':
  ------------------
  |  Branch (2100:13): [True: 1, False: 2.98M]
  ------------------
 2101|      1|                end_fraction_value(visitor, ec);
 2102|      1|                if (ec) return;
  ------------------
  |  Branch (2102:21): [True: 0, False: 1]
  ------------------
 2103|      1|                begin_member_or_element(ec);
 2104|      1|                if (ec) return;
  ------------------
  |  Branch (2104:21): [True: 0, False: 1]
  ------------------
 2105|      1|                ++input_ptr_;
 2106|      1|                ++position_;
 2107|      1|                return;
 2108|  2.98M|            case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (2108:13): [True: 2.95M, False: 31.5k]
  |  Branch (2108:22): [True: 2.22k, False: 2.98M]
  |  Branch (2108:31): [True: 1.63k, False: 2.98M]
  |  Branch (2108:40): [True: 1.86k, False: 2.98M]
  |  Branch (2108:49): [True: 2.89k, False: 2.98M]
  |  Branch (2108:58): [True: 1.14k, False: 2.98M]
  |  Branch (2108:67): [True: 1.77k, False: 2.98M]
  |  Branch (2108:76): [True: 5.20k, False: 2.97M]
  |  Branch (2108:85): [True: 14.4k, False: 2.97M]
  |  Branch (2108:95): [True: 407, False: 2.98M]
  ------------------
 2109|  2.98M|                string_buffer_.push_back(static_cast<char>(*input_ptr_));
 2110|  2.98M|                ++input_ptr_;
 2111|  2.98M|                ++position_;
 2112|  2.98M|                goto exp3;
 2113|      2|            default:
  ------------------
  |  Branch (2113:13): [True: 2, False: 2.98M]
  ------------------
 2114|      2|                err_handler_(json_errc::invalid_number, *this);
 2115|      2|                ec = json_errc::invalid_number;
 2116|      2|                more_ = false;
 2117|      2|                state_ = json_parse_state::exp3;
 2118|      2|                return;
 2119|  2.98M|        }
 2120|       |
 2121|      0|        JSONCONS_UNREACHABLE();               
  ------------------
  |  |   46|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 2122|  2.98M|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10parse_nullERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1646|     78|    {
 1647|     78|        saved_position_ = position_;
 1648|     78|        if (JSONCONS_LIKELY(end_input_ - input_ptr_ >= 4))
  ------------------
  |  |   44|     78|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (44:28): [True: 40, False: 38]
  |  |  ------------------
  ------------------
 1649|     40|        {
 1650|     40|            if (*(input_ptr_+1) == 'u' && *(input_ptr_+2) == 'l' && *(input_ptr_+3) == 'l')
  ------------------
  |  Branch (1650:17): [True: 17, False: 23]
  |  Branch (1650:43): [True: 15, False: 2]
  |  Branch (1650:69): [True: 1, False: 14]
  ------------------
 1651|      1|            {
 1652|      1|                input_ptr_ += 4;
 1653|      1|                position_ += 4;
 1654|      1|                more_ = visitor.null_value(semantic_tag::none, *this, ec);
 1655|      1|                if (parent() == json_parse_state::root)
  ------------------
  |  Branch (1655:21): [True: 1, False: 0]
  ------------------
 1656|      1|                {
 1657|      1|                    state_ = json_parse_state::accept;
 1658|      1|                }
 1659|      0|                else
 1660|      0|                {
 1661|      0|                    state_ = json_parse_state::expect_comma_or_end;
 1662|      0|                }
 1663|      1|            }
 1664|     39|            else
 1665|     39|            {
 1666|     39|                err_handler_(json_errc::invalid_value, *this);
 1667|     39|                ec = json_errc::invalid_value;
 1668|     39|                more_ = false;
 1669|     39|                return;
 1670|     39|            }
 1671|     40|        }
 1672|     38|        else
 1673|     38|        {
 1674|     38|            ++input_ptr_;
 1675|     38|            ++position_;
 1676|     38|            state_ = json_parse_state::n;
 1677|     38|        }
 1678|     78|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10parse_trueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1611|     83|    {
 1612|     83|        saved_position_ = position_;
 1613|     83|        if (JSONCONS_LIKELY(end_input_ - input_ptr_ >= 4))
  ------------------
  |  |   44|     83|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (44:28): [True: 48, False: 35]
  |  |  ------------------
  ------------------
 1614|     48|        {
 1615|     48|            if (*(input_ptr_+1) == 'r' && *(input_ptr_+2) == 'u' && *(input_ptr_+3) == 'e')
  ------------------
  |  Branch (1615:17): [True: 27, False: 21]
  |  Branch (1615:43): [True: 10, False: 17]
  |  Branch (1615:69): [True: 1, False: 9]
  ------------------
 1616|      1|            {
 1617|      1|                input_ptr_ += 4;
 1618|      1|                position_ += 4;
 1619|      1|                more_ = visitor.bool_value(true, semantic_tag::none, *this, ec);
 1620|      1|                if (parent() == json_parse_state::root)
  ------------------
  |  Branch (1620:21): [True: 1, False: 0]
  ------------------
 1621|      1|                {
 1622|      1|                    state_ = json_parse_state::accept;
 1623|      1|                }
 1624|      0|                else
 1625|      0|                {
 1626|      0|                    state_ = json_parse_state::expect_comma_or_end;
 1627|      0|                }
 1628|      1|            }
 1629|     47|            else
 1630|     47|            {
 1631|     47|                err_handler_(json_errc::invalid_value, *this);
 1632|     47|                ec = json_errc::invalid_value;
 1633|     47|                more_ = false;
 1634|     47|                return;
 1635|     47|            }
 1636|     48|        }
 1637|     35|        else
 1638|     35|        {
 1639|     35|            ++input_ptr_;
 1640|     35|            ++position_;
 1641|     35|            state_ = json_parse_state::t;
 1642|     35|        }
 1643|     83|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11parse_falseERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1681|     95|    {
 1682|     95|        saved_position_ = position_;
 1683|     95|        if (JSONCONS_LIKELY(end_input_ - input_ptr_ >= 5))
  ------------------
  |  |   44|     95|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (44:28): [True: 45, False: 50]
  |  |  ------------------
  ------------------
 1684|     45|        {
 1685|     45|            if (*(input_ptr_+1) == 'a' && *(input_ptr_+2) == 'l' && *(input_ptr_+3) == 's' && *(input_ptr_+4) == 'e')
  ------------------
  |  Branch (1685:17): [True: 40, False: 5]
  |  Branch (1685:43): [True: 27, False: 13]
  |  Branch (1685:69): [True: 15, False: 12]
  |  Branch (1685:95): [True: 1, False: 14]
  ------------------
 1686|      1|            {
 1687|      1|                input_ptr_ += 5;
 1688|      1|                position_ += 5;
 1689|      1|                more_ = visitor.bool_value(false, semantic_tag::none, *this, ec);
 1690|      1|                if (parent() == json_parse_state::root)
  ------------------
  |  Branch (1690:21): [True: 1, False: 0]
  ------------------
 1691|      1|                {
 1692|      1|                    state_ = json_parse_state::accept;
 1693|      1|                }
 1694|      0|                else
 1695|      0|                {
 1696|      0|                    state_ = json_parse_state::expect_comma_or_end;
 1697|      0|                }
 1698|      1|            }
 1699|     44|            else
 1700|     44|            {
 1701|     44|                err_handler_(json_errc::invalid_value, *this);
 1702|     44|                ec = json_errc::invalid_value;
 1703|     44|                more_ = false;
 1704|     44|                return;
 1705|     44|            }
 1706|     45|        }
 1707|     50|        else
 1708|     50|        {
 1709|     50|            ++input_ptr_;
 1710|     50|            ++position_;
 1711|     50|            state_ = json_parse_state::f;
 1712|     50|        }
 1713|     95|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10end_objectERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  349|      7|    {
  350|      7|        if (JSONCONS_UNLIKELY(nesting_depth_ < 1))
  ------------------
  |  |   45|      7|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 7, False: 0]
  |  |  ------------------
  ------------------
  351|      7|        {
  352|      7|            err_handler_(json_errc::unexpected_rbrace, *this);
  353|      7|            ec = json_errc::unexpected_rbrace;
  354|      7|            more_ = false;
  355|      7|            return;
  356|      7|        }
  357|      0|        --nesting_depth_;
  358|      0|        state_ = pop_state();
  359|      0|        if (state_ == json_parse_state::object)
  ------------------
  |  Branch (359:13): [True: 0, False: 0]
  ------------------
  360|      0|        {
  361|      0|            more_ = visitor.end_object(*this, ec);
  362|      0|        }
  363|      0|        else if (state_ == json_parse_state::array)
  ------------------
  |  Branch (363:18): [True: 0, False: 0]
  ------------------
  364|      0|        {
  365|      0|            err_handler_(json_errc::expected_comma_or_rbracket, *this);
  366|      0|            ec = json_errc::expected_comma_or_rbracket;
  367|      0|            more_ = false;
  368|      0|            return;
  369|      0|        }
  370|      0|        else
  371|      0|        {
  372|      0|            err_handler_(json_errc::unexpected_rbrace, *this);
  373|      0|            ec = json_errc::unexpected_rbrace;
  374|      0|            more_ = false;
  375|      0|            return;
  376|      0|        }
  377|       |
  378|      0|        if (parent() == json_parse_state::root)
  ------------------
  |  Branch (378:13): [True: 0, False: 0]
  ------------------
  379|      0|        {
  380|      0|            state_ = json_parse_state::accept;
  381|      0|        }
  382|      0|        else
  383|      0|        {
  384|      0|            state_ = json_parse_state::expect_comma_or_end;
  385|      0|        }
  386|      0|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE9end_arrayERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  406|      7|    {
  407|      7|        if (nesting_depth_ < 1)
  ------------------
  |  Branch (407:13): [True: 7, False: 0]
  ------------------
  408|      7|        {
  409|      7|            err_handler_(json_errc::unexpected_rbracket, *this);
  410|      7|            ec = json_errc::unexpected_rbracket;
  411|      7|            more_ = false;
  412|      7|            return;
  413|      7|        }
  414|      0|        --nesting_depth_;
  415|      0|        state_ = pop_state();
  416|      0|        if (state_ == json_parse_state::array)
  ------------------
  |  Branch (416:13): [True: 0, False: 0]
  ------------------
  417|      0|        {
  418|      0|            more_ = visitor.end_array(*this, ec);
  419|      0|        }
  420|      0|        else if (state_ == json_parse_state::object)
  ------------------
  |  Branch (420:18): [True: 0, False: 0]
  ------------------
  421|      0|        {
  422|      0|            err_handler_(json_errc::expected_comma_or_rbrace, *this);
  423|      0|            ec = json_errc::expected_comma_or_rbrace;
  424|      0|            more_ = false;
  425|      0|            return;
  426|      0|        }
  427|      0|        else
  428|      0|        {
  429|      0|            err_handler_(json_errc::unexpected_rbracket, *this);
  430|      0|            ec = json_errc::unexpected_rbracket;
  431|      0|            more_ = false;
  432|      0|            return;
  433|      0|        }
  434|      0|        if (parent() == json_parse_state::root)
  ------------------
  |  Branch (434:13): [True: 0, False: 0]
  ------------------
  435|      0|        {
  436|      0|            state_ = json_parse_state::accept;
  437|      0|        }
  438|      0|        else
  439|      0|        {
  440|      0|            state_ = json_parse_state::expect_comma_or_end;
  441|      0|        }
  442|      0|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE23begin_member_or_elementERNS1_10error_codeE:
 2768|      5|    {
 2769|      5|        switch (parent())
 2770|      5|        {
 2771|      0|        case json_parse_state::object:
  ------------------
  |  Branch (2771:9): [True: 0, False: 5]
  ------------------
 2772|      0|            state_ = json_parse_state::expect_member_name;
 2773|      0|            break;
 2774|      0|        case json_parse_state::array:
  ------------------
  |  Branch (2774:9): [True: 0, False: 5]
  ------------------
 2775|      0|            state_ = json_parse_state::expect_value;
 2776|      0|            break;
 2777|      5|        case json_parse_state::root:
  ------------------
  |  Branch (2777:9): [True: 5, False: 0]
  ------------------
 2778|      5|            break;
 2779|      0|        default:
  ------------------
  |  Branch (2779:9): [True: 0, False: 5]
  ------------------
 2780|      0|            more_ = err_handler_(json_errc::syntax_error, *this);
 2781|      0|            if (!more_)
  ------------------
  |  Branch (2781:17): [True: 0, False: 0]
  ------------------
 2782|      0|            {
 2783|      0|                ec = json_errc::syntax_error;
 2784|      0|                return;
 2785|      0|            }
 2786|      0|            break;
 2787|      5|        }
 2788|      5|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE6parentEv:
  209|  1.98k|    {
  210|  1.98k|        JSONCONS_ASSERT(state_stack_.size() >= 1);
  ------------------
  |  |  378|  1.98k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 1.98k]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  211|  1.98k|        return state_stack_.back();
  212|  1.98k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE5enterEv:
  220|  3.87k|    {
  221|  3.87k|        return state_ == json_parse_state::start;
  222|  3.87k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE6acceptEv:
  225|  3.76k|    {
  226|  3.76k|        return state_ == json_parse_state::accept || done_;
  ------------------
  |  Branch (226:16): [True: 1.81k, False: 1.95k]
  |  Branch (226:54): [True: 1.93k, False: 13]
  ------------------
  227|  3.76k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEEC2ERKNS_25basic_json_decode_optionsIcEENS1_8functionIFbNS_9json_errcERKNS_11ser_contextEEEERKS3_:
  179|  3.33k|    {
  180|  3.33k|        string_buffer_.reserve(initial_string_buffer_capacity_);
  181|       |
  182|  3.33k|        state_stack_.reserve(initial_stack_capacity_);
  183|  3.33k|        push_state(json_parse_state::root);
  184|       |
  185|  3.33k|        if (options_.enable_str_to_nan())
  ------------------
  |  Branch (185:13): [True: 0, False: 3.33k]
  ------------------
  186|      0|        {
  187|      0|            string_double_map_.emplace_back(options_.nan_to_str(),std::nan(""));
  188|      0|        }
  189|  3.33k|        if (options_.enable_str_to_inf())
  ------------------
  |  Branch (189:13): [True: 0, False: 3.33k]
  ------------------
  190|      0|        {
  191|      0|            string_double_map_.emplace_back(options_.inf_to_str(),std::numeric_limits<double>::infinity());
  192|      0|        }
  193|  3.33k|        if (options_.enable_str_to_neginf())
  ------------------
  |  Branch (193:13): [True: 0, False: 3.33k]
  ------------------
  194|      0|        {
  195|      0|            string_double_map_.emplace_back(options_.neginf_to_str(),-std::numeric_limits<double>::infinity());
  196|      0|        }
  197|  3.33k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE4doneEv:
  215|  8.64k|    {
  216|  8.64k|        return done_;
  217|  8.64k|    }

_ZN8jsoncons18basic_json_visitorIcED2Ev:
   38|  3.33k|        virtual ~basic_json_visitor() noexcept = default;
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  269|      1|        {
  270|      1|            return visit_begin_array(tag, context, ec);
  271|      1|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  251|      2|        {
  252|      2|            return visit_begin_object(tag, context, ec);
  253|      2|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
   41|  1.94k|        {
   42|  1.94k|            visit_flush();
   43|  1.94k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  343|    223|        {
  344|    223|            return visit_int64(value, tag, context, ec);
  345|    223|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNS_6detail17basic_string_viewIcNSt3__111char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS4_10error_codeE:
  307|    259|        {
  308|    259|            return visit_string(value, tag, context, ec);
  309|    259|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  335|    304|        {
  336|    304|            return visit_uint64(value, tag, context, ec);
  337|    304|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  359|  1.18k|        {
  360|  1.18k|            return visit_double(value, tag, context, ec);
  361|  1.18k|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  299|      4|        {
  300|      4|            return visit_bool(value, tag, context, ec);
  301|      4|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  291|      2|        {
  292|      2|            return visit_null(tag, context, ec);
  293|      2|        }
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
   36|  3.33k|        basic_json_visitor() = default;

_ZN8jsoncons11ser_contextD2Ev:
   15|  6.66k|    virtual ~ser_context() noexcept = default;

_ZN8jsoncons13stream_sourceIcED2Ev:
  121|  3.33k|        {
  122|  3.33k|        }
_ZNK8jsoncons13stream_sourceIcE3eofEv:
  148|  15.2k|        {
  149|  15.2k|            return buffer_length_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (149:20): [True: 15.2k, False: 0]
  |  Branch (149:43): [True: 8.91k, False: 6.38k]
  ------------------
  150|  15.2k|        }
_ZN8jsoncons13stream_sourceIcE11read_bufferEv:
  205|  6.38k|        {
  206|  6.38k|            if (buffer_length_ == 0)
  ------------------
  |  Branch (206:17): [True: 6.38k, False: 0]
  ------------------
  207|  6.38k|            {
  208|  6.38k|                fill_buffer();
  209|  6.38k|            }
  210|  6.38k|            const value_type* data = buffer_data_;
  211|  6.38k|            std::size_t length = buffer_length_;
  212|  6.38k|            buffer_data_ += buffer_length_;
  213|  6.38k|            position_ += buffer_length_;
  214|  6.38k|            buffer_length_ = 0;
  215|       |
  216|  6.38k|            return span<const value_type>(data, length);
  217|  6.38k|        }
_ZN8jsoncons13stream_sourceIcE11fill_bufferEv:
  276|  6.38k|        {
  277|  6.38k|            if (stream_ptr_->eof())
  ------------------
  |  Branch (277:17): [True: 0, False: 6.38k]
  ------------------
  278|      0|            {
  279|      0|                buffer_length_ = 0;
  280|      0|                return;
  281|      0|            }
  282|       |
  283|  6.38k|            buffer_data_ = buffer_.data();
  284|  6.38k|            JSONCONS_TRY
  ------------------
  |  |  239|  6.38k|    #define JSONCONS_TRY try
  ------------------
  285|  6.38k|            {
  286|  6.38k|                std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(buffer_.data()), buffer_.size());
  287|  6.38k|                buffer_length_ = static_cast<std::size_t>(count);
  288|       |
  289|  6.38k|                if (buffer_length_ < buffer_.size())
  ------------------
  |  Branch (289:21): [True: 3.32k, False: 3.06k]
  ------------------
  290|  3.32k|                {
  291|  3.32k|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  292|  3.32k|                }
  293|  6.38k|            }
  294|  6.38k|            JSONCONS_CATCH(const std::exception&)     
  295|  6.38k|            {
  296|      0|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  297|      0|                buffer_length_ = 0;
  298|      0|            }
  299|  6.38k|        }
_ZN8jsoncons13stream_sourceIcEC2ERNSt3__113basic_istreamIcNS2_11char_traitsIcEEEEm:
  101|  3.33k|        {
  102|  3.33k|        }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   48|  3.33k|        {
   49|  3.33k|        }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   36|  3.33k|            null_buffer() = default;

_ZN8jsoncons19json_source_adaptorINS_13stream_sourceIcEEE11read_bufferERNSt3__110error_codeE:
  118|  10.8k|        {
  119|  10.8k|            if (source_.eof())
  ------------------
  |  Branch (119:17): [True: 4.45k, False: 6.38k]
  ------------------
  120|  4.45k|            {
  121|  4.45k|                return span<const value_type>();
  122|  4.45k|            }
  123|       |
  124|  6.38k|            auto s = source_.read_buffer();
  125|  6.38k|            const value_type* data = s.data();
  126|  6.38k|            std::size_t length = s.size();
  127|       |
  128|  6.38k|            if (bof_ && length > 0)
  ------------------
  |  Branch (128:17): [True: 3.33k, False: 3.05k]
  |  Branch (128:25): [True: 3.33k, False: 0]
  ------------------
  129|  3.33k|            {
  130|  3.33k|                auto r = unicode_traits::detect_json_encoding(data, length);
  131|  3.33k|                if (!(r.encoding == unicode_traits::encoding_kind::utf8 || r.encoding == unicode_traits::encoding_kind::undetected))
  ------------------
  |  Branch (131:23): [True: 3.31k, False: 15]
  |  Branch (131:76): [True: 0, False: 15]
  ------------------
  132|     15|                {
  133|     15|                    ec = json_errc::illegal_unicode_character;
  134|     15|                    return span<const value_type>();
  135|     15|                }
  136|  3.31k|                length -= (r.ptr - data);
  137|  3.31k|                data = r.ptr;
  138|  3.31k|                bof_ = false;
  139|  3.31k|            }
  140|       |            
  141|  6.37k|            return span<const value_type>(data, length);           
  142|  6.38k|        }
_ZNK8jsoncons19json_source_adaptorINS_13stream_sourceIcEEE3eofEv:
  108|  4.46k|        {
  109|  4.46k|            return source_.eof();
  110|  4.46k|        }
_ZN8jsoncons19json_source_adaptorINS_13stream_sourceIcEEEC2IRNSt3__119basic_istringstreamIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEOT_:
  104|  3.33k|        {
  105|  3.33k|        }

_ZN8jsoncons18basic_staj_visitorIcE11visit_flushEv:
 1113|  1.94k|    {
 1114|  1.94k|    }
_ZN8jsoncons18basic_staj_visitorIcE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  854|      2|    {
  855|      2|        event_ = basic_staj_event<CharT>(staj_event_type::begin_object, tag);
  856|      2|        return !pred_(event_, context);
  857|      2|    }
_ZN8jsoncons16basic_staj_eventIcEC2ENS_15staj_event_typeENS_12semantic_tagE:
  164|  3.33k|    {
  165|  3.33k|    }
_ZN8jsoncons18basic_staj_visitorIcE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  872|      1|    {
  873|      1|        event_ = basic_staj_event<CharT>(staj_event_type::begin_array, tag);
  874|      1|        return !pred_(event_, context);
  875|      1|    }
_ZN8jsoncons16basic_staj_eventIcEC2ERKNS_6detail17basic_string_viewIcNSt3__111char_traitsIcEEEENS_15staj_event_typeENS_12semantic_tagE:
  211|    259|    {
  212|    259|        value_.string_data_ = s.data();
  213|    259|    }
_ZN8jsoncons18basic_staj_visitorIcE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  896|      2|    {
  897|      2|        event_ = basic_staj_event<CharT>(staj_event_type::null_value, tag);
  898|      2|        return !pred_(event_, context);
  899|      2|    }
_ZN8jsoncons18basic_staj_visitorIcE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  902|      4|    {
  903|      4|        event_ = basic_staj_event<CharT>(value, tag);
  904|      4|        return !pred_(event_, context);
  905|      4|    }
_ZN8jsoncons16basic_staj_eventIcEC2EbNS_12semantic_tagE:
  179|      4|    {
  180|      4|        value_.bool_value_ = value;
  181|      4|    }
_ZN8jsoncons18basic_staj_visitorIcE12visit_stringERKNS_6detail17basic_string_viewIcNSt3__111char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS4_10error_codeE:
  908|    259|    {
  909|    259|        event_ = basic_staj_event<CharT>(s, staj_event_type::string_value, tag);
  910|    259|        return !pred_(event_, context);
  911|    259|    }
_ZN8jsoncons18basic_staj_visitorIcE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  935|    304|    {
  936|    304|        event_ = basic_staj_event<CharT>(value, tag);
  937|    304|        return !pred_(event_, context);
  938|    304|    }
_ZN8jsoncons16basic_staj_eventIcEC2EmNS_12semantic_tagE:
  191|    304|    {
  192|    304|        value_.uint64_value_ = value;
  193|    304|    }
_ZN8jsoncons18basic_staj_visitorIcE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  944|    223|    {
  945|    223|        event_ = basic_staj_event<CharT>(value, tag);
  946|    223|        return !pred_(event_, context);
  947|    223|    }
_ZN8jsoncons16basic_staj_eventIcEC2ElNS_12semantic_tagE:
  185|    223|    {
  186|    223|        value_.int64_value_ = value;
  187|    223|    }
_ZN8jsoncons18basic_staj_visitorIcE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  962|  1.18k|    {
  963|  1.18k|        event_ = basic_staj_event<CharT>(value, tag);
  964|  1.18k|        return !pred_(event_, context);
  965|  1.18k|    }
_ZN8jsoncons16basic_staj_eventIcEC2EdNS_12semantic_tagE:
  203|  1.18k|    {
  204|  1.18k|        value_.double_value_ = value;
  205|  1.18k|    }
_ZN8jsoncons17basic_staj_cursorIcED2Ev:
 1124|  3.33k|    virtual ~basic_staj_cursor() noexcept = default;
_ZNK8jsoncons16basic_staj_eventIcE3tagEv:
  426|  1.97k|    semantic_tag tag() const noexcept { return tag_; }
_ZNK8jsoncons18basic_staj_visitorIcE5eventEv:
  563|  1.98k|    {
  564|  1.98k|        return event_;
  565|  1.98k|    }
_ZN8jsoncons18basic_staj_visitorIcEC2ENSt3__18functionIFbRKNS_16basic_staj_eventIcEERKNS_11ser_contextEEEE:
  550|  3.33k|    {
  551|  3.33k|    }
_ZNK8jsoncons16basic_staj_eventIcE3getINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEET_RNS3_10error_codeE:
  250|  1.98k|    {
  251|  1.98k|        return get_<T>(std::allocator<char>{}, ec);
  252|  1.98k|    }
_ZNK8jsoncons16basic_staj_eventIcE4get_INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES8_cEENS3_9enable_ifIXaasr16extension_traits9is_stringIT_EE5valuesr3std7is_sameINSB_10value_typeET1_EE5valueESB_E4typeET0_RNS3_10error_codeE:
  257|  1.98k|    {
  258|  1.98k|        switch (event_type_)
  259|  1.98k|        {
  260|      0|            case staj_event_type::key:
  ------------------
  |  Branch (260:13): [True: 0, False: 1.98k]
  ------------------
  261|    259|            case staj_event_type::string_value:
  ------------------
  |  Branch (261:13): [True: 259, False: 1.72k]
  ------------------
  262|    259|            {
  263|    259|                value_converter<jsoncons::basic_string_view<CharT>,T> converter;
  264|    259|                return converter.convert(jsoncons::basic_string_view<CharT>(value_.string_data_, length_), tag(), ec);
  265|      0|            }
  266|      0|            case staj_event_type::byte_string_value:
  ------------------
  |  Branch (266:13): [True: 0, False: 1.98k]
  ------------------
  267|      0|            {
  268|      0|                value_converter<jsoncons::byte_string_view,T> converter;
  269|      0|                return converter.convert(byte_string_view(value_.byte_string_data_,length_),tag(),ec);
  270|      0|            }
  271|    304|            case staj_event_type::uint64_value:
  ------------------
  |  Branch (271:13): [True: 304, False: 1.67k]
  ------------------
  272|    304|            {
  273|    304|                value_converter<uint64_t,T> converter;
  274|    304|                return converter.convert(value_.uint64_value_, tag(), ec);
  275|      0|            }
  276|    223|            case staj_event_type::int64_value:
  ------------------
  |  Branch (276:13): [True: 223, False: 1.75k]
  ------------------
  277|    223|            {
  278|    223|                value_converter<int64_t,T> converter;
  279|    223|                return converter.convert(value_.int64_value_, tag(), ec);
  280|      0|            }
  281|      0|            case staj_event_type::half_value:
  ------------------
  |  Branch (281:13): [True: 0, False: 1.98k]
  ------------------
  282|      0|            {
  283|      0|                value_converter<half_arg_t,T> converter;
  284|      0|                return converter.convert(value_.half_value_, tag(), ec);
  285|      0|            }
  286|  1.18k|            case staj_event_type::double_value:
  ------------------
  |  Branch (286:13): [True: 1.18k, False: 795]
  ------------------
  287|  1.18k|            {
  288|  1.18k|                value_converter<double,T> converter;
  289|  1.18k|                return converter.convert(value_.double_value_, tag(), ec);
  290|      0|            }
  291|      4|            case staj_event_type::bool_value:
  ------------------
  |  Branch (291:13): [True: 4, False: 1.97k]
  ------------------
  292|      4|            {
  293|      4|                value_converter<bool,T> converter;
  294|      4|                return converter.convert(value_.bool_value_,tag(),ec);
  295|      0|            }
  296|      2|            case staj_event_type::null_value:
  ------------------
  |  Branch (296:13): [True: 2, False: 1.97k]
  ------------------
  297|      2|            {
  298|      2|                value_converter<null_type,T> converter;
  299|      2|                return converter.convert(tag(), ec);
  300|      0|            }
  301|      3|            default:
  ------------------
  |  Branch (301:13): [True: 3, False: 1.97k]
  ------------------
  302|      3|            {
  303|      3|                ec = conv_errc::not_string;
  304|      3|                return T{};
  305|      0|            }
  306|  1.98k|        }
  307|  1.98k|    }

_ZN8jsoncons16typed_array_viewC2Ev:
   80|  3.33k|        {
   81|  3.33k|        }

_ZN8jsoncons14unicode_traits20detect_json_encodingIcEENSt3__19enable_ifIXsr16extension_traits8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m:
  105|  3.33k|    {
  106|  3.33k|        detect_encoding_result<CharT> r = detect_encoding_from_bom(data,length);
  107|  3.33k|        if (r.encoding != encoding_kind::undetected)
  ------------------
  |  Branch (107:13): [True: 14, False: 3.31k]
  ------------------
  108|     14|        {
  109|     14|            return r;
  110|     14|        }
  111|  3.31k|        else if (length < 4)
  ------------------
  |  Branch (111:18): [True: 456, False: 2.86k]
  ------------------
  112|    456|        {
  113|    456|            return detect_encoding_result<CharT>{data,encoding_kind::utf8};
  114|    456|        }
  115|  2.86k|        else if (*data == 0 && *(data+1) == 0 && *(data+2) == 0)
  ------------------
  |  Branch (115:18): [True: 27, False: 2.83k]
  |  Branch (115:32): [True: 16, False: 11]
  |  Branch (115:50): [True: 2, False: 14]
  ------------------
  116|      2|        {
  117|      2|            return detect_encoding_result<CharT>{data,encoding_kind::utf32be};
  118|      2|        }
  119|  2.85k|        else if (*data == 0 && *(data+2) == 0)
  ------------------
  |  Branch (119:18): [True: 25, False: 2.83k]
  |  Branch (119:32): [True: 1, False: 24]
  ------------------
  120|      1|        {
  121|      1|            return detect_encoding_result<CharT>{data,encoding_kind::utf16be};
  122|      1|        }
  123|  2.85k|        else if (*(data+1) == 0 && *(data+2) == 0 && *(data+3) == 0)
  ------------------
  |  Branch (123:18): [True: 31, False: 2.82k]
  |  Branch (123:36): [True: 9, False: 22]
  |  Branch (123:54): [True: 1, False: 8]
  ------------------
  124|      1|        {
  125|      1|            return detect_encoding_result<CharT>{data,encoding_kind::utf32le};
  126|      1|        }
  127|  2.85k|        else if (*(data+1) == 0 && *(data+3) == 0)
  ------------------
  |  Branch (127:18): [True: 30, False: 2.82k]
  |  Branch (127:36): [True: 6, False: 24]
  ------------------
  128|      6|        {
  129|      6|            return detect_encoding_result<CharT>{data,encoding_kind::utf16le};
  130|      6|        }
  131|  2.85k|        else
  132|  2.85k|        {
  133|  2.85k|            return detect_encoding_result<CharT>{data,encoding_kind::utf8};
  134|  2.85k|        }
  135|  3.33k|    }
_ZN8jsoncons14unicode_traits24detect_encoding_from_bomIcEENSt3__19enable_ifIXsr16extension_traits8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m:
   62|  3.33k|    {
   63|  3.33k|        const uint8_t bom_utf8[] = {0xef,0xbb,0xbf}; 
   64|  3.33k|        const uint8_t bom_utf16le[] = {0xff,0xfe}; 
   65|  3.33k|        const uint8_t bom_utf16be[] = {0xfe,0xff}; 
   66|  3.33k|        const uint8_t bom_utf32le[] = {0xff,0xfe,0x00,0x00}; 
   67|  3.33k|        const uint8_t bom_utf32be[] = {0x00,0x00,0xfe,0xff}; 
   68|       |
   69|  3.33k|        if (length >= 4 && !memcmp(data,bom_utf32le,4))
  ------------------
  |  Branch (69:13): [True: 2.87k, False: 459]
  |  Branch (69:28): [True: 1, False: 2.87k]
  ------------------
   70|      1|        {
   71|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32le};
   72|      1|        }
   73|  3.33k|        else if (length >= 4 && !memcmp(data,bom_utf32be,4))
  ------------------
  |  Branch (73:18): [True: 2.87k, False: 459]
  |  Branch (73:33): [True: 1, False: 2.87k]
  ------------------
   74|      1|        {
   75|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32be};
   76|      1|        }
   77|  3.32k|        else if (length >= 2 && !memcmp(data,bom_utf16le,2))
  ------------------
  |  Branch (77:18): [True: 3.27k, False: 54]
  |  Branch (77:33): [True: 2, False: 3.27k]
  ------------------
   78|      2|        {
   79|      2|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16le};
   80|      2|        }
   81|  3.32k|        else if (length >= 2 && !memcmp(data,bom_utf16be,2))
  ------------------
  |  Branch (81:18): [True: 3.27k, False: 54]
  |  Branch (81:33): [True: 1, False: 3.27k]
  ------------------
   82|      1|        {
   83|      1|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16be};
   84|      1|        }
   85|  3.32k|        else if (length >= 3 && !memcmp(data,bom_utf8,3))
  ------------------
  |  Branch (85:18): [True: 3.07k, False: 248]
  |  Branch (85:33): [True: 9, False: 3.06k]
  ------------------
   86|      9|        {
   87|      9|            return detect_encoding_result<CharT>{data+3,encoding_kind::utf8};
   88|      9|        }
   89|  3.31k|        else
   90|  3.31k|        {
   91|  3.31k|            return detect_encoding_result<CharT>{data,encoding_kind::undetected};
   92|  3.31k|        }
   93|  3.33k|    }
_ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr16extension_traits8is_char8IT_EE5valueENS0_14convert_resultIS4_EEE4typeEPKS4_m:
 1130|    180|    {
 1131|    180|        conv_errc  result = conv_errc();
 1132|    180|        const CharT* last = data + length;
 1133|  1.69M|        while (data != last) 
  ------------------
  |  Branch (1133:16): [True: 1.69M, False: 93]
  ------------------
 1134|  1.69M|        {
 1135|  1.69M|            std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[static_cast<uint8_t>(*data)]) + 1;
 1136|  1.69M|            if (len > (std::size_t)(last - data))
  ------------------
  |  Branch (1136:17): [True: 3, False: 1.69M]
  ------------------
 1137|      3|            {
 1138|      3|                return convert_result<CharT>{data, conv_errc::source_exhausted};
 1139|      3|            }
 1140|  1.69M|            if ((result=is_legal_utf8(data, len)) != conv_errc())
  ------------------
  |  Branch (1140:17): [True: 84, False: 1.69M]
  ------------------
 1141|     84|            {
 1142|     84|                return convert_result<CharT>{data,result} ;
 1143|     84|            }
 1144|  1.69M|            data += len;
 1145|  1.69M|        }
 1146|     93|        return convert_result<CharT>{data,result} ;
 1147|    180|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8IcEENSt3__19enable_ifIXsr16extension_traits8is_char8IT_EE5valueENS0_9conv_errcEE4typeEPKS4_m:
  299|  1.69M|    {
  300|  1.69M|        uint8_t a;
  301|  1.69M|        const CharT* srcptr = first+length;
  302|  1.69M|        switch (length) {
  303|     27|        default:
  ------------------
  |  Branch (303:9): [True: 27, False: 1.69M]
  ------------------
  304|     27|            return conv_errc::over_long_utf8_sequence;
  305|    413|        case 4:
  ------------------
  |  Branch (305:9): [True: 413, False: 1.69M]
  ------------------
  306|    413|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (306:17): [True: 5, False: 408]
  ------------------
  307|      5|                return conv_errc::expected_continuation_byte;
  308|    413|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|    408|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  309|    917|        case 3:
  ------------------
  |  Branch (309:9): [True: 509, False: 1.69M]
  ------------------
  310|    917|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (310:17): [True: 8, False: 909]
  ------------------
  311|      8|                return conv_errc::expected_continuation_byte;
  312|    917|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|    909|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  313|  1.23k|        case 2:
  ------------------
  |  Branch (313:9): [True: 329, False: 1.69M]
  ------------------
  314|  1.23k|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 12, False: 1.22k]
  ------------------
  315|     12|                return conv_errc::expected_continuation_byte;
  316|       |
  317|  1.22k|            switch (static_cast<uint8_t>(*first)) 
  318|  1.22k|            {
  319|       |                // no fall-through in this inner switch
  320|    255|                case 0xE0: if (a < 0xA0) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (320:17): [True: 255, False: 971]
  |  Branch (320:32): [True: 6, False: 249]
  ------------------
  321|    249|                case 0xED: if (a > 0x9F) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (321:17): [True: 232, False: 994]
  |  Branch (321:32): [True: 5, False: 227]
  ------------------
  322|    227|                case 0xF0: if (a < 0x90) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (322:17): [True: 206, False: 1.02k]
  |  Branch (322:32): [True: 5, False: 201]
  ------------------
  323|    201|                case 0xF4: if (a > 0x8F) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (323:17): [True: 200, False: 1.02k]
  |  Branch (323:32): [True: 1, False: 199]
  ------------------
  324|    333|                default:   if (a < 0x80) return conv_errc::source_illegal;
  ------------------
  |  Branch (324:17): [True: 333, False: 893]
  |  Branch (324:32): [True: 0, False: 333]
  ------------------
  325|  1.22k|            }
  326|       |
  327|  1.22k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|  1.20k|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  328|  1.69M|        case 1:
  ------------------
  |  Branch (328:9): [True: 1.69M, False: 1.27k]
  ------------------
  329|  1.69M|            if (static_cast<uint8_t>(*first) >= 0x80 && static_cast<uint8_t>(*first) < 0xC2)
  ------------------
  |  Branch (329:17): [True: 1.22k, False: 1.69M]
  |  Branch (329:57): [True: 14, False: 1.20k]
  ------------------
  330|     14|                return conv_errc::source_illegal;
  331|  1.69M|            break;
  332|  1.69M|        }
  333|  1.69M|        if (static_cast<uint8_t>(*first) > 0xF4) 
  ------------------
  |  Branch (333:13): [True: 1, False: 1.69M]
  ------------------
  334|      1|            return conv_errc::source_illegal;
  335|       |
  336|  1.69M|        return conv_errc();
  337|  1.69M|    }
_ZN8jsoncons14unicode_traits17is_high_surrogateEj:
  203|  1.16M|    {
  204|  1.16M|        return (ch >= sur_high_start && ch <= sur_high_end);
  ------------------
  |  Branch (204:17): [True: 662k, False: 506k]
  |  Branch (204:41): [True: 651k, False: 11.4k]
  ------------------
  205|  1.16M|    }
_ZN8jsoncons14unicode_traits7convertIjNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_9enable_ifIXaaaasr16extension_traits9is_char32IT_EE5valuesr16extension_traits18is_back_insertableIT0_EE5valuesr16extension_traits8is_char8INSB_10value_typeEEE5valueENS0_14convert_resultISA_EEE4typeEPKSA_mRSB_NS0_10conv_flagsE:
  963|  1.16M|    {
  964|  1.16M|        conv_errc  result = conv_errc();
  965|  1.16M|        const CharT* last = data + length;
  966|  2.32M|        while (data < last) 
  ------------------
  |  Branch (966:16): [True: 1.16M, False: 1.15M]
  ------------------
  967|  1.16M|        {
  968|  1.16M|            unsigned short bytes_to_write = 0;
  969|  1.16M|            const uint32_t byteMask = 0xBF;
  970|  1.16M|            const uint32_t byteMark = 0x80; 
  971|  1.16M|            uint32_t ch = *data++;
  972|  1.16M|            if (flags == conv_flags::strict ) 
  ------------------
  |  Branch (972:17): [True: 1.16M, False: 0]
  ------------------
  973|  1.16M|            {
  974|       |                /* UTF-16 surrogate values are illegal in UTF-32 */
  975|  1.16M|                if (is_surrogate(ch)) 
  ------------------
  |  Branch (975:21): [True: 10.6k, False: 1.15M]
  ------------------
  976|  10.6k|                {
  977|  10.6k|                    --data; /* return to the illegal value itself */
  978|  10.6k|                    result = conv_errc::illegal_surrogate_value;
  979|  10.6k|                    break;
  980|  10.6k|                }
  981|  1.16M|            }
  982|       |            /*
  983|       |             * Figure out how many bytes the result will require. Turn any
  984|       |             * illegally large UTF32 things (> Plane 17) into replacement chars.
  985|       |             */
  986|  1.15M|            if (ch < (uint32_t)0x80) {      bytes_to_write = 1;
  ------------------
  |  Branch (986:17): [True: 9.32k, False: 1.14M]
  ------------------
  987|  1.14M|            } else if (ch < (uint32_t)0x800) {     bytes_to_write = 2;
  ------------------
  |  Branch (987:24): [True: 1.97k, False: 1.14M]
  ------------------
  988|  1.14M|            } else if (ch < (uint32_t)0x10000) {   bytes_to_write = 3;
  ------------------
  |  Branch (988:24): [True: 495k, False: 650k]
  ------------------
  989|   650k|            } else if (ch <= max_legal_utf32) {  bytes_to_write = 4;
  ------------------
  |  Branch (989:24): [True: 650k, False: 0]
  ------------------
  990|   650k|            } else {                            
  991|      0|                bytes_to_write = 3;
  992|      0|                ch = replacement_char;
  993|      0|                result = conv_errc::source_illegal;
  994|      0|            }
  995|       |
  996|  1.15M|            uint8_t byte1 = 0;
  997|  1.15M|            uint8_t byte2 = 0;
  998|  1.15M|            uint8_t byte3 = 0;
  999|  1.15M|            uint8_t byte4 = 0;
 1000|       |
 1001|  1.15M|            switch (bytes_to_write) {
  ------------------
  |  Branch (1001:21): [True: 0, False: 1.15M]
  ------------------
 1002|   650k|            case 4:
  ------------------
  |  Branch (1002:13): [True: 650k, False: 507k]
  ------------------
 1003|   650k|                byte4 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1004|   650k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|   650k|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
 1005|  1.14M|            case 3:
  ------------------
  |  Branch (1005:13): [True: 495k, False: 662k]
  ------------------
 1006|  1.14M|                byte3 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1007|  1.14M|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|  1.14M|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
 1008|  1.14M|            case 2:
  ------------------
  |  Branch (1008:13): [True: 1.97k, False: 1.15M]
  ------------------
 1009|  1.14M|                byte2 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1010|  1.14M|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|  1.14M|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
 1011|  1.15M|            case 1:
  ------------------
  |  Branch (1011:13): [True: 9.32k, False: 1.14M]
  ------------------
 1012|  1.15M|                byte1 = (uint8_t) (ch | first_byte_mark[bytes_to_write]);
 1013|  1.15M|                break;
 1014|  1.15M|            }
 1015|       |
 1016|  1.15M|            switch (bytes_to_write) 
  ------------------
  |  Branch (1016:21): [True: 0, False: 1.15M]
  ------------------
 1017|  1.15M|            {
 1018|   650k|            case 4: 
  ------------------
  |  Branch (1018:13): [True: 650k, False: 507k]
  ------------------
 1019|   650k|                target.push_back(byte1);
 1020|   650k|                target.push_back(byte2);
 1021|   650k|                target.push_back(byte3);
 1022|   650k|                target.push_back(byte4);
 1023|   650k|                break;
 1024|   495k|            case 3: 
  ------------------
  |  Branch (1024:13): [True: 495k, False: 662k]
  ------------------
 1025|   495k|                target.push_back(byte1);
 1026|   495k|                target.push_back(byte2);
 1027|   495k|                target.push_back(byte3);
 1028|   495k|                break;
 1029|  1.97k|            case 2: 
  ------------------
  |  Branch (1029:13): [True: 1.97k, False: 1.15M]
  ------------------
 1030|  1.97k|                target.push_back(byte1);
 1031|  1.97k|                target.push_back(byte2);
 1032|  1.97k|                break;
 1033|  9.32k|            case 1: 
  ------------------
  |  Branch (1033:13): [True: 9.32k, False: 1.14M]
  ------------------
 1034|  9.32k|                target.push_back(byte1);
 1035|  9.32k|                break;
 1036|  1.15M|            }
 1037|  1.15M|        }
 1038|  1.16M|        return convert_result<CharT>{data,result} ;
 1039|  1.16M|    }
_ZN8jsoncons14unicode_traits12is_surrogateEj:
  215|  1.16M|    {
  216|  1.16M|        return (ch >= sur_high_start && ch <= sur_low_end);
  ------------------
  |  Branch (216:17): [True: 662k, False: 506k]
  |  Branch (216:41): [True: 10.6k, False: 651k]
  ------------------
  217|  1.16M|    }

_ZN8jsoncons20value_converter_baseINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERKS6_:
   36|  1.97k|        {
   37|  1.97k|        }
_ZN8jsoncons15value_converterINS_6detail17basic_string_viewIcNSt3__111char_traitsIcEEEENS3_12basic_stringIcS5_NS3_9allocatorIcEEEEvE7convertERKS6_NS_12semantic_tagERNS3_10error_codeE:
  131|    259|        {
  132|    259|            return Into(value.begin(),value.end(),this->get_allocator());
  133|    259|        }
_ZNK8jsoncons20value_converter_baseINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE13get_allocatorEv:
   40|  1.97k|        {
   41|  1.97k|            return alloc_;
   42|  1.97k|        }
_ZN8jsoncons15value_converterImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEvE7convertEmNS_12semantic_tagERNS1_10error_codeE:
  257|    304|        {
  258|    304|            Into s(this->get_allocator());
  259|    304|            jsoncons::detail::from_integer(value, s);
  260|    304|            return s;
  261|    304|        }
_ZN8jsoncons15value_converterIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEvE7convertElNS_12semantic_tagERNS1_10error_codeE:
  257|    223|        {
  258|    223|            Into s(this->get_allocator());
  259|    223|            jsoncons::detail::from_integer(value, s);
  260|    223|            return s;
  261|    223|        }
_ZN8jsoncons15value_converterIdNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEvE7convertEdNS_12semantic_tagERNS1_10error_codeE:
  274|  1.18k|        {
  275|  1.18k|            Into s(this->get_allocator());
  276|  1.18k|            jsoncons::detail::write_double f{float_chars_format::general,0};
  277|  1.18k|            f(value, s);
  278|  1.18k|            return s;
  279|  1.18k|        }
_ZN8jsoncons15value_converterIbNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEvE7convertEbNS_12semantic_tagERNS1_10error_codeE:
  312|      4|        {
  313|      4|            constexpr const char_type* true_constant = JSONCONS_CSTRING_CONSTANT(char_type,"true"); 
  ------------------
  |  |  295|      4|#define JSONCONS_CSTRING_CONSTANT(CharT, Str) cstring_constant_of_type<CharT>(Str, JSONCONS_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  293|      4|#define JSONCONS_WIDEN(A) JSONCONS_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  291|      4|#define JSONCONS_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  314|      4|            constexpr const char_type* false_constant = JSONCONS_CSTRING_CONSTANT(char_type,"false"); 
  ------------------
  |  |  295|      4|#define JSONCONS_CSTRING_CONSTANT(CharT, Str) cstring_constant_of_type<CharT>(Str, JSONCONS_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  293|      4|#define JSONCONS_WIDEN(A) JSONCONS_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  291|      4|#define JSONCONS_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  315|       |
  316|      4|            return value ? Into(true_constant,4) : Into(false_constant,5);
  ------------------
  |  Branch (316:20): [True: 2, False: 2]
  ------------------
  317|      4|        }
_ZN8jsoncons15value_converterINS_9null_typeENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvE7convertENS_12semantic_tagERNS2_10error_codeE:
  330|      2|        {
  331|      2|            constexpr const char_type* null_constant = JSONCONS_CSTRING_CONSTANT(char_type,"null"); 
  ------------------
  |  |  295|      2|#define JSONCONS_CSTRING_CONSTANT(CharT, Str) cstring_constant_of_type<CharT>(Str, JSONCONS_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  293|      2|#define JSONCONS_WIDEN(A) JSONCONS_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  291|      2|#define JSONCONS_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  332|       |
  333|      2|            return Into(null_constant,4);
  334|      2|        }