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

_ZN8jsoncons15make_error_codeENS_9conv_errcE:
  177|      5|{
  178|      5|    return std::error_code(static_cast<int>(result),conv_error_category());
  179|      5|}
_ZN8jsoncons19conv_error_categoryEv:
  170|      5|{
  171|      5|  static detail::conv_error_category_impl instance;
  172|      5|  return instance;
  173|      5|}

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

_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|    412|{
   17|    412|    return T(std::forward<Args>(args)..., alloc);
   18|    412|}
_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.41k|{
   17|  1.41k|    return T(std::forward<Args>(args)..., alloc);
   18|  1.41k|}
_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|      8|{
   17|      8|    return T(std::forward<Args>(args)..., alloc);
   18|      8|}

_ZN8jsoncons6detail4spanIKcLm18446744073709551615EEC2Ev:
   58|  4.05k|        {
   59|  4.05k|        }
_ZN8jsoncons6detail4spanIKcLm18446744073709551615EEC2EPS2_m:
   61|  13.4k|            : data_(data), size_(size)
   62|  13.4k|        {
   63|  13.4k|        }
_ZNK8jsoncons6detail4spanIKcLm18446744073709551615EE4sizeEv:
  116|  24.2k|        {
  117|  24.2k|            return size_;
  118|  24.2k|        }
_ZNK8jsoncons6detail4spanIKcLm18446744073709551615EE4dataEv:
  111|  13.4k|        {
  112|  13.4k|            return data_;
  113|  13.4k|        }

_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_ED2Ev:
  257|  3.21k|    ~basic_json_cursor() = default;
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E9read_nextERNS_18basic_json_visitorIcEERNS2_10error_codeE:
  529|  5.04k|    {
  530|  5.04k|        parser_.restart();
  531|  14.5k|        while (!parser_.stopped())
  ------------------
  |  Branch (531:16): [True: 10.8k, False: 3.66k]
  ------------------
  532|  10.8k|        {
  533|  10.8k|            if (parser_.source_exhausted())
  ------------------
  |  Branch (533:17): [True: 10.7k, False: 65]
  ------------------
  534|  10.7k|            {
  535|  10.7k|                auto s = source_.read_chunk(ec);
  536|  10.7k|                if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  10.7k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 18, False: 10.7k]
  |  |  ------------------
  ------------------
  537|  10.7k|                if (s.size() > 0)
  ------------------
  |  Branch (537:21): [True: 6.71k, False: 4.05k]
  ------------------
  538|  6.71k|                {
  539|  6.71k|                    parser_.update(s.data(),s.size());
  540|  6.71k|                    if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  6.71k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 6.71k]
  |  |  ------------------
  ------------------
  541|  6.71k|                }
  542|  10.7k|            }
  543|  10.8k|            bool eof = parser_.source_exhausted() && source_.eof();
  ------------------
  |  Branch (543:24): [True: 4.05k, False: 6.77k]
  |  Branch (543:54): [True: 4.05k, False: 0]
  ------------------
  544|  10.8k|            parser_.parse_some(visitor, ec);
  545|  10.8k|            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  10.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.33k, False: 9.50k]
  |  |  ------------------
  ------------------
  546|  9.50k|            if (eof)
  ------------------
  |  Branch (546:17): [True: 3.44k, False: 6.06k]
  ------------------
  547|  3.44k|            {
  548|  3.44k|                if (parser_.enter())
  ------------------
  |  Branch (548:21): [True: 24, False: 3.41k]
  ------------------
  549|     24|                {
  550|     24|                    done_ = true;
  551|     24|                    break;
  552|     24|                }
  553|  3.41k|                else if (!parser_.accept())
  ------------------
  |  Branch (553:26): [True: 10, False: 3.40k]
  ------------------
  554|     10|                {
  555|     10|                    ec = json_errc::unexpected_eof;
  556|     10|                    return;
  557|     10|                }
  558|  3.44k|            }
  559|  9.50k|        }
  560|  5.04k|    }
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_EC1IRNS2_19basic_istringstreamIcNS2_11char_traitsIcEES4_EEEEOT_RNS2_10error_codeE:
  134|  3.21k|        : basic_json_cursor(std::allocator_arg, Allocator(), 
  135|  3.21k|              std::forward<Sourceable>(source),
  136|  3.21k|              basic_json_decode_options<CharT>(),
  137|  3.21k|              ec)
  138|  3.21k|    {
  139|  3.21k|    }
_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.21k|       : source_(std::forward<Sourceable>(source)),
  204|  3.21k|         parser_(options, alloc)
  205|  3.21k|    {
  206|  3.21k|        parser_.cursor_mode(true);
  207|       |
  208|  3.21k|        if (!read_done())
  ------------------
  |  Branch (208:13): [True: 3.21k, False: 0]
  ------------------
  209|  3.21k|        {
  210|  3.21k|            std::error_code local_ec;
  211|  3.21k|            read_next(local_ec);
  212|  3.21k|            if (local_ec)
  ------------------
  |  Branch (212:17): [True: 1.36k, False: 1.85k]
  ------------------
  213|  1.36k|            {
  214|  1.36k|                if (local_ec == json_errc::unexpected_eof)
  ------------------
  |  Branch (214:21): [True: 625, False: 735]
  ------------------
  215|    625|                {
  216|    625|                    done_ = true;
  217|    625|                }
  218|    735|                else
  219|    735|                {
  220|    735|                    ec = local_ec;
  221|    735|                }
  222|  1.36k|            }
  223|  3.21k|        }
  224|  3.21k|    }
_ZNK8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E9read_doneEv:
  470|  3.21k|    {
  471|  3.21k|        return parser_.done() || done_;
  ------------------
  |  Branch (471:16): [True: 0, False: 3.21k]
  |  Branch (471:34): [True: 0, False: 3.21k]
  ------------------
  472|  3.21k|    }
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E9read_nextERNS2_10error_codeE:
  524|  5.04k|    {
  525|  5.04k|        read_next(cursor_visitor_, ec);
  526|  5.04k|    }
_ZNK8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E4doneEv:
  336|  5.05k|    {
  337|  5.05k|        return parser_.done() || done_;
  ------------------
  |  Branch (337:16): [True: 1.83k, False: 3.22k]
  |  Branch (337:34): [True: 649, False: 2.57k]
  ------------------
  338|  5.05k|    }
_ZNK8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E7currentEv:
  341|  1.83k|    {
  342|  1.83k|        return cursor_visitor_.event();
  343|  1.83k|    }
_ZN8jsoncons17basic_json_cursorIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E4nextERNS2_10error_codeE:
  391|  1.83k|    {
  392|  1.83k|        read_next(ec);
  393|  1.83k|    }

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

_ZN8jsoncons25basic_json_decode_optionsIcEC1Ev:
  266|  3.21k|        : err_handler_(default_json_parsing())
  267|  3.21k|    {
  268|  3.21k|    }
_ZN8jsoncons25basic_json_options_commonIcEC2Ev:
  106|  3.21k|        enable_nan_to_num_(false),
  107|  3.21k|        enable_inf_to_num_(false),
  108|  3.21k|        enable_neginf_to_num_(false),
  109|  3.21k|        enable_nan_to_str_(false),
  110|  3.21k|        enable_inf_to_str_(false),
  111|  3.21k|        enable_neginf_to_str_(false),
  112|  3.21k|        enable_str_to_nan_(false),
  113|  3.21k|        enable_str_to_inf_(false),
  114|  3.21k|        enable_str_to_neginf_(false),
  115|  3.21k|        max_nesting_depth_(1024)
  116|  3.21k|    {}
_ZN8jsoncons20default_json_parsingclENS_9json_errcERKNS_11ser_contextE:
   48|  41.4k|    {
   49|  41.4k|        return ec == json_errc::illegal_comment;
   50|  41.4k|    }
_ZN8jsoncons25basic_json_options_commonIcED2Ev:
  118|  3.21k|    virtual ~basic_json_options_common() = default;
_ZNK8jsoncons25basic_json_options_commonIcE17max_nesting_depthEv:
  245|  6.43k|    {
  246|  6.43k|        return max_nesting_depth_;
  247|  6.43k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE20allow_trailing_commaEv:
  300|  3.21k|    {
  301|  3.21k|        return allow_trailing_comma_;
  302|  3.21k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE14allow_commentsEv:
  295|  3.21k|    {
  296|  3.21k|        return allow_comments_;
  297|  3.21k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE15lossless_numberEv:
  286|  3.21k|    {
  287|  3.21k|        return lossless_number_;
  288|  3.21k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE15lossless_bignumEv:
  290|  3.21k|    {
  291|  3.21k|        return lossless_bignum_;
  292|  3.21k|    }
_ZNK8jsoncons25basic_json_options_commonIcE17enable_str_to_infEv:
  158|  3.21k|    {
  159|  3.21k|        return enable_str_to_inf_;
  160|  3.21k|    }
_ZNK8jsoncons25basic_json_options_commonIcE20enable_str_to_neginfEv:
  168|  3.21k|    {
  169|  3.21k|        return enable_str_to_neginf_ || enable_str_to_inf_;
  ------------------
  |  Branch (169:16): [True: 0, False: 3.21k]
  |  Branch (169:41): [True: 0, False: 3.21k]
  ------------------
  170|  3.21k|    }
_ZNK8jsoncons25basic_json_options_commonIcE17enable_str_to_nanEv:
  148|  3.21k|    {
  149|  3.21k|        return enable_str_to_nan_;
  150|  3.21k|    }
_ZNK8jsoncons25basic_json_options_commonIcE10inf_to_strEv:
  221|  3.21k|    {
  222|  3.21k|        return inf_to_str_;
  223|  3.21k|    }
_ZNK8jsoncons25basic_json_options_commonIcE13neginf_to_strEv:
  226|  3.21k|    {
  227|  3.21k|        if (enable_neginf_to_str_)
  ------------------
  |  Branch (227:13): [True: 0, False: 3.21k]
  ------------------
  228|      0|        {
  229|      0|            return neginf_to_str_;
  230|      0|        }
  231|  3.21k|        else if (enable_inf_to_str_)
  ------------------
  |  Branch (231:18): [True: 0, False: 3.21k]
  ------------------
  232|      0|        {
  233|      0|            string_type s;
  234|      0|            s.push_back('-');
  235|      0|            s.append(inf_to_str_);
  236|      0|            return s;
  237|      0|        }
  238|  3.21k|        else
  239|  3.21k|        {
  240|  3.21k|            return neginf_to_str_; // empty string
  241|  3.21k|        }
  242|  3.21k|    }
_ZNK8jsoncons25basic_json_options_commonIcE10nan_to_strEv:
  216|  3.21k|    {
  217|  3.21k|        return nan_to_str_;
  218|  3.21k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE11err_handlerEv:
  306|  3.21k|    {
  307|  3.21k|        return err_handler_;
  308|  3.21k|    }

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

_ZN8jsoncons19typed_array_visitorD2Ev:
   33|  3.21k|        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_RETURN;
  ------------------
  |  |  276|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  321|      3|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|  1.83k|        {
  109|  1.83k|            visit_flush();
  110|  1.83k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|    250|        {
  424|    250|            visit_int64(value, tag, context, ec);
  425|    250|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    250|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  426|    250|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  383|    412|        {
  384|    412|            visit_string(value, tag, context, ec);
  385|    412|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    412|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  386|    412|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|    934|        {
  442|    934|            visit_double(value, tag, context, ec);
  443|    934|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    934|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  444|    934|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|    226|        {
  415|    226|            visit_uint64(value, tag, context, ec);
  416|    226|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    226|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  417|    226|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  339|      2|        {
  340|      2|            visit_begin_array(tag, context, ec);
  341|      2|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  342|      2|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  374|      5|        {
  375|      5|            visit_bool(value, tag, context, ec);
  376|      5|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      5|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  377|      5|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  365|      3|        {
  366|      3|            visit_null(tag, context, ec);
  367|      3|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  368|      3|        }
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|  3.21k|        basic_json_visitor() = default;

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

_ZN8jsoncons13stream_sourceIcNSt3__19allocatorIcEEED2Ev:
  193|  3.21k|    {
  194|  3.21k|        if (chunk_)
  ------------------
  |  Branch (194:13): [True: 3.21k, False: 0]
  ------------------
  195|  3.21k|        {
  196|  3.21k|            std::allocator_traits<char_allocator_type>::deallocate(alloc_, chunk_, chunk_size_);
  197|  3.21k|        }
  198|  3.21k|    }
_ZNK8jsoncons13stream_sourceIcNSt3__19allocatorIcEEE3eofEv:
  271|  14.8k|    {
  272|  14.8k|        return remaining_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:16): [True: 14.8k, False: 0]
  |  Branch (272:35): [True: 8.09k, False: 6.74k]
  ------------------
  273|  14.8k|    }
_ZN8jsoncons13stream_sourceIcNSt3__19allocatorIcEEE10read_chunkEv:
  330|  6.74k|    {
  331|  6.74k|        if (remaining_ == 0)
  ------------------
  |  Branch (331:13): [True: 6.74k, False: 0]
  ------------------
  332|  6.74k|        {
  333|  6.74k|            data_end_ = chunk_;
  334|  6.74k|            remaining_ = fill_buffer(chunk_, chunk_size_);
  335|  6.74k|        }
  336|  6.74k|        const value_type* data = data_end_;
  337|  6.74k|        std::size_t length = remaining_;
  338|  6.74k|        data_end_ += remaining_;
  339|  6.74k|        position_ += remaining_;
  340|  6.74k|        remaining_ = 0;
  341|       |
  342|  6.74k|        return span<const value_type>(data, length);
  343|  6.74k|    }
_ZN8jsoncons13stream_sourceIcNSt3__19allocatorIcEEE11fill_bufferEPcm:
  442|  6.74k|    {
  443|  6.74k|        if (stream_ptr_->eof())
  ------------------
  |  Branch (443:13): [True: 0, False: 6.74k]
  ------------------
  444|      0|        {
  445|      0|            return 0;
  446|      0|        }
  447|       |
  448|  6.74k|        JSONCONS_TRY
  ------------------
  |  |   37|  6.74k|    #define JSONCONS_TRY try
  ------------------
  449|  6.74k|        {
  450|  6.74k|            std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(chunk), chunk_size);
  451|  6.74k|            std::size_t length = static_cast<std::size_t>(count);
  452|       |
  453|  6.74k|            if (length < chunk_size)
  ------------------
  |  Branch (453:17): [True: 3.20k, False: 3.54k]
  ------------------
  454|  3.20k|            {
  455|  3.20k|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  456|  3.20k|            }
  457|  6.74k|            return length;
  458|  6.74k|        }
  459|  6.74k|        JSONCONS_CATCH(const std::exception&)     
  460|  6.74k|        {
  461|      0|            stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  462|      0|            return 0;
  463|      0|        }
  464|  6.74k|    }
_ZN8jsoncons13stream_sourceIcNSt3__19allocatorIcEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  176|  3.21k|        : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  177|  3.21k|          chunk_size_(default_max_chunk_size)
  178|  3.21k|    {
  179|  3.21k|        chunk_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, chunk_size_);
  180|  3.21k|        data_end_ = chunk_;
  181|  3.21k|    }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   57|  3.21k|      : std::basic_istream<CharT>(&nb_)
   58|  3.21k|    {
   59|  3.21k|    }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   43|  3.21k|        null_buffer() = default;

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

_ZN8jsoncons17basic_staj_cursorIcED2Ev:
  558|  3.21k|    virtual ~basic_staj_cursor() = default;
_ZNK8jsoncons18basic_staj_visitorIcE5eventEv:
  418|  1.83k|    {
  419|  1.83k|        return event_;
  420|  1.83k|    }
_ZN8jsoncons18basic_staj_visitorIcEC2Ev:
  406|  3.21k|        : event_(staj_events::null_value)
  407|  3.21k|    {
  408|  3.21k|    }
_ZN8jsoncons18basic_staj_visitorIcE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  515|    226|    {
  516|    226|        event_ = staj_event_type(value, tag);
  517|    226|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    226|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  518|    226|    }
_ZN8jsoncons18basic_staj_visitorIcE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  524|    250|    {
  525|    250|        event_ = staj_event_type(value, tag);
  526|    250|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    250|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  527|    250|    }
_ZN8jsoncons18basic_staj_visitorIcE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  542|    934|    {
  543|    934|        event_ = staj_event_type(value, tag);
  544|    934|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    934|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  545|    934|    }
_ZN8jsoncons18basic_staj_visitorIcE11visit_flushEv:
  548|  1.83k|    {
  549|  1.83k|    }
_ZN8jsoncons18basic_staj_visitorIcE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  434|      3|    {
  435|      3|        event_ = staj_event_type(staj_events::begin_object, tag);
  436|      3|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  437|      3|    }
_ZN8jsoncons18basic_staj_visitorIcE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  452|      2|    {
  453|      2|        event_ = staj_event_type(staj_events::begin_array, tag);
  454|      2|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  455|      2|    }
_ZN8jsoncons18basic_staj_visitorIcE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  476|      3|    {
  477|      3|        event_ = staj_event_type(staj_events::null_value, tag);
  478|      3|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  479|      3|    }
_ZN8jsoncons18basic_staj_visitorIcE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  482|      5|    {
  483|      5|        event_ = staj_event_type(value, tag);
  484|      5|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      5|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  485|      5|    }
_ZN8jsoncons18basic_staj_visitorIcE12visit_stringERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  488|    412|    {
  489|    412|        event_ = staj_event_type(s, staj_events::string_value, tag);
  490|    412|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    412|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  491|    412|    }

_ZN8jsonconsanENS_11staj_eventsES0_:
   67|  1.83k|{ return (staj_events)((uint64_t)lhs & (uint64_t)rhs); }
_ZNK8jsoncons16basic_staj_eventIcE11storage_tagEv:
  213|  1.83k|    {
  214|  1.83k|        static constexpr staj_events mask = ~staj_events::key_flag;
  215|  1.83k|        return event_flags_ & mask;
  216|  1.83k|    }
_ZN8jsoncons16basic_staj_eventIcEC2ENS_11staj_eventsENS_12semantic_tagES2_:
  223|  3.22k|        : event_flags_(event_type | key_flag), tag_(tag), value_()
  224|  3.22k|    {
  225|  3.22k|    }
_ZN8jsonconsorENS_11staj_eventsES0_:
   62|  5.05k|{ return (staj_events)((uint64_t)lhs | (uint64_t)rhs); }
_ZN8jsoncons16basic_staj_eventIcEC2EmNS_12semantic_tagENS_11staj_eventsE:
  250|    226|        : event_flags_(staj_events::uint64_value | key_flag), tag_(tag)
  251|    226|    {
  252|    226|        value_.uint64_value_ = value;
  253|    226|    }
_ZN8jsoncons16basic_staj_eventIcEC2ElNS_12semantic_tagENS_11staj_eventsE:
  243|    250|        : event_flags_(staj_events::int64_value | key_flag), tag_(tag)
  244|    250|    {
  245|    250|        value_.int64_value_ = value;
  246|    250|    }
_ZN8jsoncons16basic_staj_eventIcEC2EdNS_12semantic_tagENS_11staj_eventsE:
  264|    934|        : event_flags_(staj_events::double_value | key_flag), tag_(tag)
  265|    934|    {
  266|    934|        value_.double_value_ = value;
  267|    934|    }
_ZN8jsoncons16basic_staj_eventIcEC2ERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_11staj_eventsENS_12semantic_tagES9_:
  273|    412|        : event_flags_(event_type | key_flag), tag_(tag), length_(s.length())
  274|    412|    {
  275|    412|        value_.string_data_ = s.data();
  276|    412|    }
_ZN8jsoncons16basic_staj_eventIcEC2EbNS_12semantic_tagENS_11staj_eventsE:
  236|      5|        : event_flags_(staj_events::bool_value | key_flag), tag_(tag)
  237|      5|    {
  238|      5|        value_.bool_value_ = value;
  239|      5|    }
_ZNK8jsoncons16basic_staj_eventIcE3getINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEET_RNS3_10error_codeE:
  317|  1.83k|    {
  318|  1.83k|        return get_<T>(std::allocator<char>{}, ec);
  319|  1.83k|    }
_ZNK8jsoncons16basic_staj_eventIcE4get_INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES8_cEENS3_9enable_ifIXaasr10ext_traits9is_stringIT_EE5valuesr3std7is_sameINSB_10value_typeET1_EE5valueESB_E4typeET0_RNS3_10error_codeE:
  324|  1.83k|    {
  325|  1.83k|        constexpr const char_type* true_literal = JSONCONS_CSTRING_CONSTANT(char_type,"true"); 
  ------------------
  |  |  262|  1.83k|#define JSONCONS_CSTRING_CONSTANT(CharT, Str) jsoncons::cstring_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  260|  1.83k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  257|  1.83k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  326|  1.83k|        constexpr const char_type* false_literal = JSONCONS_CSTRING_CONSTANT(char_type,"false"); 
  ------------------
  |  |  262|  1.83k|#define JSONCONS_CSTRING_CONSTANT(CharT, Str) jsoncons::cstring_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  260|  1.83k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  257|  1.83k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  327|  1.83k|        constexpr const char_type* null_literal = JSONCONS_CSTRING_CONSTANT(char_type,"null"); 
  ------------------
  |  |  262|  1.83k|#define JSONCONS_CSTRING_CONSTANT(CharT, Str) jsoncons::cstring_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  260|  1.83k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  257|  1.83k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  328|       |
  329|  1.83k|        switch (storage_tag())
  330|  1.83k|        {
  331|    412|            case staj_events::string_value:
  ------------------
  |  Branch (331:13): [True: 412, False: 1.42k]
  ------------------
  332|    412|            {
  333|    412|                return jsoncons::make_obj_using_allocator<T>(alloc, value_.string_data_, length_);
  334|      0|            }
  335|      0|            case staj_events::byte_string_value:
  ------------------
  |  Branch (335:13): [True: 0, False: 1.83k]
  ------------------
  336|      0|            {
  337|      0|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  338|      0|                bytes_to_string(value_.byte_string_data_, value_.byte_string_data_+length_, tag(), s);
  339|      0|                return s;
  340|      0|            }
  341|    226|            case staj_events::uint64_value:
  ------------------
  |  Branch (341:13): [True: 226, False: 1.60k]
  ------------------
  342|    226|            {
  343|    226|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  344|    226|                jsoncons::from_integer(value_.uint64_value_, s);
  345|    226|                return s;
  346|      0|            }
  347|    250|            case staj_events::int64_value:
  ------------------
  |  Branch (347:13): [True: 250, False: 1.58k]
  ------------------
  348|    250|            {
  349|    250|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  350|    250|                jsoncons::from_integer(value_.int64_value_, s);
  351|    250|                return s;
  352|      0|            }
  353|      0|            case staj_events::half_value:
  ------------------
  |  Branch (353:13): [True: 0, False: 1.83k]
  ------------------
  354|      0|            {
  355|      0|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  356|      0|                jsoncons::write_double f{float_chars_format::general,0};
  357|      0|                double x = binary::decode_half(value_.half_value_);
  358|      0|                f(x, s);
  359|      0|                return s;
  360|      0|            }
  361|    934|            case staj_events::double_value:
  ------------------
  |  Branch (361:13): [True: 934, False: 901]
  ------------------
  362|    934|            {
  363|    934|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  364|    934|                jsoncons::write_double f{float_chars_format::general,0};
  365|    934|                f(value_.double_value_, s);
  366|    934|                return s;
  367|      0|            }
  368|      5|            case staj_events::bool_value:
  ------------------
  |  Branch (368:13): [True: 5, False: 1.83k]
  ------------------
  369|      5|            {
  370|      5|                return jsoncons::make_obj_using_allocator<T>(alloc, value_.bool_value_ ? true_literal : false_literal);
  ------------------
  |  Branch (370:69): [True: 3, False: 2]
  ------------------
  371|      0|            }
  372|      3|            case staj_events::null_value:
  ------------------
  |  Branch (372:13): [True: 3, False: 1.83k]
  ------------------
  373|      3|            {
  374|      3|                return jsoncons::make_obj_using_allocator<T>(alloc, null_literal);
  375|      0|            }
  376|      5|            default:
  ------------------
  |  Branch (376:13): [True: 5, False: 1.83k]
  ------------------
  377|      5|            {
  378|      5|                ec = conv_errc::not_string;
  379|      5|                return T{};
  380|      0|            }
  381|  1.83k|        }
  382|  1.83k|    }

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

_ZN8jsoncons14dec_to_integerIlcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  327|    416|{
  328|    416|    if (length == 0)
  ------------------
  |  Branch (328:9): [True: 0, False: 416]
  ------------------
  329|      0|    {
  330|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  331|      0|    }
  332|       |
  333|    416|    bool sign = *s == '-';
  334|    416|    s += sign;
  335|    416|    length -= sign;
  336|       |
  337|    416|    using U = typename ext_traits::make_unsigned<T>::type;
  338|       |
  339|    416|    U num;
  340|    416|    auto ru = dec_to_integer(s, length, num);
  341|    416|    if (ru.ec != std::errc{})
  ------------------
  |  Branch (341:9): [True: 61, False: 355]
  ------------------
  342|     61|    {
  343|     61|        return to_number_result<CharT>(ru.ptr, ru.ec);
  344|     61|    }
  345|    355|    if (sign)
  ------------------
  |  Branch (345:9): [True: 355, False: 0]
  ------------------
  346|    355|    {
  347|    355|        if (num > static_cast<U>(-((ext_traits::integer_limits<T>::lowest)()+T(1))) + U(1))
  ------------------
  |  Branch (347:13): [True: 105, False: 250]
  ------------------
  348|    105|        {
  349|    105|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  350|    105|        }
  351|    250|        else
  352|    250|        {
  353|    250|            value = static_cast<T>(U(0) - num);
  354|    250|            return to_number_result<CharT>(ru.ptr, std::errc{});
  355|    250|        }
  356|    355|    }
  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|    355|}
_ZN8jsoncons16to_number_resultIcEC2EPKcNSt3__14errcE:
  141|  1.18k|        : ptr(ptr_), ec(ec_)
  142|  1.18k|    {
  143|  1.18k|    }
_ZN8jsoncons14dec_to_integerImcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedntsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  265|    710|{
  266|    710|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|    710|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 710]
  |  |  ------------------
  ------------------
  267|      0|    {
  268|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  269|      0|    }
  270|       |
  271|    710|    static constexpr T max_value = (ext_traits::integer_limits<T>::max)();
  272|    710|    static constexpr T max_value_div_10 = max_value / 10;
  273|       |
  274|    710|    T num = 0;
  275|    710|    const CharT* cur = s;
  276|    710|    const CharT* last = s + length;
  277|    710|    static constexpr std::size_t digits10 = static_cast<std::size_t>(ext_traits::integer_limits<T>::digits10);
  278|    710|    const std::size_t n = (std::min)(digits10, length);
  279|    710|    const CharT* stop = s + n;
  280|       |     
  281|  11.6k|    while (cur < stop)
  ------------------
  |  Branch (281:12): [True: 10.9k, False: 710]
  ------------------
  282|  10.9k|    {
  283|  10.9k|        uint8_t d;
  284|  10.9k|        if (JSONCONS_LIKELY((d = static_cast<uint8_t>(*cur - '0')) <= 9) )
  ------------------
  |  |   77|  10.9k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 10.9k, False: 0]
  |  |  ------------------
  ------------------
  285|  10.9k|        {
  286|  10.9k|            num = static_cast<T>(d) + num*10;
  287|  10.9k|        }
  288|      0|        else
  289|      0|        {
  290|      0|            return to_number_result<CharT>(cur, std::errc::invalid_argument);
  291|      0|        }
  292|  10.9k|        ++cur;
  293|  10.9k|    }
  294|    710|    if (cur == last)
  ------------------
  |  Branch (294:9): [True: 303, False: 407]
  ------------------
  295|    303|    {
  296|    303|        value = num;
  297|    303|        return to_number_result<CharT>(cur, std::errc{});
  298|    303|    }
  299|    407|    if (cur+1 != last)
  ------------------
  |  Branch (299:9): [True: 110, False: 297]
  ------------------
  300|    110|    {
  301|    110|        return to_number_result<CharT>(cur, std::errc::result_out_of_range);
  302|    110|    }
  303|    297|    if (is_digit(*cur))
  ------------------
  |  Branch (303:9): [True: 297, False: 0]
  ------------------
  304|    297|    {
  305|    297|        if (num > max_value_div_10)
  ------------------
  |  Branch (305:13): [True: 16, False: 281]
  ------------------
  306|     16|        {
  307|     16|            return to_number_result<CharT>(cur, std::errc::result_out_of_range);
  308|     16|        }
  309|    281|        uint8_t d = static_cast<uint8_t>(*cur - '0');
  310|    281|        num = num*10;
  311|    281|        if (num > max_value - d)
  ------------------
  |  Branch (311:13): [True: 3, False: 278]
  ------------------
  312|      3|        {
  313|      3|            return to_number_result<CharT>(s, std::errc::result_out_of_range);
  314|      3|        }
  315|    278|        num += d;
  316|    278|        ++cur;
  317|    278|        value = num;
  318|    278|        return to_number_result<CharT>(cur, std::errc{});
  319|    281|    }
  320|       |    
  321|      0|    return to_number_result<CharT>(cur, std::errc::invalid_argument);
  322|    297|}
_ZN8jsoncons8is_digitEc:
   83|  29.4M|constexpr bool is_digit(char d) {
   84|  29.4M|    return is_type(static_cast<uint8_t>(d), (uint8_t)(DIGIT_TYPE_ZERO | DIGIT_TYPE_NONZERO));
   85|  29.4M|}
_ZN8jsoncons7is_typeEhh:
   68|  29.4M|constexpr bool is_type(uint8_t d, uint8_t type) {
   69|  29.4M|    return (digi_table[d] & type) != 0;
   70|  29.4M|}
_ZNK8jsoncons16to_number_resultIcEcvbEv:
  150|  1.70k|    {
  151|  1.70k|        return ec == std::errc{};
  152|  1.70k|    }
_ZN8jsoncons16decstr_to_doubleEPKcmRd:
  866|  1.18k|{
  867|  1.18k|    const char* cur = s+length;
  868|  1.18k|    char *end = nullptr;
  869|  1.18k|    val = strtod(s, &end);
  870|  1.18k|    const char* str_end = end;
  871|  1.18k|    if (JSONCONS_UNLIKELY(end < cur))
  ------------------
  |  |   78|  1.18k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.18k]
  |  |  ------------------
  ------------------
  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.18k|    if (JSONCONS_UNLIKELY(val <= -HUGE_VAL || val >= HUGE_VAL))
  ------------------
  |  |   78|  2.34k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 60, False: 1.12k]
  |  |  |  Branch (78:50): [True: 19, False: 1.16k]
  |  |  |  Branch (78:50): [True: 41, False: 1.12k]
  |  |  ------------------
  ------------------
  888|     60|    {
  889|     60|        return to_number_result<char>{str_end, std::errc::result_out_of_range};
  890|     60|    }
  891|  1.12k|    return to_number_result<char>{str_end};
  892|  1.18k|}
_ZN8jsoncons16to_number_resultIcEC2EPKc:
  137|  1.12k|        : ptr(ptr_), ec(std::errc{})
  138|  1.12k|    {
  139|  1.12k|    }
_ZN8jsoncons16is_nonzero_digitEc:
   78|    469|constexpr bool is_nonzero_digit(char d) {
   79|    469|    return is_type(static_cast<uint8_t>(d), (uint8_t)DIGIT_TYPE_NONZERO);
   80|    469|}
_ZN8jsoncons6is_expEc:
   88|    695|constexpr bool is_exp(char d) {
   89|    695|    return is_type(static_cast<uint8_t>(d), (uint8_t)DIGIT_TYPE_EXP);
   90|    695|}

_ZN8jsoncons14unicode_traits20detect_json_encodingIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m:
  109|  3.21k|    {
  110|  3.21k|        detect_encoding_result<CharT> r = detect_encoding_from_bom(data,length);
  111|  3.21k|        if (r.encoding != encoding_kind::undetected)
  ------------------
  |  Branch (111:13): [True: 48, False: 3.17k]
  ------------------
  112|     48|        {
  113|     48|            return r;
  114|     48|        }
  115|  3.17k|        else if (length < 4)
  ------------------
  |  Branch (115:18): [True: 414, False: 2.75k]
  ------------------
  116|    414|        {
  117|    414|            return detect_encoding_result<CharT>{data,encoding_kind::utf8};
  118|    414|        }
  119|  2.75k|        else if (*data == 0 && *(data+1) == 0 && *(data+2) == 0)
  ------------------
  |  Branch (119:18): [True: 24, False: 2.73k]
  |  Branch (119:32): [True: 15, False: 9]
  |  Branch (119:50): [True: 2, False: 13]
  ------------------
  120|      2|        {
  121|      2|            return detect_encoding_result<CharT>{data,encoding_kind::utf32be};
  122|      2|        }
  123|  2.75k|        else if (*data == 0 && *(data+2) == 0)
  ------------------
  |  Branch (123:18): [True: 22, False: 2.73k]
  |  Branch (123:32): [True: 3, False: 19]
  ------------------
  124|      3|        {
  125|      3|            return detect_encoding_result<CharT>{data,encoding_kind::utf16be};
  126|      3|        }
  127|  2.75k|        else if (*(data+1) == 0 && *(data+2) == 0 && *(data+3) == 0)
  ------------------
  |  Branch (127:18): [True: 28, False: 2.72k]
  |  Branch (127:36): [True: 12, False: 16]
  |  Branch (127:54): [True: 2, False: 10]
  ------------------
  128|      2|        {
  129|      2|            return detect_encoding_result<CharT>{data,encoding_kind::utf32le};
  130|      2|        }
  131|  2.75k|        else if (*(data+1) == 0 && *(data+3) == 0)
  ------------------
  |  Branch (131:18): [True: 26, False: 2.72k]
  |  Branch (131:36): [True: 4, False: 22]
  ------------------
  132|      4|        {
  133|      4|            return detect_encoding_result<CharT>{data,encoding_kind::utf16le};
  134|      4|        }
  135|  2.74k|        else
  136|  2.74k|        {
  137|  2.74k|            return detect_encoding_result<CharT>{data,encoding_kind::utf8};
  138|  2.74k|        }
  139|  3.21k|    }
_ZN8jsoncons14unicode_traits24detect_encoding_from_bomIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m:
   66|  3.21k|    {
   67|  3.21k|        static constexpr uint8_t bom_utf8[] = {0xef,0xbb,0xbf}; 
   68|  3.21k|        static constexpr uint8_t bom_utf16le[] = {0xff,0xfe}; 
   69|  3.21k|        static constexpr uint8_t bom_utf16be[] = {0xfe,0xff}; 
   70|  3.21k|        static constexpr uint8_t bom_utf32le[] = {0xff,0xfe,0x00,0x00}; 
   71|  3.21k|        static constexpr uint8_t bom_utf32be[] = {0x00,0x00,0xfe,0xff}; 
   72|       |
   73|  3.21k|        if (length >= 4 && !memcmp(data,bom_utf32le,4))
  ------------------
  |  Branch (73:13): [True: 2.80k, False: 417]
  |  Branch (73:28): [True: 1, False: 2.80k]
  ------------------
   74|      1|        {
   75|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32le};
   76|      1|        }
   77|  3.21k|        else if (length >= 4 && !memcmp(data,bom_utf32be,4))
  ------------------
  |  Branch (77:18): [True: 2.80k, False: 417]
  |  Branch (77:33): [True: 1, False: 2.80k]
  ------------------
   78|      1|        {
   79|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32be};
   80|      1|        }
   81|  3.21k|        else if (length >= 2 && !memcmp(data,bom_utf16le,2))
  ------------------
  |  Branch (81:18): [True: 3.16k, False: 54]
  |  Branch (81:33): [True: 4, False: 3.15k]
  ------------------
   82|      4|        {
   83|      4|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16le};
   84|      4|        }
   85|  3.21k|        else if (length >= 2 && !memcmp(data,bom_utf16be,2))
  ------------------
  |  Branch (85:18): [True: 3.15k, False: 54]
  |  Branch (85:33): [True: 1, False: 3.15k]
  ------------------
   86|      1|        {
   87|      1|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16be};
   88|      1|        }
   89|  3.21k|        else if (length >= 3 && !memcmp(data,bom_utf8,3))
  ------------------
  |  Branch (89:18): [True: 2.97k, False: 233]
  |  Branch (89:33): [True: 41, False: 2.93k]
  ------------------
   90|     41|        {
   91|     41|            return detect_encoding_result<CharT>{data+3,encoding_kind::utf8};
   92|     41|        }
   93|  3.17k|        else
   94|  3.17k|        {
   95|  3.17k|            return detect_encoding_result<CharT>{data,encoding_kind::undetected};
   96|  3.17k|        }
   97|  3.21k|    }
_ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_14unicode_resultIS4_EEE4typeEPKS4_m:
 1147|    313|    {
 1148|    313|        const uint8_t* it = reinterpret_cast<const uint8_t*>(data);
 1149|    313|        const uint8_t* end = it + length;
 1150|       |
 1151|    313|        unicode_errc  result{};
 1152|   196k|        while (it != end) 
  ------------------
  |  Branch (1152:16): [True: 196k, False: 118]
  ------------------
 1153|   196k|        {
 1154|   196k|            if ((end - it) >= 8)
  ------------------
  |  Branch (1154:17): [True: 196k, False: 256]
  ------------------
 1155|   196k|            {
 1156|  1.26M|                JSONCONS_REPEAT8({if (JSONCONS_LIKELY((*it & 0x80) == 0)) ++it; else goto non_ascii;})
  ------------------
  |  |  281|   392k|#define JSONCONS_REPEAT8(x)  { x x x x x x x x }
  |  |  ------------------
  |  |  |  Branch (281:32): [True: 193k, False: 3.37k]
  |  |  |  Branch (281:34): [True: 185k, False: 7.24k]
  |  |  |  Branch (281:36): [True: 183k, False: 2.36k]
  |  |  |  Branch (281:38): [True: 181k, False: 2.26k]
  |  |  |  Branch (281:40): [True: 180k, False: 814]
  |  |  |  Branch (281:42): [True: 174k, False: 5.85k]
  |  |  |  Branch (281:44): [True: 168k, False: 6.20k]
  |  |  |  Branch (281:46): [True: 160k, False: 7.40k]
  |  |  ------------------
  ------------------
 1157|   160k|                continue;
 1158|  1.26M|            }
 1159|  35.7k|    non_ascii:
 1160|  35.7k|            const std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[*it]) + 1;
 1161|  35.7k|            if (len > (std::size_t)(end - it))
  ------------------
  |  Branch (1161:17): [True: 33, False: 35.7k]
  ------------------
 1162|     33|            {
 1163|     33|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), unicode_errc::source_exhausted};
 1164|     33|            }
 1165|  35.7k|            if ((result=is_legal_utf8(it, len)) != unicode_errc())
  ------------------
  |  Branch (1165:17): [True: 162, False: 35.5k]
  ------------------
 1166|    162|            {
 1167|    162|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1168|    162|            }
 1169|  35.5k|            it += len;
 1170|  35.5k|        }
 1171|    118|        return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1172|    313|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8EPKhm:
  305|  35.7k|    {
  306|  35.7k|        const uint8_t* it = reinterpret_cast<const uint8_t*>(bytes);
  307|  35.7k|        const uint8_t* end = it+length;
  308|       |
  309|  35.7k|        uint8_t byte;
  310|  35.7k|        switch (length) {
  311|     31|        default:
  ------------------
  |  Branch (311:9): [True: 31, False: 35.7k]
  ------------------
  312|     31|            return unicode_errc::over_long_utf8_sequence;
  313|    915|        case 4:
  ------------------
  |  Branch (313:9): [True: 915, False: 34.8k]
  ------------------
  314|    915|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 5, False: 910]
  ------------------
  315|      5|                return unicode_errc::bad_continuation_byte;
  316|    910|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|    910|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  317|  8.03k|        case 3:
  ------------------
  |  Branch (317:9): [True: 7.12k, False: 28.6k]
  ------------------
  318|  8.03k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (318:17): [True: 10, False: 8.02k]
  ------------------
  319|     10|                return unicode_errc::bad_continuation_byte;
  320|  8.02k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|  8.02k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  321|  35.5k|        case 2:
  ------------------
  |  Branch (321:9): [True: 27.5k, False: 8.21k]
  ------------------
  322|  35.5k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (322:17): [True: 45, False: 35.5k]
  ------------------
  323|     45|                return unicode_errc::bad_continuation_byte;
  324|       |
  325|  35.5k|            switch (*it) 
  326|  35.5k|            {
  327|       |                // no fall-through in this inner switch
  328|  6.37k|                case 0xE0: if (byte < 0xA0) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (328:17): [True: 6.37k, False: 29.1k]
  |  Branch (328:32): [True: 7, False: 6.37k]
  ------------------
  329|  6.37k|                case 0xED: if (byte > 0x9F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (329:17): [True: 397, False: 35.1k]
  |  Branch (329:32): [True: 2, False: 395]
  ------------------
  330|    632|                case 0xF0: if (byte < 0x90) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (330:17): [True: 632, False: 34.8k]
  |  Branch (330:32): [True: 5, False: 627]
  ------------------
  331|    627|                case 0xF4: if (byte > 0x8F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (331:17): [True: 255, False: 35.2k]
  |  Branch (331:32): [True: 3, False: 252]
  ------------------
  332|  27.8k|                default:   if (byte < 0x80) return unicode_errc::source_illegal;
  ------------------
  |  Branch (332:17): [True: 27.8k, False: 7.66k]
  |  Branch (332:32): [True: 0, False: 27.8k]
  ------------------
  333|  35.5k|            }
  334|       |
  335|  35.4k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|  35.4k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  336|  35.6k|        case 1:
  ------------------
  |  Branch (336:9): [True: 138, False: 35.5k]
  ------------------
  337|  35.6k|            if (*it >= 0x80 && *it < 0xC2)
  ------------------
  |  Branch (337:17): [True: 35.5k, False: 86]
  |  Branch (337:32): [True: 53, False: 35.4k]
  ------------------
  338|     53|                return unicode_errc::source_illegal;
  339|  35.5k|            break;
  340|  35.7k|        }
  341|  35.5k|        if (*it > 0xF4) 
  ------------------
  |  Branch (341:13): [True: 1, False: 35.5k]
  ------------------
  342|      1|            return unicode_errc::source_illegal;
  343|       |
  344|  35.5k|        return unicode_errc();
  345|  35.5k|    }
_ZN8jsoncons14unicode_traits17is_high_surrogateEj:
  209|   552k|    {
  210|   552k|        return (ch >= sur_high_start && ch <= sur_high_end);
  ------------------
  |  Branch (210:17): [True: 320k, False: 231k]
  |  Branch (210:41): [True: 275k, False: 45.5k]
  ------------------
  211|   552k|    }
_ZN8jsoncons14unicode_traits7convertIjNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_9enable_ifIXaaaasr10ext_traits9is_char32IT_EE5valuesr10ext_traits18is_back_insertableIT0_EE5valuesr10ext_traits8is_char8INSB_10value_typeEEE5valueENS0_14unicode_resultISA_EEE4typeEPKSA_mRSB_NS0_11strict_flagE:
  980|   552k|    {
  981|   552k|        unicode_errc  result{};
  982|   552k|        const CharT* last = data + length;
  983|  1.06M|        while (data < last) 
  ------------------
  |  Branch (983:16): [True: 552k, False: 510k]
  ------------------
  984|   552k|        {
  985|   552k|            uint16_t bytes_to_write = 0;
  986|   552k|            static constexpr uint32_t byteMask = 0xBF;
  987|   552k|            static constexpr uint32_t byteMark = 0x80; 
  988|   552k|            uint32_t ch = *data++;
  989|   552k|            if (flags == strict_flag::strict ) 
  ------------------
  |  Branch (989:17): [True: 552k, False: 0]
  ------------------
  990|   552k|            {
  991|       |                /* UTF-16 surrogate values are illegal in UTF-32 */
  992|   552k|                if (is_surrogate(ch)) 
  ------------------
  |  Branch (992:21): [True: 42.0k, False: 510k]
  ------------------
  993|  42.0k|                {
  994|  42.0k|                    --data; /* return to the illegal value itself */
  995|  42.0k|                    result = unicode_errc::illegal_surrogate_value;
  996|  42.0k|                    break;
  997|  42.0k|                }
  998|   552k|            }
  999|       |            /*
 1000|       |             * Figure out how many bytes the result will require. Turn any
 1001|       |             * illegally large UTF32 things (> Plane 17) into replacement chars.
 1002|       |             */
 1003|   510k|            if (ch < (uint32_t)0x80) {      bytes_to_write = 1;
  ------------------
  |  Branch (1003:17): [True: 1.79k, False: 508k]
  ------------------
 1004|   508k|            } else if (ch < (uint32_t)0x800) {     bytes_to_write = 2;
  ------------------
  |  Branch (1004:24): [True: 5.40k, False: 502k]
  ------------------
 1005|   502k|            } else if (ch < (uint32_t)0x10000) {   bytes_to_write = 3;
  ------------------
  |  Branch (1005:24): [True: 227k, False: 275k]
  ------------------
 1006|   275k|            } else if (ch <= max_legal_utf32) {  bytes_to_write = 4;
  ------------------
  |  Branch (1006:24): [True: 275k, False: 0]
  ------------------
 1007|   275k|            } else {                            
 1008|      0|                bytes_to_write = 3;
 1009|      0|                ch = replacement_char;
 1010|      0|                result = unicode_errc::source_illegal;
 1011|      0|            }
 1012|       |
 1013|   510k|            uint8_t byte1 = 0;
 1014|   510k|            uint8_t byte2 = 0;
 1015|   510k|            uint8_t byte3 = 0;
 1016|   510k|            uint8_t byte4 = 0;
 1017|       |
 1018|   510k|            switch (bytes_to_write) {
  ------------------
  |  Branch (1018:21): [True: 510k, False: 0]
  ------------------
 1019|   275k|            case 4:
  ------------------
  |  Branch (1019:13): [True: 275k, False: 234k]
  ------------------
 1020|   275k|                byte4 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1021|   275k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|   275k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
 1022|   502k|            case 3:
  ------------------
  |  Branch (1022:13): [True: 227k, False: 282k]
  ------------------
 1023|   502k|                byte3 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1024|   502k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|   502k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
 1025|   508k|            case 2:
  ------------------
  |  Branch (1025:13): [True: 5.40k, False: 504k]
  ------------------
 1026|   508k|                byte2 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1027|   508k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|   508k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
 1028|   510k|            case 1:
  ------------------
  |  Branch (1028:13): [True: 1.79k, False: 508k]
  ------------------
 1029|   510k|                byte1 = (uint8_t) (ch | first_byte_mark[bytes_to_write]);
 1030|   510k|                break;
 1031|   510k|            }
 1032|       |
 1033|   510k|            switch (bytes_to_write) 
  ------------------
  |  Branch (1033:21): [True: 510k, False: 0]
  ------------------
 1034|   510k|            {
 1035|   275k|            case 4: 
  ------------------
  |  Branch (1035:13): [True: 275k, False: 234k]
  ------------------
 1036|   275k|                target.push_back(byte1);
 1037|   275k|                target.push_back(byte2);
 1038|   275k|                target.push_back(byte3);
 1039|   275k|                target.push_back(byte4);
 1040|   275k|                break;
 1041|   227k|            case 3: 
  ------------------
  |  Branch (1041:13): [True: 227k, False: 282k]
  ------------------
 1042|   227k|                target.push_back(byte1);
 1043|   227k|                target.push_back(byte2);
 1044|   227k|                target.push_back(byte3);
 1045|   227k|                break;
 1046|  5.40k|            case 2: 
  ------------------
  |  Branch (1046:13): [True: 5.40k, False: 504k]
  ------------------
 1047|  5.40k|                target.push_back(byte1);
 1048|  5.40k|                target.push_back(byte2);
 1049|  5.40k|                break;
 1050|  1.79k|            case 1: 
  ------------------
  |  Branch (1050:13): [True: 1.79k, False: 508k]
  ------------------
 1051|  1.79k|                target.push_back(byte1);
 1052|  1.79k|                break;
 1053|   510k|            }
 1054|   510k|        }
 1055|   552k|        return unicode_result<CharT>{data,result} ;
 1056|   552k|    }
_ZN8jsoncons14unicode_traits12is_surrogateEj:
  221|   552k|    {
  222|   552k|        return (ch >= sur_high_start && ch <= sur_low_end);
  ------------------
  |  Branch (222:17): [True: 320k, False: 231k]
  |  Branch (222:41): [True: 42.0k, False: 278k]
  ------------------
  223|   552k|    }

_ZN8jsoncons12from_integerImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|    226|{
   43|    226|    using char_type = typename Result::value_type;
   44|       |
   45|    226|    char_type buf[255];
   46|    226|    char_type *p = buf;
   47|    226|    const char_type* last = buf+255;
   48|       |
   49|    226|    bool is_negative = value < 0;
   50|       |
   51|    226|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 226]
  ------------------
   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|    226|    else
   60|    226|    {
   61|       |
   62|    226|        do
   63|  2.92k|        {
   64|  2.92k|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  2.92k|        }
   66|  2.92k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 2.70k, False: 226]
  |  Branch (66:33): [True: 2.70k, False: 0]
  ------------------
   67|    226|    }
   68|    226|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   49|    226|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 226]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|    226|    std::size_t count = (p - buf);
   71|    226|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 226]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  3.15k|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 2.92k, False: 226]
  ------------------
   77|  2.92k|    {
   78|  2.92k|        result.push_back(*p);
   79|  2.92k|    }
   80|       |
   81|    226|    return count;
   82|    226|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|    250|{
   43|    250|    using char_type = typename Result::value_type;
   44|       |
   45|    250|    char_type buf[255];
   46|    250|    char_type *p = buf;
   47|    250|    const char_type* last = buf+255;
   48|       |
   49|    250|    bool is_negative = value < 0;
   50|       |
   51|    250|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 248, False: 2]
  ------------------
   52|    248|    {
   53|    248|        do
   54|  3.06k|        {
   55|  3.06k|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|  3.06k|        }
   57|  3.06k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 2.81k, False: 248]
  |  Branch (57:33): [True: 2.81k, False: 0]
  ------------------
   58|    248|    }
   59|      2|    else
   60|      2|    {
   61|       |
   62|      2|        do
   63|      2|        {
   64|      2|            *p++ = static_cast<char_type>(48 + value % 10);
   65|      2|        }
   66|      2|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 0, False: 2]
  |  Branch (66:33): [True: 0, False: 0]
  ------------------
   67|      2|    }
   68|    250|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   49|    250|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 250]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|    250|    std::size_t count = (p - buf);
   71|    250|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 248, False: 2]
  ------------------
   72|    248|    {
   73|    248|        result.push_back('-');
   74|    248|        ++count;
   75|    248|    }
   76|  3.31k|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 3.06k, False: 250]
  ------------------
   77|  3.06k|    {
   78|  3.06k|        result.push_back(*p);
   79|  3.06k|    }
   80|       |
   81|    250|    return count;
   82|    250|}
_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|    934|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|    934|    {
  489|    934|#if !defined(JSONCONS_NO_LOCALECONV)
  490|    934|        struct lconv *lc = localeconv();
  491|    934|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 934, False: 0]
  |  Branch (491:30): [True: 934, False: 0]
  ------------------
  492|    934|        {
  493|    934|            decimal_point_ = lc->decimal_point[0];
  494|    934|        }
  495|    934|#endif
  496|    934|    }
_ZN8jsoncons12write_doubleclINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEmdRT_:
  503|    934|    {
  504|    934|        std::size_t count = 0;
  505|       |
  506|    934|        char number_buffer[200];
  507|    934|        int length = 0;
  508|       |
  509|    934|        switch (float_format_)
  510|    934|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 934]
  ------------------
  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: 934]
  ------------------
  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|    934|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 934, False: 0]
  ------------------
  552|    934|            {
  553|    934|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 934]
  ------------------
  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|    934|                else
  563|    934|                {
  564|    934|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 934]
  ------------------
  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|    934|                }             
  569|    934|                break;
  570|    934|            }
  571|    934|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 934]
  ------------------
  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|    934|        }
  575|    934|        return count;
  576|    934|    }
_ZN8jsoncons11dump_bufferINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKcmcRT_:
  243|    189|{
  244|    189|    const char *sbeg = buffer;
  245|    189|    const char *send = sbeg + length;
  246|       |
  247|    189|    if (sbeg != send)
  ------------------
  |  Branch (247:9): [True: 189, False: 0]
  ------------------
  248|    189|    {
  249|    189|        bool needs_dot = true;
  250|  2.53k|        for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (250:36): [True: 2.34k, False: 189]
  ------------------
  251|  2.34k|        {
  252|  2.34k|            switch (*q)
  253|  2.34k|            {
  254|     10|            case '-':
  ------------------
  |  Branch (254:13): [True: 10, False: 2.33k]
  ------------------
  255|    307|            case '0':
  ------------------
  |  Branch (255:13): [True: 297, False: 2.05k]
  ------------------
  256|    490|            case '1':
  ------------------
  |  Branch (256:13): [True: 183, False: 2.16k]
  ------------------
  257|    692|            case '2':
  ------------------
  |  Branch (257:13): [True: 202, False: 2.14k]
  ------------------
  258|    891|            case '3':
  ------------------
  |  Branch (258:13): [True: 199, False: 2.14k]
  ------------------
  259|  1.06k|            case '4':
  ------------------
  |  Branch (259:13): [True: 169, False: 2.17k]
  ------------------
  260|  1.23k|            case '5':
  ------------------
  |  Branch (260:13): [True: 173, False: 2.17k]
  ------------------
  261|  1.40k|            case '6':
  ------------------
  |  Branch (261:13): [True: 171, False: 2.17k]
  ------------------
  262|  1.53k|            case '7':
  ------------------
  |  Branch (262:13): [True: 133, False: 2.21k]
  ------------------
  263|  1.74k|            case '8':
  ------------------
  |  Branch (263:13): [True: 207, False: 2.14k]
  ------------------
  264|  2.05k|            case '9':
  ------------------
  |  Branch (264:13): [True: 315, False: 2.03k]
  ------------------
  265|  2.11k|            case '+':
  ------------------
  |  Branch (265:13): [True: 51, False: 2.29k]
  ------------------
  266|  2.11k|                result.push_back(*q);
  267|  2.11k|                break;
  268|     58|            case 'e':
  ------------------
  |  Branch (268:13): [True: 58, False: 2.29k]
  ------------------
  269|     58|            case 'E':
  ------------------
  |  Branch (269:13): [True: 0, False: 2.34k]
  ------------------
  270|     58|                result.push_back('e');
  271|     58|                needs_dot = false;
  272|     58|                break;
  273|    180|            default:
  ------------------
  |  Branch (273:13): [True: 180, False: 2.16k]
  ------------------
  274|    180|                if (*q == decimal_point)
  ------------------
  |  Branch (274:21): [True: 180, False: 0]
  ------------------
  275|    180|                {
  276|    180|                    needs_dot = false;
  277|    180|                    result.push_back('.');
  278|    180|                }
  279|    180|                break;
  280|  2.34k|            }
  281|  2.34k|        }
  282|    189|        if (needs_dot)
  ------------------
  |  Branch (282:13): [True: 1, False: 188]
  ------------------
  283|      1|        {
  284|      1|            result.push_back('.');
  285|      1|            result.push_back('0');
  286|      1|        }
  287|    189|    }
  288|    189|}
_ZN8jsoncons15prettify_stringINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKciiiiRT_:
  171|    734|{
  172|    734|    int nb_digits = length;
  173|    734|    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|    734|    int kk = nb_digits + k;
  179|       |
  180|    734|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 155, False: 579]
  |  Branch (180:28): [True: 60, False: 95]
  ------------------
  181|     60|    {
  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|    214|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 154, False: 60]
  ------------------
  186|    154|        {
  187|    154|            result.push_back(buffer[i]);
  188|    154|        }
  189|    348|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 288, False: 60]
  ------------------
  190|    288|        {
  191|    288|            result.push_back('0');
  192|    288|        }
  193|     60|        result.push_back('.');
  194|     60|        result.push_back('0');
  195|     60|    } 
  196|    674|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 285, False: 389]
  |  Branch (196:24): [True: 190, False: 95]
  ------------------
  197|    190|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|  1.08k|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 899, False: 190]
  ------------------
  200|    899|        {
  201|    899|            result.push_back(buffer[i]);
  202|    899|        }
  203|    190|        result.push_back('.');
  204|  1.10k|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 915, False: 190]
  ------------------
  205|    915|        {
  206|    915|            result.push_back(buffer[i]);
  207|    915|        }
  208|    190|    } 
  209|    484|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 123, False: 361]
  |  Branch (209:30): [True: 28, False: 95]
  ------------------
  210|     28|    {
  211|     28|        offset = 2 - kk;
  212|       |
  213|     28|        result.push_back('0');
  214|     28|        result.push_back('.');
  215|     45|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 17, False: 28]
  ------------------
  216|     17|            result.push_back('0');
  217|    151|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 123, False: 28]
  ------------------
  218|    123|        {
  219|    123|            result.push_back(buffer[i]);
  220|    123|        }
  221|     28|    } 
  222|    456|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 147, False: 309]
  ------------------
  223|    147|    {
  224|    147|        result.push_back(buffer[0]);
  225|    147|        result.push_back('e');
  226|    147|        fill_exponent(kk - 1, result);
  227|    147|    } 
  228|    309|    else
  229|    309|    {
  230|    309|        result.push_back(buffer[0]);
  231|    309|        result.push_back('.');
  232|  1.65k|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 1.34k, False: 309]
  ------------------
  233|  1.34k|        {
  234|  1.34k|            result.push_back(buffer[i]);
  235|  1.34k|        }
  236|    309|        result.push_back('e');
  237|    309|        fill_exponent(kk - 1, result);
  238|    309|    }
  239|    734|}
_ZN8jsoncons13fill_exponentINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEviRT_:
  136|    456|{
  137|    456|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 361, False: 95]
  ------------------
  138|    361|    {
  139|    361|        result.push_back('-');
  140|    361|        K = -K;
  141|    361|    }
  142|     95|    else
  143|     95|    {
  144|     95|        result.push_back('+'); // compatibility with sprintf
  145|     95|    }
  146|       |
  147|    456|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 6, False: 450]
  ------------------
  148|      6|    {
  149|      6|        result.push_back('0'); // compatibility with sprintf
  150|      6|        result.push_back((char)('0' + K));
  151|      6|    }
  152|    450|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 74, False: 376]
  ------------------
  153|     74|    {
  154|     74|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|     74|        result.push_back((char)('0' + K));
  156|     74|    }
  157|    376|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 376, False: 0]
  ------------------
  158|    376|    {
  159|    376|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|    376|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|    376|        result.push_back((char)('0' + K));
  162|    376|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|    456|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_:
  475|    934|{
  476|    934|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|    934|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_NS1_17integral_constantIbLb1EEE:
  366|    934|{
  367|    934|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 11, False: 923]
  ------------------
  368|     11|    {
  369|     11|        result.push_back('0');
  370|     11|        result.push_back('.');
  371|     11|        result.push_back('0');
  372|     11|        return true;
  373|     11|    }
  374|       |
  375|    923|    int length = 0;
  376|    923|    int k;
  377|       |
  378|    923|    char buffer[100];
  379|       |
  380|    923|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 18, False: 905]
  ------------------
  381|    923|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 734, False: 189]
  ------------------
  382|    734|    {
  383|    734|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 15, False: 719]
  ------------------
  384|     15|        {
  385|     15|            result.push_back('-');
  386|     15|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|    734|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|    734|        return true;
  391|    734|    }
  392|    189|    else
  393|    189|    {
  394|    189|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|    189|    }
  396|    923|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_NS1_17integral_constantIbLb0EEE:
  329|    189|{
  330|    189|    if (val == 0)
  ------------------
  |  Branch (330:9): [True: 0, False: 189]
  ------------------
  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|    189|    char buffer[100];
  339|    189|    int precision = std::numeric_limits<double>::digits10;
  340|    189|    int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  341|    189|    if (length < 0)
  ------------------
  |  Branch (341:9): [True: 0, False: 189]
  ------------------
  342|      0|    {
  343|      0|        return false;
  344|      0|    }
  345|    189|    double x{0};
  346|    189|    auto res = decstr_to_double(buffer, length, x);
  347|    189|    if (res.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (347:9): [True: 0, False: 189]
  ------------------
  348|      0|    {
  349|      0|        return false;
  350|      0|    }
  351|    189|    if (x != val)
  ------------------
  |  Branch (351:9): [True: 51, False: 138]
  ------------------
  352|     51|    {
  353|     51|        const int precision2 = std::numeric_limits<double>::max_digits10;
  354|     51|        length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  355|     51|        if (length < 0)
  ------------------
  |  Branch (355:13): [True: 0, False: 51]
  ------------------
  356|      0|        {
  357|      0|            return false;
  358|      0|        }
  359|     51|    }
  360|    189|    dump_buffer(buffer, length, decimal_point, result);
  361|    189|    return true;
  362|    189|}