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

_ZN8jsoncons15make_error_codeENS_9conv_errcE:
  174|      4|{
  175|      4|    return std::error_code(static_cast<int>(result),conv_error_category());
  176|      4|}
_ZN8jsoncons19conv_error_categoryEv:
  167|      4|{
  168|      4|  static detail::conv_error_category_impl instance;
  169|      4|  return instance;
  170|      4|}

_ZN8jsoncons6detail6grisu3EdPcPiS2_:
  293|    999|{
  294|    999|    diy_fp_t w_m, w_p;
  295|    999|    int q = 64, alpha = -59, gamma = -56;
  296|    999|    normalized_boundaries(v, &w_m, &w_p);
  297|    999|    diy_fp_t w = normalize_diy_fp(double2diy_fp(v));
  298|    999|    int mk = k_comp(w_p.e + q, alpha, gamma);
  299|    999|    diy_fp_t c_mk = cached_power(mk);
  300|    999|    diy_fp_t W  = multiply(w,   c_mk);
  301|    999|    diy_fp_t Wp = multiply(w_p, c_mk);
  302|    999|    diy_fp_t Wm = multiply(w_m, c_mk);
  303|    999|    *K = -mk;
  304|    999|    bool result = digit_gen(Wm, W, Wp, buffer, length, K);
  305|    999|    buffer[*length] = 0;
  306|    999|    return result;
  307|    999|}
_ZN8jsoncons6detail21normalized_boundariesEdPNS0_8diy_fp_tES2_:
  188|    999|{
  189|    999|    diy_fp_t v = double2diy_fp(d);
  190|    999|    diy_fp_t pl, mi;
  191|    999|    bool significand_is_zero = v.f == dp_hidden_bit;
  192|    999|    pl.f  = (v.f << 1) + 1; pl.e  = v.e - 1;
  193|    999|    pl = normalize_boundary(pl);
  194|    999|    if (significand_is_zero)
  ------------------
  |  Branch (194:9): [True: 6, False: 993]
  ------------------
  195|      6|    {
  196|      6|        mi.f = (v.f << 2) - 1;
  197|      6|        mi.e = v.e - 2;
  198|      6|    } else
  199|    993|    {
  200|    993|        mi.f = (v.f << 1) - 1;
  201|    993|        mi.e = v.e - 1;
  202|    993|    }
  203|    999|    int x = mi.e - pl.e;
  204|    999|    mi.f <<= x;
  205|    999|    mi.e = pl.e;
  206|    999|    *out_m_plus = pl;
  207|    999|    *out_m_minus = mi;
  208|    999|}
_ZN8jsoncons6detail18normalize_boundaryENS0_8diy_fp_tE:
  171|    999|{
  172|    999|    diy_fp_t res = in;
  173|       |    /* Normalize now */
  174|       |    /* the original number could have been a denormal. */
  175|  11.8k|    while (!(res.f & (dp_hidden_bit << 1)))
  ------------------
  |  Branch (175:12): [True: 10.9k, False: 999]
  ------------------
  176|  10.9k|    {
  177|  10.9k|        res.f <<= 1;
  178|  10.9k|        res.e--;
  179|  10.9k|    }
  180|       |    /* do the final shifts in one go. Don't forget the hidden bit (the '-1') */
  181|    999|    res.f <<= (diy_significand_size - dp_significand_size - 2);
  182|    999|    res.e = res.e - (diy_significand_size - dp_significand_size - 2);
  183|    999|    return res;
  184|    999|}
_ZN8jsoncons6detail16normalize_diy_fpENS0_8diy_fp_tE:
  134|    999|{
  135|    999|    diy_fp_t res = in;
  136|       |    /* Normalize now */
  137|       |    /* the original number could have been a denormal. */
  138|  11.8k|    while (!(res.f & dp_hidden_bit))
  ------------------
  |  Branch (138:12): [True: 10.9k, False: 999]
  ------------------
  139|  10.9k|    {
  140|  10.9k|        res.f <<= 1;
  141|  10.9k|        res.e--;
  142|  10.9k|    }
  143|       |    /* do the final shifts in one go. Don't forget the hidden bit (the '-1') */
  144|    999|    res.f <<= (diy_significand_size - dp_significand_size - 1);
  145|    999|    res.e = res.e - (diy_significand_size - dp_significand_size - 1);
  146|    999|    return res;
  147|    999|}
_ZN8jsoncons6detail13double2diy_fpEd:
  151|  1.99k|{
  152|  1.99k|    uint64_t d64 = double_to_uint64(d);
  153|  1.99k|    int biased_e = (d64 & dp_exponent_mask) >> dp_significand_size;
  154|  1.99k|    uint64_t significand = (d64 & dp_significand_mask);
  155|  1.99k|    diy_fp_t res;
  156|  1.99k|    if (biased_e != 0)
  ------------------
  |  Branch (156:9): [True: 1.27k, False: 724]
  ------------------
  157|  1.27k|    {
  158|  1.27k|        res.f = significand + dp_hidden_bit;
  159|  1.27k|        res.e = biased_e - dp_exponent_bias;
  160|  1.27k|    } 
  161|    724|    else
  162|    724|    {
  163|    724|        res.f = significand;
  164|    724|        res.e = dp_min_exponent + 1;
  165|    724|    }
  166|  1.99k|    return res;
  167|  1.99k|}
_ZN8jsoncons6detail16double_to_uint64Ed:
  120|  1.99k|uint64_t double_to_uint64(double d) {uint64_t d64; std::memcpy(&d64,&d,sizeof(double)); return d64; }
_ZN8jsoncons6detail6k_compEiii:
   82|    999|{
   83|    999|    constexpr double d_1_log2_10 = 0.30102999566398114; //  1 / lg(10)
   84|    999|    int x = alpha - e + 63;
   85|    999|    return static_cast<int>(std::ceil(x * d_1_log2_10));
   86|    999|}
_ZN8jsoncons6detail12cached_powerEi:
   97|    999|{
   98|    999|    diy_fp_t res;
   99|    999|    int index = 343 + k;
  100|    999|    res.f = powers_ten[index];
  101|    999|    res.e = powers_ten_e[index];
  102|    999|    return res;
  103|    999|}
_ZN8jsoncons6detail8multiplyENS0_8diy_fp_tES1_:
   65|  2.99k|{
   66|  2.99k|    uint64_t a, b, c, d, ac, bc, ad, bd, tmp;
   67|  2.99k|    diy_fp_t r; uint64_t M32 = 0xFFFFFFFF;
   68|  2.99k|    a = x.f >> 32; b = x.f & M32;
   69|  2.99k|    c = y.f >> 32; d = y.f & M32;
   70|  2.99k|    ac = a * c; bc = b * c; ad = a * d; bd = b * d;
   71|  2.99k|    tmp = (bd >> 32) + (ad & M32) + (bc & M32);
   72|  2.99k|    tmp += 1U << 31; /// mult_round
   73|  2.99k|    r.f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
   74|  2.99k|    r.e = x.e + y.e + 64;
   75|  2.99k|    return r;
   76|  2.99k|}
_ZN8jsoncons6detail9digit_genENS0_8diy_fp_tES1_S1_PcPiS3_:
  250|    999|{
  251|    999|    static constexpr uint32_t TEN2 = 100;
  252|       |
  253|    999|    uint32_t div, p1; uint64_t p2, tmp, unit = 1;
  254|    999|    int d, kappa;
  255|    999|    diy_fp_t one, wp_W, Delta;
  256|    999|    Delta = minus(Wp, Wm); Delta.f += 2 * unit;
  257|    999|    wp_W = minus(Wp, W); wp_W.f += unit;
  258|    999|    one.f = ((uint64_t)1) << -Wp.e; one.e = Wp.e;
  259|    999|    p1 = static_cast<uint32_t>((Wp.f + 1) >> -one.e);
  260|    999|    p2 = (Wp.f + 1) & (one.f - 1);
  261|    999|    *len = 0; kappa = 3; div = TEN2;
  262|  3.44k|    while (kappa > 0)
  ------------------
  |  Branch (262:12): [True: 2.75k, False: 686]
  ------------------
  263|  2.75k|    {
  264|  2.75k|        d = p1 / div;
  265|  2.75k|        if (d || *len) buffer[(*len)++] = (char)('0' + d);
  ------------------
  |  Branch (265:13): [True: 1.53k, False: 1.22k]
  |  Branch (265:18): [True: 72, False: 1.15k]
  ------------------
  266|  2.75k|        p1 %= div; kappa--;
  267|  2.75k|        tmp = (((uint64_t)p1) << -one.e) + p2;
  268|  2.75k|        if (tmp < Delta.f)
  ------------------
  |  Branch (268:13): [True: 313, False: 2.44k]
  ------------------
  269|    313|        {
  270|    313|            *K += kappa;
  271|    313|            return round_weed(buffer, *len, wp_W.f, Delta.f, tmp,
  272|    313|                              ((uint64_t)div) << -one.e, unit);
  273|    313|        }
  274|  2.44k|        div /= 10;
  275|  2.44k|    }
  276|  4.56k|    while (1)
  ------------------
  |  Branch (276:12): [True: 4.56k, Folded]
  ------------------
  277|  4.56k|    {
  278|  4.56k|        p2 *= 10; Delta.f *= 10; unit *= 10;
  279|  4.56k|        d = static_cast<int>(p2 >> -one.e);
  280|  4.56k|        if (d || *len) buffer[(*len)++] = (char)('0' + d);
  ------------------
  |  Branch (280:13): [True: 3.61k, False: 957]
  |  Branch (280:18): [True: 957, False: 0]
  ------------------
  281|  4.56k|        p2 &= one.f - 1; kappa--;
  282|  4.56k|        if (p2 < Delta.f)
  ------------------
  |  Branch (282:13): [True: 686, False: 3.88k]
  ------------------
  283|    686|        {
  284|    686|            *K += kappa;
  285|    686|            return round_weed(buffer, *len, wp_W.f * unit, Delta.f, p2,
  286|    686|                              one.f, unit);
  287|    686|        }
  288|  4.56k|    }
  289|    686|}
_ZN8jsoncons6detail5minusENS0_8diy_fp_tES1_:
   56|  1.99k|{
   57|  1.99k|    assert(x.e == y.e);
  ------------------
  |  Branch (57:5): [True: 1.99k, False: 0]
  ------------------
   58|  1.99k|    assert(x.f >= y.f);
  ------------------
  |  Branch (58:5): [True: 1.99k, False: 0]
  ------------------
   59|  1.99k|    diy_fp_t r = { x.f = x.f - y.f, x.e };
   60|  1.99k|    return r;
   61|  1.99k|}
_ZN8jsoncons6detail10round_weedEPcimmmmm:
  230|    999|{
  231|    999|    uint64_t wp_Wup = wp_W - ulp;
  232|    999|    uint64_t wp_Wdown = wp_W + ulp;
  233|  1.33k|    while (rest < wp_Wup &&  /// round1
  ------------------
  |  Branch (233:12): [True: 803, False: 528]
  ------------------
  234|    803|           Delta - rest >= ten_kappa &&
  ------------------
  |  Branch (234:12): [True: 503, False: 300]
  ------------------
  235|    503|           (rest + ten_kappa < wp_Wup || /// closer
  ------------------
  |  Branch (235:13): [True: 253, False: 250]
  ------------------
  236|    250|            wp_Wup - rest >= rest + ten_kappa - wp_Wup))
  ------------------
  |  Branch (236:13): [True: 79, False: 171]
  ------------------
  237|    332|    {
  238|    332|        buffer[len - 1]--; rest += ten_kappa;
  239|    332|    }
  240|    999|    if (rest < wp_Wdown && /// round2
  ------------------
  |  Branch (240:9): [True: 556, False: 443]
  ------------------
  241|    556|        Delta - rest >= ten_kappa &&
  ------------------
  |  Branch (241:9): [True: 185, False: 371]
  ------------------
  242|    185|        (rest + ten_kappa < wp_Wdown ||
  ------------------
  |  Branch (242:10): [True: 0, False: 185]
  ------------------
  243|    185|         wp_Wdown - rest > rest + ten_kappa - wp_Wdown)) return 0;
  ------------------
  |  Branch (243:10): [True: 44, False: 141]
  ------------------
  244|    955|    return 2 * ulp <= rest && rest <= Delta - 4 * ulp; /// weed
  ------------------
  |  Branch (244:12): [True: 893, False: 62]
  |  Branch (244:31): [True: 806, False: 87]
  ------------------
  245|    999|}

_ZN8jsoncons6detail24make_obj_using_allocatorINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES7_JRKPKcRKmEEENS2_9enable_ifIXaaaantsr10ext_traits11is_std_pairIT_EE5valuesr3std14uses_allocatorISG_T0_EE5valuesr3std16is_constructibleISG_DpT1_SH_EE5valueESG_E4typeERKSH_DpOSI_:
   16|    402|{
   17|    402|    return T(std::forward<Args>(args)..., alloc);
   18|    402|}
_ZN8jsoncons6detail24make_obj_using_allocatorINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES7_JEEENS2_9enable_ifIXaaaantsr10ext_traits11is_std_pairIT_EE5valuesr3std14uses_allocatorISA_T0_EE5valuesr3std16is_constructibleISA_DpT1_SB_EE5valueESA_E4typeERKSB_DpOSC_:
   16|  1.54k|{
   17|  1.54k|    return T(std::forward<Args>(args)..., alloc);
   18|  1.54k|}
_ZN8jsoncons6detail24make_obj_using_allocatorINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES7_JRKPKcEEENS2_9enable_ifIXaaaantsr10ext_traits11is_std_pairIT_EE5valuesr3std14uses_allocatorISE_T0_EE5valuesr3std16is_constructibleISE_DpT1_SF_EE5valueESE_E4typeERKSF_DpOSG_:
   16|      6|{
   17|      6|    return T(std::forward<Args>(args)..., alloc);
   18|      6|}

_ZN8jsoncons6detail4spanIKcLm18446744073709551615EEC2Ev:
   58|  4.33k|        {
   59|  4.33k|        }
_ZN8jsoncons6detail4spanIKcLm18446744073709551615EEC2EPS2_m:
   61|  13.9k|            : data_(data), size_(size)
   62|  13.9k|        {
   63|  13.9k|        }
_ZNK8jsoncons6detail4spanIKcLm18446744073709551615EE4sizeEv:
  116|  25.2k|        {
  117|  25.2k|            return size_;
  118|  25.2k|        }
_ZNK8jsoncons6detail4spanIKcLm18446744073709551615EE4dataEv:
  111|  13.9k|        {
  112|  13.9k|            return data_;
  113|  13.9k|        }
_ZN8jsoncons6detail4spanIKmLm18446744073709551615EEC2Ev:
   58|  3.31k|        {
   59|  3.31k|        }

_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_ED2Ev:
  257|  3.31k|    ~basic_json_cursor() = default;
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E9read_nextERNS_18basic_json_visitorIcEERNS2_10error_codeE:
  529|  5.26k|    {
  530|  5.26k|        parser_.restart();
  531|  15.2k|        while (!parser_.stopped())
  ------------------
  |  Branch (531:16): [True: 11.3k, False: 3.91k]
  ------------------
  532|  11.3k|        {
  533|  11.3k|            if (parser_.source_exhausted())
  ------------------
  |  Branch (533:17): [True: 11.3k, False: 68]
  ------------------
  534|  11.3k|            {
  535|  11.3k|                auto s = source_.read_buffer(ec);
  536|  11.3k|                if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  11.3k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 16, False: 11.2k]
  |  |  ------------------
  ------------------
  537|  11.2k|                if (s.size() > 0)
  ------------------
  |  Branch (537:21): [True: 6.93k, False: 4.34k]
  ------------------
  538|  6.93k|                {
  539|  6.93k|                    parser_.update(s.data(),s.size());
  540|  6.93k|                    if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  6.93k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 6.93k]
  |  |  ------------------
  ------------------
  541|  6.93k|                }
  542|  11.2k|            }
  543|  11.3k|            bool eof = parser_.source_exhausted() && source_.eof();
  ------------------
  |  Branch (543:24): [True: 4.34k, False: 7.00k]
  |  Branch (543:54): [True: 4.34k, False: 0]
  ------------------
  544|  11.3k|            parser_.parse_some(visitor, ec);
  545|  11.3k|            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  11.3k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.30k, False: 10.0k]
  |  |  ------------------
  ------------------
  546|  10.0k|            if (eof)
  ------------------
  |  Branch (546:17): [True: 3.71k, False: 6.32k]
  ------------------
  547|  3.71k|            {
  548|  3.71k|                if (parser_.enter())
  ------------------
  |  Branch (548:21): [True: 24, False: 3.69k]
  ------------------
  549|     24|                {
  550|     24|                    done_ = true;
  551|     24|                    break;
  552|     24|                }
  553|  3.69k|                else if (!parser_.accept())
  ------------------
  |  Branch (553:26): [True: 11, False: 3.68k]
  ------------------
  554|     11|                {
  555|     11|                    ec = json_errc::unexpected_eof;
  556|     11|                    return;
  557|     11|                }
  558|  3.71k|            }
  559|  10.0k|        }
  560|  5.26k|    }
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_EC1IRNS2_19basic_istringstreamIcNS2_11char_traitsIcEES4_EEEEOT_RNS2_10error_codeE:
  134|  3.31k|        : basic_json_cursor(std::allocator_arg, Allocator(), 
  135|  3.31k|              std::forward<Sourceable>(source),
  136|  3.31k|              basic_json_decode_options<CharT>(),
  137|  3.31k|              ec)
  138|  3.31k|    {
  139|  3.31k|    }
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_EC1IRNS2_19basic_istringstreamIcNS2_11char_traitsIcEES4_EEEENS2_15allocator_arg_tERKS4_OT_RKNS_25basic_json_decode_optionsIcEERNS2_10error_codeEPNS2_9enable_ifIXntsr3std16is_constructibleINS2_17basic_string_viewIcSA_EESG_EE5valueEvE4typeE:
  203|  3.31k|       : source_(std::forward<Sourceable>(source)),
  204|  3.31k|         parser_(options, alloc)
  205|  3.31k|    {
  206|  3.31k|        parser_.cursor_mode(true);
  207|       |
  208|  3.31k|        if (!read_done())
  ------------------
  |  Branch (208:13): [True: 3.31k, False: 0]
  ------------------
  209|  3.31k|        {
  210|  3.31k|            std::error_code local_ec;
  211|  3.31k|            read_next(local_ec);
  212|  3.31k|            if (local_ec)
  ------------------
  |  Branch (212:17): [True: 1.33k, False: 1.98k]
  ------------------
  213|  1.33k|            {
  214|  1.33k|                if (local_ec == json_errc::unexpected_eof)
  ------------------
  |  Branch (214:21): [True: 639, False: 694]
  ------------------
  215|    639|                {
  216|    639|                    done_ = true;
  217|    639|                }
  218|    694|                else
  219|    694|                {
  220|    694|                    ec = local_ec;
  221|    694|                }
  222|  1.33k|            }
  223|  3.31k|        }
  224|  3.31k|    }
_ZNK8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E9read_doneEv:
  470|  3.31k|    {
  471|  3.31k|        return parser_.done() || done_;
  ------------------
  |  Branch (471:16): [True: 0, False: 3.31k]
  |  Branch (471:34): [True: 0, False: 3.31k]
  ------------------
  472|  3.31k|    }
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E9read_nextERNS2_10error_codeE:
  524|  5.26k|    {
  525|  5.26k|        read_next(cursor_visitor_, ec);
  526|  5.26k|    }
_ZNK8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E4doneEv:
  336|  5.27k|    {
  337|  5.27k|        return parser_.done() || done_;
  ------------------
  |  Branch (337:16): [True: 1.95k, False: 3.31k]
  |  Branch (337:34): [True: 663, False: 2.65k]
  ------------------
  338|  5.27k|    }
_ZNK8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E7currentEv:
  341|  1.95k|    {
  342|  1.95k|        return cursor_visitor_.event();
  343|  1.95k|    }
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E4nextERNS2_10error_codeE:
  391|  1.95k|    {
  392|  1.95k|        read_next(ec);
  393|  1.95k|    }

_ZN8jsoncons15make_error_codeENS_9json_errcE:
  141|  2.66k|    {
  142|  2.66k|        return std::error_code(static_cast<int>(result),json_error_category());
  143|  2.66k|    }
_ZN8jsoncons19json_error_categoryEv:
  135|  2.66k|    {
  136|  2.66k|      static json_error_category_impl instance;
  137|  2.66k|      return instance;
  138|  2.66k|    }

_ZN8jsoncons25basic_json_decode_optionsIcEC1Ev:
  266|  3.31k|        : err_handler_(default_json_parsing())
  267|  3.31k|    {
  268|  3.31k|    }
_ZN8jsoncons25basic_json_options_commonIcEC2Ev:
  106|  3.31k|        enable_nan_to_num_(false),
  107|  3.31k|        enable_inf_to_num_(false),
  108|  3.31k|        enable_neginf_to_num_(false),
  109|  3.31k|        enable_nan_to_str_(false),
  110|  3.31k|        enable_inf_to_str_(false),
  111|  3.31k|        enable_neginf_to_str_(false),
  112|  3.31k|        enable_str_to_nan_(false),
  113|  3.31k|        enable_str_to_inf_(false),
  114|  3.31k|        enable_str_to_neginf_(false),
  115|  3.31k|        max_nesting_depth_(1024)
  116|  3.31k|    {}
_ZN8jsoncons20default_json_parsingclENS_9json_errcERKNS_11ser_contextE:
   48|  35.8k|    {
   49|  35.8k|        return ec == json_errc::illegal_comment;
   50|  35.8k|    }
_ZN8jsoncons25basic_json_options_commonIcED2Ev:
  118|  3.31k|    virtual ~basic_json_options_common() = default;
_ZNK8jsoncons25basic_json_options_commonIcE17max_nesting_depthEv:
  245|  6.63k|    {
  246|  6.63k|        return max_nesting_depth_;
  247|  6.63k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE20allow_trailing_commaEv:
  300|  3.31k|    {
  301|  3.31k|        return allow_trailing_comma_;
  302|  3.31k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE14allow_commentsEv:
  295|  3.31k|    {
  296|  3.31k|        return allow_comments_;
  297|  3.31k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE15lossless_numberEv:
  286|  3.31k|    {
  287|  3.31k|        return lossless_number_;
  288|  3.31k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE15lossless_bignumEv:
  290|  3.31k|    {
  291|  3.31k|        return lossless_bignum_;
  292|  3.31k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE11err_handlerEv:
  306|  3.31k|    {
  307|  3.31k|        return err_handler_;
  308|  3.31k|    }
_ZNK8jsoncons25basic_json_options_commonIcE17enable_str_to_nanEv:
  148|  3.31k|    {
  149|  3.31k|        return enable_str_to_nan_;
  150|  3.31k|    }
_ZNK8jsoncons25basic_json_options_commonIcE17enable_str_to_infEv:
  158|  3.31k|    {
  159|  3.31k|        return enable_str_to_inf_;
  160|  3.31k|    }
_ZNK8jsoncons25basic_json_options_commonIcE20enable_str_to_neginfEv:
  168|  3.31k|    {
  169|  3.31k|        return enable_str_to_neginf_ || enable_str_to_inf_;
  ------------------
  |  Branch (169:16): [True: 0, False: 3.31k]
  |  Branch (169:41): [True: 0, False: 3.31k]
  ------------------
  170|  3.31k|    }

_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEED2Ev:
  281|  3.31k|    {
  282|  3.31k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11cursor_modeEb:
  251|  3.31k|    {
  252|  3.31k|        cursor_mode_ = value;
  253|  3.31k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE7restartEv:
  516|  5.26k|    {
  517|  5.26k|        more_ = true;
  518|  5.26k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE7stoppedEv:
  306|  15.2k|    {
  307|  15.2k|        return !more_;
  308|  15.2k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE16source_exhaustedEv:
  271|  22.7k|    {
  272|  22.7k|        return input_ptr_ == input_end_;
  273|  22.7k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE6updateEPKcm:
  560|  6.93k|    {
  561|  6.93k|        input_end_ = data + length;
  562|  6.93k|        input_ptr_ = data;
  563|  6.93k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10parse_someERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  576|  11.3k|    {
  577|  11.3k|        parse_some_(visitor, ec);
  578|  11.3k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11parse_some_ERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  600|  11.3k|    {
  601|  11.3k|        if (state_ == parse_state::accept)
  ------------------
  |  Branch (601:13): [True: 1.95k, False: 9.39k]
  ------------------
  602|  1.95k|        {
  603|  1.95k|            visitor.flush();
  604|  1.95k|            done_ = true;
  605|  1.95k|            state_ = parse_state::done;
  606|  1.95k|            more_ = false;
  607|  1.95k|            return;
  608|  1.95k|        }
  609|  9.39k|        const char_type* local_input_end = input_end_;
  610|       |
  611|  9.39k|        if (input_ptr_ == local_input_end && more_)
  ------------------
  |  Branch (611:13): [True: 2.46k, False: 6.93k]
  |  Branch (611:46): [True: 2.46k, False: 0]
  ------------------
  612|  2.46k|        {
  613|  2.46k|            switch (state_)
  614|  2.46k|            {
  615|  1.80k|                case parse_state::number:  
  ------------------
  |  Branch (615:17): [True: 1.80k, False: 651]
  ------------------
  616|  1.80k|                    if (number_state_ == parse_number_state::zero || number_state_ == parse_number_state::integer)
  ------------------
  |  Branch (616:25): [True: 0, False: 1.80k]
  |  Branch (616:70): [True: 741, False: 1.06k]
  ------------------
  617|    741|                    {
  618|    741|                        end_integer_value(visitor, ec);
  619|    741|                        if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|    741|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 741]
  |  |  ------------------
  ------------------
  620|    741|                    }
  621|  1.06k|                    else if (number_state_ == parse_number_state::fraction2 || number_state_ == parse_number_state::exp3)
  ------------------
  |  Branch (621:30): [True: 402, False: 666]
  |  Branch (621:80): [True: 654, False: 12]
  ------------------
  622|  1.05k|                    {
  623|  1.05k|                        end_fraction_value(visitor, ec);
  624|  1.05k|                        if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  1.05k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.05k]
  |  |  ------------------
  ------------------
  625|  1.05k|                    }
  626|     12|                    else
  627|     12|                    {
  628|     12|                        err_handler_(json_errc::unexpected_eof, *this);
  629|     12|                        ec = json_errc::unexpected_eof;
  630|     12|                        more_ = false;
  631|     12|                    }
  632|  1.80k|                    break;
  633|  1.80k|                case parse_state::accept:
  ------------------
  |  Branch (633:17): [True: 0, False: 2.46k]
  ------------------
  634|      0|                    visitor.flush();
  635|      0|                    done_ = true;
  636|      0|                    state_ = parse_state::done;
  637|      0|                    more_ = false;
  638|      0|                    break;
  639|     82|                case parse_state::start:
  ------------------
  |  Branch (639:17): [True: 82, False: 2.37k]
  ------------------
  640|     82|                    more_ = false;
  641|     82|                    ec = json_errc::unexpected_eof;
  642|     82|                    return;                
  643|      0|                case parse_state::done:
  ------------------
  |  Branch (643:17): [True: 0, False: 2.46k]
  ------------------
  644|      0|                    more_ = false;
  645|      0|                    break;
  646|     35|                case parse_state::cr:
  ------------------
  |  Branch (646:17): [True: 35, False: 2.42k]
  ------------------
  647|     35|                    state_ = pop_state();
  648|     35|                    break;
  649|    534|                default:
  ------------------
  |  Branch (649:17): [True: 534, False: 1.92k]
  ------------------
  650|    534|                    err_handler_(json_errc::unexpected_eof, *this);
  651|    534|                    ec = json_errc::unexpected_eof;
  652|    534|                    more_ = false;
  653|    534|                    return;
  654|  2.46k|            }
  655|  2.46k|        }
  656|       |
  657|  3.37M|        while ((input_ptr_ < local_input_end) && more_)
  ------------------
  |  Branch (657:16): [True: 3.37M, False: 8.03k]
  |  Branch (657:50): [True: 3.36M, False: 70]
  ------------------
  658|  3.36M|        {
  659|  3.36M|            switch (state_)
  660|  3.36M|            {
  661|      0|                case parse_state::accept:
  ------------------
  |  Branch (661:17): [True: 0, False: 3.36M]
  ------------------
  662|      0|                    visitor.flush();
  663|      0|                    done_ = true;
  664|      0|                    state_ = parse_state::done;
  665|      0|                    more_ = false;
  666|      0|                    break;
  667|  1.36k|                case parse_state::cr:
  ------------------
  |  Branch (667:17): [True: 1.36k, False: 3.36M]
  ------------------
  668|  1.36k|                    ++line_;
  669|  1.36k|                    switch (*input_ptr_)
  670|  1.36k|                    {
  671|    206|                        case '\n':
  ------------------
  |  Branch (671:25): [True: 206, False: 1.16k]
  ------------------
  672|    206|                            ++input_ptr_;
  673|    206|                            ++position_;
  674|    206|                            state_ = pop_state();
  675|    206|                            break;
  676|  1.16k|                        default:
  ------------------
  |  Branch (676:25): [True: 1.16k, False: 206]
  ------------------
  677|  1.16k|                            state_ = pop_state();
  678|  1.16k|                            break;
  679|  1.36k|                    }
  680|  1.36k|                    mark_position_ = position_;
  681|  1.36k|                    break;
  682|  72.5k|                case parse_state::start: 
  ------------------
  |  Branch (682:17): [True: 72.5k, False: 3.29M]
  ------------------
  683|  72.5k|                {
  684|  72.5k|                    switch (*input_ptr_)
  685|  72.5k|                    {
  686|  1.39k|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|     39|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 21, False: 72.5k]
  |  |  |  Branch (34:19): [True: 3, False: 72.5k]
  |  |  |  Branch (34:29): [True: 1, False: 72.5k]
  |  |  |  Branch (34:39): [True: 2, False: 72.5k]
  |  |  |  Branch (34:49): [True: 1, False: 72.5k]
  |  |  |  Branch (34:59): [True: 2, False: 72.5k]
  |  |  |  Branch (34:69): [True: 2, False: 72.5k]
  |  |  |  Branch (34:79): [True: 1, False: 72.5k]
  |  |  |  Branch (34:89): [True: 4, False: 72.5k]
  |  |  |  Branch (34:99): [True: 2, False: 72.5k]
  |  |  ------------------
  |  |   35|     57|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 2, False: 72.5k]
  |  |  |  Branch (35:19): [True: 2, False: 72.5k]
  |  |  |  Branch (35:29): [True: 3, False: 72.5k]
  |  |  |  Branch (35:39): [True: 1, False: 72.5k]
  |  |  |  Branch (35:49): [True: 2, False: 72.5k]
  |  |  |  Branch (35:59): [True: 2, False: 72.5k]
  |  |  |  Branch (35:69): [True: 2, False: 72.5k]
  |  |  |  Branch (35:79): [True: 1, False: 72.5k]
  |  |  |  Branch (35:89): [True: 2, False: 72.5k]
  |  |  |  Branch (35:99): [True: 1, False: 72.5k]
  |  |  ------------------
  |  |   36|     73|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 3, False: 72.5k]
  |  |  |  Branch (36:19): [True: 2, False: 72.5k]
  |  |  |  Branch (36:29): [True: 2, False: 72.5k]
  |  |  |  Branch (36:39): [True: 2, False: 72.5k]
  |  |  |  Branch (36:49): [True: 1, False: 72.5k]
  |  |  |  Branch (36:59): [True: 1, False: 72.5k]
  |  |  |  Branch (36:69): [True: 1, False: 72.5k]
  |  |  |  Branch (36:79): [True: 2, False: 72.5k]
  |  |  ------------------
  ------------------
  687|  1.39k|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
  688|  1.39k|                            if (!more_)
  ------------------
  |  Branch (688:33): [True: 73, False: 0]
  ------------------
  689|     73|                            {
  690|     73|                                ec = json_errc::illegal_control_character;
  691|     73|                                return;
  692|     73|                            }
  693|      0|                            break;
  694|  34.8k|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (694:25): [True: 453, False: 72.1k]
  |  Branch (694:34): [True: 768, False: 71.8k]
  |  Branch (694:44): [True: 20.3k, False: 52.2k]
  |  Branch (694:54): [True: 13.2k, False: 59.3k]
  ------------------
  695|  34.8k|                            skip_space(&input_ptr_);
  696|  34.8k|                            break;
  697|  34.6k|                        case '/': 
  ------------------
  |  Branch (697:25): [True: 34.6k, False: 37.9k]
  ------------------
  698|  34.6k|                            ++input_ptr_;
  699|  34.6k|                            ++position_;
  700|  34.6k|                            push_state(state_);
  701|  34.6k|                            state_ = parse_state::slash;
  702|  34.6k|                            break;
  703|      3|                        case '{':
  ------------------
  |  Branch (703:25): [True: 3, False: 72.5k]
  ------------------
  704|      3|                            begin_position_ = position_;
  705|      3|                            ++input_ptr_;
  706|      3|                            ++position_;
  707|      3|                            begin_object(visitor, ec);
  708|      3|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
  709|      3|                            break;
  710|      3|                        case '[':
  ------------------
  |  Branch (710:25): [True: 1, False: 72.5k]
  ------------------
  711|      1|                            begin_position_ = position_;
  712|      1|                            ++input_ptr_;
  713|      1|                            ++position_;
  714|      1|                            begin_array(visitor, ec);
  715|      1|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  716|      1|                            break;
  717|    726|                        case '\"':
  ------------------
  |  Branch (717:25): [True: 726, False: 71.8k]
  ------------------
  718|    726|                            state_ = parse_state::string;
  719|    726|                            string_state_ = parse_string_state{};
  720|    726|                            begin_position_ = position_;
  721|    726|                            ++input_ptr_;
  722|    726|                            ++position_;
  723|    726|                            escape_tag_ = semantic_tag::noesc;
  724|    726|                            buffer_.clear();
  725|    726|                            input_ptr_ = parse_string(input_ptr_, visitor, ec);
  726|    726|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|    726|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 188, False: 538]
  |  |  ------------------
  ------------------
  727|    538|                            break;
  728|    538|                        case '-':
  ------------------
  |  Branch (728:25): [True: 471, False: 72.1k]
  ------------------
  729|    471|                            buffer_.clear();
  730|    471|                            buffer_.push_back('-');
  731|    471|                            begin_position_ = position_;
  732|    471|                            ++input_ptr_;
  733|    471|                            ++position_;
  734|    471|                            state_ = parse_state::number;
  735|    471|                            number_state_ = parse_number_state::minus;
  736|    471|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
  737|    471|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|    471|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 13, False: 458]
  |  |  ------------------
  ------------------
  738|    458|                            break;
  739|    458|                        case '0': 
  ------------------
  |  Branch (739:25): [True: 110, False: 72.4k]
  ------------------
  740|    110|                            buffer_.clear();
  741|    110|                            buffer_.push_back(static_cast<char>(*input_ptr_));
  742|    110|                            state_ = parse_state::number;
  743|    110|                            number_state_ = parse_number_state::zero;
  744|    110|                            begin_position_ = position_;
  745|    110|                            ++input_ptr_;
  746|    110|                            ++position_;
  747|    110|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
  748|    110|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|    110|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 106]
  |  |  ------------------
  ------------------
  749|    106|                            break;
  750|  1.33k|                        case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (750:25): [True: 279, False: 72.3k]
  |  Branch (750:34): [True: 177, False: 72.4k]
  |  Branch (750:43): [True: 98, False: 72.4k]
  |  Branch (750:52): [True: 73, False: 72.5k]
  |  Branch (750:61): [True: 78, False: 72.5k]
  |  Branch (750:70): [True: 84, False: 72.5k]
  |  Branch (750:79): [True: 117, False: 72.4k]
  |  Branch (750:88): [True: 176, False: 72.4k]
  |  Branch (750:98): [True: 248, False: 72.3k]
  ------------------
  751|  1.33k|                            buffer_.clear();
  752|  1.33k|                            buffer_.push_back(static_cast<char>(*input_ptr_));
  753|  1.33k|                            begin_position_ = position_;
  754|  1.33k|                            ++input_ptr_;
  755|  1.33k|                            ++position_;
  756|  1.33k|                            state_ = parse_state::number;
  757|  1.33k|                            number_state_ = parse_number_state::integer;
  758|  1.33k|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
  759|  1.33k|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  1.33k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 15, False: 1.31k]
  |  |  ------------------
  ------------------
  760|  1.31k|                            break;
  761|  1.31k|                        case 'n':
  ------------------
  |  Branch (761:25): [True: 85, False: 72.5k]
  ------------------
  762|     85|                            parse_null(visitor, ec);
  763|     85|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|     85|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 45, False: 40]
  |  |  ------------------
  ------------------
  764|     40|                            break;
  765|     76|                        case 't':
  ------------------
  |  Branch (765:25): [True: 76, False: 72.5k]
  ------------------
  766|     76|                            input_ptr_ = parse_true(input_ptr_, visitor, ec);
  767|     76|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|     76|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 34, False: 42]
  |  |  ------------------
  ------------------
  768|     42|                            break;
  769|    110|                        case 'f':
  ------------------
  |  Branch (769:25): [True: 110, False: 72.4k]
  ------------------
  770|    110|                            input_ptr_ = parse_false(input_ptr_, visitor, ec);
  771|    110|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|    110|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 57, False: 53]
  |  |  ------------------
  ------------------
  772|     53|                            break;
  773|     53|                        case '}':
  ------------------
  |  Branch (773:25): [True: 1, False: 72.5k]
  ------------------
  774|      1|                            err_handler_(json_errc::unexpected_rbrace, *this);
  775|      1|                            ec = json_errc::unexpected_rbrace;
  776|      1|                            more_ = false;
  777|      1|                            return;
  778|      4|                        case ']':
  ------------------
  |  Branch (778:25): [True: 4, False: 72.5k]
  ------------------
  779|      4|                            err_handler_(json_errc::unexpected_rbracket, *this);
  780|      4|                            ec = json_errc::unexpected_rbracket;
  781|      4|                            more_ = false;
  782|      4|                            return;
  783|     89|                        default:
  ------------------
  |  Branch (783:25): [True: 89, False: 72.4k]
  ------------------
  784|     89|                            err_handler_(json_errc::syntax_error, *this);
  785|     89|                            ec = json_errc::syntax_error;
  786|     89|                            more_ = false;
  787|     89|                            return;
  788|  72.5k|                    }
  789|  72.0k|                    break;
  790|  72.5k|                }
  791|  72.0k|                case parse_state::expect_comma_or_end: 
  ------------------
  |  Branch (791:17): [True: 0, False: 3.36M]
  ------------------
  792|      0|                {
  793|      0|                    switch (*input_ptr_)
  794|      0|                    {
  795|      0|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|      0|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 0, False: 0]
  |  |  |  Branch (34:19): [True: 0, False: 0]
  |  |  |  Branch (34:29): [True: 0, False: 0]
  |  |  |  Branch (34:39): [True: 0, False: 0]
  |  |  |  Branch (34:49): [True: 0, False: 0]
  |  |  |  Branch (34:59): [True: 0, False: 0]
  |  |  |  Branch (34:69): [True: 0, False: 0]
  |  |  |  Branch (34:79): [True: 0, False: 0]
  |  |  |  Branch (34:89): [True: 0, False: 0]
  |  |  |  Branch (34:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   35|      0|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 0, False: 0]
  |  |  |  Branch (35:19): [True: 0, False: 0]
  |  |  |  Branch (35:29): [True: 0, False: 0]
  |  |  |  Branch (35:39): [True: 0, False: 0]
  |  |  |  Branch (35:49): [True: 0, False: 0]
  |  |  |  Branch (35:59): [True: 0, False: 0]
  |  |  |  Branch (35:69): [True: 0, False: 0]
  |  |  |  Branch (35:79): [True: 0, False: 0]
  |  |  |  Branch (35:89): [True: 0, False: 0]
  |  |  |  Branch (35:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   36|      0|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 0, False: 0]
  |  |  |  Branch (36:19): [True: 0, False: 0]
  |  |  |  Branch (36:29): [True: 0, False: 0]
  |  |  |  Branch (36:39): [True: 0, False: 0]
  |  |  |  Branch (36:49): [True: 0, False: 0]
  |  |  |  Branch (36:59): [True: 0, False: 0]
  |  |  |  Branch (36:69): [True: 0, False: 0]
  |  |  |  Branch (36:79): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  796|      0|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
  797|      0|                            if (!more_)
  ------------------
  |  Branch (797:33): [True: 0, False: 0]
  ------------------
  798|      0|                            {
  799|      0|                                ec = json_errc::illegal_control_character;
  800|      0|                                return;
  801|      0|                            }
  802|      0|                            ++input_ptr_;
  803|      0|                            ++position_;
  804|      0|                            break;
  805|      0|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (805:25): [True: 0, False: 0]
  |  Branch (805:34): [True: 0, False: 0]
  |  Branch (805:44): [True: 0, False: 0]
  |  Branch (805:54): [True: 0, False: 0]
  ------------------
  806|      0|                            skip_space(&input_ptr_);
  807|      0|                            break;
  808|      0|                        case '/':
  ------------------
  |  Branch (808:25): [True: 0, False: 0]
  ------------------
  809|      0|                            ++input_ptr_;
  810|      0|                            ++position_;
  811|      0|                            push_state(state_); 
  812|      0|                            state_ = parse_state::slash;
  813|      0|                            break;
  814|      0|                        case '}':
  ------------------
  |  Branch (814:25): [True: 0, False: 0]
  ------------------
  815|      0|                            begin_position_ = position_;
  816|      0|                            ++input_ptr_;
  817|      0|                            ++position_;
  818|      0|                            end_object(visitor, ec);
  819|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  820|      0|                            break;
  821|      0|                        case ']':
  ------------------
  |  Branch (821:25): [True: 0, False: 0]
  ------------------
  822|      0|                            begin_position_ = position_;
  823|      0|                            ++input_ptr_;
  824|      0|                            ++position_;
  825|      0|                            end_array(visitor, ec);
  826|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  827|      0|                            break;
  828|      0|                        case ',':
  ------------------
  |  Branch (828:25): [True: 0, False: 0]
  ------------------
  829|      0|                            begin_member_or_element(ec);
  830|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  831|      0|                            ++input_ptr_;
  832|      0|                            ++position_;
  833|      0|                            break;
  834|      0|                        default:
  ------------------
  |  Branch (834:25): [True: 0, False: 0]
  ------------------
  835|      0|                            if (parent() == parse_state::array)
  ------------------
  |  Branch (835:33): [True: 0, False: 0]
  ------------------
  836|      0|                            {
  837|      0|                                more_ = err_handler_(json_errc::expected_comma_or_rbracket, *this);
  838|      0|                                if (!more_)
  ------------------
  |  Branch (838:37): [True: 0, False: 0]
  ------------------
  839|      0|                                {
  840|      0|                                    ec = json_errc::expected_comma_or_rbracket;
  841|      0|                                    return;
  842|      0|                                }
  843|      0|                            }
  844|      0|                            else if (parent() == parse_state::object)
  ------------------
  |  Branch (844:38): [True: 0, False: 0]
  ------------------
  845|      0|                            {
  846|      0|                                more_ = err_handler_(json_errc::expected_comma_or_rbrace, *this);
  847|      0|                                if (!more_)
  ------------------
  |  Branch (847:37): [True: 0, False: 0]
  ------------------
  848|      0|                                {
  849|      0|                                    ec = json_errc::expected_comma_or_rbrace;
  850|      0|                                    return;
  851|      0|                                }
  852|      0|                            }
  853|      0|                            else
  854|      0|                            {
  855|      0|                                more_ = err_handler_(json_errc::unexpected_character, *this);
  856|      0|                                if (!more_)
  ------------------
  |  Branch (856:37): [True: 0, False: 0]
  ------------------
  857|      0|                                {
  858|      0|                                    ec = json_errc::unexpected_character;
  859|      0|                                    return;
  860|      0|                                }
  861|      0|                            }
  862|      0|                            ++input_ptr_;
  863|      0|                            ++position_;
  864|      0|                            break;
  865|      0|                    }
  866|      0|                    break;
  867|      0|                }
  868|      0|                case parse_state::expect_member_name_or_end: 
  ------------------
  |  Branch (868:17): [True: 0, False: 3.36M]
  ------------------
  869|      0|                {
  870|      0|                    if (input_ptr_ >= local_input_end)
  ------------------
  |  Branch (870:25): [True: 0, False: 0]
  ------------------
  871|      0|                    {
  872|      0|                        return;
  873|      0|                    }
  874|      0|                    switch (*input_ptr_)
  875|      0|                    {
  876|      0|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|      0|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 0, False: 0]
  |  |  |  Branch (34:19): [True: 0, False: 0]
  |  |  |  Branch (34:29): [True: 0, False: 0]
  |  |  |  Branch (34:39): [True: 0, False: 0]
  |  |  |  Branch (34:49): [True: 0, False: 0]
  |  |  |  Branch (34:59): [True: 0, False: 0]
  |  |  |  Branch (34:69): [True: 0, False: 0]
  |  |  |  Branch (34:79): [True: 0, False: 0]
  |  |  |  Branch (34:89): [True: 0, False: 0]
  |  |  |  Branch (34:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   35|      0|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 0, False: 0]
  |  |  |  Branch (35:19): [True: 0, False: 0]
  |  |  |  Branch (35:29): [True: 0, False: 0]
  |  |  |  Branch (35:39): [True: 0, False: 0]
  |  |  |  Branch (35:49): [True: 0, False: 0]
  |  |  |  Branch (35:59): [True: 0, False: 0]
  |  |  |  Branch (35:69): [True: 0, False: 0]
  |  |  |  Branch (35:79): [True: 0, False: 0]
  |  |  |  Branch (35:89): [True: 0, False: 0]
  |  |  |  Branch (35:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   36|      0|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 0, False: 0]
  |  |  |  Branch (36:19): [True: 0, False: 0]
  |  |  |  Branch (36:29): [True: 0, False: 0]
  |  |  |  Branch (36:39): [True: 0, False: 0]
  |  |  |  Branch (36:49): [True: 0, False: 0]
  |  |  |  Branch (36:59): [True: 0, False: 0]
  |  |  |  Branch (36:69): [True: 0, False: 0]
  |  |  |  Branch (36:79): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  877|      0|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
  878|      0|                            if (!more_)
  ------------------
  |  Branch (878:33): [True: 0, False: 0]
  ------------------
  879|      0|                            {
  880|      0|                                ec = json_errc::illegal_control_character;
  881|      0|                                return;
  882|      0|                            }
  883|      0|                            ++input_ptr_;
  884|      0|                            ++position_;
  885|      0|                            break;
  886|      0|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (886:25): [True: 0, False: 0]
  |  Branch (886:34): [True: 0, False: 0]
  |  Branch (886:44): [True: 0, False: 0]
  |  Branch (886:54): [True: 0, False: 0]
  ------------------
  887|      0|                            skip_space(&input_ptr_);
  888|      0|                            break;
  889|      0|                        case '/':
  ------------------
  |  Branch (889:25): [True: 0, False: 0]
  ------------------
  890|      0|                            ++input_ptr_;
  891|      0|                            ++position_;
  892|      0|                            push_state(state_); 
  893|      0|                            state_ = parse_state::slash;
  894|      0|                            break;
  895|      0|                        case '}':
  ------------------
  |  Branch (895:25): [True: 0, False: 0]
  ------------------
  896|      0|                            begin_position_ = position_;
  897|      0|                            ++input_ptr_;
  898|      0|                            ++position_;
  899|      0|                            end_object(visitor, ec);
  900|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  901|      0|                            break;
  902|      0|                        case '\"':
  ------------------
  |  Branch (902:25): [True: 0, False: 0]
  ------------------
  903|      0|                            begin_position_ = position_;
  904|      0|                            ++input_ptr_;
  905|      0|                            ++position_;
  906|      0|                            push_state(parse_state::member_name);
  907|      0|                            state_ = parse_state::string;
  908|      0|                            string_state_ = parse_string_state{};
  909|      0|                            escape_tag_ = semantic_tag::noesc;
  910|      0|                            buffer_.clear();
  911|      0|                            input_ptr_ = parse_string(input_ptr_, visitor, ec);
  912|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  913|      0|                            break;
  914|      0|                        case '\'':
  ------------------
  |  Branch (914:25): [True: 0, False: 0]
  ------------------
  915|      0|                            more_ = err_handler_(json_errc::single_quote, *this);
  916|      0|                            if (!more_)
  ------------------
  |  Branch (916:33): [True: 0, False: 0]
  ------------------
  917|      0|                            {
  918|      0|                                ec = json_errc::single_quote;
  919|      0|                                return;
  920|      0|                            }
  921|      0|                            ++input_ptr_;
  922|      0|                            ++position_;
  923|      0|                            break;
  924|      0|                        default:
  ------------------
  |  Branch (924:25): [True: 0, False: 0]
  ------------------
  925|      0|                            more_ = err_handler_(json_errc::expected_key, *this);
  926|      0|                            if (!more_)
  ------------------
  |  Branch (926:33): [True: 0, False: 0]
  ------------------
  927|      0|                            {
  928|      0|                                ec = json_errc::expected_key;
  929|      0|                                return;
  930|      0|                            }
  931|      0|                            ++input_ptr_;
  932|      0|                            ++position_;
  933|      0|                            break;
  934|      0|                    }
  935|      0|                    break;
  936|      0|                }
  937|      0|                case parse_state::expect_member_name: 
  ------------------
  |  Branch (937:17): [True: 0, False: 3.36M]
  ------------------
  938|      0|                {
  939|      0|                    switch (*input_ptr_)
  940|      0|                    {
  941|      0|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|      0|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 0, False: 0]
  |  |  |  Branch (34:19): [True: 0, False: 0]
  |  |  |  Branch (34:29): [True: 0, False: 0]
  |  |  |  Branch (34:39): [True: 0, False: 0]
  |  |  |  Branch (34:49): [True: 0, False: 0]
  |  |  |  Branch (34:59): [True: 0, False: 0]
  |  |  |  Branch (34:69): [True: 0, False: 0]
  |  |  |  Branch (34:79): [True: 0, False: 0]
  |  |  |  Branch (34:89): [True: 0, False: 0]
  |  |  |  Branch (34:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   35|      0|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 0, False: 0]
  |  |  |  Branch (35:19): [True: 0, False: 0]
  |  |  |  Branch (35:29): [True: 0, False: 0]
  |  |  |  Branch (35:39): [True: 0, False: 0]
  |  |  |  Branch (35:49): [True: 0, False: 0]
  |  |  |  Branch (35:59): [True: 0, False: 0]
  |  |  |  Branch (35:69): [True: 0, False: 0]
  |  |  |  Branch (35:79): [True: 0, False: 0]
  |  |  |  Branch (35:89): [True: 0, False: 0]
  |  |  |  Branch (35:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   36|      0|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 0, False: 0]
  |  |  |  Branch (36:19): [True: 0, False: 0]
  |  |  |  Branch (36:29): [True: 0, False: 0]
  |  |  |  Branch (36:39): [True: 0, False: 0]
  |  |  |  Branch (36:49): [True: 0, False: 0]
  |  |  |  Branch (36:59): [True: 0, False: 0]
  |  |  |  Branch (36:69): [True: 0, False: 0]
  |  |  |  Branch (36:79): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  942|      0|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
  943|      0|                            if (!more_)
  ------------------
  |  Branch (943:33): [True: 0, False: 0]
  ------------------
  944|      0|                            {
  945|      0|                                ec = json_errc::illegal_control_character;
  946|      0|                                return;
  947|      0|                            }
  948|      0|                            ++input_ptr_;
  949|      0|                            ++position_;
  950|      0|                            break;
  951|      0|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (951:25): [True: 0, False: 0]
  |  Branch (951:34): [True: 0, False: 0]
  |  Branch (951:44): [True: 0, False: 0]
  |  Branch (951:54): [True: 0, False: 0]
  ------------------
  952|      0|                            skip_space(&input_ptr_);
  953|      0|                            break;
  954|      0|                        case '/': 
  ------------------
  |  Branch (954:25): [True: 0, False: 0]
  ------------------
  955|      0|                            ++input_ptr_;
  956|      0|                            ++position_;
  957|      0|                            push_state(state_);
  958|      0|                            state_ = parse_state::slash;
  959|      0|                            break;
  960|      0|                        case '\"':
  ------------------
  |  Branch (960:25): [True: 0, False: 0]
  ------------------
  961|      0|                            begin_position_ = position_;
  962|      0|                            ++input_ptr_;
  963|      0|                            ++position_;
  964|      0|                            push_state(parse_state::member_name);
  965|      0|                            state_ = parse_state::string;
  966|      0|                            string_state_ = parse_string_state{};
  967|      0|                            escape_tag_ = semantic_tag::noesc;
  968|      0|                            buffer_.clear();
  969|      0|                            input_ptr_ = parse_string(input_ptr_, visitor, ec);
  970|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  971|      0|                            break;
  972|      0|                        case '}':
  ------------------
  |  Branch (972:25): [True: 0, False: 0]
  ------------------
  973|      0|                            begin_position_ = position_;
  974|      0|                            ++input_ptr_;
  975|      0|                            ++position_;
  976|      0|                            if (!allow_trailing_comma_)
  ------------------
  |  Branch (976:33): [True: 0, False: 0]
  ------------------
  977|      0|                            {
  978|      0|                                more_ = err_handler_(json_errc::extra_comma, *this);
  979|      0|                                if (!more_)
  ------------------
  |  Branch (979:37): [True: 0, False: 0]
  ------------------
  980|      0|                                {
  981|      0|                                    ec = json_errc::extra_comma;
  982|      0|                                    return;
  983|      0|                                }
  984|      0|                            }
  985|      0|                            end_object(visitor, ec);  // Recover
  986|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  987|      0|                            break;
  988|      0|                        case '\'':
  ------------------
  |  Branch (988:25): [True: 0, False: 0]
  ------------------
  989|      0|                            more_ = err_handler_(json_errc::single_quote, *this);
  990|      0|                            if (!more_)
  ------------------
  |  Branch (990:33): [True: 0, False: 0]
  ------------------
  991|      0|                            {
  992|      0|                                ec = json_errc::single_quote;
  993|      0|                                return;
  994|      0|                            }
  995|      0|                            ++input_ptr_;
  996|      0|                            ++position_;
  997|      0|                            break;
  998|      0|                        default:
  ------------------
  |  Branch (998:25): [True: 0, False: 0]
  ------------------
  999|      0|                            more_ = err_handler_(json_errc::expected_key, *this);
 1000|      0|                            if (!more_)
  ------------------
  |  Branch (1000:33): [True: 0, False: 0]
  ------------------
 1001|      0|                            {
 1002|      0|                                ec = json_errc::expected_key;
 1003|      0|                                return;
 1004|      0|                            }
 1005|      0|                            ++input_ptr_;
 1006|      0|                            ++position_;
 1007|      0|                            break;
 1008|      0|                    }
 1009|      0|                    break;
 1010|      0|                }
 1011|      0|                case parse_state::expect_colon: 
  ------------------
  |  Branch (1011:17): [True: 0, False: 3.36M]
  ------------------
 1012|      0|                {
 1013|      0|                    switch (*input_ptr_)
 1014|      0|                    {
 1015|      0|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|      0|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 0, False: 0]
  |  |  |  Branch (34:19): [True: 0, False: 0]
  |  |  |  Branch (34:29): [True: 0, False: 0]
  |  |  |  Branch (34:39): [True: 0, False: 0]
  |  |  |  Branch (34:49): [True: 0, False: 0]
  |  |  |  Branch (34:59): [True: 0, False: 0]
  |  |  |  Branch (34:69): [True: 0, False: 0]
  |  |  |  Branch (34:79): [True: 0, False: 0]
  |  |  |  Branch (34:89): [True: 0, False: 0]
  |  |  |  Branch (34:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   35|      0|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 0, False: 0]
  |  |  |  Branch (35:19): [True: 0, False: 0]
  |  |  |  Branch (35:29): [True: 0, False: 0]
  |  |  |  Branch (35:39): [True: 0, False: 0]
  |  |  |  Branch (35:49): [True: 0, False: 0]
  |  |  |  Branch (35:59): [True: 0, False: 0]
  |  |  |  Branch (35:69): [True: 0, False: 0]
  |  |  |  Branch (35:79): [True: 0, False: 0]
  |  |  |  Branch (35:89): [True: 0, False: 0]
  |  |  |  Branch (35:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   36|      0|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 0, False: 0]
  |  |  |  Branch (36:19): [True: 0, False: 0]
  |  |  |  Branch (36:29): [True: 0, False: 0]
  |  |  |  Branch (36:39): [True: 0, False: 0]
  |  |  |  Branch (36:49): [True: 0, False: 0]
  |  |  |  Branch (36:59): [True: 0, False: 0]
  |  |  |  Branch (36:69): [True: 0, False: 0]
  |  |  |  Branch (36:79): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1016|      0|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
 1017|      0|                            if (!more_)
  ------------------
  |  Branch (1017:33): [True: 0, False: 0]
  ------------------
 1018|      0|                            {
 1019|      0|                                ec = json_errc::illegal_control_character;
 1020|      0|                                return;
 1021|      0|                            }
 1022|      0|                            ++input_ptr_;
 1023|      0|                            ++position_;
 1024|      0|                            break;
 1025|      0|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (1025:25): [True: 0, False: 0]
  |  Branch (1025:34): [True: 0, False: 0]
  |  Branch (1025:44): [True: 0, False: 0]
  |  Branch (1025:54): [True: 0, False: 0]
  ------------------
 1026|      0|                            skip_space(&input_ptr_);
 1027|      0|                            break;
 1028|      0|                        case '/': 
  ------------------
  |  Branch (1028:25): [True: 0, False: 0]
  ------------------
 1029|      0|                            push_state(state_);
 1030|      0|                            state_ = parse_state::slash;
 1031|      0|                            ++input_ptr_;
 1032|      0|                            ++position_;
 1033|      0|                            break;
 1034|      0|                        case ':':
  ------------------
  |  Branch (1034:25): [True: 0, False: 0]
  ------------------
 1035|      0|                            state_ = parse_state::expect_value;
 1036|      0|                            ++input_ptr_;
 1037|      0|                            ++position_;
 1038|      0|                            break;
 1039|      0|                        default:
  ------------------
  |  Branch (1039:25): [True: 0, False: 0]
  ------------------
 1040|      0|                            more_ = err_handler_(json_errc::expected_colon, *this);
 1041|      0|                            if (!more_)
  ------------------
  |  Branch (1041:33): [True: 0, False: 0]
  ------------------
 1042|      0|                            {
 1043|      0|                                ec = json_errc::expected_colon;
 1044|      0|                                return;
 1045|      0|                            }
 1046|      0|                            ++input_ptr_;
 1047|      0|                            ++position_;
 1048|      0|                            break;
 1049|      0|                    }
 1050|      0|                    break;
 1051|      0|                }
 1052|      0|                case parse_state::expect_value: 
  ------------------
  |  Branch (1052:17): [True: 0, False: 3.36M]
  ------------------
 1053|      0|                {
 1054|      0|                    switch (*input_ptr_)
 1055|      0|                    {
 1056|      0|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|      0|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 0, False: 0]
  |  |  |  Branch (34:19): [True: 0, False: 0]
  |  |  |  Branch (34:29): [True: 0, False: 0]
  |  |  |  Branch (34:39): [True: 0, False: 0]
  |  |  |  Branch (34:49): [True: 0, False: 0]
  |  |  |  Branch (34:59): [True: 0, False: 0]
  |  |  |  Branch (34:69): [True: 0, False: 0]
  |  |  |  Branch (34:79): [True: 0, False: 0]
  |  |  |  Branch (34:89): [True: 0, False: 0]
  |  |  |  Branch (34:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   35|      0|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 0, False: 0]
  |  |  |  Branch (35:19): [True: 0, False: 0]
  |  |  |  Branch (35:29): [True: 0, False: 0]
  |  |  |  Branch (35:39): [True: 0, False: 0]
  |  |  |  Branch (35:49): [True: 0, False: 0]
  |  |  |  Branch (35:59): [True: 0, False: 0]
  |  |  |  Branch (35:69): [True: 0, False: 0]
  |  |  |  Branch (35:79): [True: 0, False: 0]
  |  |  |  Branch (35:89): [True: 0, False: 0]
  |  |  |  Branch (35:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   36|      0|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 0, False: 0]
  |  |  |  Branch (36:19): [True: 0, False: 0]
  |  |  |  Branch (36:29): [True: 0, False: 0]
  |  |  |  Branch (36:39): [True: 0, False: 0]
  |  |  |  Branch (36:49): [True: 0, False: 0]
  |  |  |  Branch (36:59): [True: 0, False: 0]
  |  |  |  Branch (36:69): [True: 0, False: 0]
  |  |  |  Branch (36:79): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1057|      0|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
 1058|      0|                            if (!more_)
  ------------------
  |  Branch (1058:33): [True: 0, False: 0]
  ------------------
 1059|      0|                            {
 1060|      0|                                ec = json_errc::illegal_control_character;
 1061|      0|                                return;
 1062|      0|                            }
 1063|      0|                            ++input_ptr_;
 1064|      0|                            ++position_;
 1065|      0|                            break;
 1066|      0|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (1066:25): [True: 0, False: 0]
  |  Branch (1066:34): [True: 0, False: 0]
  |  Branch (1066:44): [True: 0, False: 0]
  |  Branch (1066:54): [True: 0, False: 0]
  ------------------
 1067|      0|                            skip_space(&input_ptr_);
 1068|      0|                            break;
 1069|      0|                        case '/': 
  ------------------
  |  Branch (1069:25): [True: 0, False: 0]
  ------------------
 1070|      0|                            push_state(state_);
 1071|      0|                            ++input_ptr_;
 1072|      0|                            ++position_;
 1073|      0|                            state_ = parse_state::slash;
 1074|      0|                            break;
 1075|      0|                        case '{':
  ------------------
  |  Branch (1075:25): [True: 0, False: 0]
  ------------------
 1076|      0|                            begin_position_ = position_;
 1077|      0|                            ++input_ptr_;
 1078|      0|                            ++position_;
 1079|      0|                            begin_object(visitor, ec);
 1080|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1081|      0|                            break;
 1082|      0|                        case '[':
  ------------------
  |  Branch (1082:25): [True: 0, False: 0]
  ------------------
 1083|      0|                            begin_position_ = position_;
 1084|      0|                            ++input_ptr_;
 1085|      0|                            ++position_;
 1086|      0|                            begin_array(visitor, ec);
 1087|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1088|      0|                            break;
 1089|      0|                        case '\"':
  ------------------
  |  Branch (1089:25): [True: 0, False: 0]
  ------------------
 1090|      0|                            begin_position_ = position_;
 1091|      0|                            ++input_ptr_;
 1092|      0|                            ++position_;
 1093|      0|                            state_ = parse_state::string;
 1094|      0|                            string_state_ = parse_string_state{};
 1095|      0|                            escape_tag_ = semantic_tag::noesc;
 1096|      0|                            buffer_.clear();
 1097|      0|                            input_ptr_ = parse_string(input_ptr_, visitor, ec);
 1098|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1099|      0|                            break;
 1100|      0|                        case '-':
  ------------------
  |  Branch (1100:25): [True: 0, False: 0]
  ------------------
 1101|      0|                            buffer_.clear();
 1102|      0|                            buffer_.push_back('-');
 1103|      0|                            begin_position_ = position_;
 1104|      0|                            ++input_ptr_;
 1105|      0|                            ++position_;
 1106|      0|                            state_ = parse_state::number;
 1107|      0|                            number_state_ = parse_number_state::minus;
 1108|      0|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
 1109|      0|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1110|      0|                            break;
 1111|      0|                        case '0': 
  ------------------
  |  Branch (1111:25): [True: 0, False: 0]
  ------------------
 1112|      0|                            buffer_.clear();
 1113|      0|                            buffer_.push_back(static_cast<char>(*input_ptr_));
 1114|      0|                            begin_position_ = position_;
 1115|      0|                            ++input_ptr_;
 1116|      0|                            ++position_;
 1117|      0|                            state_ = parse_state::number;
 1118|      0|                            number_state_ = parse_number_state::zero;
 1119|      0|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
 1120|      0|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1121|      0|                            break;
 1122|      0|                        case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (1122:25): [True: 0, False: 0]
  |  Branch (1122:34): [True: 0, False: 0]
  |  Branch (1122:43): [True: 0, False: 0]
  |  Branch (1122:52): [True: 0, False: 0]
  |  Branch (1122:61): [True: 0, False: 0]
  |  Branch (1122:70): [True: 0, False: 0]
  |  Branch (1122:79): [True: 0, False: 0]
  |  Branch (1122:88): [True: 0, False: 0]
  |  Branch (1122:98): [True: 0, False: 0]
  ------------------
 1123|      0|                            buffer_.clear();
 1124|      0|                            buffer_.push_back(static_cast<char>(*input_ptr_));
 1125|      0|                            begin_position_ = position_;
 1126|      0|                            ++input_ptr_;
 1127|      0|                            ++position_;
 1128|      0|                            state_ = parse_state::number;
 1129|      0|                            number_state_ = parse_number_state::integer;
 1130|      0|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
 1131|      0|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1132|      0|                            break;
 1133|      0|                        case 'n':
  ------------------
  |  Branch (1133:25): [True: 0, False: 0]
  ------------------
 1134|      0|                            parse_null(visitor, ec);
 1135|      0|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1136|      0|                            break;
 1137|      0|                        case 't':
  ------------------
  |  Branch (1137:25): [True: 0, False: 0]
  ------------------
 1138|      0|                            input_ptr_ = parse_true(input_ptr_, visitor, ec);
 1139|      0|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1140|      0|                            break;
 1141|      0|                        case 'f':
  ------------------
  |  Branch (1141:25): [True: 0, False: 0]
  ------------------
 1142|      0|                            input_ptr_ = parse_false(input_ptr_, visitor, ec);
 1143|      0|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1144|      0|                            break;
 1145|      0|                        case ']':
  ------------------
  |  Branch (1145:25): [True: 0, False: 0]
  ------------------
 1146|      0|                            begin_position_ = position_;
 1147|      0|                            ++input_ptr_;
 1148|      0|                            ++position_;
 1149|      0|                            if (parent() == parse_state::array)
  ------------------
  |  Branch (1149:33): [True: 0, False: 0]
  ------------------
 1150|      0|                            {
 1151|      0|                                if (!allow_trailing_comma_)
  ------------------
  |  Branch (1151:37): [True: 0, False: 0]
  ------------------
 1152|      0|                                {
 1153|      0|                                    more_ = err_handler_(json_errc::extra_comma, *this);
 1154|      0|                                    if (!more_)
  ------------------
  |  Branch (1154:41): [True: 0, False: 0]
  ------------------
 1155|      0|                                    {
 1156|      0|                                        ec = json_errc::extra_comma;
 1157|      0|                                        return;
 1158|      0|                                    }
 1159|      0|                                }
 1160|      0|                                end_array(visitor, ec);  // Recover
 1161|      0|                                if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1162|      0|                            }
 1163|      0|                            else
 1164|      0|                            {
 1165|      0|                                more_ = err_handler_(json_errc::expected_value, *this);
 1166|      0|                                if (!more_)
  ------------------
  |  Branch (1166:37): [True: 0, False: 0]
  ------------------
 1167|      0|                                {
 1168|      0|                                    ec = json_errc::expected_value;
 1169|      0|                                    return;
 1170|      0|                                }
 1171|      0|                            }
 1172|       |                            
 1173|      0|                            break;
 1174|      0|                        case '\'':
  ------------------
  |  Branch (1174:25): [True: 0, False: 0]
  ------------------
 1175|      0|                            more_ = err_handler_(json_errc::single_quote, *this);
 1176|      0|                            if (!more_)
  ------------------
  |  Branch (1176:33): [True: 0, False: 0]
  ------------------
 1177|      0|                            {
 1178|      0|                                ec = json_errc::single_quote;
 1179|      0|                                return;
 1180|      0|                            }
 1181|      0|                            ++input_ptr_;
 1182|      0|                            ++position_;
 1183|      0|                            break;
 1184|      0|                        default:
  ------------------
  |  Branch (1184:25): [True: 0, False: 0]
  ------------------
 1185|      0|                            more_ = err_handler_(json_errc::expected_value, *this);
 1186|      0|                            if (!more_)
  ------------------
  |  Branch (1186:33): [True: 0, False: 0]
  ------------------
 1187|      0|                            {
 1188|      0|                                ec = json_errc::expected_value;
 1189|      0|                                return;
 1190|      0|                            }
 1191|      0|                            ++input_ptr_;
 1192|      0|                            ++position_;
 1193|      0|                            break;
 1194|      0|                    }
 1195|      0|                    break;
 1196|      0|                }
 1197|      0|                case parse_state::expect_value_or_end: 
  ------------------
  |  Branch (1197:17): [True: 0, False: 3.36M]
  ------------------
 1198|      0|                {
 1199|      0|                    switch (*input_ptr_)
 1200|      0|                    {
 1201|      0|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|      0|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 0, False: 0]
  |  |  |  Branch (34:19): [True: 0, False: 0]
  |  |  |  Branch (34:29): [True: 0, False: 0]
  |  |  |  Branch (34:39): [True: 0, False: 0]
  |  |  |  Branch (34:49): [True: 0, False: 0]
  |  |  |  Branch (34:59): [True: 0, False: 0]
  |  |  |  Branch (34:69): [True: 0, False: 0]
  |  |  |  Branch (34:79): [True: 0, False: 0]
  |  |  |  Branch (34:89): [True: 0, False: 0]
  |  |  |  Branch (34:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   35|      0|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 0, False: 0]
  |  |  |  Branch (35:19): [True: 0, False: 0]
  |  |  |  Branch (35:29): [True: 0, False: 0]
  |  |  |  Branch (35:39): [True: 0, False: 0]
  |  |  |  Branch (35:49): [True: 0, False: 0]
  |  |  |  Branch (35:59): [True: 0, False: 0]
  |  |  |  Branch (35:69): [True: 0, False: 0]
  |  |  |  Branch (35:79): [True: 0, False: 0]
  |  |  |  Branch (35:89): [True: 0, False: 0]
  |  |  |  Branch (35:99): [True: 0, False: 0]
  |  |  ------------------
  |  |   36|      0|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 0, False: 0]
  |  |  |  Branch (36:19): [True: 0, False: 0]
  |  |  |  Branch (36:29): [True: 0, False: 0]
  |  |  |  Branch (36:39): [True: 0, False: 0]
  |  |  |  Branch (36:49): [True: 0, False: 0]
  |  |  |  Branch (36:59): [True: 0, False: 0]
  |  |  |  Branch (36:69): [True: 0, False: 0]
  |  |  |  Branch (36:79): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1202|      0|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
 1203|      0|                            if (!more_)
  ------------------
  |  Branch (1203:33): [True: 0, False: 0]
  ------------------
 1204|      0|                            {
 1205|      0|                                ec = json_errc::illegal_control_character;
 1206|      0|                                return;
 1207|      0|                            }
 1208|      0|                            ++input_ptr_;
 1209|      0|                            ++position_;
 1210|      0|                            break;
 1211|      0|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (1211:25): [True: 0, False: 0]
  |  Branch (1211:34): [True: 0, False: 0]
  |  Branch (1211:44): [True: 0, False: 0]
  |  Branch (1211:54): [True: 0, False: 0]
  ------------------
 1212|      0|                            skip_space(&input_ptr_);
 1213|      0|                            break;
 1214|      0|                        case '/': 
  ------------------
  |  Branch (1214:25): [True: 0, False: 0]
  ------------------
 1215|      0|                            ++input_ptr_;
 1216|      0|                            ++position_;
 1217|      0|                            push_state(state_);
 1218|      0|                            state_ = parse_state::slash;
 1219|      0|                            break;
 1220|      0|                        case '{':
  ------------------
  |  Branch (1220:25): [True: 0, False: 0]
  ------------------
 1221|      0|                            begin_position_ = position_;
 1222|      0|                            ++input_ptr_;
 1223|      0|                            ++position_;
 1224|      0|                            begin_object(visitor, ec);
 1225|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1226|      0|                            break;
 1227|      0|                        case '[':
  ------------------
  |  Branch (1227:25): [True: 0, False: 0]
  ------------------
 1228|      0|                            begin_position_ = position_;
 1229|      0|                            ++input_ptr_;
 1230|      0|                            ++position_;
 1231|      0|                            begin_array(visitor, ec);
 1232|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1233|      0|                            break;
 1234|      0|                        case ']':
  ------------------
  |  Branch (1234:25): [True: 0, False: 0]
  ------------------
 1235|      0|                            begin_position_ = position_;
 1236|      0|                            ++input_ptr_;
 1237|      0|                            ++position_;
 1238|      0|                            end_array(visitor, ec);
 1239|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1240|      0|                            break;
 1241|      0|                        case '\"':
  ------------------
  |  Branch (1241:25): [True: 0, False: 0]
  ------------------
 1242|      0|                            begin_position_ = position_;
 1243|      0|                            ++input_ptr_;
 1244|      0|                            ++position_;
 1245|      0|                            state_ = parse_state::string;
 1246|      0|                            string_state_ = parse_string_state{};
 1247|      0|                            escape_tag_ = semantic_tag::noesc;
 1248|      0|                            buffer_.clear();
 1249|      0|                            input_ptr_ = parse_string(input_ptr_, visitor, ec);
 1250|      0|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1251|      0|                            break;
 1252|      0|                        case '-':
  ------------------
  |  Branch (1252:25): [True: 0, False: 0]
  ------------------
 1253|      0|                            buffer_.clear();
 1254|      0|                            buffer_.push_back('-');
 1255|      0|                            begin_position_ = position_;
 1256|      0|                            ++input_ptr_;
 1257|      0|                            ++position_;
 1258|      0|                            state_ = parse_state::number;
 1259|      0|                            number_state_ = parse_number_state::minus;
 1260|      0|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
 1261|      0|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1262|      0|                            break;
 1263|      0|                        case '0': 
  ------------------
  |  Branch (1263:25): [True: 0, False: 0]
  ------------------
 1264|      0|                            buffer_.clear();
 1265|      0|                            buffer_.push_back(static_cast<char>(*input_ptr_));
 1266|      0|                            begin_position_ = position_;
 1267|      0|                            ++input_ptr_;
 1268|      0|                            ++position_;
 1269|      0|                            state_ = parse_state::number;
 1270|      0|                            number_state_ = parse_number_state::zero;
 1271|      0|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
 1272|      0|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1273|      0|                            break;
 1274|      0|                        case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (1274:25): [True: 0, False: 0]
  |  Branch (1274:34): [True: 0, False: 0]
  |  Branch (1274:43): [True: 0, False: 0]
  |  Branch (1274:52): [True: 0, False: 0]
  |  Branch (1274:61): [True: 0, False: 0]
  |  Branch (1274:70): [True: 0, False: 0]
  |  Branch (1274:79): [True: 0, False: 0]
  |  Branch (1274:88): [True: 0, False: 0]
  |  Branch (1274:98): [True: 0, False: 0]
  ------------------
 1275|      0|                            buffer_.clear();
 1276|      0|                            buffer_.push_back(static_cast<char>(*input_ptr_));
 1277|      0|                            begin_position_ = position_;
 1278|      0|                            ++input_ptr_;
 1279|      0|                            ++position_;
 1280|      0|                            state_ = parse_state::number;
 1281|      0|                            number_state_ = parse_number_state::integer;
 1282|      0|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
 1283|      0|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1284|      0|                            break;
 1285|      0|                        case 'n':
  ------------------
  |  Branch (1285:25): [True: 0, False: 0]
  ------------------
 1286|      0|                            parse_null(visitor, ec);
 1287|      0|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1288|      0|                            break;
 1289|      0|                        case 't':
  ------------------
  |  Branch (1289:25): [True: 0, False: 0]
  ------------------
 1290|      0|                            input_ptr_ = parse_true(input_ptr_, visitor, ec);
 1291|      0|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1292|      0|                            break;
 1293|      0|                        case 'f':
  ------------------
  |  Branch (1293:25): [True: 0, False: 0]
  ------------------
 1294|      0|                            input_ptr_ = parse_false(input_ptr_, visitor, ec);
 1295|      0|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1296|      0|                            break;
 1297|      0|                        case '\'':
  ------------------
  |  Branch (1297:25): [True: 0, False: 0]
  ------------------
 1298|      0|                            more_ = err_handler_(json_errc::single_quote, *this);
 1299|      0|                            if (!more_)
  ------------------
  |  Branch (1299:33): [True: 0, False: 0]
  ------------------
 1300|      0|                            {
 1301|      0|                                ec = json_errc::single_quote;
 1302|      0|                                return;
 1303|      0|                            }
 1304|      0|                            ++input_ptr_;
 1305|      0|                            ++position_;
 1306|      0|                            break;
 1307|      0|                        default:
  ------------------
  |  Branch (1307:25): [True: 0, False: 0]
  ------------------
 1308|      0|                            more_ = err_handler_(json_errc::expected_value, *this);
 1309|      0|                            if (!more_)
  ------------------
  |  Branch (1309:33): [True: 0, False: 0]
  ------------------
 1310|      0|                            {
 1311|      0|                                ec = json_errc::expected_value;
 1312|      0|                                return;
 1313|      0|                            }
 1314|      0|                            ++input_ptr_;
 1315|      0|                            ++position_;
 1316|      0|                            break;
 1317|      0|                        }
 1318|      0|                    }
 1319|      0|                    break;
 1320|   271k|                case parse_state::string: 
  ------------------
  |  Branch (1320:17): [True: 271k, False: 3.09M]
  ------------------
 1321|   271k|                    input_ptr_ = parse_string(input_ptr_, visitor, ec);
 1322|   271k|                    if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|   271k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 28, False: 271k]
  |  |  ------------------
  ------------------
 1323|   271k|                    break;
 1324|   271k|                case parse_state::number:
  ------------------
  |  Branch (1324:17): [True: 2.05k, False: 3.36M]
  ------------------
 1325|  2.05k|                    input_ptr_ = parse_number(input_ptr_, visitor, ec);  
 1326|  2.05k|                    if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  2.05k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 5, False: 2.05k]
  |  |  ------------------
  ------------------
 1327|  2.05k|                    break;
 1328|  2.05k|                case parse_state::t: 
  ------------------
  |  Branch (1328:17): [True: 40, False: 3.36M]
  ------------------
 1329|     40|                    switch (*input_ptr_)
 1330|     40|                    {
 1331|     26|                        case 'r':
  ------------------
  |  Branch (1331:25): [True: 26, False: 14]
  ------------------
 1332|     26|                            ++input_ptr_;
 1333|     26|                            ++position_;
 1334|     26|                            state_ = parse_state::tr;
 1335|     26|                            break;
 1336|     14|                        default:
  ------------------
  |  Branch (1336:25): [True: 14, False: 26]
  ------------------
 1337|     14|                            err_handler_(json_errc::invalid_value, *this);
 1338|     14|                            ec = json_errc::invalid_value;
 1339|     14|                            more_ = false;
 1340|     14|                            return;
 1341|     40|                    }
 1342|     26|                    break;
 1343|     26|                case parse_state::tr: 
  ------------------
  |  Branch (1343:17): [True: 25, False: 3.36M]
  ------------------
 1344|     25|                    switch (*input_ptr_)
 1345|     25|                    {
 1346|     14|                        case 'u':
  ------------------
  |  Branch (1346:25): [True: 14, False: 11]
  ------------------
 1347|     14|                            state_ = parse_state::tru;
 1348|     14|                            break;
 1349|     11|                        default:
  ------------------
  |  Branch (1349:25): [True: 11, False: 14]
  ------------------
 1350|     11|                            err_handler_(json_errc::invalid_value, *this);
 1351|     11|                            ec = json_errc::invalid_value;
 1352|     11|                            more_ = false;
 1353|     11|                            return;
 1354|     25|                    }
 1355|     14|                    ++input_ptr_;
 1356|     14|                    ++position_;
 1357|     14|                    break;
 1358|     13|                case parse_state::tru: 
  ------------------
  |  Branch (1358:17): [True: 13, False: 3.36M]
  ------------------
 1359|     13|                    switch (*input_ptr_)
 1360|     13|                    {
 1361|      1|                        case 'e':
  ------------------
  |  Branch (1361:25): [True: 1, False: 12]
  ------------------
 1362|      1|                            ++input_ptr_;
 1363|      1|                            ++position_;
 1364|      1|                            visitor.bool_value(true,  semantic_tag::none, *this, ec);
 1365|      1|                            if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1366|      1|                            if (level_ == 0)
  ------------------
  |  Branch (1366:33): [True: 1, False: 0]
  ------------------
 1367|      1|                            {
 1368|      1|                                state_ = parse_state::accept;
 1369|      1|                            }
 1370|      0|                            else
 1371|      0|                            {
 1372|      0|                                state_ = parse_state::expect_comma_or_end;
 1373|      0|                            }
 1374|      1|                            more_ = !cursor_mode_;
 1375|      1|                            break;
 1376|     12|                        default:
  ------------------
  |  Branch (1376:25): [True: 12, False: 1]
  ------------------
 1377|     12|                            err_handler_(json_errc::invalid_value, *this);
 1378|     12|                            ec = json_errc::invalid_value;
 1379|     12|                            more_ = false;
 1380|     12|                            return;
 1381|     13|                    }
 1382|      1|                    break;
 1383|     50|                case parse_state::f: 
  ------------------
  |  Branch (1383:17): [True: 50, False: 3.36M]
  ------------------
 1384|     50|                    switch (*input_ptr_)
 1385|     50|                    {
 1386|     38|                        case 'a':
  ------------------
  |  Branch (1386:25): [True: 38, False: 12]
  ------------------
 1387|     38|                            ++input_ptr_;
 1388|     38|                            ++position_;
 1389|     38|                            state_ = parse_state::fa;
 1390|     38|                            break;
 1391|     12|                        default:
  ------------------
  |  Branch (1391:25): [True: 12, False: 38]
  ------------------
 1392|     12|                            err_handler_(json_errc::invalid_value, *this);
 1393|     12|                            ec = json_errc::invalid_value;
 1394|     12|                            more_ = false;
 1395|     12|                            return;
 1396|     50|                    }
 1397|     38|                    break;
 1398|     38|                case parse_state::fa: 
  ------------------
  |  Branch (1398:17): [True: 37, False: 3.36M]
  ------------------
 1399|     37|                    switch (*input_ptr_)
 1400|     37|                    {
 1401|     25|                        case 'l':
  ------------------
  |  Branch (1401:25): [True: 25, False: 12]
  ------------------
 1402|     25|                            state_ = parse_state::fal;
 1403|     25|                            break;
 1404|     12|                        default:
  ------------------
  |  Branch (1404:25): [True: 12, False: 25]
  ------------------
 1405|     12|                            err_handler_(json_errc::invalid_value, *this);
 1406|     12|                            ec = json_errc::invalid_value;
 1407|     12|                            more_ = false;
 1408|     12|                            return;
 1409|     37|                    }
 1410|     25|                    ++input_ptr_;
 1411|     25|                    ++position_;
 1412|     25|                    break;
 1413|     24|                case parse_state::fal: 
  ------------------
  |  Branch (1413:17): [True: 24, False: 3.36M]
  ------------------
 1414|     24|                    switch (*input_ptr_)
 1415|     24|                    {
 1416|     12|                        case 's':
  ------------------
  |  Branch (1416:25): [True: 12, False: 12]
  ------------------
 1417|     12|                            state_ = parse_state::fals;
 1418|     12|                            break;
 1419|     12|                        default:
  ------------------
  |  Branch (1419:25): [True: 12, False: 12]
  ------------------
 1420|     12|                            err_handler_(json_errc::invalid_value, *this);
 1421|     12|                            ec = json_errc::invalid_value;
 1422|     12|                            more_ = false;
 1423|     12|                            return;
 1424|     24|                    }
 1425|     12|                    ++input_ptr_;
 1426|     12|                    ++position_;
 1427|     12|                    break;
 1428|     11|                case parse_state::fals: 
  ------------------
  |  Branch (1428:17): [True: 11, False: 3.36M]
  ------------------
 1429|     11|                    switch (*input_ptr_)
 1430|     11|                    {
 1431|      1|                        case 'e':
  ------------------
  |  Branch (1431:25): [True: 1, False: 10]
  ------------------
 1432|      1|                            ++input_ptr_;
 1433|      1|                            ++position_;
 1434|      1|                            visitor.bool_value(false, semantic_tag::none, *this, ec);
 1435|      1|                            if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1436|      1|                            if (level_ == 0)
  ------------------
  |  Branch (1436:33): [True: 1, False: 0]
  ------------------
 1437|      1|                            {
 1438|      1|                                state_ = parse_state::accept;
 1439|      1|                            }
 1440|      0|                            else
 1441|      0|                            {
 1442|      0|                                state_ = parse_state::expect_comma_or_end;
 1443|      0|                            }
 1444|      1|                            more_ = !cursor_mode_;
 1445|      1|                            break;
 1446|     10|                        default:
  ------------------
  |  Branch (1446:25): [True: 10, False: 1]
  ------------------
 1447|     10|                            err_handler_(json_errc::invalid_value, *this);
 1448|     10|                            ec = json_errc::invalid_value;
 1449|     10|                            more_ = false;
 1450|     10|                            return;
 1451|     11|                    }
 1452|      1|                    break;
 1453|     38|                case parse_state::n: 
  ------------------
  |  Branch (1453:17): [True: 38, False: 3.36M]
  ------------------
 1454|     38|                    switch (*input_ptr_)
 1455|     38|                    {
 1456|     24|                        case 'u':
  ------------------
  |  Branch (1456:25): [True: 24, False: 14]
  ------------------
 1457|     24|                            ++input_ptr_;
 1458|     24|                            ++position_;
 1459|     24|                            state_ = parse_state::nu;
 1460|     24|                            break;
 1461|     14|                        default:
  ------------------
  |  Branch (1461:25): [True: 14, False: 24]
  ------------------
 1462|     14|                            err_handler_(json_errc::invalid_value, *this);
 1463|     14|                            ec = json_errc::invalid_value;
 1464|     14|                            more_ = false;
 1465|     14|                            return;
 1466|     38|                    }
 1467|     24|                    break;
 1468|     24|                case parse_state::nu: 
  ------------------
  |  Branch (1468:17): [True: 23, False: 3.36M]
  ------------------
 1469|     23|                    switch (*input_ptr_)
 1470|     23|                    {
 1471|     12|                        case 'l':
  ------------------
  |  Branch (1471:25): [True: 12, False: 11]
  ------------------
 1472|     12|                            state_ = parse_state::nul;
 1473|     12|                            break;
 1474|     11|                        default:
  ------------------
  |  Branch (1474:25): [True: 11, False: 12]
  ------------------
 1475|     11|                            err_handler_(json_errc::invalid_value, *this);
 1476|     11|                            ec = json_errc::invalid_value;
 1477|     11|                            more_ = false;
 1478|     11|                            return;
 1479|     23|                    }
 1480|     12|                    ++input_ptr_;
 1481|     12|                    ++position_;
 1482|     12|                    break;
 1483|     11|                case parse_state::nul: 
  ------------------
  |  Branch (1483:17): [True: 11, False: 3.36M]
  ------------------
 1484|     11|                    ++position_;
 1485|     11|                    switch (*input_ptr_)
 1486|     11|                    {
 1487|      1|                        case 'l':
  ------------------
  |  Branch (1487:25): [True: 1, False: 10]
  ------------------
 1488|      1|                            visitor.null_value(semantic_tag::none, *this, ec);
 1489|      1|                            if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1490|      1|                            if (level_ == 0)
  ------------------
  |  Branch (1490:33): [True: 1, False: 0]
  ------------------
 1491|      1|                            {
 1492|      1|                                state_ = parse_state::accept;
 1493|      1|                            }
 1494|      0|                            else
 1495|      0|                            {
 1496|      0|                                state_ = parse_state::expect_comma_or_end;
 1497|      0|                            }
 1498|      1|                            more_ = !cursor_mode_;
 1499|      1|                            break;
 1500|     10|                        default:
  ------------------
  |  Branch (1500:25): [True: 10, False: 1]
  ------------------
 1501|     10|                            err_handler_(json_errc::invalid_value, *this);
 1502|     10|                            ec = json_errc::invalid_value;
 1503|     10|                            more_ = false;
 1504|     10|                            return;
 1505|     11|                    }
 1506|      1|                    ++input_ptr_;
 1507|      1|                    break;
 1508|  34.6k|                case parse_state::slash: 
  ------------------
  |  Branch (1508:17): [True: 34.6k, False: 3.33M]
  ------------------
 1509|  34.6k|                {
 1510|  34.6k|                    switch (*input_ptr_)
 1511|  34.6k|                    {
 1512|  1.38k|                        case '*':
  ------------------
  |  Branch (1512:25): [True: 1.38k, False: 33.2k]
  ------------------
 1513|  1.38k|                            if (!allow_comments_)
  ------------------
  |  Branch (1513:33): [True: 0, False: 1.38k]
  ------------------
 1514|      0|                            {
 1515|      0|                                ec = json_errc::illegal_comment;
 1516|      0|                                return;
 1517|      0|                            }
 1518|  1.38k|                            more_ = err_handler_(json_errc::illegal_comment, *this);
 1519|  1.38k|                            if (!more_)
  ------------------
  |  Branch (1519:33): [True: 0, False: 1.38k]
  ------------------
 1520|      0|                            {
 1521|      0|                                ec = json_errc::illegal_comment;
 1522|      0|                                return;
 1523|      0|                            }
 1524|  1.38k|                            state_ = parse_state::slash_star;
 1525|  1.38k|                            break;
 1526|  33.2k|                        case '/':
  ------------------
  |  Branch (1526:25): [True: 33.2k, False: 1.39k]
  ------------------
 1527|  33.2k|                            if (!allow_comments_)
  ------------------
  |  Branch (1527:33): [True: 0, False: 33.2k]
  ------------------
 1528|      0|                            {
 1529|      0|                                ec = json_errc::illegal_comment;
 1530|      0|                                return;
 1531|      0|                            }
 1532|  33.2k|                            more_ = err_handler_(json_errc::illegal_comment, *this);
 1533|  33.2k|                            if (!more_)
  ------------------
  |  Branch (1533:33): [True: 0, False: 33.2k]
  ------------------
 1534|      0|                            {
 1535|      0|                                ec = json_errc::illegal_comment;
 1536|      0|                                return;
 1537|      0|                            }
 1538|  33.2k|                            state_ = parse_state::slash_slash;
 1539|  33.2k|                            break;
 1540|      4|                        default:    
  ------------------
  |  Branch (1540:25): [True: 4, False: 34.6k]
  ------------------
 1541|      4|                            more_ = err_handler_(json_errc::syntax_error, *this);
 1542|      4|                            if (!more_)
  ------------------
  |  Branch (1542:33): [True: 4, False: 0]
  ------------------
 1543|      4|                            {
 1544|      4|                                ec = json_errc::syntax_error;
 1545|      4|                                return;
 1546|      4|                            }
 1547|      0|                            break;
 1548|  34.6k|                    }
 1549|  34.6k|                    ++input_ptr_;
 1550|  34.6k|                    ++position_;
 1551|  34.6k|                    break;
 1552|  34.6k|                }
 1553|  1.56M|                case parse_state::slash_star:  
  ------------------
  |  Branch (1553:17): [True: 1.56M, False: 1.80M]
  ------------------
 1554|  1.56M|                {
 1555|  1.56M|                    switch (*input_ptr_)
 1556|  1.56M|                    {
 1557|  1.25k|                        case '\r':
  ------------------
  |  Branch (1557:25): [True: 1.25k, False: 1.56M]
  ------------------
 1558|  1.25k|                            push_state(state_);
 1559|  1.25k|                            ++input_ptr_;
 1560|  1.25k|                            ++position_;
 1561|  1.25k|                            state_ = parse_state::cr;
 1562|  1.25k|                            break;
 1563|  1.09k|                        case '\n':
  ------------------
  |  Branch (1563:25): [True: 1.09k, False: 1.56M]
  ------------------
 1564|  1.09k|                            ++input_ptr_;
 1565|  1.09k|                            ++line_;
 1566|  1.09k|                            ++position_;
 1567|  1.09k|                            mark_position_ = position_;
 1568|  1.09k|                            break;
 1569|  2.55k|                        case '*':
  ------------------
  |  Branch (1569:25): [True: 2.55k, False: 1.56M]
  ------------------
 1570|  2.55k|                            ++input_ptr_;
 1571|  2.55k|                            ++position_;
 1572|  2.55k|                            state_ = parse_state::slash_star_star;
 1573|  2.55k|                            break;
 1574|  1.56M|                        default:
  ------------------
  |  Branch (1574:25): [True: 1.56M, False: 4.90k]
  ------------------
 1575|  1.56M|                            ++input_ptr_;
 1576|  1.56M|                            ++position_;
 1577|  1.56M|                            break;
 1578|  1.56M|                    }
 1579|  1.56M|                    break;
 1580|  1.56M|                }
 1581|  1.56M|                case parse_state::slash_slash: 
  ------------------
  |  Branch (1581:17): [True: 1.41M, False: 1.95M]
  ------------------
 1582|  1.41M|                {
 1583|  1.41M|                    switch (*input_ptr_)
 1584|  1.41M|                    {
 1585|  12.9k|                    case '\r':
  ------------------
  |  Branch (1585:21): [True: 12.9k, False: 1.40M]
  ------------------
 1586|  33.2k|                    case '\n':
  ------------------
  |  Branch (1586:21): [True: 20.2k, False: 1.39M]
  ------------------
 1587|  33.2k|                        state_ = pop_state();
 1588|  33.2k|                        break;
 1589|  1.38M|                    default:
  ------------------
  |  Branch (1589:21): [True: 1.38M, False: 33.2k]
  ------------------
 1590|  1.38M|                        ++input_ptr_;
 1591|  1.38M|                        ++position_;
 1592|  1.41M|                    }
 1593|  1.41M|                    break;
 1594|  1.41M|                }
 1595|  1.41M|                case parse_state::slash_star_star: 
  ------------------
  |  Branch (1595:17): [True: 2.54k, False: 3.36M]
  ------------------
 1596|  2.54k|                {
 1597|  2.54k|                    switch (*input_ptr_)
 1598|  2.54k|                    {
 1599|  1.30k|                    case '/':
  ------------------
  |  Branch (1599:21): [True: 1.30k, False: 1.23k]
  ------------------
 1600|  1.30k|                        state_ = pop_state();
 1601|  1.30k|                        break;
 1602|  1.23k|                    default:    
  ------------------
  |  Branch (1602:21): [True: 1.23k, False: 1.30k]
  ------------------
 1603|  1.23k|                        state_ = parse_state::slash_star;
 1604|  1.23k|                        break;
 1605|  2.54k|                    }
 1606|  2.54k|                    ++input_ptr_;
 1607|  2.54k|                    ++position_;
 1608|  2.54k|                    break;
 1609|  2.54k|                }
 1610|      0|                default:
  ------------------
  |  Branch (1610:17): [True: 0, False: 3.36M]
  ------------------
 1611|      0|                    JSONCONS_ASSERT(false);
  ------------------
  |  |   45|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, Folded]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1612|      0|                    break;
 1613|  3.36M|            }
 1614|  3.36M|        }
 1615|  8.78k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE17end_integer_valueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2457|    790|    {
 2458|    790|        if (buffer_[0] == '-')
  ------------------
  |  Branch (2458:13): [True: 411, False: 379]
  ------------------
 2459|    411|        {
 2460|    411|            end_negative_value(visitor, ec);
 2461|    411|        }
 2462|    379|        else
 2463|    379|        {
 2464|    379|            end_positive_value(visitor, ec);
 2465|    379|        }
 2466|    790|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE18end_negative_valueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2469|    411|    {
 2470|    411|        int64_t val;
 2471|    411|        auto result = jsoncons::dec_to_integer(buffer_.data(), buffer_.length(), val);
 2472|    411|        if (result)
  ------------------
  |  Branch (2472:13): [True: 231, False: 180]
  ------------------
 2473|    231|        {
 2474|    231|            visitor.int64_value(val, semantic_tag::none, *this, ec);
 2475|    231|            if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|    231|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 231]
  |  |  ------------------
  ------------------
 2476|    231|        }
 2477|    180|        else // Must be overflow
 2478|    180|        {
 2479|    180|            if (lossless_bignum_)
  ------------------
  |  Branch (2479:17): [True: 180, False: 0]
  ------------------
 2480|    180|            {
 2481|    180|                visitor.string_value(buffer_, semantic_tag::bigint, *this, ec);
 2482|    180|                if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|    180|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 180]
  |  |  ------------------
  ------------------
 2483|    180|            }
 2484|      0|            else
 2485|      0|            {
 2486|      0|                double d{0};
 2487|      0|                result = jsoncons::decstr_to_double(&buffer_[0], buffer_.length(), d);
 2488|      0|                if (JSONCONS_LIKELY(result))
  ------------------
  |  |   77|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2489|      0|                {
 2490|      0|                    visitor.double_value(d, semantic_tag::none, *this, ec);
 2491|      0|                    if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2492|      0|                }
 2493|      0|                else if (result.ec == std::errc::result_out_of_range)
  ------------------
  |  Branch (2493:26): [True: 0, False: 0]
  ------------------
 2494|      0|                {
 2495|      0|                    visitor.double_value(d, semantic_tag{}, *this, ec); // REVISIT
 2496|      0|                    if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2497|      0|                }
 2498|      0|                else
 2499|      0|                {
 2500|      0|                    ec = json_errc::invalid_number;
 2501|      0|                    more_ = false;
 2502|      0|                    return;
 2503|      0|                }
 2504|      0|            }
 2505|    180|        }
 2506|    411|        more_ = !cursor_mode_;
 2507|    411|        after_value(ec);
 2508|    411|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11after_valueERNS1_10error_codeE:
 2684|  1.86k|    {
 2685|  1.86k|        switch (parent())
 2686|  1.86k|        {
 2687|      0|            case parse_state::array:
  ------------------
  |  Branch (2687:13): [True: 0, False: 1.86k]
  ------------------
 2688|      0|            case parse_state::object:
  ------------------
  |  Branch (2688:13): [True: 0, False: 1.86k]
  ------------------
 2689|      0|                state_ = parse_state::expect_comma_or_end;
 2690|      0|                break;
 2691|  1.86k|            case parse_state::root:
  ------------------
  |  Branch (2691:13): [True: 1.86k, False: 0]
  ------------------
 2692|  1.86k|                state_ = parse_state::accept;
 2693|  1.86k|                break;
 2694|      0|            default:
  ------------------
  |  Branch (2694:13): [True: 0, False: 1.86k]
  ------------------
 2695|      0|                more_ = err_handler_(json_errc::syntax_error, *this);
 2696|      0|                if (!more_)
  ------------------
  |  Branch (2696:21): [True: 0, False: 0]
  ------------------
 2697|      0|                {
 2698|      0|                    ec = json_errc::syntax_error;
 2699|      0|                    return;
 2700|      0|                }
 2701|      0|                break;
 2702|  1.86k|        }
 2703|  1.86k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE18end_positive_valueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2511|    379|    {
 2512|    379|        uint64_t val;
 2513|    379|        auto result = jsoncons::dec_to_integer(buffer_.data(), buffer_.length(), val);
 2514|    379|        if (result)
  ------------------
  |  Branch (2514:13): [True: 306, False: 73]
  ------------------
 2515|    306|        {
 2516|    306|            visitor.uint64_value(val, semantic_tag::none, *this, ec);
 2517|    306|            if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|    306|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 306]
  |  |  ------------------
  ------------------
 2518|    306|        }
 2519|     73|        else // Must be overflow
 2520|     73|        {
 2521|     73|            if (lossless_bignum_)
  ------------------
  |  Branch (2521:17): [True: 73, False: 0]
  ------------------
 2522|     73|            {
 2523|     73|                visitor.string_value(buffer_, semantic_tag::bigint, *this, ec);
 2524|     73|                if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|     73|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 73]
  |  |  ------------------
  ------------------
 2525|     73|            }
 2526|      0|            else
 2527|      0|            {
 2528|      0|                double d{0};
 2529|      0|                result = jsoncons::decstr_to_double(&buffer_[0], buffer_.length(), d);
 2530|      0|                if (JSONCONS_LIKELY(result))
  ------------------
  |  |   77|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2531|      0|                {
 2532|      0|                    visitor.double_value(d, semantic_tag::none, *this, ec);
 2533|      0|                    if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2534|      0|                }
 2535|      0|                else if (result.ec == std::errc::result_out_of_range)
  ------------------
  |  Branch (2535:26): [True: 0, False: 0]
  ------------------
 2536|      0|                {
 2537|      0|                    visitor.double_value(d, semantic_tag{}, *this, ec); // REVISIT
 2538|      0|                    if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2539|      0|                }
 2540|      0|                else
 2541|      0|                {
 2542|      0|                    ec = json_errc::invalid_number;
 2543|      0|                    more_ = false;
 2544|      0|                    return;
 2545|      0|                }
 2546|      0|            }
 2547|     73|        }
 2548|    379|        more_ = !cursor_mode_;
 2549|    379|        after_value(ec);
 2550|    379|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE18end_fraction_valueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2553|  1.07k|    {
 2554|  1.07k|        if (lossless_number_)
  ------------------
  |  Branch (2554:13): [True: 0, False: 1.07k]
  ------------------
 2555|      0|        {
 2556|      0|            visitor.string_value(buffer_, semantic_tag::bigdec, *this, ec);
 2557|      0|            if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2558|      0|        }
 2559|  1.07k|        else
 2560|  1.07k|        {
 2561|  1.07k|            double d{0};
 2562|  1.07k|            auto result = jsoncons::decstr_to_double(&buffer_[0], buffer_.length(), d);
 2563|  1.07k|            if (JSONCONS_LIKELY(result))
  ------------------
  |  |   77|  1.07k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 1.00k, False: 63]
  |  |  ------------------
  ------------------
 2564|  1.00k|            {
 2565|  1.00k|                visitor.double_value(d, semantic_tag::none, *this, ec);
 2566|  1.00k|                if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|  1.00k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.00k]
  |  |  ------------------
  ------------------
 2567|  1.00k|            }
 2568|     63|            else if (result.ec == std::errc::result_out_of_range)
  ------------------
  |  Branch (2568:22): [True: 63, False: 0]
  ------------------
 2569|     63|            {
 2570|     63|                if (lossless_bignum_)
  ------------------
  |  Branch (2570:21): [True: 63, False: 0]
  ------------------
 2571|     63|                {
 2572|     63|                    visitor.string_value(buffer_, semantic_tag::bigdec, *this, ec);
 2573|     63|                    if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|     63|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 63]
  |  |  ------------------
  ------------------
 2574|     63|                }
 2575|      0|                else
 2576|      0|                {
 2577|      0|                    visitor.double_value(d, semantic_tag{}, *this, ec); // REVISIT
 2578|      0|                    if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2579|      0|                }
 2580|     63|            }
 2581|      0|            else
 2582|      0|            {
 2583|      0|                ec = json_errc::invalid_number;
 2584|      0|                more_ = false;
 2585|      0|                return;
 2586|      0|            }
 2587|  1.07k|        }
 2588|       |
 2589|  1.07k|        more_ = !cursor_mode_;
 2590|  1.07k|        after_value(ec);
 2591|  1.07k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE9pop_stateEv:
 2712|  35.9k|    {
 2713|  35.9k|        JSONCONS_ASSERT(!state_stack_.empty())
  ------------------
  |  |   45|  35.9k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 35.9k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 2714|  35.9k|        parse_state state = state_stack_.back();
 2715|  35.9k|        state_stack_.pop_back();
 2716|  35.9k|        return state;
 2717|  35.9k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10skip_spaceEPPKc:
 2408|  34.8k|    {
 2409|  34.8k|        const char_type* local_input_end = input_end_;
 2410|  34.8k|        const char_type* cur = *ptr;
 2411|       |
 2412|  5.51M|        while (cur < local_input_end) 
  ------------------
  |  Branch (2412:16): [True: 5.51M, False: 242]
  ------------------
 2413|  5.51M|        {
 2414|  5.51M|            if (*cur == ' ' || *cur == '\t')
  ------------------
  |  Branch (2414:17): [True: 51.8k, False: 5.45M]
  |  Branch (2414:32): [True: 3.29M, False: 2.16M]
  ------------------
 2415|  3.34M|            {
 2416|  3.34M|                ++cur;
 2417|  3.34M|                ++position_;
 2418|  3.34M|                continue;
 2419|  3.34M|            }
 2420|  2.16M|            if (*cur == '\n')
  ------------------
  |  Branch (2420:17): [True: 114k, False: 2.05M]
  ------------------
 2421|   114k|            {
 2422|   114k|                ++cur;
 2423|   114k|                ++line_;
 2424|   114k|                ++position_;
 2425|   114k|                mark_position_ = position_;
 2426|   114k|                continue;
 2427|   114k|            }
 2428|  2.05M|            if (*cur == '\r')
  ------------------
  |  Branch (2428:17): [True: 2.01M, False: 34.4k]
  ------------------
 2429|  2.01M|            {
 2430|  2.01M|                ++cur;
 2431|  2.01M|                ++position_;
 2432|  2.01M|                if (cur < local_input_end)
  ------------------
  |  Branch (2432:21): [True: 2.01M, False: 148]
  ------------------
 2433|  2.01M|                {
 2434|  2.01M|                    ++line_;
 2435|  2.01M|                    if (*cur == '\n')
  ------------------
  |  Branch (2435:25): [True: 3.82k, False: 2.01M]
  ------------------
 2436|  3.82k|                    {
 2437|  3.82k|                        ++cur;
 2438|  3.82k|                        ++position_;
 2439|  3.82k|                    }
 2440|  2.01M|                    mark_position_ = position_;
 2441|  2.01M|                }
 2442|    148|                else
 2443|    148|                {
 2444|    148|                    push_state(state_);
 2445|    148|                    state_ = parse_state::cr;
 2446|    148|                    *ptr = cur;
 2447|    148|                    return; 
 2448|    148|                }
 2449|  2.01M|                continue;
 2450|  2.01M|            }
 2451|  34.4k|            break;
 2452|  2.05M|        }
 2453|  34.6k|        *ptr = cur;
 2454|  34.6k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10push_stateENS_11parse_stateE:
 2706|  39.3k|    {
 2707|  39.3k|        state_stack_.push_back(state);
 2708|       |        //std::cout << "max_nesting_depth: " << max_nesting_depth_ << ", capacity: " << state_stack_.capacity() << ", nesting_depth: " << level_ << ", stack size: " << state_stack_.size() << "\n";
 2709|  39.3k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE12begin_objectERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  361|      3|    {
  362|      3|        if (JSONCONS_UNLIKELY(++level_ > max_nesting_depth_))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
  363|      0|        {
  364|      0|            more_ = err_handler_(json_errc::max_nesting_depth_exceeded, *this);
  365|      0|            if (!more_)
  ------------------
  |  Branch (365:17): [True: 0, False: 0]
  ------------------
  366|      0|            {
  367|      0|                ec = json_errc::max_nesting_depth_exceeded;
  368|      0|                return;
  369|      0|            }
  370|      0|        } 
  371|       |
  372|      3|        push_state(parse_state::object);
  373|      3|        state_ = parse_state::expect_member_name_or_end;
  374|      3|        visitor.begin_object(semantic_tag::none, *this, ec);
  375|      3|        more_ = !cursor_mode_;
  376|      3|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11begin_arrayERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  425|      1|    {
  426|      1|        if (++level_ > max_nesting_depth_)
  ------------------
  |  Branch (426:13): [True: 0, False: 1]
  ------------------
  427|      0|        {
  428|      0|            more_ = err_handler_(json_errc::max_nesting_depth_exceeded, *this);
  429|      0|            if (!more_)
  ------------------
  |  Branch (429:17): [True: 0, False: 0]
  ------------------
  430|      0|            {
  431|      0|                ec = json_errc::max_nesting_depth_exceeded;
  432|      0|                return;
  433|      0|            }
  434|      0|        }
  435|       |
  436|      1|        push_state(parse_state::array);
  437|      1|        state_ = parse_state::expect_value_or_end;
  438|      1|        visitor.begin_array(semantic_tag::none, *this, ec);
  439|      1|        if (JSONCONS_UNLIKELY(ec)){return;};
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  440|       |
  441|      1|        more_ = !cursor_mode_;
  442|      1|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE12parse_stringEPKcRNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1955|   272k|    {
 1956|   272k|        const char_type* local_input_end = input_end_;
 1957|   272k|        const char_type* sb = cur;
 1958|       |
 1959|   272k|        switch (string_state_)
 1960|   272k|        {
 1961|   271k|            case parse_string_state::text:
  ------------------
  |  Branch (1961:13): [True: 271k, False: 688]
  ------------------
 1962|   271k|                goto text;
 1963|    139|            case parse_string_state::escape:
  ------------------
  |  Branch (1963:13): [True: 139, False: 272k]
  ------------------
 1964|    139|                goto escape;
 1965|     64|            case parse_string_state::escape_u1:
  ------------------
  |  Branch (1965:13): [True: 64, False: 272k]
  ------------------
 1966|     64|                goto escape_u1;
 1967|     64|            case parse_string_state::escape_u2:
  ------------------
  |  Branch (1967:13): [True: 64, False: 272k]
  ------------------
 1968|     64|                goto escape_u2;
 1969|     64|            case parse_string_state::escape_u3:
  ------------------
  |  Branch (1969:13): [True: 64, False: 272k]
  ------------------
 1970|     64|                goto escape_u3;
 1971|     56|            case parse_string_state::escape_u4:
  ------------------
  |  Branch (1971:13): [True: 56, False: 272k]
  ------------------
 1972|     56|                goto escape_u4;
 1973|     48|            case parse_string_state::escape_expect_surrogate_pair1:
  ------------------
  |  Branch (1973:13): [True: 48, False: 272k]
  ------------------
 1974|     48|                goto escape_expect_surrogate_pair1;
 1975|     64|            case parse_string_state::escape_expect_surrogate_pair2:
  ------------------
  |  Branch (1975:13): [True: 64, False: 272k]
  ------------------
 1976|     64|                goto escape_expect_surrogate_pair2;
 1977|     47|            case parse_string_state::escape_u5:
  ------------------
  |  Branch (1977:13): [True: 47, False: 272k]
  ------------------
 1978|     47|                goto escape_u5;
 1979|     47|            case parse_string_state::escape_u6:
  ------------------
  |  Branch (1979:13): [True: 47, False: 272k]
  ------------------
 1980|     47|                goto escape_u6;
 1981|     47|            case parse_string_state::escape_u7:
  ------------------
  |  Branch (1981:13): [True: 47, False: 272k]
  ------------------
 1982|     47|                goto escape_u7;
 1983|     48|            case parse_string_state::escape_u8:
  ------------------
  |  Branch (1983:13): [True: 48, False: 272k]
  ------------------
 1984|     48|                goto escape_u8;
 1985|      0|            default:
  ------------------
  |  Branch (1985:13): [True: 0, False: 272k]
  ------------------
 1986|      0|                JSONCONS_UNREACHABLE();               
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1987|   272k|        }
 1988|       |
 1989|  2.37M|text:
 1990|  13.0M|        while (cur < local_input_end)
  ------------------
  |  Branch (1990:16): [True: 13.0M, False: 614]
  ------------------
 1991|  13.0M|        {
 1992|  13.0M|            switch (*cur)
 1993|  13.0M|            {
 1994|    498|                JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|     12|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 2, False: 13.0M]
  |  |  |  Branch (34:19): [True: 2, False: 13.0M]
  |  |  |  Branch (34:29): [True: 1, False: 13.0M]
  |  |  |  Branch (34:39): [True: 1, False: 13.0M]
  |  |  |  Branch (34:49): [True: 1, False: 13.0M]
  |  |  |  Branch (34:59): [True: 1, False: 13.0M]
  |  |  |  Branch (34:69): [True: 1, False: 13.0M]
  |  |  |  Branch (34:79): [True: 1, False: 13.0M]
  |  |  |  Branch (34:89): [True: 1, False: 13.0M]
  |  |  |  Branch (34:99): [True: 1, False: 13.0M]
  |  |  ------------------
  |  |   35|     22|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 1, False: 13.0M]
  |  |  |  Branch (35:19): [True: 1, False: 13.0M]
  |  |  |  Branch (35:29): [True: 1, False: 13.0M]
  |  |  |  Branch (35:39): [True: 1, False: 13.0M]
  |  |  |  Branch (35:49): [True: 1, False: 13.0M]
  |  |  |  Branch (35:59): [True: 1, False: 13.0M]
  |  |  |  Branch (35:69): [True: 1, False: 13.0M]
  |  |  |  Branch (35:79): [True: 1, False: 13.0M]
  |  |  |  Branch (35:89): [True: 1, False: 13.0M]
  |  |  |  Branch (35:99): [True: 1, False: 13.0M]
  |  |  ------------------
  |  |   36|     32|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 1, False: 13.0M]
  |  |  |  Branch (36:19): [True: 1, False: 13.0M]
  |  |  |  Branch (36:29): [True: 1, False: 13.0M]
  |  |  |  Branch (36:39): [True: 2, False: 13.0M]
  |  |  |  Branch (36:49): [True: 1, False: 13.0M]
  |  |  |  Branch (36:59): [True: 1, False: 13.0M]
  |  |  |  Branch (36:69): [True: 1, False: 13.0M]
  |  |  |  Branch (36:79): [True: 1, False: 13.0M]
  |  |  ------------------
  ------------------
 1995|    498|                {
 1996|    498|                    position_ += (cur - sb + 1);
 1997|    498|                    more_ = err_handler_(json_errc::illegal_control_character, *this);
 1998|    498|                    if (!more_)
  ------------------
  |  Branch (1998:25): [True: 32, False: 0]
  ------------------
 1999|     32|                    {
 2000|     32|                        ec = json_errc::illegal_control_character;
 2001|     32|                        string_state_ = parse_string_state{};
 2002|     32|                        return cur;
 2003|     32|                    }
 2004|       |                    // recovery - skip
 2005|      0|                    buffer_.append(sb,cur-sb);
 2006|      0|                    ++cur;
 2007|      0|                    string_state_ = parse_string_state{};
 2008|      0|                    return cur;
 2009|    498|                }
 2010|      2|                case '\n':
  ------------------
  |  Branch (2010:17): [True: 2, False: 13.0M]
  ------------------
 2011|      3|                case '\r':
  ------------------
  |  Branch (2011:17): [True: 1, False: 13.0M]
  ------------------
 2012|      4|                case '\t':
  ------------------
  |  Branch (2012:17): [True: 1, False: 13.0M]
  ------------------
 2013|      4|                {
 2014|      4|                    position_ += (cur - sb + 1);
 2015|      4|                    if (!err_handler_(json_errc::illegal_character_in_string, *this))
  ------------------
  |  Branch (2015:25): [True: 4, False: 0]
  ------------------
 2016|      4|                    {
 2017|      4|                        more_ = false;
 2018|      4|                        ec = json_errc::illegal_character_in_string;
 2019|      4|                        return cur;
 2020|      4|                    }
 2021|       |                    // recovery - skip
 2022|      0|                    buffer_.append(sb,cur-sb);
 2023|      0|                    sb = cur + 1;
 2024|      0|                    break;
 2025|      4|                }
 2026|  2.36M|                case '\\': 
  ------------------
  |  Branch (2026:17): [True: 2.36M, False: 10.7M]
  ------------------
 2027|  2.36M|                {
 2028|  2.36M|                    buffer_.append(sb,cur-sb);
 2029|  2.36M|                    position_ += (cur - sb + 1);
 2030|  2.36M|                    ++cur;
 2031|  2.36M|                    escape_tag_ = semantic_tag{};
 2032|  2.36M|                    goto escape;
 2033|      4|                }
 2034|    183|                case '\"':
  ------------------
  |  Branch (2034:17): [True: 183, False: 13.0M]
  ------------------
 2035|    183|                {
 2036|    183|                    position_ += (cur - sb + 1);
 2037|    183|                    if (buffer_.empty())
  ------------------
  |  Branch (2037:25): [True: 138, False: 45]
  ------------------
 2038|    138|                    {
 2039|    138|                        end_string_value(sb,cur-sb, visitor, ec);
 2040|    138|                        if (JSONCONS_UNLIKELY(ec)) {return cur;}
  ------------------
  |  |   78|    138|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 70, False: 68]
  |  |  ------------------
  ------------------
 2041|    138|                    }
 2042|     45|                    else
 2043|     45|                    {
 2044|     45|                        buffer_.append(sb,cur-sb);
 2045|     45|                        end_string_value(buffer_.data(), buffer_.length(), visitor, ec);
 2046|     45|                        if (JSONCONS_UNLIKELY(ec)) {return cur;}
  ------------------
  |  |   78|     45|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 27, False: 18]
  |  |  ------------------
  ------------------
 2047|     45|                    }
 2048|     86|                    ++cur;
 2049|     86|                    return cur;
 2050|    183|                }
 2051|  10.7M|            default:
  ------------------
  |  Branch (2051:13): [True: 10.7M, False: 2.36M]
  ------------------
 2052|  10.7M|                break;
 2053|  13.0M|            }
 2054|  10.7M|            ++cur;
 2055|  10.7M|        }
 2056|       |
 2057|       |        // Buffer exhausted               
 2058|    614|        {
 2059|    614|            buffer_.append(sb,cur-sb);
 2060|    614|            position_ += (cur - sb);
 2061|    614|            string_state_ = parse_string_state{};
 2062|    614|            return cur;
 2063|  2.37M|        }
 2064|       |
 2065|  2.36M|escape:
 2066|  2.36M|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|  2.36M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 157, False: 2.36M]
  |  |  ------------------
  ------------------
 2067|    157|        {
 2068|    157|            string_state_ = parse_string_state::escape;
 2069|    157|            return cur;
 2070|    157|        }
 2071|  2.36M|        switch (*cur)
 2072|  2.36M|        {
 2073|   323k|        case '\"':
  ------------------
  |  Branch (2073:9): [True: 323k, False: 2.04M]
  ------------------
 2074|   323k|            buffer_.push_back('\"');
 2075|   323k|            sb = ++cur;
 2076|   323k|            ++position_;
 2077|   323k|            goto text;
 2078|  1.50M|        case '\\': 
  ------------------
  |  Branch (2078:9): [True: 1.50M, False: 864k]
  ------------------
 2079|  1.50M|            buffer_.push_back('\\');
 2080|  1.50M|            sb = ++cur;
 2081|  1.50M|            ++position_;
 2082|  1.50M|            goto text;
 2083|  1.22k|        case '/':
  ------------------
  |  Branch (2083:9): [True: 1.22k, False: 2.36M]
  ------------------
 2084|  1.22k|            buffer_.push_back('/');
 2085|  1.22k|            sb = ++cur;
 2086|  1.22k|            ++position_;
 2087|  1.22k|            goto text;
 2088|    210|        case 'b':
  ------------------
  |  Branch (2088:9): [True: 210, False: 2.36M]
  ------------------
 2089|    210|            buffer_.push_back('\b');
 2090|    210|            sb = ++cur;
 2091|    210|            ++position_;
 2092|    210|            goto text;
 2093|    227|        case 'f':
  ------------------
  |  Branch (2093:9): [True: 227, False: 2.36M]
  ------------------
 2094|    227|            buffer_.push_back('\f');
 2095|    227|            sb = ++cur;
 2096|    227|            ++position_;
 2097|    227|            goto text;
 2098|    261|        case 'n':
  ------------------
  |  Branch (2098:9): [True: 261, False: 2.36M]
  ------------------
 2099|    261|            buffer_.push_back('\n');
 2100|    261|            sb = ++cur;
 2101|    261|            ++position_;
 2102|    261|            goto text;
 2103|    433|        case 'r':
  ------------------
  |  Branch (2103:9): [True: 433, False: 2.36M]
  ------------------
 2104|    433|            buffer_.push_back('\r');
 2105|    433|            sb = ++cur;
 2106|    433|            ++position_;
 2107|    433|            goto text;
 2108|    615|        case 't':
  ------------------
  |  Branch (2108:9): [True: 615, False: 2.36M]
  ------------------
 2109|    615|            buffer_.push_back('\t');
 2110|    615|            sb = ++cur;
 2111|    615|            ++position_;
 2112|    615|            goto text;
 2113|   538k|        case 'u':
  ------------------
  |  Branch (2113:9): [True: 538k, False: 1.83M]
  ------------------
 2114|   538k|             cp_ = 0;
 2115|   538k|             ++cur;
 2116|   538k|             ++position_;
 2117|   538k|             goto escape_u1;
 2118|      4|        default:    
  ------------------
  |  Branch (2118:9): [True: 4, False: 2.36M]
  ------------------
 2119|      4|            err_handler_(json_errc::illegal_escaped_character, *this);
 2120|      4|            ec = json_errc::illegal_escaped_character;
 2121|      4|            more_ = false;
 2122|      4|            string_state_ = parse_string_state::escape;
 2123|      4|            return cur;
 2124|  2.36M|        }
 2125|       |
 2126|   538k|escape_u1:
 2127|   538k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   538k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 76, False: 538k]
  |  |  ------------------
  ------------------
 2128|     76|        {
 2129|     76|            string_state_ = parse_string_state::escape_u1;
 2130|     76|            return cur;
 2131|     76|        }
 2132|   538k|        {
 2133|   538k|            cp_ = append_to_codepoint(0, *cur, ec);
 2134|   538k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   538k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 35, False: 538k]
  |  |  ------------------
  ------------------
 2135|     35|            {
 2136|     35|                string_state_ = parse_string_state::escape_u1;
 2137|     35|                return cur;
 2138|     35|            }
 2139|   538k|            ++cur;
 2140|   538k|            ++position_;
 2141|   538k|            goto escape_u2;
 2142|   538k|        }
 2143|       |
 2144|   538k|escape_u2:
 2145|   538k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   538k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 90, False: 538k]
  |  |  ------------------
  ------------------
 2146|     90|        {
 2147|     90|            string_state_ = parse_string_state::escape_u2;
 2148|     90|            return cur;
 2149|     90|        }
 2150|   538k|        {
 2151|   538k|            cp_ = append_to_codepoint(cp_, *cur, ec);
 2152|   538k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   538k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 538k]
  |  |  ------------------
  ------------------
 2153|      7|            {
 2154|      7|                string_state_ = parse_string_state::escape_u2;
 2155|      7|                return cur;
 2156|      7|            }
 2157|   538k|            ++cur;
 2158|   538k|            ++position_;
 2159|   538k|            goto escape_u3;
 2160|   538k|        }
 2161|       |
 2162|   538k|escape_u3:
 2163|   538k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   538k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 83, False: 538k]
  |  |  ------------------
  ------------------
 2164|     83|        {
 2165|     83|            string_state_ = parse_string_state::escape_u3;
 2166|     83|            return cur;
 2167|     83|        }
 2168|   538k|        {
 2169|   538k|            cp_ = append_to_codepoint(cp_, *cur, ec);
 2170|   538k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   538k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 538k]
  |  |  ------------------
  ------------------
 2171|      7|            {
 2172|      7|                string_state_ = parse_string_state::escape_u3;
 2173|      7|                return cur;
 2174|      7|            }
 2175|   538k|            ++cur;
 2176|   538k|            ++position_;
 2177|   538k|            goto escape_u4;
 2178|   538k|        }
 2179|       |
 2180|   538k|escape_u4:
 2181|   538k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   538k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 76, False: 538k]
  |  |  ------------------
  ------------------
 2182|     76|        {
 2183|     76|            string_state_ = parse_string_state::escape_u4;
 2184|     76|            return cur;
 2185|     76|        }
 2186|   538k|        {
 2187|   538k|            cp_ = append_to_codepoint(cp_, *cur, ec);
 2188|   538k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   538k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 538k]
  |  |  ------------------
  ------------------
 2189|      1|            {
 2190|      1|                string_state_ = parse_string_state::escape_u4;
 2191|      1|                return cur;
 2192|      1|            }
 2193|   538k|            if (unicode_traits::is_high_surrogate(cp_))
  ------------------
  |  Branch (2193:17): [True: 267k, False: 270k]
  ------------------
 2194|   267k|            {
 2195|   267k|                ++cur;
 2196|   267k|                ++position_;
 2197|   267k|                goto escape_expect_surrogate_pair1;
 2198|   267k|            }
 2199|   270k|            else
 2200|   270k|            {
 2201|   270k|                unicode_traits::convert(&cp_, 1, buffer_);
 2202|   270k|                sb = ++cur;
 2203|   270k|                ++position_;
 2204|   270k|                string_state_ = parse_string_state{};
 2205|   270k|                return cur;
 2206|   270k|            }
 2207|   538k|        }
 2208|       |
 2209|   267k|escape_expect_surrogate_pair1:
 2210|   267k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   267k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 65, False: 267k]
  |  |  ------------------
  ------------------
 2211|     65|        {
 2212|     65|            string_state_ = parse_string_state::escape_expect_surrogate_pair1;
 2213|     65|            return cur;
 2214|     65|        }
 2215|   267k|        {
 2216|   267k|            switch (*cur)
 2217|   267k|            {
 2218|   267k|            case '\\': 
  ------------------
  |  Branch (2218:13): [True: 267k, False: 12]
  ------------------
 2219|   267k|                cp2_ = 0;
 2220|   267k|                ++cur;
 2221|   267k|                ++position_;
 2222|   267k|                goto escape_expect_surrogate_pair2;
 2223|     12|            default:
  ------------------
  |  Branch (2223:13): [True: 12, False: 267k]
  ------------------
 2224|     12|                err_handler_(json_errc::expected_codepoint_surrogate_pair, *this);
 2225|     12|                ec = json_errc::expected_codepoint_surrogate_pair;
 2226|     12|                more_ = false;
 2227|     12|                string_state_ = parse_string_state::escape_expect_surrogate_pair1;
 2228|     12|                return cur;
 2229|   267k|            }
 2230|   267k|        }
 2231|       |
 2232|   267k|escape_expect_surrogate_pair2:
 2233|   267k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   267k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 81, False: 267k]
  |  |  ------------------
  ------------------
 2234|     81|        {
 2235|     81|            string_state_ = parse_string_state::escape_expect_surrogate_pair2;
 2236|     81|            return cur;
 2237|     81|        }
 2238|   267k|        {
 2239|   267k|            switch (*cur)
 2240|   267k|            {
 2241|   267k|            case 'u':
  ------------------
  |  Branch (2241:13): [True: 267k, False: 12]
  ------------------
 2242|   267k|                ++cur;
 2243|   267k|                ++position_;
 2244|   267k|                goto escape_u5;
 2245|     12|            default:
  ------------------
  |  Branch (2245:13): [True: 12, False: 267k]
  ------------------
 2246|     12|                err_handler_(json_errc::expected_codepoint_surrogate_pair, *this);
 2247|     12|                ec = json_errc::expected_codepoint_surrogate_pair;
 2248|     12|                more_ = false;
 2249|     12|                string_state_ = parse_string_state::escape_expect_surrogate_pair2;
 2250|     12|                return cur;
 2251|   267k|            }
 2252|   267k|        }
 2253|       |
 2254|   267k|escape_u5:
 2255|   267k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   267k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 62, False: 267k]
  |  |  ------------------
  ------------------
 2256|     62|        {
 2257|     62|            string_state_ = parse_string_state::escape_u5;
 2258|     62|            return cur;
 2259|     62|        }
 2260|   267k|        {
 2261|   267k|            cp2_ = append_to_codepoint(0, *cur, ec);
 2262|   267k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   267k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 267k]
  |  |  ------------------
  ------------------
 2263|      1|            {
 2264|      1|                string_state_ = parse_string_state::escape_u5;
 2265|      1|                return cur;
 2266|      1|            }
 2267|   267k|        }
 2268|   267k|        ++cur;
 2269|   267k|        ++position_;
 2270|   267k|        goto escape_u6;
 2271|       |
 2272|   267k|escape_u6:
 2273|   267k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   267k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 57, False: 267k]
  |  |  ------------------
  ------------------
 2274|     57|        {
 2275|     57|            string_state_ = parse_string_state::escape_u6;
 2276|     57|            return cur;
 2277|     57|        }
 2278|   267k|        {
 2279|   267k|            cp2_ = append_to_codepoint(cp2_, *cur, ec);
 2280|   267k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   267k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 267k]
  |  |  ------------------
  ------------------
 2281|      1|            {
 2282|      1|                string_state_ = parse_string_state::escape_u6;
 2283|      1|                return cur;
 2284|      1|            }
 2285|   267k|            ++cur;
 2286|   267k|            ++position_;
 2287|   267k|            goto escape_u7;
 2288|   267k|        }
 2289|       |
 2290|   267k|escape_u7:
 2291|   267k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   267k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 62, False: 267k]
  |  |  ------------------
  ------------------
 2292|     62|        {
 2293|     62|            string_state_ = parse_string_state::escape_u7;
 2294|     62|            return cur;
 2295|     62|        }
 2296|   267k|        {
 2297|   267k|            cp2_ = append_to_codepoint(cp2_, *cur, ec);
 2298|   267k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   267k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 267k]
  |  |  ------------------
  ------------------
 2299|      2|            {
 2300|      2|                string_state_ = parse_string_state::escape_u7;
 2301|      2|                return cur;
 2302|      2|            }
 2303|   267k|            ++cur;
 2304|   267k|            ++position_;
 2305|   267k|            goto escape_u8;
 2306|   267k|        }
 2307|       |
 2308|   267k|escape_u8:
 2309|   267k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   267k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 63, False: 267k]
  |  |  ------------------
  ------------------
 2310|     63|        {
 2311|     63|            string_state_ = parse_string_state::escape_u8;
 2312|     63|            return cur;
 2313|     63|        }
 2314|   267k|        {
 2315|   267k|            cp2_ = append_to_codepoint(cp2_, *cur, ec);
 2316|   267k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   267k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 267k]
  |  |  ------------------
  ------------------
 2317|      1|            {
 2318|      1|                string_state_ = parse_string_state::escape_u8;
 2319|      1|                return cur;
 2320|      1|            }
 2321|   267k|            uint32_t cp = 0x10000 + ((cp_ & 0x3FF) << 10) + (cp2_ & 0x3FF);
 2322|   267k|            unicode_traits::convert(&cp, 1, buffer_);
 2323|   267k|            sb = ++cur;
 2324|   267k|            ++position_;
 2325|   267k|            goto text;
 2326|   267k|        }
 2327|       |
 2328|      0|        JSONCONS_UNREACHABLE();               
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 2329|   267k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE16end_string_valueEPKcmRNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2594|    183|    {
 2595|    183|        string_view_type sv(s, length);
 2596|    183|        auto result = unicode_traits::validate(s, length);
 2597|    183|        if (result.ec != unicode_traits::conv_errc())
  ------------------
  |  Branch (2597:13): [True: 97, False: 86]
  ------------------
 2598|     97|        {
 2599|     97|            translate_conv_errc(result.ec,ec);
 2600|     97|            position_ += (result.ptr - s);
 2601|     97|            return;
 2602|     97|        }
 2603|     86|        switch (parent())
 2604|     86|        {
 2605|      0|            case parse_state::member_name:
  ------------------
  |  Branch (2605:13): [True: 0, False: 86]
  ------------------
 2606|      0|                visitor.key(sv, *this, ec);
 2607|      0|                if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2608|      0|                more_ = !cursor_mode_;
 2609|      0|                pop_state();
 2610|      0|                state_ = parse_state::expect_colon;
 2611|      0|                break;
 2612|      0|            case parse_state::object:
  ------------------
  |  Branch (2612:13): [True: 0, False: 86]
  ------------------
 2613|      0|            case parse_state::array:
  ------------------
  |  Branch (2613:13): [True: 0, False: 86]
  ------------------
 2614|      0|            {
 2615|      0|                auto it = std::find_if(string_double_map_.begin(), string_double_map_.end(), string_maps_to_double{ sv });
 2616|      0|                if (it != string_double_map_.end())
  ------------------
  |  Branch (2616:21): [True: 0, False: 0]
  ------------------
 2617|      0|                {
 2618|      0|                    visitor.double_value((*it).second, semantic_tag::none, *this, ec);
 2619|      0|                    if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2620|      0|                    more_ = !cursor_mode_;
 2621|      0|                }
 2622|      0|                else
 2623|      0|                {
 2624|      0|                    visitor.string_value(sv, escape_tag_, *this, ec);
 2625|      0|                    if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2626|      0|                    more_ = !cursor_mode_;
 2627|      0|                }
 2628|      0|                state_ = parse_state::expect_comma_or_end;
 2629|      0|                break;
 2630|      0|            }
 2631|     86|            case parse_state::root:
  ------------------
  |  Branch (2631:13): [True: 86, False: 0]
  ------------------
 2632|     86|            {
 2633|     86|                auto it = std::find_if(string_double_map_.begin(),string_double_map_.end(),string_maps_to_double{sv});
 2634|     86|                if (it != string_double_map_.end())
  ------------------
  |  Branch (2634:21): [True: 0, False: 86]
  ------------------
 2635|      0|                {
 2636|      0|                    visitor.double_value((*it).second, semantic_tag::none, *this, ec);
 2637|      0|                    if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2638|      0|                    more_ = !cursor_mode_;
 2639|      0|                }
 2640|     86|                else
 2641|     86|                {
 2642|     86|                    visitor.string_value(sv, escape_tag_, *this, ec);
 2643|     86|                    if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|     86|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 86]
  |  |  ------------------
  ------------------
 2644|     86|                    more_ = !cursor_mode_;
 2645|     86|                }
 2646|     86|                state_ = parse_state::accept;
 2647|     86|                break;
 2648|     86|            }
 2649|      0|            default:
  ------------------
  |  Branch (2649:13): [True: 0, False: 86]
  ------------------
 2650|      0|                more_ = err_handler_(json_errc::syntax_error, *this);
 2651|      0|                if (!more_)
  ------------------
  |  Branch (2651:21): [True: 0, False: 0]
  ------------------
 2652|      0|                {
 2653|      0|                    ec = json_errc::syntax_error;
 2654|      0|                    return;
 2655|      0|                }
 2656|      0|                break;
 2657|     86|        }
 2658|     86|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE19translate_conv_errcENS_14unicode_traits9conv_errcERNS1_10error_codeE:
 2332|     97|    {
 2333|     97|        switch (result)
 2334|     97|        {
 2335|      0|        case unicode_traits::conv_errc():
  ------------------
  |  Branch (2335:9): [True: 0, False: 97]
  ------------------
 2336|      0|            break;
 2337|     23|        case unicode_traits::conv_errc::over_long_utf8_sequence:
  ------------------
  |  Branch (2337:9): [True: 23, False: 74]
  ------------------
 2338|     23|            more_ = err_handler_(json_errc::over_long_utf8_sequence, *this);
 2339|     23|            if (!more_)
  ------------------
  |  Branch (2339:17): [True: 23, False: 0]
  ------------------
 2340|     23|            {
 2341|     23|                ec = json_errc::over_long_utf8_sequence;
 2342|     23|                return;
 2343|     23|            }
 2344|      0|            break;
 2345|      0|        case unicode_traits::conv_errc::unpaired_high_surrogate:
  ------------------
  |  Branch (2345:9): [True: 0, False: 97]
  ------------------
 2346|      0|            more_ = err_handler_(json_errc::unpaired_high_surrogate, *this);
 2347|      0|            if (!more_)
  ------------------
  |  Branch (2347:17): [True: 0, False: 0]
  ------------------
 2348|      0|            {
 2349|      0|                ec = json_errc::unpaired_high_surrogate;
 2350|      0|                return;
 2351|      0|            }
 2352|      0|            break;
 2353|     24|        case unicode_traits::conv_errc::expected_continuation_byte:
  ------------------
  |  Branch (2353:9): [True: 24, False: 73]
  ------------------
 2354|     24|            more_ = err_handler_(json_errc::expected_continuation_byte, *this);
 2355|     24|            if (!more_)
  ------------------
  |  Branch (2355:17): [True: 24, False: 0]
  ------------------
 2356|     24|            {
 2357|     24|                ec = json_errc::expected_continuation_byte;
 2358|     24|                return;
 2359|     24|            }
 2360|      0|            break;
 2361|      0|        case unicode_traits::conv_errc::illegal_surrogate_value:
  ------------------
  |  Branch (2361:9): [True: 0, False: 97]
  ------------------
 2362|      0|            more_ = err_handler_(json_errc::illegal_surrogate_value, *this);
 2363|      0|            if (!more_)
  ------------------
  |  Branch (2363:17): [True: 0, False: 0]
  ------------------
 2364|      0|            {
 2365|      0|                ec = json_errc::illegal_surrogate_value;
 2366|      0|                return;
 2367|      0|            }
 2368|      0|            break;
 2369|     50|        default:
  ------------------
  |  Branch (2369:9): [True: 50, False: 47]
  ------------------
 2370|     50|            more_ = err_handler_(json_errc::illegal_codepoint, *this);
 2371|     50|            if (!more_)
  ------------------
  |  Branch (2371:17): [True: 50, False: 0]
  ------------------
 2372|     50|            {
 2373|     50|                ec = json_errc::illegal_codepoint;
 2374|     50|                return;
 2375|     50|            }
 2376|      0|            break;
 2377|     97|        }
 2378|     97|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE19append_to_codepointEjiRNS1_10error_codeE:
 2720|  3.22M|    {
 2721|  3.22M|        cp *= 16;
 2722|  3.22M|        if (c >= '0'  &&  c <= '9')
  ------------------
  |  Branch (2722:13): [True: 3.22M, False: 30]
  |  Branch (2722:27): [True: 927k, False: 2.29M]
  ------------------
 2723|   927k|        {
 2724|   927k|            cp += c - '0';
 2725|   927k|        }
 2726|  2.29M|        else if (c >= 'a'  &&  c <= 'f')
  ------------------
  |  Branch (2726:18): [True: 492k, False: 1.80M]
  |  Branch (2726:32): [True: 492k, False: 12]
  ------------------
 2727|   492k|        {
 2728|   492k|            cp += c - 'a' + 10;
 2729|   492k|        }
 2730|  1.80M|        else if (c >= 'A'  &&  c <= 'F')
  ------------------
  |  Branch (2730:18): [True: 1.80M, False: 34]
  |  Branch (2730:32): [True: 1.80M, False: 21]
  ------------------
 2731|  1.80M|        {
 2732|  1.80M|            cp += c - 'A' + 10;
 2733|  1.80M|        }
 2734|     55|        else
 2735|     55|        {
 2736|     55|            more_ = err_handler_(json_errc::invalid_unicode_escape_sequence, *this);
 2737|     55|            if (!more_)
  ------------------
  |  Branch (2737:17): [True: 55, False: 0]
  ------------------
 2738|     55|            {
 2739|     55|                ec = json_errc::invalid_unicode_escape_sequence;
 2740|     55|                return cp;
 2741|     55|            }
 2742|     55|        }
 2743|  3.22M|        return cp;
 2744|  3.22M|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE12parse_numberEPKcRNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1731|  3.97k|    {
 1732|  3.97k|        const char_type* cur = hdr;
 1733|  3.97k|        const char_type* local_input_end = input_end_;
 1734|       |
 1735|  3.97k|        switch (number_state_)
 1736|  3.97k|        {
 1737|    472|            case parse_number_state::minus:
  ------------------
  |  Branch (1737:13): [True: 472, False: 3.49k]
  ------------------
 1738|    472|                goto minus_sign;
 1739|    110|            case parse_number_state::zero:
  ------------------
  |  Branch (1739:13): [True: 110, False: 3.86k]
  ------------------
 1740|    110|                goto zero;
 1741|  2.76k|            case parse_number_state::integer:
  ------------------
  |  Branch (1741:13): [True: 2.76k, False: 1.21k]
  ------------------
 1742|  2.76k|                goto integer;
 1743|      3|            case parse_number_state::fraction1:
  ------------------
  |  Branch (1743:13): [True: 3, False: 3.96k]
  ------------------
 1744|      3|                goto fraction1;
 1745|    311|            case parse_number_state::fraction2:
  ------------------
  |  Branch (1745:13): [True: 311, False: 3.65k]
  ------------------
 1746|    311|                goto fraction2;
 1747|      3|            case parse_number_state::exp1:
  ------------------
  |  Branch (1747:13): [True: 3, False: 3.96k]
  ------------------
 1748|      3|                goto exp1;
 1749|      1|            case parse_number_state::exp2:
  ------------------
  |  Branch (1749:13): [True: 1, False: 3.96k]
  ------------------
 1750|      1|                goto exp2;
 1751|    310|            case parse_number_state::exp3:
  ------------------
  |  Branch (1751:13): [True: 310, False: 3.66k]
  ------------------
 1752|    310|                goto exp3;
 1753|      0|            default:
  ------------------
  |  Branch (1753:13): [True: 0, False: 3.97k]
  ------------------
 1754|      0|                JSONCONS_UNREACHABLE();               
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1755|  3.97k|        }
 1756|    472|minus_sign:
 1757|    472|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|    472|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 468]
  |  |  ------------------
  ------------------
 1758|      4|        {
 1759|      4|            number_state_ = parse_number_state::minus;
 1760|      4|            buffer_.append(hdr, cur);
 1761|      4|            position_ += (cur - hdr);
 1762|      4|            return cur;
 1763|      4|        }
 1764|    468|        if (jsoncons::is_nonzero_digit(*cur))
  ------------------
  |  Branch (1764:13): [True: 445, False: 23]
  ------------------
 1765|    445|        {
 1766|    445|            ++cur;
 1767|    445|            goto integer;
 1768|    445|        }
 1769|     23|        if (*cur == '0')
  ------------------
  |  Branch (1769:13): [True: 11, False: 12]
  ------------------
 1770|     11|        {
 1771|     11|            ++cur;
 1772|     11|            goto zero;
 1773|     11|        }
 1774|     12|        err_handler_(json_errc::invalid_number, *this);
 1775|     12|        ec = json_errc::invalid_number;
 1776|     12|        more_ = false;
 1777|     12|        position_ += (cur - hdr);
 1778|     12|        return cur;
 1779|    121|zero:
 1780|    121|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|    121|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 72, False: 49]
  |  |  ------------------
  ------------------
 1781|     72|        {
 1782|     72|            number_state_ = parse_number_state::integer;
 1783|     72|            buffer_.append(hdr, cur);
 1784|     72|            position_ += (cur - hdr);
 1785|     72|            return cur;
 1786|     72|        }
 1787|     49|        if (*cur == '.')
  ------------------
  |  Branch (1787:13): [True: 29, False: 20]
  ------------------
 1788|     29|        {
 1789|     29|            ++cur;
 1790|     29|            goto fraction1;
 1791|     29|        }
 1792|     20|        if (jsoncons::is_exp(*cur))
  ------------------
  |  Branch (1792:13): [True: 4, False: 16]
  ------------------
 1793|      4|        {
 1794|      4|            ++cur;
 1795|      4|            goto exp1;
 1796|      4|        }
 1797|     16|        if (jsoncons::is_digit(*cur))
  ------------------
  |  Branch (1797:13): [True: 3, False: 13]
  ------------------
 1798|      3|        {
 1799|      3|            err_handler_(json_errc::leading_zero, *this);
 1800|      3|            ec = json_errc::leading_zero;
 1801|      3|            more_ = false;
 1802|      3|            number_state_ = parse_number_state::zero;
 1803|       |
 1804|      3|            position_ += (cur - hdr);
 1805|      3|            return cur;
 1806|      3|        }
 1807|     13|        buffer_.append(hdr, cur);
 1808|     13|        position_ += (cur - hdr);
 1809|     13|        end_integer_value(visitor, ec);
 1810|     13|        return cur;
 1811|  3.20k|integer:
 1812|  23.3M|        while (true)
  ------------------
  |  Branch (1812:16): [True: 23.3M, Folded]
  ------------------
 1813|  23.3M|        {
 1814|  23.3M|            if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|  23.3M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2.09k, False: 23.3M]
  |  |  ------------------
  ------------------
 1815|  2.09k|            {
 1816|  2.09k|                number_state_ = parse_number_state::integer;
 1817|  2.09k|                buffer_.append(hdr, cur);
 1818|  2.09k|                position_ += (cur - hdr);
 1819|  2.09k|                return cur;
 1820|  2.09k|            }
 1821|  23.3M|            if (JSONCONS_UNLIKELY(!jsoncons::is_digit(*cur)))
  ------------------
  |  |   78|  23.3M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.10k, False: 23.3M]
  |  |  ------------------
  ------------------
 1822|  1.10k|            {
 1823|  1.10k|                break;
 1824|  1.10k|            }
 1825|  23.3M|            ++cur;
 1826|  23.3M|        }
 1827|  1.10k|        if (*cur == '.')
  ------------------
  |  Branch (1827:13): [True: 401, False: 705]
  ------------------
 1828|    401|        {
 1829|    401|            ++cur;
 1830|    401|            goto fraction1;
 1831|    401|        }
 1832|    705|        if (jsoncons::is_exp(*cur))
  ------------------
  |  Branch (1832:13): [True: 669, False: 36]
  ------------------
 1833|    669|        {
 1834|    669|            ++cur;
 1835|    669|            goto exp1;
 1836|    669|        }
 1837|     36|        buffer_.append(hdr, cur);
 1838|     36|        position_ += (cur - hdr);
 1839|     36|        end_integer_value(visitor, ec);
 1840|     36|        return cur;
 1841|    433|fraction1:
 1842|    433|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|    433|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 5, False: 428]
  |  |  ------------------
  ------------------
 1843|      5|        {
 1844|      5|            number_state_ = parse_number_state::fraction1;
 1845|      5|            buffer_.append(hdr, cur);
 1846|      5|            position_ += (cur - hdr);
 1847|      5|            return cur;
 1848|      5|        }
 1849|    428|        if (jsoncons::is_digit(*cur))
  ------------------
  |  Branch (1849:13): [True: 427, False: 1]
  ------------------
 1850|    427|        {
 1851|    427|            ++cur;
 1852|    427|            goto fraction2;
 1853|    427|        }
 1854|      1|        err_handler_(json_errc::invalid_number, *this);
 1855|      1|        ec = json_errc::invalid_number;
 1856|      1|        more_ = false;
 1857|      1|        number_state_ = parse_number_state::fraction1;
 1858|      1|        position_ += (cur - hdr);
 1859|      1|        return cur;
 1860|    738|fraction2:
 1861|  5.05M|        while (true)
  ------------------
  |  Branch (1861:16): [True: 5.05M, Folded]
  ------------------
 1862|  5.05M|        {
 1863|  5.05M|            if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|  5.05M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 713, False: 5.05M]
  |  |  ------------------
  ------------------
 1864|    713|            {
 1865|    713|                number_state_ = parse_number_state::fraction2;
 1866|    713|                buffer_.append(hdr, cur);
 1867|    713|                position_ += (cur - hdr);
 1868|    713|                return cur;
 1869|    713|            }
 1870|  5.05M|            if (JSONCONS_UNLIKELY(!jsoncons::is_digit(*cur)))
  ------------------
  |  |   78|  5.05M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 25, False: 5.05M]
  |  |  ------------------
  ------------------
 1871|     25|            {
 1872|     25|                break;
 1873|     25|            }
 1874|  5.05M|            ++cur;
 1875|  5.05M|        }
 1876|     25|        if (jsoncons::is_exp(*cur))
  ------------------
  |  Branch (1876:13): [True: 16, False: 9]
  ------------------
 1877|     16|        {
 1878|     16|            ++cur;
 1879|     16|            goto exp1;
 1880|     16|        }
 1881|      9|        buffer_.append(hdr, cur);
 1882|      9|        position_ += (cur - hdr);
 1883|      9|        end_fraction_value(visitor, ec);
 1884|      9|        return cur;
 1885|    692|exp1:
 1886|    692|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|    692|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 685]
  |  |  ------------------
  ------------------
 1887|      7|        {
 1888|      7|            number_state_ = parse_number_state::exp1;
 1889|      7|            buffer_.append(hdr, cur);
 1890|      7|            position_ += (cur - hdr);
 1891|      7|            return cur;
 1892|      7|        }
 1893|    685|        if (*cur == '-')
  ------------------
  |  Branch (1893:13): [True: 416, False: 269]
  ------------------
 1894|    416|        {
 1895|    416|            ++cur;
 1896|    416|            goto exp2;
 1897|    416|        }
 1898|    269|        if (jsoncons::is_digit(*cur))
  ------------------
  |  Branch (1898:13): [True: 248, False: 21]
  ------------------
 1899|    248|        {
 1900|    248|            ++cur;
 1901|    248|            goto exp3;
 1902|    248|        }
 1903|     21|        if (*cur == '+')
  ------------------
  |  Branch (1903:13): [True: 2, False: 19]
  ------------------
 1904|      2|        {
 1905|      2|            ++cur;
 1906|      2|            goto exp2;
 1907|      2|        }
 1908|     19|        err_handler_(json_errc::invalid_number, *this);
 1909|     19|        ec = json_errc::invalid_number;
 1910|     19|        more_ = false;
 1911|     19|        position_ += (cur - hdr);
 1912|     19|        return cur;
 1913|    419|exp2:
 1914|    419|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|    419|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 415]
  |  |  ------------------
  ------------------
 1915|      4|        {
 1916|      4|            number_state_ = parse_number_state::exp2;
 1917|      4|            buffer_.append(hdr, cur);
 1918|      4|            position_ += (cur - hdr);
 1919|      4|            return cur;
 1920|      4|        }
 1921|    415|        if (jsoncons::is_digit(*cur))
  ------------------
  |  Branch (1921:13): [True: 413, False: 2]
  ------------------
 1922|    413|        {
 1923|    413|            ++cur;
 1924|    413|            goto exp3;
 1925|    413|        }
 1926|      2|        err_handler_(json_errc::invalid_number, *this);
 1927|      2|        ec = json_errc::invalid_number;
 1928|      2|        more_ = false;
 1929|      2|        position_ += (cur - hdr);
 1930|      2|        return cur;
 1931|       |        
 1932|    971|exp3:
 1933|  4.95M|        while (true)
  ------------------
  |  Branch (1933:16): [True: 4.95M, Folded]
  ------------------
 1934|  4.95M|        {
 1935|  4.95M|            if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|  4.95M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 964, False: 4.95M]
  |  |  ------------------
  ------------------
 1936|    964|            {
 1937|    964|                number_state_ = parse_number_state::exp3;
 1938|    964|                buffer_.append(hdr, cur);
 1939|    964|                position_ += (cur - hdr);
 1940|    964|                return cur;
 1941|    964|            }
 1942|  4.95M|            if (JSONCONS_UNLIKELY(!jsoncons::is_digit(*cur)))
  ------------------
  |  |   78|  4.95M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 4.95M]
  |  |  ------------------
  ------------------
 1943|      7|            {
 1944|      7|                break;
 1945|      7|            }
 1946|  4.95M|            ++cur;
 1947|  4.95M|        }
 1948|      7|        buffer_.append(hdr, cur);
 1949|      7|        position_ += (cur - hdr);
 1950|      7|        end_fraction_value(visitor, ec);
 1951|      7|        return cur;
 1952|    971|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10parse_nullERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1656|     85|    {
 1657|     85|        begin_position_ = position_;
 1658|     85|        if (JSONCONS_LIKELY(input_end_ - input_ptr_ >= 4))
  ------------------
  |  |   77|     85|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 46, False: 39]
  |  |  ------------------
  ------------------
 1659|     46|        {
 1660|     46|            if (*(input_ptr_+1) == 'u' && *(input_ptr_+2) == 'l' && *(input_ptr_+3) == 'l')
  ------------------
  |  Branch (1660:17): [True: 25, False: 21]
  |  Branch (1660:43): [True: 12, False: 13]
  |  Branch (1660:69): [True: 1, False: 11]
  ------------------
 1661|      1|            {
 1662|      1|                input_ptr_ += 4;
 1663|      1|                position_ += 4;
 1664|      1|                visitor.null_value(semantic_tag::none, *this, ec);
 1665|      1|                if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1666|      1|                more_ = !cursor_mode_;
 1667|      1|                if (level_ == 0)
  ------------------
  |  Branch (1667:21): [True: 1, False: 0]
  ------------------
 1668|      1|                {
 1669|      1|                    state_ = parse_state::accept;
 1670|      1|                }
 1671|      0|                else
 1672|      0|                {
 1673|      0|                    state_ = parse_state::expect_comma_or_end;
 1674|      0|                }
 1675|      1|            }
 1676|     45|            else
 1677|     45|            {
 1678|     45|                err_handler_(json_errc::invalid_value, *this);
 1679|     45|                ec = json_errc::invalid_value;
 1680|     45|                more_ = false;
 1681|     45|                return;
 1682|     45|            }
 1683|     46|        }
 1684|     39|        else
 1685|     39|        {
 1686|     39|            ++input_ptr_;
 1687|     39|            ++position_;
 1688|     39|            state_ = parse_state::n;
 1689|     39|        }
 1690|     85|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10parse_trueEPKcRNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1618|     76|    {
 1619|     76|        begin_position_ = position_;
 1620|     76|        if (JSONCONS_LIKELY(input_end_ - cur >= 4))
  ------------------
  |  |   77|     76|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 35, False: 41]
  |  |  ------------------
  ------------------
 1621|     35|        {
 1622|     35|            if (*(cur+1) == 'r' && *(cur+2) == 'u' && *(cur+3) == 'e')
  ------------------
  |  Branch (1622:17): [True: 26, False: 9]
  |  Branch (1622:36): [True: 15, False: 11]
  |  Branch (1622:55): [True: 1, False: 14]
  ------------------
 1623|      1|            {
 1624|      1|                cur += 4;
 1625|      1|                position_ += 4;
 1626|      1|                visitor.bool_value(true, semantic_tag::none, *this, ec);
 1627|      1|                if (JSONCONS_UNLIKELY(ec)){return cur;}
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1628|      1|                if (level_ == 0)
  ------------------
  |  Branch (1628:21): [True: 1, False: 0]
  ------------------
 1629|      1|                {
 1630|      1|                    state_ = parse_state::accept;
 1631|      1|                }
 1632|      0|                else
 1633|      0|                {
 1634|      0|                    state_ = parse_state::expect_comma_or_end;
 1635|      0|                }
 1636|      1|                more_ = !cursor_mode_;
 1637|      1|            }
 1638|     34|            else
 1639|     34|            {
 1640|     34|                err_handler_(json_errc::invalid_value, *this);
 1641|     34|                ec = json_errc::invalid_value;
 1642|     34|                more_ = false;
 1643|     34|                return cur;
 1644|     34|            }
 1645|     35|        }
 1646|     41|        else
 1647|     41|        {
 1648|     41|            ++cur;
 1649|     41|            ++position_;
 1650|     41|            state_ = parse_state::t;
 1651|     41|        }
 1652|     42|        return cur;
 1653|     76|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11parse_falseEPKcRNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1693|    110|    {
 1694|    110|        begin_position_ = position_;
 1695|    110|        if (JSONCONS_LIKELY(input_end_ - cur >= 5))
  ------------------
  |  |   77|    110|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 58, False: 52]
  |  |  ------------------
  ------------------
 1696|     58|        {
 1697|     58|            if (*(cur+1) == 'a' && *(cur+2) == 'l' && *(cur+3) == 's' && *(cur+4) == 'e')
  ------------------
  |  Branch (1697:17): [True: 36, False: 22]
  |  Branch (1697:36): [True: 25, False: 11]
  |  Branch (1697:55): [True: 11, False: 14]
  |  Branch (1697:74): [True: 1, False: 10]
  ------------------
 1698|      1|            {
 1699|      1|                cur += 5;
 1700|      1|                position_ += 5;
 1701|      1|                visitor.bool_value(false, semantic_tag::none, *this, ec);
 1702|      1|                if (JSONCONS_UNLIKELY(ec)){return cur;}
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1703|      1|                more_ = !cursor_mode_;
 1704|      1|                if (level_ == 0)
  ------------------
  |  Branch (1704:21): [True: 1, False: 0]
  ------------------
 1705|      1|                {
 1706|      1|                    state_ = parse_state::accept;
 1707|      1|                }
 1708|      0|                else
 1709|      0|                {
 1710|      0|                    state_ = parse_state::expect_comma_or_end;
 1711|      0|                }
 1712|      1|            }
 1713|     57|            else
 1714|     57|            {
 1715|     57|                err_handler_(json_errc::invalid_value, *this);
 1716|     57|                ec = json_errc::invalid_value;
 1717|     57|                more_ = false;
 1718|     57|                return cur;
 1719|     57|            }
 1720|     58|        }
 1721|     52|        else
 1722|     52|        {
 1723|     52|            ++cur;
 1724|     52|            ++position_;
 1725|     52|            state_ = parse_state::f;
 1726|     52|        }
 1727|     53|        return cur;
 1728|    110|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE6parentEv:
  285|  1.94k|    {
  286|  1.94k|        JSONCONS_ASSERT(state_stack_.size() >= 1);
  ------------------
  |  |   45|  1.94k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 1.94k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  287|  1.94k|        return state_stack_.back();
  288|  1.94k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE5enterEv:
  296|  3.71k|    {
  297|  3.71k|        return state_ == parse_state::start;
  298|  3.71k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE6acceptEv:
  301|  3.69k|    {
  302|  3.69k|        return state_ == parse_state::accept || done_;
  ------------------
  |  Branch (302:16): [True: 1.79k, False: 1.89k]
  |  Branch (302:49): [True: 1.88k, False: 11]
  ------------------
  303|  3.69k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEEC2ERKNS_25basic_json_decode_optionsIcEERKS3_:
  178|  3.31k|       : max_nesting_depth_(options.max_nesting_depth()),
  179|  3.31k|         allow_trailing_comma_(options.allow_trailing_comma()),
  180|  3.31k|         allow_comments_(options.allow_comments()),
  181|  3.31k|         lossless_number_(options.lossless_number()),
  182|  3.31k|         lossless_bignum_(options.lossless_bignum()),
  183|       |#if !defined(JSONCONS_NO_DEPRECATED)
  184|  3.31k|         err_handler_(options.err_handler()),
  185|       |#else
  186|       |         err_handler_(default_json_parsing()),
  187|       |#endif
  188|  3.31k|         buffer_(temp_alloc),
  189|  3.31k|         state_stack_(temp_alloc)
  190|  3.31k|    {
  191|  3.31k|        buffer_.reserve(initial_buffer_capacity);
  192|       |
  193|  3.31k|        std::size_t initial_stack_capacity = options.max_nesting_depth() <= (default_initial_stack_capacity-2) ? (options.max_nesting_depth()+2) : default_initial_stack_capacity;
  ------------------
  |  Branch (193:46): [True: 0, False: 3.31k]
  ------------------
  194|  3.31k|        state_stack_.reserve(initial_stack_capacity );
  195|  3.31k|        push_state(parse_state::root);
  196|       |
  197|  3.31k|        if (options.enable_str_to_nan())
  ------------------
  |  Branch (197:13): [True: 0, False: 3.31k]
  ------------------
  198|      0|        {
  199|      0|            string_double_map_.emplace_back(options.nan_to_str(),std::nan(""));
  200|      0|        }
  201|  3.31k|        if (options.enable_str_to_inf())
  ------------------
  |  Branch (201:13): [True: 0, False: 3.31k]
  ------------------
  202|      0|        {
  203|      0|            string_double_map_.emplace_back(options.inf_to_str(),std::numeric_limits<double>::infinity());
  204|      0|        }
  205|  3.31k|        if (options.enable_str_to_neginf())
  ------------------
  |  Branch (205:13): [True: 0, False: 3.31k]
  ------------------
  206|      0|        {
  207|      0|            string_double_map_.emplace_back(options.neginf_to_str(),-std::numeric_limits<double>::infinity());
  208|      0|        }
  209|  3.31k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE4doneEv:
  291|  8.58k|    {
  292|  8.58k|        return done_;
  293|  8.58k|    }

_ZN8jsoncons19typed_array_visitorD2Ev:
   33|  3.31k|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  318|      3|        {
  319|      3|            visit_begin_object(tag, context, ec);
  320|      3|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      3|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  321|      3|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|  1.95k|        {
  109|  1.95k|            visit_flush();
  110|  1.95k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|    231|        {
  424|    231|            visit_int64(value, tag, context, ec);
  425|    231|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|    231|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  426|    231|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  383|    402|        {
  384|    402|            visit_string(value, tag, context, ec);
  385|    402|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|    402|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  386|    402|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|  1.00k|        {
  442|  1.00k|            visit_double(value, tag, context, ec);
  443|  1.00k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.00k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  444|  1.00k|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|    306|        {
  415|    306|            visit_uint64(value, tag, context, ec);
  416|    306|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|    306|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  417|    306|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  339|      1|        {
  340|      1|            visit_begin_array(tag, context, ec);
  341|      1|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      1|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  342|      1|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  374|      4|        {
  375|      4|            visit_bool(value, tag, context, ec);
  376|      4|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      4|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  377|      4|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  365|      2|        {
  366|      2|            visit_null(tag, context, ec);
  367|      2|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      2|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  368|      2|        }
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|  3.31k|        basic_json_visitor() = default;

_ZN8jsoncons11ser_contextD2Ev:
   21|  6.63k|    virtual ~ser_context() = default;

_ZN8jsoncons13stream_sourceIcNSt3__19allocatorIcEEED2Ev:
  188|  3.31k|        {
  189|  3.31k|            if (buffer_)
  ------------------
  |  Branch (189:17): [True: 3.31k, False: 0]
  ------------------
  190|  3.31k|            {
  191|  3.31k|                std::allocator_traits<char_allocator_type>::deallocate(alloc_, buffer_, buffer_size_);
  192|  3.31k|            }
  193|  3.31k|        }
_ZNK8jsoncons13stream_sourceIcNSt3__19allocatorIcEEE3eofEv:
  271|  15.6k|        {
  272|  15.6k|            return length_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:20): [True: 15.6k, False: 0]
  |  Branch (272:36): [True: 8.66k, False: 6.98k]
  ------------------
  273|  15.6k|        }
_ZN8jsoncons13stream_sourceIcNSt3__19allocatorIcEEE11read_bufferEv:
  328|  6.98k|        {
  329|  6.98k|            if (length_ == 0)
  ------------------
  |  Branch (329:17): [True: 6.98k, False: 0]
  ------------------
  330|  6.98k|            {
  331|  6.98k|                fill_buffer();
  332|  6.98k|            }
  333|  6.98k|            const value_type* data = data_;
  334|  6.98k|            std::size_t length = length_;
  335|  6.98k|            data_ += length_;
  336|  6.98k|            position_ += length_;
  337|  6.98k|            length_ = 0;
  338|       |
  339|  6.98k|            return span<const value_type>(data, length);
  340|  6.98k|        }
_ZN8jsoncons13stream_sourceIcNSt3__19allocatorIcEEE11fill_bufferEv:
  399|  6.98k|        {
  400|  6.98k|            if (stream_ptr_->eof())
  ------------------
  |  Branch (400:17): [True: 0, False: 6.98k]
  ------------------
  401|      0|            {
  402|      0|                length_ = 0;
  403|      0|                return;
  404|      0|            }
  405|       |
  406|  6.98k|            data_ = buffer_;
  407|  6.98k|            JSONCONS_TRY
  ------------------
  |  |   37|  6.98k|    #define JSONCONS_TRY try
  ------------------
  408|  6.98k|            {
  409|  6.98k|                std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(buffer_), buffer_size_);
  410|  6.98k|                length_ = static_cast<std::size_t>(count);
  411|       |
  412|  6.98k|                if (length_ < buffer_size_)
  ------------------
  |  Branch (412:21): [True: 3.29k, False: 3.68k]
  ------------------
  413|  3.29k|                {
  414|  3.29k|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  415|  3.29k|                }
  416|  6.98k|            }
  417|  6.98k|            JSONCONS_CATCH(const std::exception&)     
  418|  6.98k|            {
  419|      0|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  420|      0|                length_ = 0;
  421|      0|            }
  422|  6.98k|        }
_ZN8jsoncons13stream_sourceIcNSt3__19allocatorIcEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  171|  3.31k|            : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  172|  3.31k|              buffer_size_(default_max_buffer_size)
  173|  3.31k|        {
  174|  3.31k|            buffer_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, buffer_size_);
  175|  3.31k|            data_ = buffer_;
  176|  3.31k|        }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   54|  3.31k|          : std::basic_istream<CharT>(&nb_)
   55|  3.31k|        {
   56|  3.31k|        }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   40|  3.31k|            null_buffer() = default;

_ZN8jsoncons19json_source_adaptorINS_13stream_sourceIcNSt3__19allocatorIcEEEEE11read_bufferERNS2_10error_codeE:
  113|  11.3k|        {
  114|  11.3k|            if (source_.eof())
  ------------------
  |  Branch (114:17): [True: 4.31k, False: 6.98k]
  ------------------
  115|  4.31k|            {
  116|  4.31k|                return span<const value_type>();
  117|  4.31k|            }
  118|       |
  119|  6.98k|            auto s = source_.read_buffer();
  120|  6.98k|            const value_type* data = s.data();
  121|  6.98k|            std::size_t length = s.size();
  122|       |
  123|  6.98k|            if (bof_ && length > 0)
  ------------------
  |  Branch (123:17): [True: 3.31k, False: 3.66k]
  |  Branch (123:25): [True: 3.31k, False: 0]
  ------------------
  124|  3.31k|            {
  125|  3.31k|                auto r = unicode_traits::detect_json_encoding(data, length);
  126|  3.31k|                if (!(r.encoding == unicode_traits::encoding_kind::utf8 || r.encoding == unicode_traits::encoding_kind::undetected))
  ------------------
  |  Branch (126:23): [True: 3.29k, False: 16]
  |  Branch (126:76): [True: 0, False: 16]
  ------------------
  127|     16|                {
  128|     16|                    ec = json_errc::illegal_unicode_character;
  129|     16|                    return span<const value_type>();
  130|     16|                }
  131|  3.29k|                length -= (r.ptr - data);
  132|  3.29k|                data = r.ptr;
  133|  3.29k|                bof_ = false;
  134|  3.29k|            }
  135|       |            
  136|  6.96k|            return span<const value_type>(data, length);           
  137|  6.98k|        }
_ZNK8jsoncons19json_source_adaptorINS_13stream_sourceIcNSt3__19allocatorIcEEEEE3eofEv:
  103|  4.34k|        {
  104|  4.34k|            return source_.eof();
  105|  4.34k|        }
_ZN8jsoncons19json_source_adaptorINS_13stream_sourceIcNSt3__19allocatorIcEEEEEC2IRNS2_19basic_istringstreamIcNS2_11char_traitsIcEES4_EEEEOT_:
   98|  3.31k|            : source_(std::forward<Sourceable>(source)), bof_(true)
   99|  3.31k|        {
  100|  3.31k|        }

_ZN8jsoncons17basic_staj_cursorIcED2Ev:
  262|  3.31k|    virtual ~basic_staj_cursor() = default;
_ZNK8jsoncons18basic_staj_visitorIcE5eventEv:
   75|  1.95k|    {
   76|  1.95k|        return event_;
   77|  1.95k|    }
_ZN8jsoncons18basic_staj_visitorIcEC2Ev:
   59|  3.31k|        : event_(staj_events::null_value),
   60|  3.31k|          state_(), shape_()
   61|  3.31k|    {
   62|  3.31k|    }
_ZN8jsoncons18basic_staj_visitorIcE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  201|    306|    {
  202|    306|        event_ = basic_staj_event<CharT>(value, tag);
  203|    306|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|    306|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  204|    306|    }
_ZN8jsoncons18basic_staj_visitorIcE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  210|    231|    {
  211|    231|        event_ = basic_staj_event<CharT>(value, tag);
  212|    231|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|    231|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  213|    231|    }
_ZN8jsoncons18basic_staj_visitorIcE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  228|  1.00k|    {
  229|  1.00k|        event_ = basic_staj_event<CharT>(value, tag);
  230|  1.00k|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.00k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  231|  1.00k|    }
_ZN8jsoncons18basic_staj_visitorIcE11visit_flushEv:
  252|  1.95k|    {
  253|  1.95k|    }
_ZN8jsoncons18basic_staj_visitorIcE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  120|      3|    {
  121|      3|        event_ = basic_staj_event<CharT>(staj_events::begin_object, tag);
  122|      3|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      3|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  123|      3|    }
_ZN8jsoncons18basic_staj_visitorIcE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  138|      1|    {
  139|      1|        event_ = basic_staj_event<CharT>(staj_events::begin_array, tag);
  140|      1|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      1|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  141|      1|    }
_ZN8jsoncons18basic_staj_visitorIcE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  162|      2|    {
  163|      2|        event_ = basic_staj_event<CharT>(staj_events::null_value, tag);
  164|      2|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      2|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  165|      2|    }
_ZN8jsoncons18basic_staj_visitorIcE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  168|      4|    {
  169|      4|        event_ = basic_staj_event<CharT>(value, tag);
  170|      4|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      4|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  171|      4|    }
_ZN8jsoncons18basic_staj_visitorIcE12visit_stringERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  174|    402|    {
  175|    402|        event_ = basic_staj_event<CharT>(s, staj_events::string_value, tag);
  176|    402|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|    402|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  177|    402|    }

_ZN8jsoncons16basic_staj_eventIcEC2ENS_11staj_eventsENS_12semantic_tagE:
  211|  3.32k|        : event_type_(event_type), tag_(tag), value_()
  212|  3.32k|    {
  213|  3.32k|    }
_ZN8jsoncons16basic_staj_eventIcEC2EmNS_12semantic_tagE:
  238|    306|        : event_type_(staj_events::uint64_value), tag_(tag)
  239|    306|    {
  240|    306|        value_.uint64_value_ = value;
  241|    306|    }
_ZN8jsoncons16basic_staj_eventIcEC2ElNS_12semantic_tagE:
  232|    231|        : event_type_(staj_events::int64_value), tag_(tag)
  233|    231|    {
  234|    231|        value_.int64_value_ = value;
  235|    231|    }
_ZN8jsoncons16basic_staj_eventIcEC2EdNS_12semantic_tagE:
  250|  1.00k|        : event_type_(staj_events::double_value), tag_(tag)
  251|  1.00k|    {
  252|  1.00k|        value_.double_value_ = value;
  253|  1.00k|    }
_ZN8jsoncons16basic_staj_eventIcEC2ERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_11staj_eventsENS_12semantic_tagE:
  258|    402|        : event_type_(event_type), tag_(tag), length_(s.length())
  259|    402|    {
  260|    402|        value_.string_data_ = s.data();
  261|    402|    }
_ZN8jsoncons16basic_staj_eventIcEC2EbNS_12semantic_tagE:
  226|      4|        : event_type_(staj_events::bool_value), tag_(tag)
  227|      4|    {
  228|      4|        value_.bool_value_ = value;
  229|      4|    }
_ZNK8jsoncons16basic_staj_eventIcE3getINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEET_RNS3_10error_codeE:
  300|  1.95k|    {
  301|  1.95k|        return get_<T>(std::allocator<char>{}, ec);
  302|  1.95k|    }
_ZNK8jsoncons16basic_staj_eventIcE4get_INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES8_cEENS3_9enable_ifIXaasr10ext_traits9is_stringIT_EE5valuesr3std7is_sameINSB_10value_typeET1_EE5valueESB_E4typeET0_RNS3_10error_codeE:
  307|  1.95k|    {
  308|  1.95k|        constexpr const char_type* true_constant = JSONCONS_CSTRING_CONSTANT(char_type,"true"); 
  ------------------
  |  |  258|  1.95k|#define JSONCONS_CSTRING_CONSTANT(CharT, Str) cstring_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  256|  1.95k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  253|  1.95k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  309|  1.95k|        constexpr const char_type* false_constant = JSONCONS_CSTRING_CONSTANT(char_type,"false"); 
  ------------------
  |  |  258|  1.95k|#define JSONCONS_CSTRING_CONSTANT(CharT, Str) cstring_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  256|  1.95k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  253|  1.95k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  310|  1.95k|        constexpr const char_type* null_constant = JSONCONS_CSTRING_CONSTANT(char_type,"null"); 
  ------------------
  |  |  258|  1.95k|#define JSONCONS_CSTRING_CONSTANT(CharT, Str) cstring_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  256|  1.95k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  253|  1.95k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  311|       |
  312|  1.95k|        switch (event_type_)
  313|  1.95k|        {
  314|      0|            case staj_events::key:
  ------------------
  |  Branch (314:13): [True: 0, False: 1.95k]
  ------------------
  315|    402|            case staj_events::string_value:
  ------------------
  |  Branch (315:13): [True: 402, False: 1.55k]
  ------------------
  316|    402|            {
  317|    402|                return jsoncons::make_obj_using_allocator<T>(alloc, value_.string_data_, length_);
  318|      0|            }
  319|      0|            case staj_events::byte_string_value:
  ------------------
  |  Branch (319:13): [True: 0, False: 1.95k]
  ------------------
  320|      0|            {
  321|      0|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  322|      0|                bytes_to_string(value_.byte_string_data_, value_.byte_string_data_+length_, tag(), s);
  323|      0|                return s;
  324|      0|            }
  325|    306|            case staj_events::uint64_value:
  ------------------
  |  Branch (325:13): [True: 306, False: 1.65k]
  ------------------
  326|    306|            {
  327|    306|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  328|    306|                jsoncons::from_integer(value_.uint64_value_, s);
  329|    306|                return s;
  330|      0|            }
  331|    231|            case staj_events::int64_value:
  ------------------
  |  Branch (331:13): [True: 231, False: 1.72k]
  ------------------
  332|    231|            {
  333|    231|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  334|    231|                jsoncons::from_integer(value_.int64_value_, s);
  335|    231|                return s;
  336|      0|            }
  337|      0|            case staj_events::half_value:
  ------------------
  |  Branch (337:13): [True: 0, False: 1.95k]
  ------------------
  338|      0|            {
  339|      0|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  340|      0|                jsoncons::write_double f{float_chars_format::general,0};
  341|      0|                double x = binary::decode_half(value_.half_value_);
  342|      0|                f(x, s);
  343|      0|                return s;
  344|      0|            }
  345|  1.00k|            case staj_events::double_value:
  ------------------
  |  Branch (345:13): [True: 1.00k, False: 949]
  ------------------
  346|  1.00k|            {
  347|  1.00k|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  348|  1.00k|                jsoncons::write_double f{float_chars_format::general,0};
  349|  1.00k|                f(value_.double_value_, s);
  350|  1.00k|                return s;
  351|      0|            }
  352|      4|            case staj_events::bool_value:
  ------------------
  |  Branch (352:13): [True: 4, False: 1.95k]
  ------------------
  353|      4|            {
  354|      4|                return jsoncons::make_obj_using_allocator<T>(alloc, value_.bool_value_ ? true_constant : false_constant);
  ------------------
  |  Branch (354:69): [True: 2, False: 2]
  ------------------
  355|      0|            }
  356|      2|            case staj_events::null_value:
  ------------------
  |  Branch (356:13): [True: 2, False: 1.95k]
  ------------------
  357|      2|            {
  358|      2|                return jsoncons::make_obj_using_allocator<T>(alloc, null_constant);
  359|      0|            }
  360|      4|            default:
  ------------------
  |  Branch (360:13): [True: 4, False: 1.95k]
  ------------------
  361|      4|            {
  362|      4|                ec = conv_errc::not_string;
  363|      4|                return T{};
  364|      0|            }
  365|  1.95k|        }
  366|  1.95k|    }

_ZN8jsoncons10ext_traits14integer_limitsIlvE6lowestEv:
  110|    338|        {
  111|    338|            return std::numeric_limits<T>::lowest();
  112|    338|        }

_ZN8jsoncons14dec_to_integerIlcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  327|    411|{
  328|    411|    if (length == 0)
  ------------------
  |  Branch (328:9): [True: 0, False: 411]
  ------------------
  329|      0|    {
  330|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  331|      0|    }
  332|       |
  333|    411|    bool sign = *s == '-';
  334|    411|    s += sign;
  335|    411|    length -= sign;
  336|       |
  337|    411|    using U = typename ext_traits::make_unsigned<T>::type;
  338|       |
  339|    411|    U num;
  340|    411|    auto ru = dec_to_integer(s, length, num);
  341|    411|    if (ru.ec != std::errc{})
  ------------------
  |  Branch (341:9): [True: 73, False: 338]
  ------------------
  342|     73|    {
  343|     73|        return to_number_result<CharT>(ru.ptr, ru.ec);
  344|     73|    }
  345|    338|    if (sign)
  ------------------
  |  Branch (345:9): [True: 338, False: 0]
  ------------------
  346|    338|    {
  347|    338|        if (num > static_cast<U>(-((ext_traits::integer_limits<T>::lowest)()+T(1))) + U(1))
  ------------------
  |  Branch (347:13): [True: 107, False: 231]
  ------------------
  348|    107|        {
  349|    107|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  350|    107|        }
  351|    231|        else
  352|    231|        {
  353|    231|            value = static_cast<T>(U(0) - num);
  354|    231|            return to_number_result<CharT>(ru.ptr, std::errc{});
  355|    231|        }
  356|    338|    }
  357|      0|    else
  358|      0|    {
  359|      0|        if (num > static_cast<U>((ext_traits::integer_limits<T>::max)()))
  ------------------
  |  Branch (359:13): [True: 0, False: 0]
  ------------------
  360|      0|        {
  361|      0|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  362|      0|        }
  363|      0|        else
  364|      0|        {
  365|      0|            value = static_cast<T>(num);
  366|      0|            return to_number_result<CharT>(ru.ptr, std::errc{});
  367|      0|        }
  368|      0|    }
  369|    338|}
_ZN8jsoncons16to_number_resultIcEC2EPKcNSt3__14errcE:
  141|  1.26k|        : ptr(ptr_), ec(ec_)
  142|  1.26k|    {
  143|  1.26k|    }
_ZN8jsoncons14dec_to_integerImcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedntsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  265|    790|{
  266|    790|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|    790|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 790]
  |  |  ------------------
  ------------------
  267|      0|    {
  268|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  269|      0|    }
  270|       |
  271|    790|    static constexpr T max_value = (ext_traits::integer_limits<T>::max)();
  272|    790|    static constexpr T max_value_div_10 = max_value / 10;
  273|       |
  274|    790|    T num = 0;
  275|    790|    const CharT* cur = s;
  276|    790|    const CharT* last = s + length;
  277|    790|    static constexpr std::size_t digits10 = static_cast<std::size_t>(ext_traits::integer_limits<T>::digits10);
  278|    790|    const std::size_t n = (std::min)(digits10, length);
  279|    790|    const CharT* stop = s + n;
  280|       |     
  281|  12.8k|    while (cur < stop)
  ------------------
  |  Branch (281:12): [True: 12.0k, False: 790]
  ------------------
  282|  12.0k|    {
  283|  12.0k|        uint8_t d;
  284|  12.0k|        if (JSONCONS_LIKELY((d = static_cast<uint8_t>(*cur - '0')) <= 9) )
  ------------------
  |  |   77|  12.0k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 12.0k, False: 0]
  |  |  ------------------
  ------------------
  285|  12.0k|        {
  286|  12.0k|            num = static_cast<T>(d) + num*10;
  287|  12.0k|        }
  288|      0|        else
  289|      0|        {
  290|      0|            return to_number_result<CharT>(cur, std::errc::invalid_argument);
  291|      0|        }
  292|  12.0k|        ++cur;
  293|  12.0k|    }
  294|    790|    if (cur == last)
  ------------------
  |  Branch (294:9): [True: 340, False: 450]
  ------------------
  295|    340|    {
  296|    340|        value = num;
  297|    340|        return to_number_result<CharT>(cur, std::errc{});
  298|    340|    }
  299|    450|    if (cur+1 != last)
  ------------------
  |  Branch (299:9): [True: 124, False: 326]
  ------------------
  300|    124|    {
  301|    124|        return to_number_result<CharT>(cur, std::errc::result_out_of_range);
  302|    124|    }
  303|    326|    if (is_digit(*cur))
  ------------------
  |  Branch (303:9): [True: 326, False: 0]
  ------------------
  304|    326|    {
  305|    326|        if (num > max_value_div_10)
  ------------------
  |  Branch (305:13): [True: 19, False: 307]
  ------------------
  306|     19|        {
  307|     19|            return to_number_result<CharT>(cur, std::errc::result_out_of_range);
  308|     19|        }
  309|    307|        uint8_t d = static_cast<uint8_t>(*cur - '0');
  310|    307|        num = num*10;
  311|    307|        if (num > max_value - d)
  ------------------
  |  Branch (311:13): [True: 3, False: 304]
  ------------------
  312|      3|        {
  313|      3|            return to_number_result<CharT>(s, std::errc::result_out_of_range);
  314|      3|        }
  315|    304|        num += d;
  316|    304|        ++cur;
  317|    304|        value = num;
  318|    304|        return to_number_result<CharT>(cur, std::errc{});
  319|    307|    }
  320|       |    
  321|      0|    return to_number_result<CharT>(cur, std::errc::invalid_argument);
  322|    326|}
_ZN8jsoncons8is_digitEc:
   83|  33.4M|constexpr bool is_digit(char d) {
   84|  33.4M|    return is_type(static_cast<uint8_t>(d), (uint8_t)(DIGIT_TYPE_ZERO | DIGIT_TYPE_NONZERO));
   85|  33.4M|}
_ZN8jsoncons7is_typeEhh:
   68|  33.4M|constexpr bool is_type(uint8_t d, uint8_t type) {
   69|  33.4M|    return (digi_table[d] & type) != 0;
   70|  33.4M|}
_ZNK8jsoncons16to_number_resultIcEcvbEv:
  150|  1.86k|    {
  151|  1.86k|        return ec == std::errc{};
  152|  1.86k|    }
_ZN8jsoncons16decstr_to_doubleEPKcmRd:
  866|  1.26k|{
  867|  1.26k|    const char* cur = s+length;
  868|  1.26k|    char *end = nullptr;
  869|  1.26k|    val = strtod(s, &end);
  870|  1.26k|    const char* str_end = end;
  871|  1.26k|    if (JSONCONS_UNLIKELY(end < cur))
  ------------------
  |  |   78|  1.26k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.26k]
  |  |  ------------------
  ------------------
  872|      0|    {
  873|      0|        if (*end == '.')
  ------------------
  |  Branch (873:13): [True: 0, False: 0]
  ------------------
  874|      0|        {
  875|      0|            std::string buf{s, length};
  876|      0|            char* dot_ptr = &buf[0] + (cur - end - 1);
  877|      0|            *dot_ptr = ',';
  878|      0|            end = nullptr;
  879|      0|            val = strtod(buf.c_str(), &end);
  880|      0|            str_end = s + (end - &buf[0]);
  881|      0|        }
  882|      0|        if (JSONCONS_UNLIKELY(str_end != cur))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  883|      0|        {
  884|      0|            return to_number_result<char>{str_end,std::errc::invalid_argument};
  885|      0|        }
  886|      0|    }
  887|  1.26k|    if (JSONCONS_UNLIKELY(val <= -HUGE_VAL || val >= HUGE_VAL))
  ------------------
  |  |   78|  2.51k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 63, False: 1.20k]
  |  |  |  Branch (78:50): [True: 18, False: 1.24k]
  |  |  |  Branch (78:50): [True: 45, False: 1.20k]
  |  |  ------------------
  ------------------
  888|     63|    {
  889|     63|        return to_number_result<char>{str_end, std::errc::result_out_of_range};
  890|     63|    }
  891|  1.20k|    return to_number_result<char>{str_end};
  892|  1.26k|}
_ZN8jsoncons16to_number_resultIcEC2EPKc:
  137|  1.20k|        : ptr(ptr_), ec(std::errc{})
  138|  1.20k|    {
  139|  1.20k|    }
_ZN8jsoncons16is_nonzero_digitEc:
   78|    468|constexpr bool is_nonzero_digit(char d) {
   79|    468|    return is_type(static_cast<uint8_t>(d), (uint8_t)DIGIT_TYPE_NONZERO);
   80|    468|}
_ZN8jsoncons6is_expEc:
   88|    750|constexpr bool is_exp(char d) {
   89|    750|    return is_type(static_cast<uint8_t>(d), (uint8_t)DIGIT_TYPE_EXP);
   90|    750|}

_ZN8jsoncons14unicode_traits20detect_json_encodingIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m:
  108|  3.31k|    {
  109|  3.31k|        detect_encoding_result<CharT> r = detect_encoding_from_bom(data,length);
  110|  3.31k|        if (r.encoding != encoding_kind::undetected)
  ------------------
  |  Branch (110:13): [True: 46, False: 3.26k]
  ------------------
  111|     46|        {
  112|     46|            return r;
  113|     46|        }
  114|  3.26k|        else if (length < 4)
  ------------------
  |  Branch (114:18): [True: 445, False: 2.82k]
  ------------------
  115|    445|        {
  116|    445|            return detect_encoding_result<CharT>{data,encoding_kind::utf8};
  117|    445|        }
  118|  2.82k|        else if (*data == 0 && *(data+1) == 0 && *(data+2) == 0)
  ------------------
  |  Branch (118:18): [True: 22, False: 2.80k]
  |  Branch (118:32): [True: 13, False: 9]
  |  Branch (118:50): [True: 1, False: 12]
  ------------------
  119|      1|        {
  120|      1|            return detect_encoding_result<CharT>{data,encoding_kind::utf32be};
  121|      1|        }
  122|  2.82k|        else if (*data == 0 && *(data+2) == 0)
  ------------------
  |  Branch (122:18): [True: 21, False: 2.80k]
  |  Branch (122:32): [True: 3, False: 18]
  ------------------
  123|      3|        {
  124|      3|            return detect_encoding_result<CharT>{data,encoding_kind::utf16be};
  125|      3|        }
  126|  2.82k|        else if (*(data+1) == 0 && *(data+2) == 0 && *(data+3) == 0)
  ------------------
  |  Branch (126:18): [True: 33, False: 2.78k]
  |  Branch (126:36): [True: 12, False: 21]
  |  Branch (126:54): [True: 2, False: 10]
  ------------------
  127|      2|        {
  128|      2|            return detect_encoding_result<CharT>{data,encoding_kind::utf32le};
  129|      2|        }
  130|  2.81k|        else if (*(data+1) == 0 && *(data+3) == 0)
  ------------------
  |  Branch (130:18): [True: 31, False: 2.78k]
  |  Branch (130:36): [True: 3, False: 28]
  ------------------
  131|      3|        {
  132|      3|            return detect_encoding_result<CharT>{data,encoding_kind::utf16le};
  133|      3|        }
  134|  2.81k|        else
  135|  2.81k|        {
  136|  2.81k|            return detect_encoding_result<CharT>{data,encoding_kind::utf8};
  137|  2.81k|        }
  138|  3.31k|    }
_ZN8jsoncons14unicode_traits24detect_encoding_from_bomIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m:
   65|  3.31k|    {
   66|  3.31k|        static constexpr uint8_t bom_utf8[] = {0xef,0xbb,0xbf}; 
   67|  3.31k|        static constexpr uint8_t bom_utf16le[] = {0xff,0xfe}; 
   68|  3.31k|        static constexpr uint8_t bom_utf16be[] = {0xfe,0xff}; 
   69|  3.31k|        static constexpr uint8_t bom_utf32le[] = {0xff,0xfe,0x00,0x00}; 
   70|  3.31k|        static constexpr uint8_t bom_utf32be[] = {0x00,0x00,0xfe,0xff}; 
   71|       |
   72|  3.31k|        if (length >= 4 && !memcmp(data,bom_utf32le,4))
  ------------------
  |  Branch (72:13): [True: 2.86k, False: 448]
  |  Branch (72:28): [True: 1, False: 2.86k]
  ------------------
   73|      1|        {
   74|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32le};
   75|      1|        }
   76|  3.31k|        else if (length >= 4 && !memcmp(data,bom_utf32be,4))
  ------------------
  |  Branch (76:18): [True: 2.86k, False: 448]
  |  Branch (76:33): [True: 1, False: 2.86k]
  ------------------
   77|      1|        {
   78|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32be};
   79|      1|        }
   80|  3.31k|        else if (length >= 2 && !memcmp(data,bom_utf16le,2))
  ------------------
  |  Branch (80:18): [True: 3.25k, False: 54]
  |  Branch (80:33): [True: 4, False: 3.25k]
  ------------------
   81|      4|        {
   82|      4|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16le};
   83|      4|        }
   84|  3.30k|        else if (length >= 2 && !memcmp(data,bom_utf16be,2))
  ------------------
  |  Branch (84:18): [True: 3.25k, False: 54]
  |  Branch (84:33): [True: 1, False: 3.25k]
  ------------------
   85|      1|        {
   86|      1|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16be};
   87|      1|        }
   88|  3.30k|        else if (length >= 3 && !memcmp(data,bom_utf8,3))
  ------------------
  |  Branch (88:18): [True: 3.05k, False: 254]
  |  Branch (88:33): [True: 39, False: 3.01k]
  ------------------
   89|     39|        {
   90|     39|            return detect_encoding_result<CharT>{data+3,encoding_kind::utf8};
   91|     39|        }
   92|  3.26k|        else
   93|  3.26k|        {
   94|  3.26k|            return detect_encoding_result<CharT>{data,encoding_kind::undetected};
   95|  3.26k|        }
   96|  3.31k|    }
_ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_14convert_resultIS4_EEE4typeEPKS4_m:
 1136|    183|    {
 1137|    183|        conv_errc  result = conv_errc();
 1138|    183|        const CharT* last = data + length;
 1139|  1.47M|        while (data != last) 
  ------------------
  |  Branch (1139:16): [True: 1.47M, False: 86]
  ------------------
 1140|  1.47M|        {
 1141|  1.47M|            std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[static_cast<uint8_t>(*data)]) + 1;
 1142|  1.47M|            if (len > (std::size_t)(last - data))
  ------------------
  |  Branch (1142:17): [True: 2, False: 1.47M]
  ------------------
 1143|      2|            {
 1144|      2|                return convert_result<CharT>{data, conv_errc::source_exhausted};
 1145|      2|            }
 1146|  1.47M|            if ((result=is_legal_utf8(data, len)) != conv_errc())
  ------------------
  |  Branch (1146:17): [True: 95, False: 1.47M]
  ------------------
 1147|     95|            {
 1148|     95|                return convert_result<CharT>{data,result} ;
 1149|     95|            }
 1150|  1.47M|            data += len;
 1151|  1.47M|        }
 1152|     86|        return convert_result<CharT>{data,result} ;
 1153|    183|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8IcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_9conv_errcEE4typeEPKS4_m:
  305|  1.47M|    {
  306|  1.47M|        uint8_t a;
  307|  1.47M|        const CharT* srcptr = first+length;
  308|  1.47M|        switch (length) {
  309|     23|        default:
  ------------------
  |  Branch (309:9): [True: 23, False: 1.47M]
  ------------------
  310|     23|            return conv_errc::over_long_utf8_sequence;
  311|    789|        case 4:
  ------------------
  |  Branch (311:9): [True: 789, False: 1.47M]
  ------------------
  312|    789|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (312:17): [True: 4, False: 785]
  ------------------
  313|      4|                return conv_errc::expected_continuation_byte;
  314|    785|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|    785|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  315|  1.87k|        case 3:
  ------------------
  |  Branch (315:9): [True: 1.08k, False: 1.47M]
  ------------------
  316|  1.87k|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (316:17): [True: 4, False: 1.86k]
  ------------------
  317|      4|                return conv_errc::expected_continuation_byte;
  318|  1.86k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|  1.86k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  319|  2.19k|        case 2:
  ------------------
  |  Branch (319:9): [True: 331, False: 1.47M]
  ------------------
  320|  2.19k|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (320:17): [True: 16, False: 2.18k]
  ------------------
  321|     16|                return conv_errc::expected_continuation_byte;
  322|       |
  323|  2.18k|            switch (static_cast<uint8_t>(*first)) 
  324|  2.18k|            {
  325|       |                // no fall-through in this inner switch
  326|    690|                case 0xE0: if (a < 0xA0) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (326:17): [True: 690, False: 1.49k]
  |  Branch (326:32): [True: 8, False: 682]
  ------------------
  327|    682|                case 0xED: if (a > 0x9F) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (327:17): [True: 295, False: 1.88k]
  |  Branch (327:32): [True: 3, False: 292]
  ------------------
  328|    562|                case 0xF0: if (a < 0x90) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (328:17): [True: 562, False: 1.61k]
  |  Branch (328:32): [True: 3, False: 559]
  ------------------
  329|    559|                case 0xF4: if (a > 0x8F) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (329:17): [True: 216, False: 1.96k]
  |  Branch (329:32): [True: 5, False: 211]
  ------------------
  330|    418|                default:   if (a < 0x80) return conv_errc::source_illegal;
  ------------------
  |  Branch (330:17): [True: 418, False: 1.76k]
  |  Branch (330:32): [True: 0, False: 418]
  ------------------
  331|  2.18k|            }
  332|       |
  333|  2.16k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|  2.16k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  334|  1.47M|        case 1:
  ------------------
  |  Branch (334:9): [True: 1.47M, False: 2.22k]
  ------------------
  335|  1.47M|            if (static_cast<uint8_t>(*first) >= 0x80 && static_cast<uint8_t>(*first) < 0xC2)
  ------------------
  |  Branch (335:17): [True: 2.18k, False: 1.47M]
  |  Branch (335:57): [True: 28, False: 2.16k]
  ------------------
  336|     28|                return conv_errc::source_illegal;
  337|  1.47M|            break;
  338|  1.47M|        }
  339|  1.47M|        if (static_cast<uint8_t>(*first) > 0xF4) 
  ------------------
  |  Branch (339:13): [True: 1, False: 1.47M]
  ------------------
  340|      1|            return conv_errc::source_illegal;
  341|       |
  342|  1.47M|        return conv_errc();
  343|  1.47M|    }
_ZN8jsoncons14unicode_traits17is_high_surrogateEj:
  208|   538k|    {
  209|   538k|        return (ch >= sur_high_start && ch <= sur_high_end);
  ------------------
  |  Branch (209:17): [True: 315k, False: 222k]
  |  Branch (209:41): [True: 267k, False: 47.9k]
  ------------------
  210|   538k|    }
_ZN8jsoncons14unicode_traits7convertIjNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_9enable_ifIXaaaasr10ext_traits9is_char32IT_EE5valuesr10ext_traits18is_back_insertableIT0_EE5valuesr10ext_traits8is_char8INSB_10value_typeEEE5valueENS0_14convert_resultISA_EEE4typeEPKSA_mRSB_NS0_10conv_flagsE:
  969|   538k|    {
  970|   538k|        conv_errc  result = conv_errc();
  971|   538k|        const CharT* last = data + length;
  972|  1.03M|        while (data < last) 
  ------------------
  |  Branch (972:16): [True: 538k, False: 493k]
  ------------------
  973|   538k|        {
  974|   538k|            unsigned short bytes_to_write = 0;
  975|   538k|            static constexpr uint32_t byteMask = 0xBF;
  976|   538k|            static constexpr uint32_t byteMark = 0x80; 
  977|   538k|            uint32_t ch = *data++;
  978|   538k|            if (flags == conv_flags::strict ) 
  ------------------
  |  Branch (978:17): [True: 538k, False: 0]
  ------------------
  979|   538k|            {
  980|       |                /* UTF-16 surrogate values are illegal in UTF-32 */
  981|   538k|                if (is_surrogate(ch)) 
  ------------------
  |  Branch (981:21): [True: 44.4k, False: 493k]
  ------------------
  982|  44.4k|                {
  983|  44.4k|                    --data; /* return to the illegal value itself */
  984|  44.4k|                    result = conv_errc::illegal_surrogate_value;
  985|  44.4k|                    break;
  986|  44.4k|                }
  987|   538k|            }
  988|       |            /*
  989|       |             * Figure out how many bytes the result will require. Turn any
  990|       |             * illegally large UTF32 things (> Plane 17) into replacement chars.
  991|       |             */
  992|   493k|            if (ch < (uint32_t)0x80) {      bytes_to_write = 1;
  ------------------
  |  Branch (992:17): [True: 1.62k, False: 492k]
  ------------------
  993|   492k|            } else if (ch < (uint32_t)0x800) {     bytes_to_write = 2;
  ------------------
  |  Branch (993:24): [True: 4.90k, False: 487k]
  ------------------
  994|   487k|            } else if (ch < (uint32_t)0x10000) {   bytes_to_write = 3;
  ------------------
  |  Branch (994:24): [True: 219k, False: 267k]
  ------------------
  995|   267k|            } else if (ch <= max_legal_utf32) {  bytes_to_write = 4;
  ------------------
  |  Branch (995:24): [True: 267k, False: 0]
  ------------------
  996|   267k|            } else {                            
  997|      0|                bytes_to_write = 3;
  998|      0|                ch = replacement_char;
  999|      0|                result = conv_errc::source_illegal;
 1000|      0|            }
 1001|       |
 1002|   493k|            uint8_t byte1 = 0;
 1003|   493k|            uint8_t byte2 = 0;
 1004|   493k|            uint8_t byte3 = 0;
 1005|   493k|            uint8_t byte4 = 0;
 1006|       |
 1007|   493k|            switch (bytes_to_write) {
  ------------------
  |  Branch (1007:21): [True: 493k, False: 0]
  ------------------
 1008|   267k|            case 4:
  ------------------
  |  Branch (1008:13): [True: 267k, False: 226k]
  ------------------
 1009|   267k|                byte4 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1010|   267k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|   267k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
 1011|   487k|            case 3:
  ------------------
  |  Branch (1011:13): [True: 219k, False: 274k]
  ------------------
 1012|   487k|                byte3 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1013|   487k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|   487k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
 1014|   492k|            case 2:
  ------------------
  |  Branch (1014:13): [True: 4.90k, False: 488k]
  ------------------
 1015|   492k|                byte2 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1016|   492k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|   492k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
 1017|   493k|            case 1:
  ------------------
  |  Branch (1017:13): [True: 1.62k, False: 492k]
  ------------------
 1018|   493k|                byte1 = (uint8_t) (ch | first_byte_mark[bytes_to_write]);
 1019|   493k|                break;
 1020|   493k|            }
 1021|       |
 1022|   493k|            switch (bytes_to_write) 
  ------------------
  |  Branch (1022:21): [True: 493k, False: 0]
  ------------------
 1023|   493k|            {
 1024|   267k|            case 4: 
  ------------------
  |  Branch (1024:13): [True: 267k, False: 226k]
  ------------------
 1025|   267k|                target.push_back(byte1);
 1026|   267k|                target.push_back(byte2);
 1027|   267k|                target.push_back(byte3);
 1028|   267k|                target.push_back(byte4);
 1029|   267k|                break;
 1030|   219k|            case 3: 
  ------------------
  |  Branch (1030:13): [True: 219k, False: 274k]
  ------------------
 1031|   219k|                target.push_back(byte1);
 1032|   219k|                target.push_back(byte2);
 1033|   219k|                target.push_back(byte3);
 1034|   219k|                break;
 1035|  4.90k|            case 2: 
  ------------------
  |  Branch (1035:13): [True: 4.90k, False: 488k]
  ------------------
 1036|  4.90k|                target.push_back(byte1);
 1037|  4.90k|                target.push_back(byte2);
 1038|  4.90k|                break;
 1039|  1.62k|            case 1: 
  ------------------
  |  Branch (1039:13): [True: 1.62k, False: 492k]
  ------------------
 1040|  1.62k|                target.push_back(byte1);
 1041|  1.62k|                break;
 1042|   493k|            }
 1043|   493k|        }
 1044|   538k|        return convert_result<CharT>{data,result} ;
 1045|   538k|    }
_ZN8jsoncons14unicode_traits12is_surrogateEj:
  220|   538k|    {
  221|   538k|        return (ch >= sur_high_start && ch <= sur_low_end);
  ------------------
  |  Branch (221:17): [True: 315k, False: 222k]
  |  Branch (221:41): [True: 44.4k, False: 271k]
  ------------------
  222|   538k|    }

_ZN8jsoncons12from_integerImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|    306|{
   43|    306|    using char_type = typename Result::value_type;
   44|       |
   45|    306|    char_type buf[255];
   46|    306|    char_type *p = buf;
   47|    306|    const char_type* last = buf+255;
   48|       |
   49|    306|    bool is_negative = value < 0;
   50|       |
   51|    306|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 306]
  ------------------
   52|      0|    {
   53|      0|        do
   54|      0|        {
   55|      0|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|      0|        }
   57|      0|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 0, False: 0]
  |  Branch (57:33): [True: 0, False: 0]
  ------------------
   58|      0|    }
   59|    306|    else
   60|    306|    {
   61|       |
   62|    306|        do
   63|  4.07k|        {
   64|  4.07k|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  4.07k|        }
   66|  4.07k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 3.76k, False: 306]
  |  Branch (66:33): [True: 3.76k, False: 0]
  ------------------
   67|    306|    }
   68|    306|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   45|    306|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 306]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|    306|    std::size_t count = (p - buf);
   71|    306|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 306]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  4.37k|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 4.07k, False: 306]
  ------------------
   77|  4.07k|    {
   78|  4.07k|        result.push_back(*p);
   79|  4.07k|    }
   80|       |
   81|    306|    return count;
   82|    306|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|    231|{
   43|    231|    using char_type = typename Result::value_type;
   44|       |
   45|    231|    char_type buf[255];
   46|    231|    char_type *p = buf;
   47|    231|    const char_type* last = buf+255;
   48|       |
   49|    231|    bool is_negative = value < 0;
   50|       |
   51|    231|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 230, False: 1]
  ------------------
   52|    230|    {
   53|    230|        do
   54|  2.79k|        {
   55|  2.79k|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|  2.79k|        }
   57|  2.79k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 2.56k, False: 230]
  |  Branch (57:33): [True: 2.56k, False: 0]
  ------------------
   58|    230|    }
   59|      1|    else
   60|      1|    {
   61|       |
   62|      1|        do
   63|      1|        {
   64|      1|            *p++ = static_cast<char_type>(48 + value % 10);
   65|      1|        }
   66|      1|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 0, False: 1]
  |  Branch (66:33): [True: 0, False: 0]
  ------------------
   67|      1|    }
   68|    231|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   45|    231|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 231]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|    231|    std::size_t count = (p - buf);
   71|    231|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 230, False: 1]
  ------------------
   72|    230|    {
   73|    230|        result.push_back('-');
   74|    230|        ++count;
   75|    230|    }
   76|  3.02k|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 2.79k, False: 231]
  ------------------
   77|  2.79k|    {
   78|  2.79k|        result.push_back(*p);
   79|  2.79k|    }
   80|       |
   81|    231|    return count;
   82|    231|}
_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|  1.00k|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|  1.00k|    {
  489|  1.00k|#if !defined(JSONCONS_NO_LOCALECONV)
  490|  1.00k|        struct lconv *lc = localeconv();
  491|  1.00k|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 1.00k, False: 0]
  |  Branch (491:30): [True: 1.00k, False: 0]
  ------------------
  492|  1.00k|        {
  493|  1.00k|            decimal_point_ = lc->decimal_point[0];
  494|  1.00k|        }
  495|  1.00k|#endif
  496|  1.00k|    }
_ZN8jsoncons12write_doubleclINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEmdRT_:
  503|  1.00k|    {
  504|  1.00k|        std::size_t count = 0;
  505|       |
  506|  1.00k|        char number_buffer[200];
  507|  1.00k|        int length = 0;
  508|       |
  509|  1.00k|        switch (float_format_)
  510|  1.00k|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 1.00k]
  ------------------
  512|      0|            {
  513|      0|                if (precision_ > 0)
  ------------------
  |  Branch (513:21): [True: 0, False: 0]
  ------------------
  514|      0|                {
  515|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*f", precision_, val);
  516|      0|                    if (length < 0)
  ------------------
  |  Branch (516:25): [True: 0, False: 0]
  ------------------
  517|      0|                    {
  518|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  519|      0|                    }
  520|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  521|      0|                }
  522|      0|                else
  523|      0|                {
  524|      0|                    if (!dtoa_fixed(val, decimal_point_, result))
  ------------------
  |  Branch (524:25): [True: 0, False: 0]
  ------------------
  525|      0|                    {
  526|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  527|      0|                    }
  528|      0|                }
  529|      0|            }
  530|      0|            break;
  531|      0|        case float_chars_format::scientific:
  ------------------
  |  Branch (531:9): [True: 0, False: 1.00k]
  ------------------
  532|      0|            {
  533|      0|                if (precision_ > 0)
  ------------------
  |  Branch (533:21): [True: 0, False: 0]
  ------------------
  534|      0|                {
  535|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*e", precision_, val);
  536|      0|                    if (length < 0)
  ------------------
  |  Branch (536:25): [True: 0, False: 0]
  ------------------
  537|      0|                    {
  538|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  539|      0|                    }
  540|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  541|      0|                }
  542|      0|                else
  543|      0|                {
  544|      0|                    if (!dtoa_scientific(val, decimal_point_, result))
  ------------------
  |  Branch (544:25): [True: 0, False: 0]
  ------------------
  545|      0|                    {
  546|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  547|      0|                    }
  548|      0|                }
  549|      0|            }
  550|      0|            break;
  551|  1.00k|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 1.00k, False: 0]
  ------------------
  552|  1.00k|            {
  553|  1.00k|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 1.00k]
  ------------------
  554|      0|                {
  555|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*g", precision_, val);
  556|      0|                    if (length < 0)
  ------------------
  |  Branch (556:25): [True: 0, False: 0]
  ------------------
  557|      0|                    {
  558|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  559|      0|                    }
  560|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  561|      0|                }
  562|  1.00k|                else
  563|  1.00k|                {
  564|  1.00k|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 1.00k]
  ------------------
  565|      0|                    {
  566|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  567|      0|                    }
  568|  1.00k|                }             
  569|  1.00k|                break;
  570|  1.00k|            }
  571|  1.00k|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 1.00k]
  ------------------
  572|      0|                JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  573|      0|                break;
  574|  1.00k|        }
  575|  1.00k|        return count;
  576|  1.00k|    }
_ZN8jsoncons11dump_bufferINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKcmcRT_:
  243|    193|{
  244|    193|    const char *sbeg = buffer;
  245|    193|    const char *send = sbeg + length;
  246|       |
  247|    193|    if (sbeg != send)
  ------------------
  |  Branch (247:9): [True: 193, False: 0]
  ------------------
  248|    193|    {
  249|    193|        bool needs_dot = true;
  250|  2.57k|        for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (250:36): [True: 2.38k, False: 193]
  ------------------
  251|  2.38k|        {
  252|  2.38k|            switch (*q)
  253|  2.38k|            {
  254|     10|            case '-':
  ------------------
  |  Branch (254:13): [True: 10, False: 2.37k]
  ------------------
  255|    255|            case '0':
  ------------------
  |  Branch (255:13): [True: 245, False: 2.13k]
  ------------------
  256|    466|            case '1':
  ------------------
  |  Branch (256:13): [True: 211, False: 2.17k]
  ------------------
  257|    655|            case '2':
  ------------------
  |  Branch (257:13): [True: 189, False: 2.19k]
  ------------------
  258|    877|            case '3':
  ------------------
  |  Branch (258:13): [True: 222, False: 2.16k]
  ------------------
  259|  1.08k|            case '4':
  ------------------
  |  Branch (259:13): [True: 211, False: 2.17k]
  ------------------
  260|  1.29k|            case '5':
  ------------------
  |  Branch (260:13): [True: 209, False: 2.17k]
  ------------------
  261|  1.48k|            case '6':
  ------------------
  |  Branch (261:13): [True: 188, False: 2.19k]
  ------------------
  262|  1.62k|            case '7':
  ------------------
  |  Branch (262:13): [True: 137, False: 2.24k]
  ------------------
  263|  1.85k|            case '8':
  ------------------
  |  Branch (263:13): [True: 229, False: 2.15k]
  ------------------
  264|  2.08k|            case '9':
  ------------------
  |  Branch (264:13): [True: 238, False: 2.14k]
  ------------------
  265|  2.14k|            case '+':
  ------------------
  |  Branch (265:13): [True: 52, False: 2.33k]
  ------------------
  266|  2.14k|                result.push_back(*q);
  267|  2.14k|                break;
  268|     59|            case 'e':
  ------------------
  |  Branch (268:13): [True: 59, False: 2.32k]
  ------------------
  269|     59|            case 'E':
  ------------------
  |  Branch (269:13): [True: 0, False: 2.38k]
  ------------------
  270|     59|                result.push_back('e');
  271|     59|                needs_dot = false;
  272|     59|                break;
  273|    183|            default:
  ------------------
  |  Branch (273:13): [True: 183, False: 2.20k]
  ------------------
  274|    183|                if (*q == decimal_point)
  ------------------
  |  Branch (274:21): [True: 183, False: 0]
  ------------------
  275|    183|                {
  276|    183|                    needs_dot = false;
  277|    183|                    result.push_back('.');
  278|    183|                }
  279|    183|                break;
  280|  2.38k|            }
  281|  2.38k|        }
  282|    193|        if (needs_dot)
  ------------------
  |  Branch (282:13): [True: 3, False: 190]
  ------------------
  283|      3|        {
  284|      3|            result.push_back('.');
  285|      3|            result.push_back('0');
  286|      3|        }
  287|    193|    }
  288|    193|}
_ZN8jsoncons15prettify_stringINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKcmiiiRT_:
  171|    806|{
  172|    806|    int nb_digits = (int)length;
  173|    806|    int offset;
  174|       |    /* v = buffer * 10^k
  175|       |       kk is such that 10^(kk-1) <= v < 10^kk
  176|       |       this way kk gives the position of the decimal point.
  177|       |    */
  178|    806|    int kk = nb_digits + k;
  179|       |
  180|    806|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 172, False: 634]
  |  Branch (180:28): [True: 57, False: 115]
  ------------------
  181|     57|    {
  182|       |        /* the first digits are already in. Add some 0s and call it a day. */
  183|       |        /* the max_exp is a personal choice. Only 16 digits could possibly be relevant.
  184|       |         * Basically we want to print 12340000000 rather than 1234.0e7 or 1.234e10 */
  185|    181|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 124, False: 57]
  ------------------
  186|    124|        {
  187|    124|            result.push_back(buffer[i]);
  188|    124|        }
  189|    319|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 262, False: 57]
  ------------------
  190|    262|        {
  191|    262|            result.push_back('0');
  192|    262|        }
  193|     57|        result.push_back('.');
  194|     57|        result.push_back('0');
  195|     57|    } 
  196|    749|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 334, False: 415]
  |  Branch (196:24): [True: 219, False: 115]
  ------------------
  197|    219|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|  1.28k|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 1.06k, False: 219]
  ------------------
  200|  1.06k|        {
  201|  1.06k|            result.push_back(buffer[i]);
  202|  1.06k|        }
  203|    219|        result.push_back('.');
  204|  1.26k|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 1.04k, False: 219]
  ------------------
  205|  1.04k|        {
  206|  1.04k|            result.push_back(buffer[i]);
  207|  1.04k|        }
  208|    219|    } 
  209|    530|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 139, False: 391]
  |  Branch (209:30): [True: 24, False: 115]
  ------------------
  210|     24|    {
  211|     24|        offset = 2 - kk;
  212|       |
  213|     24|        result.push_back('0');
  214|     24|        result.push_back('.');
  215|     39|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 15, False: 24]
  ------------------
  216|     15|            result.push_back('0');
  217|    104|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 80, False: 24]
  ------------------
  218|     80|        {
  219|     80|            result.push_back(buffer[i]);
  220|     80|        }
  221|     24|    } 
  222|    506|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 174, False: 332]
  ------------------
  223|    174|    {
  224|    174|        result.push_back(buffer[0]);
  225|    174|        result.push_back('e');
  226|    174|        fill_exponent(kk - 1, result);
  227|    174|    } 
  228|    332|    else
  229|    332|    {
  230|    332|        result.push_back(buffer[0]);
  231|    332|        result.push_back('.');
  232|  1.81k|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 1.48k, False: 332]
  ------------------
  233|  1.48k|        {
  234|  1.48k|            result.push_back(buffer[i]);
  235|  1.48k|        }
  236|    332|        result.push_back('e');
  237|    332|        fill_exponent(kk - 1, result);
  238|    332|    }
  239|    806|}
_ZN8jsoncons13fill_exponentINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEviRT_:
  136|    506|{
  137|    506|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 391, False: 115]
  ------------------
  138|    391|    {
  139|    391|        result.push_back('-');
  140|    391|        K = -K;
  141|    391|    }
  142|    115|    else
  143|    115|    {
  144|    115|        result.push_back('+'); // compatibility with sprintf
  145|    115|    }
  146|       |
  147|    506|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 9, False: 497]
  ------------------
  148|      9|    {
  149|      9|        result.push_back('0'); // compatibility with sprintf
  150|      9|        result.push_back((char)('0' + K));
  151|      9|    }
  152|    497|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 85, False: 412]
  ------------------
  153|     85|    {
  154|     85|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|     85|        result.push_back((char)('0' + K));
  156|     85|    }
  157|    412|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 412, False: 0]
  ------------------
  158|    412|    {
  159|    412|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|    412|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|    412|        result.push_back((char)('0' + K));
  162|    412|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|    506|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_:
  475|  1.00k|{
  476|  1.00k|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|  1.00k|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_NS1_17integral_constantIbLb1EEE:
  366|  1.00k|{
  367|  1.00k|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 10, False: 999]
  ------------------
  368|     10|    {
  369|     10|        result.push_back('0');
  370|     10|        result.push_back('.');
  371|     10|        result.push_back('0');
  372|     10|        return true;
  373|     10|    }
  374|       |
  375|    999|    int length = 0;
  376|    999|    int k;
  377|       |
  378|    999|    char buffer[100];
  379|       |
  380|    999|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 21, False: 978]
  ------------------
  381|    999|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 806, False: 193]
  ------------------
  382|    806|    {
  383|    806|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 18, False: 788]
  ------------------
  384|     18|        {
  385|     18|            result.push_back('-');
  386|     18|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|    806|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|    806|        return true;
  391|    806|    }
  392|    193|    else
  393|    193|    {
  394|    193|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|    193|    }
  396|    999|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_NS1_17integral_constantIbLb0EEE:
  329|    193|{
  330|    193|    if (val == 0)
  ------------------
  |  Branch (330:9): [True: 0, False: 193]
  ------------------
  331|      0|    {
  332|      0|        result.push_back('0');
  333|      0|        result.push_back('.');
  334|      0|        result.push_back('0');
  335|      0|        return true;
  336|      0|    }
  337|       |
  338|    193|    char buffer[100];
  339|    193|    int precision = std::numeric_limits<double>::digits10;
  340|    193|    int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  341|    193|    if (length < 0)
  ------------------
  |  Branch (341:9): [True: 0, False: 193]
  ------------------
  342|      0|    {
  343|      0|        return false;
  344|      0|    }
  345|    193|    double x{0};
  346|    193|    auto res = decstr_to_double(buffer, length, x);
  347|    193|    if (res.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (347:9): [True: 0, False: 193]
  ------------------
  348|      0|    {
  349|      0|        return false;
  350|      0|    }
  351|    193|    if (x != val)
  ------------------
  |  Branch (351:9): [True: 54, False: 139]
  ------------------
  352|     54|    {
  353|     54|        const int precision2 = std::numeric_limits<double>::max_digits10;
  354|     54|        length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  355|     54|        if (length < 0)
  ------------------
  |  Branch (355:13): [True: 0, False: 54]
  ------------------
  356|      0|        {
  357|      0|            return false;
  358|      0|        }
  359|     54|    }
  360|    193|    dump_buffer(buffer, length, decimal_point, result);
  361|    193|    return true;
  362|    193|}