LLVMFuzzerTestOneInput:
    7|  5.76k|{
    8|  5.76k|    std::string s(reinterpret_cast<const char*>(data), size);
    9|  5.76k|    std::istringstream is(s);
   10|       |
   11|  5.76k|    std::string s2;
   12|  5.76k|    json_string_encoder visitor(s2);
   13|  5.76k|    json_stream_reader reader(is, visitor);
   14|  5.76k|    std::error_code ec;
   15|  5.76k|    reader.read(ec);
   16|       |
   17|  5.76k|    return 0;
   18|  5.76k|}

_ZN8jsoncons28string_view_constant_of_typeIcEENS_6detail17basic_string_viewIT_NSt3__111char_traitsIS3_EEEEPKcPKw:
  280|      3|    {
  281|      3|        return jsoncons::string_view(c);
  282|      3|    }

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

_ZN8jsoncons6detail8chars_toC2Ev:
 1082|  15.2k|    {
 1083|  15.2k|        struct lconv * lc = localeconv();
 1084|  15.2k|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (1084:13): [True: 15.2k, False: 0]
  |  Branch (1084:30): [True: 15.2k, False: 0]
  ------------------
 1085|  15.2k|        {
 1086|  15.2k|            decimal_point_ = lc->decimal_point[0];    
 1087|  15.2k|        }
 1088|      0|        else
 1089|      0|        {
 1090|      0|            decimal_point_ = '.'; 
 1091|      0|        }
 1092|  15.2k|        buffer_.reserve(100);
 1093|  15.2k|    }
_ZNK8jsoncons6detail8chars_toclIcEENSt3__19enable_ifIXsr3std7is_sameIT_cEE5valueEdE4typeEPKS5_m:
 1106|  1.37M|    {
 1107|  1.37M|        CharT *end = nullptr;
 1108|  1.37M|        double val = strtod(s, &end);
 1109|  1.37M|        if (s == end)
  ------------------
  |  Branch (1109:13): [True: 0, False: 1.37M]
  ------------------
 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.37M|        return val;
 1114|  1.37M|    }
_ZN8jsoncons6detail20to_integer_uncheckedIlcEENSt3__19enable_ifIXaasr16extension_traits14integer_limitsIT_EE14is_specializedsr16extension_traits14integer_limitsIS4_EE9is_signedENS0_17to_integer_resultIS4_T0_EEE4typeEPKS6_mRS4_:
  728|   497k|{
  729|   497k|    static_assert(extension_traits::integer_limits<T>::is_specialized, "Integer type not specialized");
  730|   497k|    JSONCONS_ASSERT(length > 0);
  ------------------
  |  |  378|   497k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 497k]
  |  |  ------------------
  |  |  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|   497k|    n = 0;
  733|       |
  734|   497k|    const CharT* end = s + length; 
  735|   497k|    if (*s == '-')
  ------------------
  |  Branch (735:9): [True: 497k, False: 0]
  ------------------
  736|   497k|    {
  737|   497k|        static constexpr T min_value = (extension_traits::integer_limits<T>::lowest)();
  738|   497k|        static constexpr T min_value_div_10 = min_value / 10;
  739|   497k|        ++s;
  740|  1.02M|        for (; s < end; ++s)
  ------------------
  |  Branch (740:16): [True: 530k, False: 497k]
  ------------------
  741|   530k|        {
  742|   530k|            T x = (T)*s - (T)('0');
  743|   530k|            if (n < min_value_div_10)
  ------------------
  |  Branch (743:17): [True: 370, False: 530k]
  ------------------
  744|    370|            {
  745|    370|                return to_integer_result<T,CharT>(s, to_integer_errc::overflow);
  746|    370|            }
  747|   530k|            n = n * 10;
  748|   530k|            if (n < min_value + x)
  ------------------
  |  Branch (748:17): [True: 353, False: 529k]
  ------------------
  749|    353|            {
  750|    353|                return to_integer_result<T,CharT>(s, to_integer_errc::overflow);
  751|    353|            }
  752|       |
  753|   529k|            n -= x;
  754|   529k|        }
  755|   497k|    }
  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|   497k|    return to_integer_result<T,CharT>(s, to_integer_errc());
  778|   497k|}
_ZN8jsoncons6detail17to_integer_resultIlcEC2EPKcNS0_15to_integer_errcE:
   87|   497k|    {
   88|   497k|    }
_ZNK8jsoncons6detail17to_integer_resultIlcEcvbEv:
   95|   497k|    {
   96|   497k|        return ec == to_integer_errc();
   97|   497k|    }
_ZN8jsoncons6detail20to_integer_uncheckedImcEENSt3__19enable_ifIXaasr16extension_traits14integer_limitsIT_EE14is_specializedntsr16extension_traits14integer_limitsIS4_EE9is_signedENS0_17to_integer_resultIS4_T0_EEE4typeEPKS6_mRS4_:
  667|  4.35M|{
  668|  4.35M|    static_assert(extension_traits::integer_limits<T>::is_specialized, "Integer type not specialized");
  669|  4.35M|    JSONCONS_ASSERT(length > 0);
  ------------------
  |  |  378|  4.35M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 4.35M]
  |  |  ------------------
  |  |  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|  4.35M|    n = 0;
  672|  4.35M|    const CharT* end = s + length; 
  673|  4.35M|    if (*s == '-')
  ------------------
  |  Branch (673:9): [True: 0, False: 4.35M]
  ------------------
  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|  4.35M|    else
  695|  4.35M|    {
  696|  4.35M|        static constexpr T max_value = (extension_traits::integer_limits<T>::max)();
  697|  4.35M|        static constexpr T max_value_div_10 = max_value / 10;
  698|  9.13M|        for (; s < end; ++s)
  ------------------
  |  Branch (698:16): [True: 4.78M, False: 4.34M]
  ------------------
  699|  4.78M|        {
  700|  4.78M|            T x = static_cast<T>(*s) - static_cast<T>('0');
  701|  4.78M|            if (n > max_value_div_10)
  ------------------
  |  Branch (701:17): [True: 4.46k, False: 4.78M]
  ------------------
  702|  4.46k|            {
  703|  4.46k|                return to_integer_result<T,CharT>(s, to_integer_errc::overflow);
  704|  4.46k|            }
  705|  4.78M|            n = n * 10;
  706|  4.78M|            if (n > max_value - x)
  ------------------
  |  Branch (706:17): [True: 5.68k, False: 4.77M]
  ------------------
  707|  5.68k|            {
  708|  5.68k|                return to_integer_result<T,CharT>(s, to_integer_errc::overflow);
  709|  5.68k|            }
  710|       |
  711|  4.77M|            n += x;
  712|  4.77M|        }
  713|  4.35M|    }
  714|       |
  715|  4.34M|    return to_integer_result<T,CharT>(s, to_integer_errc());
  716|  4.35M|}
_ZN8jsoncons6detail17to_integer_resultImcEC2EPKcNS0_15to_integer_errcE:
   87|  4.35M|    {
   88|  4.35M|    }
_ZNK8jsoncons6detail17to_integer_resultImcEcvbEv:
   95|  4.35M|    {
   96|  4.35M|        return ec == to_integer_errc();
   97|  4.35M|    }
_ZNK8jsoncons6detail8chars_to17get_decimal_pointEv:
 1099|   494k|    {
 1100|   494k|        return decimal_point_;
 1101|   494k|    }

_ZN8jsoncons6detail4spanIKcLm18446744073709551615EEC2Ev:
   53|  6.45k|        {
   54|  6.45k|        }
_ZN8jsoncons6detail4spanIKcLm18446744073709551615EEC2EPS2_m:
   57|  20.5k|        {
   58|  20.5k|        }
_ZNK8jsoncons6detail4spanIKcLm18446744073709551615EE4sizeEv:
  111|  37.1k|        {
  112|  37.1k|            return size_;
  113|  37.1k|        }
_ZNK8jsoncons6detail4spanIKcLm18446744073709551615EE4dataEv:
  106|  20.4k|        {
  107|  20.4k|            return data_;
  108|  20.4k|        }

_ZNK8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEE4dataEv:
  157|  1.14M|        {
  158|  1.14M|            return data_;
  159|  1.14M|        }
_ZNK8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEE6lengthEv:
  119|   147k|        {
  120|   147k|            return length_;
  121|   147k|        }
_ZN8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEEC2EPKc:
   53|      3|        {
   54|      3|        }
_ZNK8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEE4sizeEv:
  114|  1.98M|        {
  115|  1.98M|            return length_;
  116|  1.98M|        }
_ZN8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEEC2IS4_NS2_9allocatorIcEEEERKNS2_12basic_stringIcT_T0_EE:
   60|  10.8k|        {
   61|  10.8k|        }
_ZN8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEEC2EPKcm:
   48|   147k|        {
   49|   147k|        }

_ZN8jsoncons6detail12write_doubleC2ENS_18float_chars_formatEi:
  472|  5.76k|        {
  473|  5.76k|    #if !defined(JSONCONS_NO_LOCALECONV)
  474|  5.76k|            struct lconv *lc = localeconv();
  475|  5.76k|            if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (475:17): [True: 5.76k, False: 0]
  |  Branch (475:34): [True: 5.76k, False: 0]
  ------------------
  476|  5.76k|            {
  477|  5.76k|                decimal_point_ = lc->decimal_point[0];
  478|  5.76k|            }
  479|  5.76k|    #endif
  480|  5.76k|        }
_ZN8jsoncons6detail16to_hex_characterEh:
   28|  68.4M|    {
   29|  68.4M|        return (char)((c < 10) ? ('0' + c) : ('A' - 10 + c));
  ------------------
  |  Branch (29:23): [True: 51.3M, False: 17.1M]
  ------------------
   30|  68.4M|    }
_ZN8jsoncons6detail12from_integerImNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEENS3_9enable_ifIXsr16extension_traits10is_integerIT_EE5valueEmE4typeESC_RT0_:
   37|  4.34M|    {
   38|  4.34M|        using char_type = typename Result::value_type;
   39|       |
   40|  4.34M|        char_type buf[255];
   41|  4.34M|        char_type *p = buf;
   42|  4.34M|        const char_type* last = buf+255;
   43|       |
   44|  4.34M|        bool is_negative = value < 0;
   45|       |
   46|  4.34M|        if (value < 0)
  ------------------
  |  Branch (46:13): [True: 0, False: 4.34M]
  ------------------
   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|  4.34M|        else
   55|  4.34M|        {
   56|       |
   57|  4.34M|            do
   58|  4.58M|            {
   59|  4.58M|                *p++ = static_cast<char_type>(48 + value % 10);
   60|  4.58M|            }
   61|  4.58M|            while ((value /= 10) && (p < last));
  ------------------
  |  Branch (61:20): [True: 235k, False: 4.34M]
  |  Branch (61:37): [True: 235k, False: 0]
  ------------------
   62|  4.34M|        }
   63|  4.34M|        JSONCONS_ASSERT(p != last);
  ------------------
  |  |  378|  4.34M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 4.34M]
  |  |  ------------------
  |  |  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|  4.34M|        std::size_t count = (p - buf);
   66|  4.34M|        if (is_negative)
  ------------------
  |  Branch (66:13): [True: 0, False: 4.34M]
  ------------------
   67|      0|        {
   68|      0|            result.push_back('-');
   69|      0|            ++count;
   70|      0|        }
   71|  8.92M|        while (--p >= buf)
  ------------------
  |  Branch (71:16): [True: 4.58M, False: 4.34M]
  ------------------
   72|  4.58M|        {
   73|  4.58M|            result.push_back(*p);
   74|  4.58M|        }
   75|       |
   76|  4.34M|        return count;
   77|  4.34M|    }
_ZN8jsoncons6detail12from_integerIlNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEENS3_9enable_ifIXsr16extension_traits10is_integerIT_EE5valueEmE4typeESC_RT0_:
   37|   497k|    {
   38|   497k|        using char_type = typename Result::value_type;
   39|       |
   40|   497k|        char_type buf[255];
   41|   497k|        char_type *p = buf;
   42|   497k|        const char_type* last = buf+255;
   43|       |
   44|   497k|        bool is_negative = value < 0;
   45|       |
   46|   497k|        if (value < 0)
  ------------------
  |  Branch (46:13): [True: 496k, False: 524]
  ------------------
   47|   496k|        {
   48|   496k|            do
   49|   516k|            {
   50|   516k|                *p++ = static_cast<char_type>(48 - (value % 10));
   51|   516k|            }
   52|   516k|            while ((value /= 10) && (p < last));
  ------------------
  |  Branch (52:20): [True: 19.4k, False: 496k]
  |  Branch (52:37): [True: 19.4k, False: 0]
  ------------------
   53|   496k|        }
   54|    524|        else
   55|    524|        {
   56|       |
   57|    524|            do
   58|    524|            {
   59|    524|                *p++ = static_cast<char_type>(48 + value % 10);
   60|    524|            }
   61|    524|            while ((value /= 10) && (p < last));
  ------------------
  |  Branch (61:20): [True: 0, False: 524]
  |  Branch (61:37): [True: 0, False: 0]
  ------------------
   62|    524|        }
   63|   497k|        JSONCONS_ASSERT(p != last);
  ------------------
  |  |  378|   497k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 497k]
  |  |  ------------------
  |  |  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|   497k|        std::size_t count = (p - buf);
   66|   497k|        if (is_negative)
  ------------------
  |  Branch (66:13): [True: 496k, False: 524]
  ------------------
   67|   496k|        {
   68|   496k|            result.push_back('-');
   69|   496k|            ++count;
   70|   496k|        }
   71|  1.01M|        while (--p >= buf)
  ------------------
  |  Branch (71:16): [True: 516k, False: 497k]
  ------------------
   72|   516k|        {
   73|   516k|            result.push_back(*p);
   74|   516k|        }
   75|       |
   76|   497k|        return count;
   77|   497k|    }
_ZN8jsoncons6detail12write_doubleclINS_11string_sinkINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEmdRT_:
  487|  1.36M|        {
  488|  1.36M|            std::size_t count = 0;
  489|       |
  490|  1.36M|            char number_buffer[200];
  491|  1.36M|            int length = 0;
  492|       |
  493|  1.36M|            switch (float_format_)
  494|  1.36M|            {
  495|      0|            case float_chars_format::fixed:
  ------------------
  |  Branch (495:13): [True: 0, False: 1.36M]
  ------------------
  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.36M]
  ------------------
  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.36M|            case float_chars_format::general:
  ------------------
  |  Branch (535:13): [True: 1.36M, False: 0]
  ------------------
  536|  1.36M|                {
  537|  1.36M|                    if (precision_ > 0)
  ------------------
  |  Branch (537:25): [True: 0, False: 1.36M]
  ------------------
  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.36M|                    else
  547|  1.36M|                    {
  548|  1.36M|                        if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (548:29): [True: 0, False: 1.36M]
  ------------------
  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.36M|                    }             
  553|  1.36M|                    break;
  554|  1.36M|                }
  555|  1.36M|                default:
  ------------------
  |  Branch (555:17): [True: 0, False: 1.36M]
  ------------------
  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.36M|            }
  559|  1.36M|            return count;
  560|  1.36M|        }
_ZN8jsoncons6detail11dump_bufferINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEvPKcmcRT_:
  238|  3.73k|    {
  239|  3.73k|        const char *sbeg = buffer;
  240|  3.73k|        const char *send = sbeg + length;
  241|       |
  242|  3.73k|        if (sbeg != send)
  ------------------
  |  Branch (242:13): [True: 3.73k, False: 0]
  ------------------
  243|  3.73k|        {
  244|  3.73k|            bool needs_dot = true;
  245|  56.6k|            for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (245:40): [True: 52.9k, False: 3.73k]
  ------------------
  246|  52.9k|            {
  247|  52.9k|                switch (*q)
  248|  52.9k|                {
  249|    211|                case '-':
  ------------------
  |  Branch (249:17): [True: 211, False: 52.7k]
  ------------------
  250|  9.51k|                case '0':
  ------------------
  |  Branch (250:17): [True: 9.30k, False: 43.6k]
  ------------------
  251|  13.8k|                case '1':
  ------------------
  |  Branch (251:17): [True: 4.30k, False: 48.6k]
  ------------------
  252|  18.4k|                case '2':
  ------------------
  |  Branch (252:17): [True: 4.66k, False: 48.2k]
  ------------------
  253|  22.1k|                case '3':
  ------------------
  |  Branch (253:17): [True: 3.67k, False: 49.2k]
  ------------------
  254|  26.6k|                case '4':
  ------------------
  |  Branch (254:17): [True: 4.47k, False: 48.4k]
  ------------------
  255|  34.8k|                case '5':
  ------------------
  |  Branch (255:17): [True: 8.18k, False: 44.7k]
  ------------------
  256|  37.2k|                case '6':
  ------------------
  |  Branch (256:17): [True: 2.43k, False: 50.5k]
  ------------------
  257|  42.5k|                case '7':
  ------------------
  |  Branch (257:17): [True: 5.29k, False: 47.6k]
  ------------------
  258|  45.3k|                case '8':
  ------------------
  |  Branch (258:17): [True: 2.80k, False: 50.1k]
  ------------------
  259|  49.1k|                case '9':
  ------------------
  |  Branch (259:17): [True: 3.79k, False: 49.1k]
  ------------------
  260|  50.1k|                case '+':
  ------------------
  |  Branch (260:17): [True: 1.05k, False: 51.8k]
  ------------------
  261|  50.1k|                    result.push_back(*q);
  262|  50.1k|                    break;
  263|  1.15k|                case 'e':
  ------------------
  |  Branch (263:17): [True: 1.15k, False: 51.7k]
  ------------------
  264|  1.15k|                case 'E':
  ------------------
  |  Branch (264:17): [True: 0, False: 52.9k]
  ------------------
  265|  1.15k|                    result.push_back('e');
  266|  1.15k|                    needs_dot = false;
  267|  1.15k|                    break;
  268|  1.59k|                default:
  ------------------
  |  Branch (268:17): [True: 1.59k, False: 51.3k]
  ------------------
  269|  1.59k|                    if (*q == decimal_point)
  ------------------
  |  Branch (269:25): [True: 1.59k, False: 0]
  ------------------
  270|  1.59k|                    {
  271|  1.59k|                        needs_dot = false;
  272|  1.59k|                        result.push_back('.');
  273|  1.59k|                    }
  274|  1.59k|                    break;
  275|  52.9k|                }
  276|  52.9k|            }
  277|  3.73k|            if (needs_dot)
  ------------------
  |  Branch (277:17): [True: 1.44k, False: 2.29k]
  ------------------
  278|  1.44k|            {
  279|  1.44k|                result.push_back('.');
  280|  1.44k|                result.push_back('0');
  281|  1.44k|            }
  282|  3.73k|        }
  283|  3.73k|    }
_ZN8jsoncons6detail15prettify_stringINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEvPKcmiiiRT_:
  166|  1.25M|    {
  167|  1.25M|        int nb_digits = (int)length;
  168|  1.25M|        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|  1.25M|        int kk = nb_digits + k;
  174|       |
  175|  1.25M|        if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (175:13): [True: 644k, False: 615k]
  |  Branch (175:32): [True: 597k, False: 46.4k]
  ------------------
  176|   597k|        {
  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|  1.29M|            for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (180:29): [True: 698k, False: 597k]
  ------------------
  181|   698k|            {
  182|   698k|                result.push_back(buffer[i]);
  183|   698k|            }
  184|  5.19M|            for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (184:37): [True: 4.59M, False: 597k]
  ------------------
  185|  4.59M|            {
  186|  4.59M|                result.push_back('0');
  187|  4.59M|            }
  188|   597k|            result.push_back('.');
  189|   597k|            result.push_back('0');
  190|   597k|        } 
  191|   661k|        else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (191:18): [True: 517k, False: 144k]
  |  Branch (191:28): [True: 470k, False: 46.4k]
  ------------------
  192|   470k|        {
  193|       |            /* comma number. Just insert a '.' at the correct location. */
  194|   959k|            for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (194:29): [True: 488k, False: 470k]
  ------------------
  195|   488k|            {
  196|   488k|                result.push_back(buffer[i]);
  197|   488k|            }
  198|   470k|            result.push_back('.');
  199|   959k|            for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (199:30): [True: 488k, False: 470k]
  ------------------
  200|   488k|            {
  201|   488k|                result.push_back(buffer[i]);
  202|   488k|            }
  203|   470k|        } 
  204|   190k|        else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (204:18): [True: 50.1k, False: 140k]
  |  Branch (204:34): [True: 3.74k, False: 46.4k]
  ------------------
  205|  3.74k|        {
  206|  3.74k|            offset = 2 - kk;
  207|       |
  208|  3.74k|            result.push_back('0');
  209|  3.74k|            result.push_back('.');
  210|  7.54k|            for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (210:29): [True: 3.80k, False: 3.74k]
  ------------------
  211|  3.80k|                result.push_back('0');
  212|  9.25k|            for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (212:29): [True: 5.51k, False: 3.74k]
  ------------------
  213|  5.51k|            {
  214|  5.51k|                result.push_back(buffer[i]);
  215|  5.51k|            }
  216|  3.74k|        } 
  217|   186k|        else if (nb_digits == 1)
  ------------------
  |  Branch (217:18): [True: 175k, False: 11.5k]
  ------------------
  218|   175k|        {
  219|   175k|            result.push_back(buffer[0]);
  220|   175k|            result.push_back('e');
  221|   175k|            fill_exponent(kk - 1, result);
  222|   175k|        } 
  223|  11.5k|        else
  224|  11.5k|        {
  225|  11.5k|            result.push_back(buffer[0]);
  226|  11.5k|            result.push_back('.');
  227|   130k|            for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (227:29): [True: 118k, False: 11.5k]
  ------------------
  228|   118k|            {
  229|   118k|                result.push_back(buffer[i]);
  230|   118k|            }
  231|  11.5k|            result.push_back('e');
  232|  11.5k|            fill_exponent(kk - 1, result);
  233|  11.5k|        }
  234|  1.25M|    }
_ZN8jsoncons6detail13fill_exponentINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEviRT_:
  131|   186k|    {
  132|   186k|        if (K < 0)
  ------------------
  |  Branch (132:13): [True: 140k, False: 46.4k]
  ------------------
  133|   140k|        {
  134|   140k|            result.push_back('-');
  135|   140k|            K = -K;
  136|   140k|        }
  137|  46.4k|        else
  138|  46.4k|        {
  139|  46.4k|            result.push_back('+'); // compatibility with sprintf
  140|  46.4k|        }
  141|       |
  142|   186k|        if (K < 10)
  ------------------
  |  Branch (142:13): [True: 210, False: 186k]
  ------------------
  143|    210|        {
  144|    210|            result.push_back('0'); // compatibility with sprintf
  145|    210|            result.push_back((char)('0' + K));
  146|    210|        }
  147|   186k|        else if (K < 100)
  ------------------
  |  Branch (147:18): [True: 49.8k, False: 136k]
  ------------------
  148|  49.8k|        {
  149|  49.8k|            result.push_back((char)('0' + K / 10)); K %= 10;
  150|  49.8k|            result.push_back((char)('0' + K));
  151|  49.8k|        }
  152|   136k|        else if (K < 1000)
  ------------------
  |  Branch (152:18): [True: 136k, False: 0]
  ------------------
  153|   136k|        {
  154|   136k|            result.push_back((char)('0' + K / 100)); K %= 100;
  155|   136k|            result.push_back((char)('0' + K / 10)); K %= 10;
  156|   136k|            result.push_back((char)('0' + K));
  157|   136k|        }
  158|      0|        else
  159|      0|        {
  160|      0|            jsoncons::detail::from_integer(K, result);
  161|      0|        }
  162|   186k|    }
_ZN8jsoncons6detail12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEbdcRT_:
  458|  1.36M|    {
  459|  1.36M|        return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  460|  1.36M|    }
_ZN8jsoncons6detail12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEbdcRT_NS3_17integral_constantIbLb1EEE:
  353|  1.36M|    {
  354|  1.36M|        if (v == 0)
  ------------------
  |  Branch (354:13): [True: 105k, False: 1.26M]
  ------------------
  355|   105k|        {
  356|   105k|            result.push_back('0');
  357|   105k|            result.push_back('.');
  358|   105k|            result.push_back('0');
  359|   105k|            return true;
  360|   105k|        }
  361|       |
  362|  1.26M|        int length = 0;
  363|  1.26M|        int k;
  364|       |
  365|  1.26M|        char buffer[100];
  366|       |
  367|  1.26M|        double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (367:20): [True: 16.9k, False: 1.24M]
  ------------------
  368|  1.26M|        if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (368:13): [True: 1.25M, False: 3.73k]
  ------------------
  369|  1.25M|        {
  370|  1.25M|            if (std::signbit(v))
  ------------------
  |  Branch (370:17): [True: 16.7k, False: 1.24M]
  ------------------
  371|  16.7k|            {
  372|  16.7k|                result.push_back('-');
  373|  16.7k|            }
  374|       |            // min exp: -4 is consistent with sprintf
  375|       |            // max exp: std::numeric_limits<double>::max_digits10
  376|  1.25M|            jsoncons::detail::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  377|  1.25M|            return true;
  378|  1.25M|        }
  379|  3.73k|        else
  380|  3.73k|        {
  381|  3.73k|            return dtoa_general(v, decimal_point, result, std::false_type());
  382|  3.73k|        }
  383|  1.26M|    }
_ZN8jsoncons6detail12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEbdcRT_NS3_17integral_constantIbLb0EEE:
  320|  3.73k|    {
  321|  3.73k|        if (val == 0)
  ------------------
  |  Branch (321:13): [True: 0, False: 3.73k]
  ------------------
  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|  3.73k|        jsoncons::detail::chars_to to_double_;
  330|       |
  331|  3.73k|        char buffer[100];
  332|  3.73k|        int precision = std::numeric_limits<double>::digits10;
  333|  3.73k|        int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  334|  3.73k|        if (length < 0)
  ------------------
  |  Branch (334:13): [True: 0, False: 3.73k]
  ------------------
  335|      0|        {
  336|      0|            return false;
  337|      0|        }
  338|  3.73k|        if (to_double_(buffer, sizeof(buffer)) != val)
  ------------------
  |  Branch (338:13): [True: 2.53k, False: 1.20k]
  ------------------
  339|  2.53k|        {
  340|  2.53k|            const int precision2 = std::numeric_limits<double>::max_digits10;
  341|  2.53k|            length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  342|  2.53k|            if (length < 0)
  ------------------
  |  Branch (342:17): [True: 0, False: 2.53k]
  ------------------
  343|      0|            {
  344|      0|                return false;
  345|      0|            }
  346|  2.53k|        }
  347|  3.73k|        dump_buffer(buffer, length, decimal_point, result);
  348|  3.73k|        return true;
  349|  3.73k|    }

_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_EC2EOS9_RKS7_:
  329|  5.76k|        {
  330|  5.76k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_EC2EOS9_RKNS_25basic_json_encode_optionsIcEERKS7_:
  342|  5.76k|        {
  343|  5.76k|            switch (options.spaces_around_colon())
  344|  5.76k|            {
  345|  5.76k|                case spaces_option::space_after:
  ------------------
  |  Branch (345:17): [True: 5.76k, False: 0]
  ------------------
  346|  5.76k|                    colon_str_ = std::basic_string<CharT>({':',' '});
  347|  5.76k|                    break;
  348|      0|                case spaces_option::space_before:
  ------------------
  |  Branch (348:17): [True: 0, False: 5.76k]
  ------------------
  349|      0|                    colon_str_ = std::basic_string<CharT>({' ',':'});
  350|      0|                    break;
  351|      0|                case spaces_option::space_before_and_after:
  ------------------
  |  Branch (351:17): [True: 0, False: 5.76k]
  ------------------
  352|      0|                    colon_str_ = std::basic_string<CharT>({' ',':',' '});
  353|      0|                    break;
  354|      0|                default:
  ------------------
  |  Branch (354:17): [True: 0, False: 5.76k]
  ------------------
  355|      0|                    colon_str_.push_back(':');
  356|      0|                    break;
  357|  5.76k|            }
  358|  5.76k|            switch (options.spaces_around_comma())
  359|  5.76k|            {
  360|  5.76k|                case spaces_option::space_after:
  ------------------
  |  Branch (360:17): [True: 5.76k, False: 0]
  ------------------
  361|  5.76k|                    comma_str_ = std::basic_string<CharT>({',',' '});
  362|  5.76k|                    break;
  363|      0|                case spaces_option::space_before:
  ------------------
  |  Branch (363:17): [True: 0, False: 5.76k]
  ------------------
  364|      0|                    comma_str_ = std::basic_string<CharT>({' ',','});
  365|      0|                    break;
  366|      0|                case spaces_option::space_before_and_after:
  ------------------
  |  Branch (366:17): [True: 0, False: 5.76k]
  ------------------
  367|      0|                    comma_str_ = std::basic_string<CharT>({' ',',',' '});
  368|      0|                    break;
  369|      0|                default:
  ------------------
  |  Branch (369:17): [True: 0, False: 5.76k]
  ------------------
  370|      0|                    comma_str_.push_back(',');
  371|      0|                    break;
  372|  5.76k|            }
  373|  5.76k|            if (options.pad_inside_object_braces())
  ------------------
  |  Branch (373:17): [True: 0, False: 5.76k]
  ------------------
  374|      0|            {
  375|      0|                open_object_brace_str_ = std::basic_string<CharT>({'{', ' '});
  376|      0|                close_object_brace_str_ = std::basic_string<CharT>({' ', '}'});
  377|      0|            }
  378|  5.76k|            else
  379|  5.76k|            {
  380|  5.76k|                open_object_brace_str_.push_back('{');
  381|  5.76k|                close_object_brace_str_.push_back('}');
  382|  5.76k|            }
  383|  5.76k|            if (options.pad_inside_array_brackets())
  ------------------
  |  Branch (383:17): [True: 0, False: 5.76k]
  ------------------
  384|      0|            {
  385|      0|                open_array_bracket_str_ = std::basic_string<CharT>({'[', ' '});
  386|      0|                close_array_bracket_str_ = std::basic_string<CharT>({' ', ']'});
  387|      0|            }
  388|  5.76k|            else
  389|  5.76k|            {
  390|  5.76k|                open_array_bracket_str_.push_back('[');
  391|  5.76k|                close_array_bracket_str_.push_back(']');
  392|  5.76k|            }
  393|  5.76k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E11visit_flushEv:
  423|  2.10k|        {
  424|  2.10k|            sink_.flush();
  425|  2.10k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  428|  19.3k|        {
  429|  19.3k|            if (JSONCONS_UNLIKELY(++nesting_depth_ > options_.max_nesting_depth()))
  ------------------
  |  |   45|  19.3k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 0, False: 19.3k]
  |  |  ------------------
  ------------------
  430|      0|            {
  431|      0|                ec = json_errc::max_nesting_depth_exceeded;
  432|      0|                return false;
  433|      0|            } 
  434|  19.3k|            if (!stack_.empty() && stack_.back().is_array() && stack_.back().count() > 0)
  ------------------
  |  Branch (434:17): [True: 18.7k, False: 610]
  |  Branch (434:36): [True: 17.2k, False: 1.48k]
  |  Branch (434:64): [True: 16.3k, False: 898]
  ------------------
  435|  16.3k|            {
  436|  16.3k|                sink_.append(comma_str_.data(),comma_str_.length());
  437|  16.3k|                column_ += comma_str_.length();
  438|  16.3k|            }
  439|       |
  440|  19.3k|            if (!stack_.empty()) // object or array
  ------------------
  |  Branch (440:17): [True: 18.7k, False: 610]
  ------------------
  441|  18.7k|            {
  442|  18.7k|                if (stack_.back().is_object())
  ------------------
  |  Branch (442:21): [True: 1.48k, False: 17.2k]
  ------------------
  443|  1.48k|                {
  444|  1.48k|                    switch (options_.object_object_line_splits())
  445|  1.48k|                    {
  446|      0|                        case line_split_kind::same_line:
  ------------------
  |  Branch (446:25): [True: 0, False: 1.48k]
  ------------------
  447|      0|                        case line_split_kind::new_line:
  ------------------
  |  Branch (447:25): [True: 0, False: 1.48k]
  ------------------
  448|      0|                            if (column_ >= options_.line_length_limit())
  ------------------
  |  Branch (448:33): [True: 0, False: 0]
  ------------------
  449|      0|                            {
  450|      0|                                break_line();
  451|      0|                            }
  452|      0|                            break;
  453|  1.48k|                        default: // multi_line
  ------------------
  |  Branch (453:25): [True: 1.48k, False: 0]
  ------------------
  454|  1.48k|                            break;
  455|  1.48k|                    }
  456|  1.48k|                    stack_.emplace_back(container_type::object,options_.object_object_line_splits(), false,
  457|  1.48k|                                        column_, column_+open_object_brace_str_.length());
  458|  1.48k|                }
  459|  17.2k|                else // array
  460|  17.2k|                {
  461|  17.2k|                    switch (options_.array_object_line_splits())
  462|  17.2k|                    {
  463|      0|                        case line_split_kind::same_line:
  ------------------
  |  Branch (463:25): [True: 0, False: 17.2k]
  ------------------
  464|      0|                            if (column_ >= options_.line_length_limit())
  ------------------
  |  Branch (464:33): [True: 0, False: 0]
  ------------------
  465|      0|                            {
  466|       |                                //stack_.back().new_line_after(true);
  467|      0|                                new_line();
  468|      0|                            }
  469|      0|                            break;
  470|      0|                        case line_split_kind::new_line:
  ------------------
  |  Branch (470:25): [True: 0, False: 17.2k]
  ------------------
  471|      0|                            stack_.back().new_line_after(true);
  472|      0|                            new_line();
  473|      0|                            break;
  474|  17.2k|                        default: // multi_line
  ------------------
  |  Branch (474:25): [True: 17.2k, False: 0]
  ------------------
  475|  17.2k|                            stack_.back().new_line_after(true);
  476|  17.2k|                            new_line();
  477|  17.2k|                            break;
  478|  17.2k|                    }
  479|  17.2k|                    stack_.emplace_back(container_type::object,options_.array_object_line_splits(), false,
  480|  17.2k|                                        column_, column_+open_object_brace_str_.length());
  481|  17.2k|                }
  482|  18.7k|            }
  483|    610|            else 
  484|    610|            {
  485|    610|                stack_.emplace_back(container_type::object, line_split_kind::multi_line, false,
  486|    610|                                    column_, column_+open_object_brace_str_.length());
  487|    610|            }
  488|  19.3k|            indent();
  489|       |            
  490|  19.3k|            sink_.append(open_object_brace_str_.data(), open_object_brace_str_.length());
  491|  19.3k|            column_ += open_object_brace_str_.length();
  492|  19.3k|            return true;
  493|  19.3k|        }
_ZNK8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context8is_arrayEv:
  280|  7.28M|            {
  281|  7.28M|                return type_ == container_type::array;
  282|  7.28M|            }
_ZNK8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context5countEv:
  255|  7.41M|            {
  256|  7.41M|                return count_;
  257|  7.41M|            }
_ZNK8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context9is_objectEv:
  275|  67.8k|            {
  276|  67.8k|                return type_ == container_type::object;
  277|  67.8k|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E10break_lineEv:
 1040|  1.56M|        {
 1041|  1.56M|            stack_.back().new_line_after(true);
 1042|  1.56M|            new_line();
 1043|  1.56M|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_contextC2ENSA_14container_typeENS_15line_split_kindEbmm:
  233|  70.4k|            {
  234|  70.4k|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E8new_lineEv:
 1020|  4.45M|        {
 1021|  4.45M|            sink_.append(options_.new_line_chars().data(),options_.new_line_chars().length());
 1022|  1.51G|            for (int i = 0; i < indent_amount_; ++i)
  ------------------
  |  Branch (1022:29): [True: 1.51G, False: 4.45M]
  ------------------
 1023|  1.51G|            {
 1024|  1.51G|                sink_.push_back(' ');
 1025|  1.51G|            }
 1026|  4.45M|            column_ = indent_amount_;
 1027|  4.45M|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context14new_line_afterEb:
  270|  4.45M|            {
  271|  4.45M|                new_line_after_ = value;
  272|  4.45M|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E6indentEv:
 1010|  70.4k|        {
 1011|  70.4k|            indent_amount_ += static_cast<int>(options_.indent_size());
 1012|  70.4k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16visit_end_objectERKNS_11ser_contextERNS2_10error_codeE:
  496|  16.7k|        {
  497|  16.7k|            JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |  378|  16.7k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 16.7k]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  498|  16.7k|            --nesting_depth_;
  499|       |
  500|  16.7k|            unindent();
  501|  16.7k|            if (stack_.back().new_line_after())
  ------------------
  |  Branch (501:17): [True: 1.79k, False: 15.0k]
  ------------------
  502|  1.79k|            {
  503|  1.79k|                new_line();
  504|  1.79k|            }
  505|  16.7k|            stack_.pop_back();
  506|  16.7k|            sink_.append(close_object_brace_str_.data(), close_object_brace_str_.length());
  507|  16.7k|            column_ += close_object_brace_str_.length();
  508|       |
  509|  16.7k|            end_value();
  510|  16.7k|            return true;
  511|  16.7k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E8unindentEv:
 1015|  23.3k|        {
 1016|  23.3k|            indent_amount_ -= static_cast<int>(options_.indent_size());
 1017|  23.3k|        }
_ZNK8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context14new_line_afterEv:
  265|  23.3k|            {
  266|  23.3k|                return new_line_after_;
  267|  23.3k|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E9end_valueEv:
 1002|  7.23M|        {
 1003|  7.23M|            if (!stack_.empty())
  ------------------
  |  Branch (1003:17): [True: 7.23M, False: 2.12k]
  ------------------
 1004|  7.23M|            {
 1005|  7.23M|                stack_.back().increment_count();
 1006|  7.23M|            }
 1007|  7.23M|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context15increment_countEv:
  260|  7.23M|            {
  261|  7.23M|                ++count_;
  262|  7.23M|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  514|  51.0k|        {
  515|  51.0k|            if (JSONCONS_UNLIKELY(++nesting_depth_ > options_.max_nesting_depth()))
  ------------------
  |  |   45|  51.0k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 0, False: 51.0k]
  |  |  ------------------
  ------------------
  516|      0|            {
  517|      0|                ec = json_errc::max_nesting_depth_exceeded;
  518|      0|                return false;
  519|      0|            } 
  520|  51.0k|            if (!stack_.empty() && stack_.back().is_array() && stack_.back().count() > 0)
  ------------------
  |  Branch (520:17): [True: 49.0k, False: 2.01k]
  |  Branch (520:36): [True: 48.2k, False: 811]
  |  Branch (520:64): [True: 16.1k, False: 32.0k]
  ------------------
  521|  16.1k|            {
  522|  16.1k|                sink_.append(comma_str_.data(),comma_str_.length());
  523|  16.1k|                column_ += comma_str_.length();
  524|  16.1k|            }
  525|  51.0k|            if (!stack_.empty())
  ------------------
  |  Branch (525:17): [True: 49.0k, False: 2.01k]
  ------------------
  526|  49.0k|            {
  527|  49.0k|                if (stack_.back().is_object())
  ------------------
  |  Branch (527:21): [True: 811, False: 48.2k]
  ------------------
  528|    811|                {
  529|    811|                    switch (options_.object_array_line_splits())
  530|    811|                    {
  531|    811|                        case line_split_kind::same_line:
  ------------------
  |  Branch (531:25): [True: 811, False: 0]
  ------------------
  532|    811|                            stack_.emplace_back(container_type::array,options_.object_array_line_splits(),false,
  533|    811|                                                column_, column_ + open_array_bracket_str_.length());
  534|    811|                            break;
  535|      0|                        case line_split_kind::new_line:
  ------------------
  |  Branch (535:25): [True: 0, False: 811]
  ------------------
  536|      0|                        {
  537|      0|                            stack_.emplace_back(container_type::array,options_.object_array_line_splits(),true,
  538|      0|                                                column_, column_+open_array_bracket_str_.length());
  539|      0|                            break;
  540|      0|                        }
  541|      0|                        default: // multi_line
  ------------------
  |  Branch (541:25): [True: 0, False: 811]
  ------------------
  542|      0|                            stack_.emplace_back(container_type::array,options_.object_array_line_splits(),true,
  543|      0|                                                column_, column_+open_array_bracket_str_.length());
  544|      0|                            break;
  545|    811|                    }
  546|    811|                }
  547|  48.2k|                else // array
  548|  48.2k|                {
  549|  48.2k|                    switch (options_.array_array_line_splits())
  550|  48.2k|                    {
  551|      0|                        case line_split_kind::same_line:
  ------------------
  |  Branch (551:25): [True: 0, False: 48.2k]
  ------------------
  552|      0|                            if (stack_.back().is_multi_line())
  ------------------
  |  Branch (552:33): [True: 0, False: 0]
  ------------------
  553|      0|                            {
  554|      0|                                stack_.back().new_line_after(true);
  555|      0|                                new_line();
  556|      0|                            }
  557|      0|                            stack_.emplace_back(container_type::array,options_.array_array_line_splits(), false,
  558|      0|                                                column_, column_+open_array_bracket_str_.length());
  559|      0|                            break;
  560|  48.2k|                        case line_split_kind::new_line:
  ------------------
  |  Branch (560:25): [True: 48.2k, False: 0]
  ------------------
  561|  48.2k|                            stack_.back().new_line_after(true);
  562|  48.2k|                            new_line();
  563|  48.2k|                            stack_.emplace_back(container_type::array,options_.array_array_line_splits(), false,
  564|  48.2k|                                                column_, column_+open_array_bracket_str_.length());
  565|  48.2k|                            break;
  566|      0|                        default: // multi_line
  ------------------
  |  Branch (566:25): [True: 0, False: 48.2k]
  ------------------
  567|      0|                            stack_.back().new_line_after(true);
  568|      0|                            new_line();
  569|      0|                            stack_.emplace_back(container_type::array,options_.array_array_line_splits(), false,
  570|      0|                                                column_, column_+open_array_bracket_str_.length());
  571|       |                            //new_line();
  572|      0|                            break;
  573|  48.2k|                    }
  574|  48.2k|                }
  575|  49.0k|            }
  576|  2.01k|            else 
  577|  2.01k|            {
  578|  2.01k|                stack_.emplace_back(container_type::array, line_split_kind::multi_line, false,
  579|  2.01k|                                    column_, column_+open_array_bracket_str_.length());
  580|  2.01k|            }
  581|  51.0k|            indent();
  582|  51.0k|            sink_.append(open_array_bracket_str_.data(), open_array_bracket_str_.length());
  583|  51.0k|            column_ += open_array_bracket_str_.length();
  584|  51.0k|            return true;
  585|  51.0k|        }
_ZNK8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context13is_multi_lineEv:
  295|  14.4M|            {
  296|  14.4M|                return line_splits_ == line_split_kind::multi_line;
  297|  14.4M|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E15visit_end_arrayERKNS_11ser_contextERNS2_10error_codeE:
  588|  6.53k|        {
  589|  6.53k|            JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |  378|  6.53k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 6.53k]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  590|  6.53k|            --nesting_depth_;
  591|       |
  592|  6.53k|            unindent();
  593|  6.53k|            if (stack_.back().new_line_after())
  ------------------
  |  Branch (593:17): [True: 2.98k, False: 3.54k]
  ------------------
  594|  2.98k|            {
  595|  2.98k|                new_line();
  596|  2.98k|            }
  597|  6.53k|            stack_.pop_back();
  598|  6.53k|            sink_.append(close_array_bracket_str_.data(), close_array_bracket_str_.length());
  599|  6.53k|            column_ += close_array_bracket_str_.length();
  600|  6.53k|            end_value();
  601|  6.53k|            return true;
  602|  6.53k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E9visit_keyERKNS_6detail17basic_string_viewIcS5_EERKNS_11ser_contextERNS2_10error_codeE:
  605|   137k|        {
  606|   137k|            JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |  378|   137k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 137k]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  607|   137k|            if (stack_.back().count() > 0)
  ------------------
  |  Branch (607:17): [True: 132k, False: 4.18k]
  ------------------
  608|   132k|            {
  609|   132k|                sink_.append(comma_str_.data(),comma_str_.length());
  610|   132k|                column_ += comma_str_.length();
  611|   132k|            }
  612|       |
  613|   137k|            if (stack_.back().is_multi_line())
  ------------------
  |  Branch (613:17): [True: 137k, False: 0]
  ------------------
  614|   137k|            {
  615|   137k|                stack_.back().new_line_after(true);
  616|   137k|                new_line();
  617|   137k|            }
  618|      0|            else if (stack_.back().count() > 0 && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (618:22): [True: 0, False: 0]
  |  Branch (618:51): [True: 0, False: 0]
  ------------------
  619|      0|            {
  620|       |                //stack_.back().new_line_after(true);
  621|      0|                new_line(stack_.back().data_pos());
  622|      0|            }
  623|       |
  624|   137k|            if (stack_.back().count() == 0)
  ------------------
  |  Branch (624:17): [True: 4.18k, False: 132k]
  ------------------
  625|  4.18k|            {
  626|  4.18k|                stack_.back().set_position(column_);
  627|  4.18k|            }
  628|   137k|            sink_.push_back('\"');
  629|   137k|            std::size_t length = jsoncons::detail::escape_string(name.data(), name.length(),options_.escape_all_non_ascii(),options_.escape_solidus(),sink_);
  630|   137k|            sink_.push_back('\"');
  631|   137k|            sink_.append(colon_str_.data(),colon_str_.length());
  632|   137k|            column_ += (length+2+colon_str_.length());
  633|   137k|            return true;
  634|   137k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context12set_positionEm:
  240|  4.18k|            {
  241|  4.18k|                data_pos_ = pos;
  242|  4.18k|            }
_ZN8jsoncons6detail13escape_stringIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEmPKT_mbbRT0_:
   46|   147k|    {
   47|   147k|        std::size_t count = 0;
   48|   147k|        const CharT* begin = s;
   49|   147k|        const CharT* end = s + length;
   50|  19.6M|        for (const CharT* it = begin; it != end; ++it)
  ------------------
  |  Branch (50:39): [True: 19.4M, False: 147k]
  ------------------
   51|  19.4M|        {
   52|  19.4M|            CharT c = *it;
   53|  19.4M|            switch (c)
   54|  19.4M|            {
   55|  34.0k|                case '\\':
  ------------------
  |  Branch (55:17): [True: 34.0k, False: 19.4M]
  ------------------
   56|  34.0k|                    sink.push_back('\\');
   57|  34.0k|                    sink.push_back('\\');
   58|  34.0k|                    count += 2;
   59|  34.0k|                    break;
   60|    370|                case '"':
  ------------------
  |  Branch (60:17): [True: 370, False: 19.4M]
  ------------------
   61|    370|                    sink.push_back('\\');
   62|    370|                    sink.push_back('\"');
   63|    370|                    count += 2;
   64|    370|                    break;
   65|    723|                case '\b':
  ------------------
  |  Branch (65:17): [True: 723, False: 19.4M]
  ------------------
   66|    723|                    sink.push_back('\\');
   67|    723|                    sink.push_back('b');
   68|    723|                    count += 2;
   69|    723|                    break;
   70|    237|                case '\f':
  ------------------
  |  Branch (70:17): [True: 237, False: 19.4M]
  ------------------
   71|    237|                    sink.push_back('\\');
   72|    237|                    sink.push_back('f');
   73|    237|                    count += 2;
   74|    237|                    break;
   75|    194|                case '\n':
  ------------------
  |  Branch (75:17): [True: 194, False: 19.4M]
  ------------------
   76|    194|                    sink.push_back('\\');
   77|    194|                    sink.push_back('n');
   78|    194|                    count += 2;
   79|    194|                    break;
   80|    247|                case '\r':
  ------------------
  |  Branch (80:17): [True: 247, False: 19.4M]
  ------------------
   81|    247|                    sink.push_back('\\');
   82|    247|                    sink.push_back('r');
   83|    247|                    count += 2;
   84|    247|                    break;
   85|    197|                case '\t':
  ------------------
  |  Branch (85:17): [True: 197, False: 19.4M]
  ------------------
   86|    197|                    sink.push_back('\\');
   87|    197|                    sink.push_back('t');
   88|    197|                    count += 2;
   89|    197|                    break;
   90|  19.4M|                default:
  ------------------
  |  Branch (90:17): [True: 19.4M, False: 35.9k]
  ------------------
   91|  19.4M|                    if (escape_solidus && c == '/')
  ------------------
  |  Branch (91:25): [True: 0, False: 19.4M]
  |  Branch (91:43): [True: 0, False: 0]
  ------------------
   92|      0|                    {
   93|      0|                        sink.push_back('\\');
   94|      0|                        sink.push_back('/');
   95|      0|                        count += 2;
   96|      0|                    }
   97|  19.4M|                    else if (is_control_character(c) || escape_all_non_ascii)
  ------------------
  |  Branch (97:30): [True: 17.1M, False: 2.32M]
  |  Branch (97:57): [True: 0, False: 2.32M]
  ------------------
   98|  17.1M|                    {
   99|       |                        // convert to codepoint
  100|  17.1M|                        uint32_t cp;
  101|  17.1M|                        auto r = unicode_traits::to_codepoint(it, end, cp, unicode_traits::conv_flags::strict);
  102|  17.1M|                        if (r.ec != unicode_traits::conv_errc())
  ------------------
  |  Branch (102:29): [True: 0, False: 17.1M]
  ------------------
  103|      0|                        {
  104|      0|                            JSONCONS_THROW(ser_error(json_errc::illegal_codepoint));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  105|      0|                        }
  106|  17.1M|                        it = r.ptr - 1;
  107|  17.1M|                        if (is_non_ascii_codepoint(cp) || is_control_character(c))
  ------------------
  |  Branch (107:29): [True: 0, False: 17.1M]
  |  Branch (107:59): [True: 17.1M, False: 0]
  ------------------
  108|  17.1M|                        {
  109|  17.1M|                            if (cp > 0xFFFF)
  ------------------
  |  Branch (109:33): [True: 0, False: 17.1M]
  ------------------
  110|      0|                            {
  111|      0|                                cp -= 0x10000;
  112|      0|                                uint32_t first = (cp >> 10) + 0xD800;
  113|      0|                                uint32_t second = ((cp & 0x03FF) + 0xDC00);
  114|       |
  115|      0|                                sink.push_back('\\');
  116|      0|                                sink.push_back('u');
  117|      0|                                sink.push_back(jsoncons::detail::to_hex_character(first >> 12 & 0x000F));
  118|      0|                                sink.push_back(jsoncons::detail::to_hex_character(first >> 8 & 0x000F));
  119|      0|                                sink.push_back(jsoncons::detail::to_hex_character(first >> 4 & 0x000F));
  120|      0|                                sink.push_back(jsoncons::detail::to_hex_character(first & 0x000F));
  121|      0|                                sink.push_back('\\');
  122|      0|                                sink.push_back('u');
  123|      0|                                sink.push_back(jsoncons::detail::to_hex_character(second >> 12 & 0x000F));
  124|      0|                                sink.push_back(jsoncons::detail::to_hex_character(second >> 8 & 0x000F));
  125|      0|                                sink.push_back(jsoncons::detail::to_hex_character(second >> 4 & 0x000F));
  126|      0|                                sink.push_back(jsoncons::detail::to_hex_character(second & 0x000F));
  127|      0|                                count += 12;
  128|      0|                            }
  129|  17.1M|                            else
  130|  17.1M|                            {
  131|  17.1M|                                sink.push_back('\\');
  132|  17.1M|                                sink.push_back('u');
  133|  17.1M|                                sink.push_back(jsoncons::detail::to_hex_character(cp >> 12 & 0x000F));
  134|  17.1M|                                sink.push_back(jsoncons::detail::to_hex_character(cp >> 8 & 0x000F));
  135|  17.1M|                                sink.push_back(jsoncons::detail::to_hex_character(cp >> 4 & 0x000F));
  136|  17.1M|                                sink.push_back(jsoncons::detail::to_hex_character(cp & 0x000F));
  137|  17.1M|                                count += 6;
  138|  17.1M|                            }
  139|  17.1M|                        }
  140|      0|                        else
  141|      0|                        {
  142|      0|                            sink.push_back(c);
  143|      0|                            ++count;
  144|      0|                        }
  145|  17.1M|                    }
  146|  2.32M|                    else
  147|  2.32M|                    {
  148|  2.32M|                        sink.push_back(c);
  149|  2.32M|                        ++count;
  150|  2.32M|                    }
  151|  19.4M|                    break;
  152|  19.4M|            }
  153|  19.4M|        }
  154|   147k|        return count;
  155|   147k|    }
_ZN8jsoncons6detail20is_control_characterEj:
   32|  36.5M|    {
   33|  36.5M|        return c <= 0x1F || c == 0x7f;
  ------------------
  |  Branch (33:16): [True: 510, False: 36.5M]
  |  Branch (33:29): [True: 34.2M, False: 2.32M]
  ------------------
   34|  36.5M|    }
_ZN8jsoncons6detail22is_non_ascii_codepointEj:
   38|  17.1M|    {
   39|  17.1M|        return cp >= 0x80;
   40|  17.1M|    }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  637|   217k|        {
  638|   217k|            if (!stack_.empty()) 
  ------------------
  |  Branch (638:17): [True: 217k, False: 2]
  ------------------
  639|   217k|            {
  640|   217k|                if (stack_.back().is_array())
  ------------------
  |  Branch (640:21): [True: 216k, False: 344]
  ------------------
  641|   216k|                {
  642|   216k|                    begin_scalar_value();
  643|   216k|                }
  644|   217k|                if (!stack_.back().is_multi_line() && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (644:21): [True: 215k, False: 1.86k]
  |  Branch (644:55): [True: 197k, False: 17.7k]
  ------------------
  645|   197k|                {
  646|   197k|                    break_line();
  647|   197k|                }
  648|   217k|            }
  649|       |
  650|   217k|            sink_.append(null_constant().data(), null_constant().size());
  651|   217k|            column_ += null_constant().size();
  652|       |
  653|   217k|            end_value();
  654|   217k|            return true;
  655|   217k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E18begin_scalar_valueEv:
  918|  7.07M|        {
  919|  7.07M|            if (!stack_.empty())
  ------------------
  |  Branch (919:17): [True: 7.07M, False: 0]
  ------------------
  920|  7.07M|            {
  921|  7.07M|                if (stack_.back().count() > 0)
  ------------------
  |  Branch (921:21): [True: 7.06M, False: 16.7k]
  ------------------
  922|  7.06M|                {
  923|  7.06M|                    sink_.append(comma_str_.data(),comma_str_.length());
  924|  7.06M|                    column_ += comma_str_.length();
  925|  7.06M|                }
  926|  7.07M|                if (stack_.back().is_multi_line() || stack_.back().is_indent_once())
  ------------------
  |  Branch (926:21): [True: 2.68M, False: 4.38M]
  |  Branch (926:54): [True: 0, False: 4.38M]
  ------------------
  927|  2.68M|                {
  928|  2.68M|                    stack_.back().new_line_after(true);
  929|  2.68M|                    new_line();
  930|  2.68M|                }
  931|  7.07M|            }
  932|  7.07M|        }
_ZNK8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context14is_indent_onceEv:
  300|  4.38M|            {
  301|  4.38M|                return count_ == 0 ? indent_before_ : false;
  ------------------
  |  Branch (301:24): [True: 15.4k, False: 4.37M]
  ------------------
  302|  4.38M|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E13null_constantEv:
  195|   673k|        {
  196|   673k|            static const jsoncons::basic_string_view<CharT> k = JSONCONS_STRING_VIEW_CONSTANT(CharT, "null");
  ------------------
  |  |  297|   673k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) string_view_constant_of_type<CharT>(Str, JSONCONS_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  293|   673k|#define JSONCONS_WIDEN(A) JSONCONS_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  291|   673k|#define JSONCONS_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  197|   673k|            return k;
  198|   673k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  889|   757k|        {
  890|   757k|            if (!stack_.empty()) 
  ------------------
  |  Branch (890:17): [True: 757k, False: 5]
  ------------------
  891|   757k|            {
  892|   757k|                if (stack_.back().is_array())
  ------------------
  |  Branch (892:21): [True: 757k, False: 353]
  ------------------
  893|   757k|                {
  894|   757k|                    begin_scalar_value();
  895|   757k|                }
  896|   757k|                if (!stack_.back().is_multi_line() && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (896:21): [True: 134k, False: 623k]
  |  Branch (896:55): [True: 10.3k, False: 124k]
  ------------------
  897|  10.3k|                {
  898|  10.3k|                    break_line();
  899|  10.3k|                }
  900|   757k|            }
  901|       |
  902|   757k|            if (value)
  ------------------
  |  Branch (902:17): [True: 438k, False: 319k]
  ------------------
  903|   438k|            {
  904|   438k|                sink_.append(true_constant().data(), true_constant().size());
  905|   438k|                column_ += true_constant().size();
  906|   438k|            }
  907|   319k|            else
  908|   319k|            {
  909|   319k|                sink_.append(false_constant().data(), false_constant().size());
  910|   319k|                column_ += false_constant().size();
  911|   319k|            }
  912|       |
  913|   757k|            end_value();
  914|   757k|            return true;
  915|   757k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E13true_constantEv:
  200|  1.31M|        {
  201|  1.31M|            static const jsoncons::basic_string_view<CharT> k = JSONCONS_STRING_VIEW_CONSTANT(CharT, "true");
  ------------------
  |  |  297|  1.31M|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) string_view_constant_of_type<CharT>(Str, JSONCONS_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  293|  1.31M|#define JSONCONS_WIDEN(A) JSONCONS_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  291|  1.31M|#define JSONCONS_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  202|  1.31M|            return k;
  203|  1.31M|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E14false_constantEv:
  205|   957k|        {
  206|   957k|            static const jsoncons::basic_string_view<CharT> k = JSONCONS_STRING_VIEW_CONSTANT(CharT, "false");
  ------------------
  |  |  297|   957k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) string_view_constant_of_type<CharT>(Str, JSONCONS_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  293|   957k|#define JSONCONS_WIDEN(A) JSONCONS_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  291|   957k|#define JSONCONS_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  207|   957k|            return k;
  208|   957k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E12visit_stringERKNS_6detail17basic_string_viewIcS5_EENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  658|  21.4k|        {
  659|  21.4k|            if (!stack_.empty()) 
  ------------------
  |  Branch (659:17): [True: 21.0k, False: 336]
  ------------------
  660|  21.0k|            {
  661|  21.0k|                if (stack_.back().is_array())
  ------------------
  |  Branch (661:21): [True: 20.8k, False: 294]
  ------------------
  662|  20.8k|                {
  663|  20.8k|                    begin_scalar_value();
  664|  20.8k|                }
  665|  21.0k|                if (!stack_.back().is_multi_line() && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (665:21): [True: 12.2k, False: 8.81k]
  |  Branch (665:55): [True: 5.97k, False: 6.30k]
  ------------------
  666|  5.97k|                {
  667|  5.97k|                    break_line();
  668|  5.97k|                }
  669|  21.0k|            }
  670|       |
  671|  21.4k|            switch (tag)
  672|  21.4k|            {
  673|  10.8k|                case semantic_tag::bigint:
  ------------------
  |  Branch (673:17): [True: 10.8k, False: 10.5k]
  ------------------
  674|  10.8k|                    write_bigint_value(sv);
  675|  10.8k|                    break;
  676|  10.5k|                default:
  ------------------
  |  Branch (676:17): [True: 10.5k, False: 10.8k]
  ------------------
  677|  10.5k|                {
  678|  10.5k|                    sink_.push_back('\"');
  679|  10.5k|                    std::size_t length = jsoncons::detail::escape_string(sv.data(), sv.length(),options_.escape_all_non_ascii(),options_.escape_solidus(),sink_);
  680|  10.5k|                    sink_.push_back('\"');
  681|  10.5k|                    column_ += (length+2);
  682|  10.5k|                    break;
  683|      0|                }
  684|  21.4k|            }
  685|       |
  686|  21.4k|            end_value();
  687|  21.4k|            return true;
  688|  21.4k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E18write_bigint_valueERKNS_6detail17basic_string_viewIcS5_EE:
  935|  10.8k|        {
  936|  10.8k|            switch (options_.bigint_format())
  937|  10.8k|            {
  938|      0|                case bigint_chars_format::number:
  ------------------
  |  Branch (938:17): [True: 0, False: 10.8k]
  ------------------
  939|      0|                {
  940|      0|                    sink_.append(sv.data(),sv.size());
  941|      0|                    column_ += sv.size();
  942|      0|                    break;
  943|      0|                }
  944|      0|                case bigint_chars_format::base64:
  ------------------
  |  Branch (944:17): [True: 0, False: 10.8k]
  ------------------
  945|      0|                {
  946|      0|                    bigint n = bigint::from_string(sv.data(), sv.length());
  947|      0|                    bool is_neg = n < 0;
  948|      0|                    if (is_neg)
  ------------------
  |  Branch (948:25): [True: 0, False: 0]
  ------------------
  949|      0|                    {
  950|      0|                        n = - n -1;
  951|      0|                    }
  952|      0|                    int signum;
  953|      0|                    std::vector<uint8_t> v;
  954|      0|                    n.write_bytes_be(signum, v);
  955|       |
  956|      0|                    sink_.push_back('\"');
  957|      0|                    if (is_neg)
  ------------------
  |  Branch (957:25): [True: 0, False: 0]
  ------------------
  958|      0|                    {
  959|      0|                        sink_.push_back('~');
  960|      0|                        ++column_;
  961|      0|                    }
  962|      0|                    std::size_t length = encode_base64(v.begin(), v.end(), sink_);
  963|      0|                    sink_.push_back('\"');
  964|      0|                    column_ += (length+2);
  965|      0|                    break;
  966|      0|                }
  967|      0|                case bigint_chars_format::base64url:
  ------------------
  |  Branch (967:17): [True: 0, False: 10.8k]
  ------------------
  968|      0|                {
  969|      0|                    bigint n = bigint::from_string(sv.data(), sv.length());
  970|      0|                    bool is_neg = n < 0;
  971|      0|                    if (is_neg)
  ------------------
  |  Branch (971:25): [True: 0, False: 0]
  ------------------
  972|      0|                    {
  973|      0|                        n = - n -1;
  974|      0|                    }
  975|      0|                    int signum;
  976|      0|                    std::vector<uint8_t> v;
  977|      0|                    n.write_bytes_be(signum, v);
  978|       |
  979|      0|                    sink_.push_back('\"');
  980|      0|                    if (is_neg)
  ------------------
  |  Branch (980:25): [True: 0, False: 0]
  ------------------
  981|      0|                    {
  982|      0|                        sink_.push_back('~');
  983|      0|                        ++column_;
  984|      0|                    }
  985|      0|                    std::size_t length = encode_base64url(v.begin(), v.end(), sink_);
  986|      0|                    sink_.push_back('\"');
  987|      0|                    column_ += (length+2);
  988|      0|                    break;
  989|      0|                }
  990|  10.8k|                default:
  ------------------
  |  Branch (990:17): [True: 10.8k, False: 0]
  ------------------
  991|  10.8k|                {
  992|  10.8k|                    sink_.push_back('\"');
  993|  10.8k|                    sink_.append(sv.data(),sv.size());
  994|  10.8k|                    sink_.push_back('\"');
  995|  10.8k|                    column_ += (sv.size() + 2);
  996|  10.8k|                    break;
  997|      0|                }
  998|  10.8k|            }
  999|  10.8k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  870|  4.34M|        {
  871|  4.34M|            if (!stack_.empty()) 
  ------------------
  |  Branch (871:17): [True: 4.34M, False: 347]
  ------------------
  872|  4.34M|            {
  873|  4.34M|                if (stack_.back().is_array())
  ------------------
  |  Branch (873:21): [True: 4.21M, False: 132k]
  ------------------
  874|  4.21M|                {
  875|  4.21M|                    begin_scalar_value();
  876|  4.21M|                }
  877|  4.34M|                if (!stack_.back().is_multi_line() && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (877:21): [True: 2.85M, False: 1.49M]
  |  Branch (877:55): [True: 737k, False: 2.11M]
  ------------------
  878|   737k|                {
  879|   737k|                    break_line();
  880|   737k|                }
  881|  4.34M|            }
  882|  4.34M|            std::size_t length = jsoncons::detail::from_integer(value, sink_);
  883|  4.34M|            column_ += length;
  884|  4.34M|            end_value();
  885|  4.34M|            return true;
  886|  4.34M|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  848|   497k|        {
  849|   497k|            if (!stack_.empty()) 
  ------------------
  |  Branch (849:17): [True: 496k, False: 237]
  ------------------
  850|   496k|            {
  851|   496k|                if (stack_.back().is_array())
  ------------------
  |  Branch (851:21): [True: 496k, False: 197]
  ------------------
  852|   496k|                {
  853|   496k|                    begin_scalar_value();
  854|   496k|                }
  855|   496k|                if (!stack_.back().is_multi_line() && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (855:21): [True: 490k, False: 6.17k]
  |  Branch (855:55): [True: 158k, False: 332k]
  ------------------
  856|   158k|                {
  857|   158k|                    break_line();
  858|   158k|                }
  859|   496k|            }
  860|   497k|            std::size_t length = jsoncons::detail::from_integer(value, sink_);
  861|   497k|            column_ += length;
  862|   497k|            end_value();
  863|   497k|            return true;
  864|   497k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  767|  1.37M|        {
  768|  1.37M|            if (!stack_.empty()) 
  ------------------
  |  Branch (768:17): [True: 1.37M, False: 1.12k]
  ------------------
  769|  1.37M|            {
  770|  1.37M|                if (stack_.back().is_array())
  ------------------
  |  Branch (770:21): [True: 1.37M, False: 580]
  ------------------
  771|  1.37M|                {
  772|  1.37M|                    begin_scalar_value();
  773|  1.37M|                }
  774|  1.37M|                if (!stack_.back().is_multi_line() && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (774:21): [True: 683k, False: 691k]
  |  Branch (774:55): [True: 451k, False: 231k]
  ------------------
  775|   451k|                {
  776|   451k|                    break_line();
  777|   451k|                }
  778|  1.37M|            }
  779|       |
  780|  1.37M|            if (!std::isfinite(value))
  ------------------
  |  Branch (780:17): [True: 7.31k, False: 1.36M]
  ------------------
  781|  7.31k|            {
  782|  7.31k|                if ((std::isnan)(value))
  ------------------
  |  Branch (782:21): [True: 0, False: 7.31k]
  ------------------
  783|      0|                {
  784|      0|                    if (options_.enable_nan_to_num())
  ------------------
  |  Branch (784:25): [True: 0, False: 0]
  ------------------
  785|      0|                    {
  786|      0|                        sink_.append(options_.nan_to_num().data(), options_.nan_to_num().length());
  787|      0|                        column_ += options_.nan_to_num().length();
  788|      0|                    }
  789|      0|                    else if (options_.enable_nan_to_str())
  ------------------
  |  Branch (789:30): [True: 0, False: 0]
  ------------------
  790|      0|                    {
  791|      0|                        visit_string(options_.nan_to_str(), semantic_tag::none, context, ec);
  792|      0|                    }
  793|      0|                    else
  794|      0|                    {
  795|      0|                        sink_.append(null_constant().data(), null_constant().size());
  796|      0|                        column_ += null_constant().size();
  797|      0|                    }
  798|      0|                }
  799|  7.31k|                else if (value == std::numeric_limits<double>::infinity())
  ------------------
  |  Branch (799:26): [True: 5.70k, False: 1.61k]
  ------------------
  800|  5.70k|                {
  801|  5.70k|                    if (options_.enable_inf_to_num())
  ------------------
  |  Branch (801:25): [True: 0, False: 5.70k]
  ------------------
  802|      0|                    {
  803|      0|                        sink_.append(options_.inf_to_num().data(), options_.inf_to_num().length());
  804|      0|                        column_ += options_.inf_to_num().length();
  805|      0|                    }
  806|  5.70k|                    else if (options_.enable_inf_to_str())
  ------------------
  |  Branch (806:30): [True: 0, False: 5.70k]
  ------------------
  807|      0|                    {
  808|      0|                        visit_string(options_.inf_to_str(), semantic_tag::none, context, ec);
  809|      0|                    }
  810|  5.70k|                    else
  811|  5.70k|                    {
  812|  5.70k|                        sink_.append(null_constant().data(), null_constant().size());
  813|  5.70k|                        column_ += null_constant().size();
  814|  5.70k|                    }
  815|  5.70k|                }
  816|  1.61k|                else
  817|  1.61k|                {
  818|  1.61k|                    if (options_.enable_neginf_to_num())
  ------------------
  |  Branch (818:25): [True: 0, False: 1.61k]
  ------------------
  819|      0|                    {
  820|      0|                        sink_.append(options_.neginf_to_num().data(), options_.neginf_to_num().length());
  821|      0|                        column_ += options_.neginf_to_num().length();
  822|      0|                    }
  823|  1.61k|                    else if (options_.enable_neginf_to_str())
  ------------------
  |  Branch (823:30): [True: 0, False: 1.61k]
  ------------------
  824|      0|                    {
  825|      0|                        visit_string(options_.neginf_to_str(), semantic_tag::none, context, ec);
  826|      0|                    }
  827|  1.61k|                    else
  828|  1.61k|                    {
  829|  1.61k|                        sink_.append(null_constant().data(), null_constant().size());
  830|  1.61k|                        column_ += null_constant().size();
  831|  1.61k|                    }
  832|  1.61k|                }
  833|  7.31k|            }
  834|  1.36M|            else
  835|  1.36M|            {
  836|  1.36M|                std::size_t length = fp_(value, sink_);
  837|  1.36M|                column_ += length;
  838|  1.36M|            }
  839|       |
  840|  1.37M|            end_value();
  841|  1.37M|            return true;
  842|  1.37M|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_ED2Ev:
  396|  5.76k|        {
  397|  5.76k|            JSONCONS_TRY
  ------------------
  |  |  239|  5.76k|    #define JSONCONS_TRY try
  ------------------
  398|  5.76k|            {
  399|  5.76k|                sink_.flush();
  400|  5.76k|            }
  401|  5.76k|            JSONCONS_CATCH(...)
  402|  5.76k|            {
  403|      0|            }
  404|  5.76k|        }

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

_ZN8jsoncons25basic_json_options_commonIcED2Ev:
  137|  23.0k|    virtual ~basic_json_options_common() noexcept = default;
_ZN8jsoncons25basic_json_encode_optionsIcEC1Ev:
  446|  5.76k|    {
  447|  5.76k|        new_line_chars_.push_back('\n');
  448|  5.76k|    }
_ZN8jsoncons25basic_json_options_commonIcEC2Ev:
  135|  11.5k|    {}
_ZN8jsoncons25basic_json_encode_optionsIcEC1ERKS1_:
  450|  5.76k|    basic_json_encode_options(const basic_json_encode_options&) = default;
_ZN8jsoncons25basic_json_options_commonIcEC2ERKS1_:
  139|  11.5k|    basic_json_options_common(const basic_json_options_common&) = default;
_ZNK8jsoncons25basic_json_encode_optionsIcE12float_formatEv:
  524|  5.76k|    {
  525|  5.76k|        return float_format_;
  526|  5.76k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE9precisionEv:
  529|  5.76k|    {
  530|  5.76k|        return precision_;
  531|  5.76k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE19spaces_around_colonEv:
  494|  5.76k|    {
  495|  5.76k|        return spaces_around_colon_;
  496|  5.76k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE19spaces_around_commaEv:
  499|  5.76k|    {
  500|  5.76k|        return spaces_around_comma_;
  501|  5.76k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE24pad_inside_object_bracesEv:
  504|  5.76k|    {
  505|  5.76k|        return pad_inside_object_braces_;
  506|  5.76k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE25pad_inside_array_bracketsEv:
  509|  5.76k|    {
  510|  5.76k|        return pad_inside_array_brackets_;
  511|  5.76k|    }
_ZNK8jsoncons25basic_json_options_commonIcE17max_nesting_depthEv:
  314|   140k|    {
  315|   140k|        return max_nesting_depth_;
  316|   140k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE25object_object_line_splitsEv:
  480|  2.97k|    line_split_kind object_object_line_splits() const  {return object_object_line_splits_;}
_ZNK8jsoncons25basic_json_encode_optionsIcE17line_length_limitEv:
  519|  4.38M|    {
  520|  4.38M|        return line_length_limit_;
  521|  4.38M|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE24array_object_line_splitsEv:
  482|  34.5k|    line_split_kind array_object_line_splits() const  {return array_object_line_splits_;}
_ZNK8jsoncons25basic_json_encode_optionsIcE14new_line_charsEv:
  514|  8.91M|    {
  515|  8.91M|        return new_line_chars_;
  516|  8.91M|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE11indent_sizeEv:
  489|  93.8k|    {
  490|  93.8k|        return indent_size_;
  491|  93.8k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE24object_array_line_splitsEv:
  484|  1.62k|    line_split_kind object_array_line_splits() const  {return object_array_line_splits_;}
_ZNK8jsoncons25basic_json_encode_optionsIcE23array_array_line_splitsEv:
  486|  96.5k|    line_split_kind array_array_line_splits() const  {return array_array_line_splits_;}
_ZNK8jsoncons25basic_json_encode_optionsIcE20escape_all_non_asciiEv:
  534|   147k|    {
  535|   147k|        return escape_all_non_ascii_;
  536|   147k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE14escape_solidusEv:
  539|   147k|    {
  540|   147k|        return escape_solidus_;
  541|   147k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE13bigint_formatEv:
  478|  10.8k|    bigint_chars_format bigint_format() const  {return bigint_format_;}
_ZNK8jsoncons25basic_json_options_commonIcE17enable_inf_to_numEv:
  152|  5.70k|    {
  153|  5.70k|        return enable_inf_to_num_;
  154|  5.70k|    }
_ZNK8jsoncons25basic_json_options_commonIcE17enable_inf_to_strEv:
  172|  5.70k|    {
  173|  5.70k|        return enable_inf_to_str_;
  174|  5.70k|    }
_ZNK8jsoncons25basic_json_options_commonIcE20enable_neginf_to_numEv:
  157|  1.61k|    {
  158|  1.61k|        return enable_neginf_to_num_ || enable_inf_to_num_;
  ------------------
  |  Branch (158:16): [True: 0, False: 1.61k]
  |  Branch (158:41): [True: 0, False: 1.61k]
  ------------------
  159|  1.61k|    }
_ZNK8jsoncons25basic_json_options_commonIcE20enable_neginf_to_strEv:
  182|  1.61k|    {
  183|  1.61k|        return enable_neginf_to_str_ || enable_inf_to_str_;
  ------------------
  |  Branch (183:16): [True: 0, False: 1.61k]
  |  Branch (183:41): [True: 0, False: 1.61k]
  ------------------
  184|  1.61k|    }
_ZN8jsoncons25basic_json_decode_optionsIcEC1Ev:
  368|  5.76k|    {
  369|  5.76k|    }
_ZN8jsoncons20default_json_parsingclENS_9json_errcERKNS_11ser_contextE:
   53|  14.2k|    {
   54|  14.2k|        return ec == json_errc::illegal_comment;
   55|  14.2k|    }
_ZN8jsoncons25basic_json_decode_optionsIcEC1ERKS1_:
  371|  5.76k|    basic_json_decode_options(const basic_json_decode_options&) = default;
_ZNK8jsoncons25basic_json_options_commonIcE17enable_str_to_nanEv:
  167|  5.76k|    {
  168|  5.76k|        return enable_str_to_nan_;
  169|  5.76k|    }
_ZNK8jsoncons25basic_json_options_commonIcE17enable_str_to_infEv:
  177|  5.76k|    {
  178|  5.76k|        return enable_str_to_inf_;
  179|  5.76k|    }
_ZNK8jsoncons25basic_json_options_commonIcE20enable_str_to_neginfEv:
  187|  5.76k|    {
  188|  5.76k|        return enable_str_to_neginf_ || enable_str_to_inf_;
  ------------------
  |  Branch (188:16): [True: 0, False: 5.76k]
  |  Branch (188:41): [True: 0, False: 5.76k]
  ------------------
  189|  5.76k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE15lossless_numberEv:
  381|  1.37M|    {
  382|  1.37M|        return lossless_number_;
  383|  1.37M|    }

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

_ZN8jsoncons17basic_json_readerIcNS_13stream_sourceIcEENSt3__19allocatorIcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES5_EEEEOT_RNS_18basic_json_visitorIcEERKS5_:
  229|  5.76k|        {
  230|  5.76k|        }
_ZN8jsoncons17basic_json_readerIcNS_13stream_sourceIcEENSt3__19allocatorIcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES5_EEEEOT_RNS_18basic_json_visitorIcEERKNS_25basic_json_decode_optionsIcEENS3_8functionIFbNS_9json_errcERKNS_11ser_contextEEEERKS5_:
  267|  5.76k|        {
  268|  5.76k|        }
_ZN8jsoncons17basic_json_readerIcNS_13stream_sourceIcEENSt3__19allocatorIcEEE4readERNS3_10error_codeE:
  415|  5.76k|        {
  416|  5.76k|            read_next(ec);
  417|  5.76k|            if (!ec)
  ------------------
  |  Branch (417:17): [True: 2.20k, False: 3.56k]
  ------------------
  418|  2.20k|            {
  419|  2.20k|                check_done(ec);
  420|  2.20k|            }
  421|  5.76k|        }
_ZN8jsoncons17basic_json_readerIcNS_13stream_sourceIcEENSt3__19allocatorIcEEE9read_nextERNS3_10error_codeE:
  294|  5.76k|        {
  295|  5.76k|            if (source_.is_error())
  ------------------
  |  Branch (295:17): [True: 0, False: 5.76k]
  ------------------
  296|      0|            {
  297|      0|                ec = json_errc::source_error;
  298|      0|                return;
  299|      0|            }        
  300|  5.76k|            parser_.reset();
  301|  18.6k|            while (!parser_.stopped())
  ------------------
  |  Branch (301:20): [True: 16.5k, False: 2.10k]
  ------------------
  302|  16.5k|            {
  303|  16.5k|                if (parser_.source_exhausted())
  ------------------
  |  Branch (303:21): [True: 16.5k, False: 0]
  ------------------
  304|  16.5k|                {
  305|  16.5k|                    auto s = source_.read_buffer(ec);
  306|  16.5k|                    if (ec) return;
  ------------------
  |  Branch (306:25): [True: 17, False: 16.4k]
  ------------------
  307|  16.4k|                    if (s.size() > 0)
  ------------------
  |  Branch (307:25): [True: 10.0k, False: 6.45k]
  ------------------
  308|  10.0k|                    {
  309|  10.0k|                        parser_.update(s.data(),s.size());
  310|  10.0k|                    }
  311|  16.4k|                }
  312|  16.4k|                bool eof = parser_.source_exhausted();
  313|  16.4k|                parser_.parse_some(visitor_, ec);
  314|  16.4k|                if (ec) return;
  ------------------
  |  Branch (314:21): [True: 2.60k, False: 13.8k]
  ------------------
  315|  13.8k|                if (eof)
  ------------------
  |  Branch (315:21): [True: 4.79k, False: 9.08k]
  ------------------
  316|  4.79k|                {
  317|  4.79k|                    if (parser_.enter())
  ------------------
  |  Branch (317:25): [True: 97, False: 4.70k]
  ------------------
  318|     97|                    {
  319|     97|                        break;
  320|     97|                    }
  321|  4.70k|                    else if (!parser_.accept())
  ------------------
  |  Branch (321:30): [True: 943, False: 3.75k]
  ------------------
  322|    943|                    {
  323|    943|                        ec = json_errc::unexpected_eof;
  324|    943|                        return;
  325|    943|                    }
  326|  4.79k|                }
  327|  13.8k|            }
  328|       |            
  329|  2.39k|            while (!source_.eof())
  ------------------
  |  Branch (329:20): [True: 215, False: 2.17k]
  ------------------
  330|    215|            {
  331|    215|                parser_.skip_whitespace();
  332|    215|                if (parser_.source_exhausted())
  ------------------
  |  Branch (332:21): [True: 194, False: 21]
  ------------------
  333|    194|                {
  334|    194|                    auto s = source_.read_buffer(ec);
  335|    194|                    if (ec) return;
  ------------------
  |  Branch (335:25): [True: 0, False: 194]
  ------------------
  336|    194|                    if (s.size() > 0)
  ------------------
  |  Branch (336:25): [True: 183, False: 11]
  ------------------
  337|    183|                    {
  338|    183|                        parser_.update(s.data(),s.size());
  339|    183|                    }
  340|    194|                }
  341|     21|                else
  342|     21|                {
  343|     21|                    break;
  344|     21|                }
  345|    215|            }
  346|  2.20k|        }
_ZN8jsoncons17basic_json_readerIcNS_13stream_sourceIcEENSt3__19allocatorIcEEE10check_doneERNS3_10error_codeE:
  369|  2.20k|        {
  370|  2.20k|            if (source_.is_error())
  ------------------
  |  Branch (370:17): [True: 0, False: 2.20k]
  ------------------
  371|      0|            {
  372|      0|                ec = json_errc::source_error;
  373|      0|                return;
  374|      0|            }   
  375|  2.20k|            if (source_.eof())
  ------------------
  |  Branch (375:17): [True: 2.17k, False: 21]
  ------------------
  376|  2.17k|            {
  377|  2.17k|                parser_.check_done(ec);
  378|  2.17k|                if (ec) return;
  ------------------
  |  Branch (378:21): [True: 30, False: 2.14k]
  ------------------
  379|  2.17k|            }
  380|     21|            else
  381|     21|            {
  382|     21|                do
  383|     21|                {
  384|     21|                    if (parser_.source_exhausted())
  ------------------
  |  Branch (384:25): [True: 0, False: 21]
  ------------------
  385|      0|                    {
  386|      0|                        auto s = source_.read_buffer(ec);
  387|      0|                        if (ec) return;
  ------------------
  |  Branch (387:29): [True: 0, False: 0]
  ------------------
  388|      0|                        if (s.size() > 0)
  ------------------
  |  Branch (388:29): [True: 0, False: 0]
  ------------------
  389|      0|                        {
  390|      0|                            parser_.update(s.data(),s.size());
  391|      0|                        }
  392|      0|                    }
  393|     21|                    if (!parser_.source_exhausted())
  ------------------
  |  Branch (393:25): [True: 21, False: 0]
  ------------------
  394|     21|                    {
  395|     21|                        parser_.check_done(ec);
  396|     21|                        if (ec) return;
  ------------------
  |  Branch (396:29): [True: 21, False: 0]
  ------------------
  397|     21|                    }
  398|     21|                }
  399|     21|                while (!eof());
  ------------------
  |  Branch (399:24): [True: 0, False: 0]
  ------------------
  400|     21|            }
  401|  2.20k|        }

_ZN8jsoncons18basic_json_visitorIcED2Ev:
   38|  11.5k|        virtual ~basic_json_visitor() noexcept = default;
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
   36|  11.5k|        basic_json_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  335|  4.34M|        {
  336|  4.34M|            return visit_uint64(value, tag, context, ec);
  337|  4.34M|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  279|  6.53k|        {
  280|  6.53k|            return visit_end_array(context, ec);
  281|  6.53k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  343|   497k|        {
  344|   497k|            return visit_int64(value, tag, context, ec);
  345|   497k|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  359|  1.37M|        {
  360|  1.37M|            return visit_double(value, tag, context, ec);
  361|  1.37M|        }
_ZN8jsoncons26basic_default_json_visitorIcEC2EbNSt3__110error_codeE:
  931|  5.76k|        {
  932|  5.76k|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
   41|  2.10k|        {
   42|  2.10k|            visit_flush();
   43|  2.10k|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNS_6detail17basic_string_viewIcNSt3__111char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS4_10error_codeE:
  307|  21.4k|        {
  308|  21.4k|            return visit_string(value, tag, context, ec);
  309|  21.4k|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  251|  19.3k|        {
  252|  19.3k|            return visit_begin_object(tag, context, ec);
  253|  19.3k|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  269|  51.0k|        {
  270|  51.0k|            return visit_begin_array(tag, context, ec);
  271|  51.0k|        }
_ZN8jsoncons18basic_json_visitorIcE3keyERKNS_6detail17basic_string_viewIcNSt3__111char_traitsIcEEEERKNS_11ser_contextERNS4_10error_codeE:
  284|   137k|        {
  285|   137k|            return visit_key(name, context, ec);
  286|   137k|        }
_ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  264|  16.7k|        {
  265|  16.7k|            return visit_end_object(context, ec);
  266|  16.7k|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  299|   757k|        {
  300|   757k|            return visit_bool(value, tag, context, ec);
  301|   757k|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  291|   217k|        {
  292|   217k|            return visit_null(tag, context, ec);
  293|   217k|        }

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

_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERS7_:
  222|  5.76k|        {
  223|  5.76k|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2EOS8_:
  216|  5.76k|        {
  217|  5.76k|            std::swap(buf_ptr,other.buf_ptr);
  218|  5.76k|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE5flushEv:
  234|  7.87k|        {
  235|  7.87k|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6appendEPKcm:
  238|  12.9M|        {
  239|  12.9M|            buf_ptr->insert(buf_ptr->end(), s, s+length);
  240|  12.9M|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9push_backEc:
  243|  1.63G|        {
  244|  1.63G|            buf_ptr->push_back(ch);
  245|  1.63G|        }

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

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

_ZN8jsoncons14unicode_traits12to_codepointIcjEENSt3__19enable_ifIXaasr16extension_traits8is_char8IT_EE5valuesr16extension_traits9is_char32IT0_EE5valueENS0_14convert_resultIS4_EEE4typeEPKS4_SB_RS5_NS0_10conv_flagsE:
  381|  17.1M|    {
  382|  17.1M|        ch = 0;
  383|  17.1M|        if (first >= last)
  ------------------
  |  Branch (383:13): [True: 0, False: 17.1M]
  ------------------
  384|      0|        {
  385|      0|            return convert_result<CharT>{first, conv_errc::source_exhausted};
  386|      0|        }
  387|  17.1M|        conv_errc  result = conv_errc();
  388|       |
  389|  17.1M|        unsigned short extra_bytes_to_read = trailing_bytes_for_utf8[static_cast<uint8_t>(*first)];
  390|  17.1M|        if (extra_bytes_to_read >= last - first) 
  ------------------
  |  Branch (390:13): [True: 0, False: 17.1M]
  ------------------
  391|      0|        {
  392|      0|            result = conv_errc::source_exhausted; 
  393|      0|            return convert_result<CharT>{first, result};
  394|      0|        }
  395|       |        // Do this check whether lenient or strict 
  396|  17.1M|        if ((result=is_legal_utf8(first, extra_bytes_to_read+1)) != conv_errc()) 
  ------------------
  |  Branch (396:13): [True: 0, False: 17.1M]
  ------------------
  397|      0|        {
  398|      0|            return convert_result<CharT>{first, result};
  399|      0|        }
  400|       |        // The cases all fall through. See "Note A" below.
  401|  17.1M|        switch (extra_bytes_to_read) 
  ------------------
  |  Branch (401:17): [True: 0, False: 17.1M]
  ------------------
  402|  17.1M|        {
  403|      0|            case 5: 
  ------------------
  |  Branch (403:13): [True: 0, False: 17.1M]
  ------------------
  404|      0|                ch += static_cast<uint8_t>(*first++); 
  405|      0|                ch <<= 6;
  406|      0|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|      0|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  407|      0|            case 4: 
  ------------------
  |  Branch (407:13): [True: 0, False: 17.1M]
  ------------------
  408|      0|                ch += static_cast<uint8_t>(*first++); 
  409|      0|                ch <<= 6;
  410|      0|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|      0|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  411|      0|            case 3: 
  ------------------
  |  Branch (411:13): [True: 0, False: 17.1M]
  ------------------
  412|      0|                ch += static_cast<uint8_t>(*first++); 
  413|      0|                ch <<= 6;
  414|      0|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|      0|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  415|      0|            case 2: 
  ------------------
  |  Branch (415:13): [True: 0, False: 17.1M]
  ------------------
  416|      0|                ch += static_cast<uint8_t>(*first++); 
  417|      0|                ch <<= 6;
  418|      0|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|      0|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  419|      0|            case 1: 
  ------------------
  |  Branch (419:13): [True: 0, False: 17.1M]
  ------------------
  420|      0|                ch += static_cast<uint8_t>(*first++); 
  421|      0|                ch <<= 6;
  422|      0|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|      0|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  423|  17.1M|            case 0: 
  ------------------
  |  Branch (423:13): [True: 17.1M, False: 0]
  ------------------
  424|  17.1M|                ch += static_cast<uint8_t>(*first++);
  425|  17.1M|                break;
  426|  17.1M|        }
  427|  17.1M|        ch -= offsets_from_utf8[extra_bytes_to_read];
  428|       |
  429|  17.1M|        if (ch <= max_legal_utf32) {
  ------------------
  |  Branch (429:13): [True: 17.1M, False: 0]
  ------------------
  430|       |            /*
  431|       |             * UTF-16 surrogate values are illegal in UTF-32, and anything
  432|       |             * over Plane 17 (> 0x10FFFF) is illegal.
  433|       |             */
  434|  17.1M|            if (is_surrogate(ch) ) 
  ------------------
  |  Branch (434:17): [True: 0, False: 17.1M]
  ------------------
  435|      0|            {
  436|      0|                if (flags == conv_flags::strict) 
  ------------------
  |  Branch (436:21): [True: 0, False: 0]
  ------------------
  437|      0|                {
  438|      0|                    first -= (extra_bytes_to_read+1); // return to the illegal value itself
  439|      0|                    result = conv_errc::source_illegal;
  440|      0|                    return convert_result<CharT>{first, result};
  441|      0|                } 
  442|      0|                else
  443|      0|                {
  444|      0|                    ch = replacement_char;
  445|      0|                }
  446|      0|            }
  447|  17.1M|        } 
  448|      0|        else // i.e., ch > max_legal_utf32
  449|      0|        { 
  450|      0|            result = conv_errc::source_illegal;
  451|      0|            ch = replacement_char;
  452|      0|        }
  453|       |
  454|  17.1M|        return convert_result<CharT>{first,result} ;
  455|  17.1M|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8IcEENSt3__19enable_ifIXsr16extension_traits8is_char8IT_EE5valueENS0_9conv_errcEE4typeEPKS4_m:
  299|  37.3M|    {
  300|  37.3M|        uint8_t a;
  301|  37.3M|        const CharT* srcptr = first+length;
  302|  37.3M|        switch (length) {
  303|     12|        default:
  ------------------
  |  Branch (303:9): [True: 12, False: 37.3M]
  ------------------
  304|     12|            return conv_errc::over_long_utf8_sequence;
  305|    582|        case 4:
  ------------------
  |  Branch (305:9): [True: 582, False: 37.3M]
  ------------------
  306|    582|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (306:17): [True: 3, False: 579]
  ------------------
  307|      3|                return conv_errc::expected_continuation_byte;
  308|    582|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|    579|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  309|  1.32k|        case 3:
  ------------------
  |  Branch (309:9): [True: 744, False: 37.3M]
  ------------------
  310|  1.32k|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (310:17): [True: 4, False: 1.31k]
  ------------------
  311|      4|                return conv_errc::expected_continuation_byte;
  312|  1.32k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|  1.31k|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  313|  1.64k|        case 2:
  ------------------
  |  Branch (313:9): [True: 327, False: 37.3M]
  ------------------
  314|  1.64k|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 3, False: 1.64k]
  ------------------
  315|      3|                return conv_errc::expected_continuation_byte;
  316|       |
  317|  1.64k|            switch (static_cast<uint8_t>(*first)) 
  318|  1.64k|            {
  319|       |                // no fall-through in this inner switch
  320|    205|                case 0xE0: if (a < 0xA0) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (320:17): [True: 205, False: 1.43k]
  |  Branch (320:32): [True: 7, False: 198]
  ------------------
  321|    441|                case 0xED: if (a > 0x9F) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (321:17): [True: 441, False: 1.20k]
  |  Branch (321:32): [True: 4, False: 437]
  ------------------
  322|    437|                case 0xF0: if (a < 0x90) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (322:17): [True: 204, False: 1.43k]
  |  Branch (322:32): [True: 5, False: 199]
  ------------------
  323|    211|                case 0xF4: if (a > 0x8F) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (323:17): [True: 211, False: 1.43k]
  |  Branch (323:32): [True: 3, False: 208]
  ------------------
  324|    582|                default:   if (a < 0x80) return conv_errc::source_illegal;
  ------------------
  |  Branch (324:17): [True: 582, False: 1.06k]
  |  Branch (324:32): [True: 0, False: 582]
  ------------------
  325|  1.64k|            }
  326|       |
  327|  1.64k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|  1.62k|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  328|  37.3M|        case 1:
  ------------------
  |  Branch (328:9): [True: 37.3M, False: 1.66k]
  ------------------
  329|  37.3M|            if (static_cast<uint8_t>(*first) >= 0x80 && static_cast<uint8_t>(*first) < 0xC2)
  ------------------
  |  Branch (329:17): [True: 1.63k, False: 37.3M]
  |  Branch (329:57): [True: 11, False: 1.62k]
  ------------------
  330|     11|                return conv_errc::source_illegal;
  331|  37.3M|            break;
  332|  37.3M|        }
  333|  37.3M|        if (static_cast<uint8_t>(*first) > 0xF4) 
  ------------------
  |  Branch (333:13): [True: 1, False: 37.3M]
  ------------------
  334|      1|            return conv_errc::source_illegal;
  335|       |
  336|  37.3M|        return conv_errc();
  337|  37.3M|    }
_ZN8jsoncons14unicode_traits12is_surrogateEj:
  215|  17.6M|    {
  216|  17.6M|        return (ch >= sur_high_start && ch <= sur_low_end);
  ------------------
  |  Branch (216:17): [True: 497k, False: 17.1M]
  |  Branch (216:41): [True: 149k, False: 347k]
  ------------------
  217|  17.6M|    }
_ZN8jsoncons14unicode_traits20detect_json_encodingIcEENSt3__19enable_ifIXsr16extension_traits8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m:
  105|  5.76k|    {
  106|  5.76k|        detect_encoding_result<CharT> r = detect_encoding_from_bom(data,length);
  107|  5.76k|        if (r.encoding != encoding_kind::undetected)
  ------------------
  |  Branch (107:13): [True: 27, False: 5.74k]
  ------------------
  108|     27|        {
  109|     27|            return r;
  110|     27|        }
  111|  5.74k|        else if (length < 4)
  ------------------
  |  Branch (111:18): [True: 589, False: 5.15k]
  ------------------
  112|    589|        {
  113|    589|            return detect_encoding_result<CharT>{data,encoding_kind::utf8};
  114|    589|        }
  115|  5.15k|        else if (*data == 0 && *(data+1) == 0 && *(data+2) == 0)
  ------------------
  |  Branch (115:18): [True: 24, False: 5.12k]
  |  Branch (115:32): [True: 15, False: 9]
  |  Branch (115:50): [True: 2, False: 13]
  ------------------
  116|      2|        {
  117|      2|            return detect_encoding_result<CharT>{data,encoding_kind::utf32be};
  118|      2|        }
  119|  5.15k|        else if (*data == 0 && *(data+2) == 0)
  ------------------
  |  Branch (119:18): [True: 22, False: 5.12k]
  |  Branch (119:32): [True: 2, False: 20]
  ------------------
  120|      2|        {
  121|      2|            return detect_encoding_result<CharT>{data,encoding_kind::utf16be};
  122|      2|        }
  123|  5.14k|        else if (*(data+1) == 0 && *(data+2) == 0 && *(data+3) == 0)
  ------------------
  |  Branch (123:18): [True: 20, False: 5.12k]
  |  Branch (123:36): [True: 5, False: 15]
  |  Branch (123:54): [True: 1, False: 4]
  ------------------
  124|      1|        {
  125|      1|            return detect_encoding_result<CharT>{data,encoding_kind::utf32le};
  126|      1|        }
  127|  5.14k|        else if (*(data+1) == 0 && *(data+3) == 0)
  ------------------
  |  Branch (127:18): [True: 19, False: 5.12k]
  |  Branch (127:36): [True: 4, False: 15]
  ------------------
  128|      4|        {
  129|      4|            return detect_encoding_result<CharT>{data,encoding_kind::utf16le};
  130|      4|        }
  131|  5.14k|        else
  132|  5.14k|        {
  133|  5.14k|            return detect_encoding_result<CharT>{data,encoding_kind::utf8};
  134|  5.14k|        }
  135|  5.76k|    }
_ZN8jsoncons14unicode_traits24detect_encoding_from_bomIcEENSt3__19enable_ifIXsr16extension_traits8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m:
   62|  5.76k|    {
   63|  5.76k|        const uint8_t bom_utf8[] = {0xef,0xbb,0xbf}; 
   64|  5.76k|        const uint8_t bom_utf16le[] = {0xff,0xfe}; 
   65|  5.76k|        const uint8_t bom_utf16be[] = {0xfe,0xff}; 
   66|  5.76k|        const uint8_t bom_utf32le[] = {0xff,0xfe,0x00,0x00}; 
   67|  5.76k|        const uint8_t bom_utf32be[] = {0x00,0x00,0xfe,0xff}; 
   68|       |
   69|  5.76k|        if (length >= 4 && !memcmp(data,bom_utf32le,4))
  ------------------
  |  Branch (69:13): [True: 5.17k, False: 592]
  |  Branch (69:28): [True: 1, False: 5.17k]
  ------------------
   70|      1|        {
   71|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32le};
   72|      1|        }
   73|  5.76k|        else if (length >= 4 && !memcmp(data,bom_utf32be,4))
  ------------------
  |  Branch (73:18): [True: 5.17k, False: 592]
  |  Branch (73:33): [True: 1, False: 5.17k]
  ------------------
   74|      1|        {
   75|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32be};
   76|      1|        }
   77|  5.76k|        else if (length >= 2 && !memcmp(data,bom_utf16le,2))
  ------------------
  |  Branch (77:18): [True: 5.71k, False: 54]
  |  Branch (77:33): [True: 5, False: 5.70k]
  ------------------
   78|      5|        {
   79|      5|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16le};
   80|      5|        }
   81|  5.76k|        else if (length >= 2 && !memcmp(data,bom_utf16be,2))
  ------------------
  |  Branch (81:18): [True: 5.70k, False: 54]
  |  Branch (81:33): [True: 1, False: 5.70k]
  ------------------
   82|      1|        {
   83|      1|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16be};
   84|      1|        }
   85|  5.76k|        else if (length >= 3 && !memcmp(data,bom_utf8,3))
  ------------------
  |  Branch (85:18): [True: 5.42k, False: 337]
  |  Branch (85:33): [True: 19, False: 5.40k]
  ------------------
   86|     19|        {
   87|     19|            return detect_encoding_result<CharT>{data+3,encoding_kind::utf8};
   88|     19|        }
   89|  5.74k|        else
   90|  5.74k|        {
   91|  5.74k|            return detect_encoding_result<CharT>{data,encoding_kind::undetected};
   92|  5.74k|        }
   93|  5.76k|    }
_ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr16extension_traits8is_char8IT_EE5valueENS0_14convert_resultIS4_EEE4typeEPKS4_m:
 1130|   147k|    {
 1131|   147k|        conv_errc  result = conv_errc();
 1132|   147k|        const CharT* last = data + length;
 1133|  20.3M|        while (data != last) 
  ------------------
  |  Branch (1133:16): [True: 20.2M, False: 147k]
  ------------------
 1134|  20.2M|        {
 1135|  20.2M|            std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[static_cast<uint8_t>(*data)]) + 1;
 1136|  20.2M|            if (len > (std::size_t)(last - data))
  ------------------
  |  Branch (1136:17): [True: 5, False: 20.2M]
  ------------------
 1137|      5|            {
 1138|      5|                return convert_result<CharT>{data, conv_errc::source_exhausted};
 1139|      5|            }
 1140|  20.2M|            if ((result=is_legal_utf8(data, len)) != conv_errc())
  ------------------
  |  Branch (1140:17): [True: 53, False: 20.2M]
  ------------------
 1141|     53|            {
 1142|     53|                return convert_result<CharT>{data,result} ;
 1143|     53|            }
 1144|  20.2M|            data += len;
 1145|  20.2M|        }
 1146|   147k|        return convert_result<CharT>{data,result} ;
 1147|   147k|    }
_ZN8jsoncons14unicode_traits17is_high_surrogateEj:
  203|   508k|    {
  204|   508k|        return (ch >= sur_high_start && ch <= sur_high_end);
  ------------------
  |  Branch (204:17): [True: 497k, False: 10.8k]
  |  Branch (204:41): [True: 346k, False: 150k]
  ------------------
  205|   508k|    }
_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|   507k|    {
  964|   507k|        conv_errc  result = conv_errc();
  965|   507k|        const CharT* last = data + length;
  966|   865k|        while (data < last) 
  ------------------
  |  Branch (966:16): [True: 507k, False: 357k]
  ------------------
  967|   507k|        {
  968|   507k|            unsigned short bytes_to_write = 0;
  969|   507k|            const uint32_t byteMask = 0xBF;
  970|   507k|            const uint32_t byteMark = 0x80; 
  971|   507k|            uint32_t ch = *data++;
  972|   507k|            if (flags == conv_flags::strict ) 
  ------------------
  |  Branch (972:17): [True: 507k, False: 0]
  ------------------
  973|   507k|            {
  974|       |                /* UTF-16 surrogate values are illegal in UTF-32 */
  975|   507k|                if (is_surrogate(ch)) 
  ------------------
  |  Branch (975:21): [True: 149k, False: 357k]
  ------------------
  976|   149k|                {
  977|   149k|                    --data; /* return to the illegal value itself */
  978|   149k|                    result = conv_errc::illegal_surrogate_value;
  979|   149k|                    break;
  980|   149k|                }
  981|   507k|            }
  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|   357k|            if (ch < (uint32_t)0x80) {      bytes_to_write = 1;
  ------------------
  |  Branch (986:17): [True: 452, False: 357k]
  ------------------
  987|   357k|            } else if (ch < (uint32_t)0x800) {     bytes_to_write = 2;
  ------------------
  |  Branch (987:24): [True: 2.69k, False: 354k]
  ------------------
  988|   354k|            } else if (ch < (uint32_t)0x10000) {   bytes_to_write = 3;
  ------------------
  |  Branch (988:24): [True: 8.12k, False: 346k]
  ------------------
  989|   346k|            } else if (ch <= max_legal_utf32) {  bytes_to_write = 4;
  ------------------
  |  Branch (989:24): [True: 346k, False: 0]
  ------------------
  990|   346k|            } else {                            
  991|      0|                bytes_to_write = 3;
  992|      0|                ch = replacement_char;
  993|      0|                result = conv_errc::source_illegal;
  994|      0|            }
  995|       |
  996|   357k|            uint8_t byte1 = 0;
  997|   357k|            uint8_t byte2 = 0;
  998|   357k|            uint8_t byte3 = 0;
  999|   357k|            uint8_t byte4 = 0;
 1000|       |
 1001|   357k|            switch (bytes_to_write) {
  ------------------
  |  Branch (1001:21): [True: 0, False: 357k]
  ------------------
 1002|   346k|            case 4:
  ------------------
  |  Branch (1002:13): [True: 346k, False: 11.2k]
  ------------------
 1003|   346k|                byte4 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1004|   346k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|   346k|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
 1005|   354k|            case 3:
  ------------------
  |  Branch (1005:13): [True: 8.12k, False: 349k]
  ------------------
 1006|   354k|                byte3 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1007|   354k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|   354k|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
 1008|   357k|            case 2:
  ------------------
  |  Branch (1008:13): [True: 2.69k, False: 355k]
  ------------------
 1009|   357k|                byte2 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1010|   357k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|   357k|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
 1011|   357k|            case 1:
  ------------------
  |  Branch (1011:13): [True: 452, False: 357k]
  ------------------
 1012|   357k|                byte1 = (uint8_t) (ch | first_byte_mark[bytes_to_write]);
 1013|   357k|                break;
 1014|   357k|            }
 1015|       |
 1016|   357k|            switch (bytes_to_write) 
  ------------------
  |  Branch (1016:21): [True: 0, False: 357k]
  ------------------
 1017|   357k|            {
 1018|   346k|            case 4: 
  ------------------
  |  Branch (1018:13): [True: 346k, False: 11.2k]
  ------------------
 1019|   346k|                target.push_back(byte1);
 1020|   346k|                target.push_back(byte2);
 1021|   346k|                target.push_back(byte3);
 1022|   346k|                target.push_back(byte4);
 1023|   346k|                break;
 1024|  8.12k|            case 3: 
  ------------------
  |  Branch (1024:13): [True: 8.12k, False: 349k]
  ------------------
 1025|  8.12k|                target.push_back(byte1);
 1026|  8.12k|                target.push_back(byte2);
 1027|  8.12k|                target.push_back(byte3);
 1028|  8.12k|                break;
 1029|  2.69k|            case 2: 
  ------------------
  |  Branch (1029:13): [True: 2.69k, False: 355k]
  ------------------
 1030|  2.69k|                target.push_back(byte1);
 1031|  2.69k|                target.push_back(byte2);
 1032|  2.69k|                break;
 1033|    452|            case 1: 
  ------------------
  |  Branch (1033:13): [True: 452, False: 357k]
  ------------------
 1034|    452|                target.push_back(byte1);
 1035|    452|                break;
 1036|   357k|            }
 1037|   357k|        }
 1038|   507k|        return convert_result<CharT>{data,result} ;
 1039|   507k|    }