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

_ZN8jsoncons28string_view_constant_of_typeIcEENSt3__117basic_string_viewIT_NS1_11char_traitsIS3_EEEEPKcPKw:
  231|      3|    {
  232|      3|        return jsoncons::string_view(c);
  233|      3|    }

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

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

_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_EC2EOS9_RKS7_:
  192|  5.17k|            : basic_json_encoder(std::forward<Sink>(sink), basic_json_encode_options<CharT>(), alloc)
  193|  5.17k|        {
  194|  5.17k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_EC2EOS9_RKNS_25basic_json_encode_optionsIcEERKS7_:
  199|  5.17k|           : sink_(std::forward<Sink>(sink)), 
  200|  5.17k|             options_(options),
  201|  5.17k|             indent_char_(options.indent_char()),
  202|  5.17k|             fp_(options.float_format(), options.precision()),
  203|  5.17k|             stack_(alloc)
  204|  5.17k|        {
  205|  5.17k|            switch (options.spaces_around_colon())
  206|  5.17k|            {
  207|  5.17k|                case spaces_option::space_after:
  ------------------
  |  Branch (207:17): [True: 5.17k, False: 0]
  ------------------
  208|  5.17k|                    colon_str_ = jsoncons::basic_string_view<CharT>(colon_space.data(), colon_space.size());
  209|  5.17k|                    break;
  210|      0|                case spaces_option::space_before:
  ------------------
  |  Branch (210:17): [True: 0, False: 5.17k]
  ------------------
  211|      0|                    colon_str_ = jsoncons::basic_string_view<CharT>(space_colon.data(), space_colon.size());
  212|      0|                    break;
  213|      0|                case spaces_option::space_before_and_after:
  ------------------
  |  Branch (213:17): [True: 0, False: 5.17k]
  ------------------
  214|      0|                    colon_str_ = jsoncons::basic_string_view<CharT>(space_colon_space.data(), space_colon_space.size());
  215|      0|                    break;
  216|      0|                default:
  ------------------
  |  Branch (216:17): [True: 0, False: 5.17k]
  ------------------
  217|      0|                    colon_str_ = jsoncons::basic_string_view<CharT>(colon.data(), colon.size());
  218|      0|                    break;
  219|  5.17k|            }
  220|  5.17k|            switch (options.spaces_around_comma())
  221|  5.17k|            {
  222|  5.17k|                case spaces_option::space_after:
  ------------------
  |  Branch (222:17): [True: 5.17k, False: 0]
  ------------------
  223|  5.17k|                    comma_str_ = jsoncons::basic_string_view<CharT>(comma_space.data(), colon_space.size());
  224|  5.17k|                    break;
  225|      0|                case spaces_option::space_before:
  ------------------
  |  Branch (225:17): [True: 0, False: 5.17k]
  ------------------
  226|      0|                    comma_str_ = jsoncons::basic_string_view<CharT>(space_comma.data(), space_comma.size());
  227|      0|                    break;
  228|      0|                case spaces_option::space_before_and_after:
  ------------------
  |  Branch (228:17): [True: 0, False: 5.17k]
  ------------------
  229|      0|                    comma_str_ = jsoncons::basic_string_view<CharT>(space_comma_space.data(), space_comma_space.size());
  230|      0|                    break;
  231|      0|                default:
  ------------------
  |  Branch (231:17): [True: 0, False: 5.17k]
  ------------------
  232|      0|                    comma_str_ = jsoncons::basic_string_view<CharT>(comma.data(), comma.size());
  233|      0|                    break;
  234|  5.17k|            }
  235|  5.17k|            if (options.pad_inside_object_braces())
  ------------------
  |  Branch (235:17): [True: 0, False: 5.17k]
  ------------------
  236|      0|            {
  237|      0|                open_brace_str_ = jsoncons::basic_string_view<CharT>(left_brace_space.data(), left_brace_space.size());
  238|      0|                close_brace_str_ = jsoncons::basic_string_view<CharT>(space_right_brace.data(), space_right_brace.size());
  239|      0|            }
  240|  5.17k|            else
  241|  5.17k|            {
  242|  5.17k|                open_brace_str_ = jsoncons::basic_string_view<CharT>(left_brace.data(), left_brace.size());
  243|  5.17k|                close_brace_str_ = jsoncons::basic_string_view<CharT>(right_brace.data(), right_brace.size());
  244|  5.17k|            }
  245|  5.17k|            if (options.pad_inside_array_brackets())
  ------------------
  |  Branch (245:17): [True: 0, False: 5.17k]
  ------------------
  246|      0|            {
  247|      0|                open_bracket_str_ = jsoncons::basic_string_view<CharT>(left_bracket_space.data(), left_bracket_space.size());
  248|      0|                close_bracket_str_ = jsoncons::basic_string_view<CharT>(space_right_bracket.data(), space_right_bracket.size());
  249|      0|            }
  250|  5.17k|            else
  251|  5.17k|            {
  252|  5.17k|                open_bracket_str_ = jsoncons::basic_string_view<CharT>(left_bracket.data(), left_bracket.size());
  253|  5.17k|                close_bracket_str_ = jsoncons::basic_string_view<CharT>(right_bracket.data(), right_bracket.size());
  254|  5.17k|            }
  255|  5.17k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E15visit_end_arrayERKNS_11ser_contextERNS2_10error_codeE:
  466|  6.85k|        {
  467|  6.85k|            JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   49|  6.85k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 6.85k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  468|  6.85k|            --nesting_depth_;
  469|       |
  470|  6.85k|            unindent();
  471|  6.85k|            if (stack_.back().new_line_after())
  ------------------
  |  Branch (471:17): [True: 5.67k, False: 1.17k]
  ------------------
  472|  5.67k|            {
  473|  5.67k|                new_line();
  474|  5.67k|            }
  475|  6.85k|            stack_.pop_back();
  476|  6.85k|            sink_.append(close_bracket_str_.data(), close_bracket_str_.length());
  477|  6.85k|            column_ += close_bracket_str_.length();
  478|  6.85k|            end_value();
  479|  6.85k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  6.85k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  480|  6.85k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E8unindentEv:
  909|  39.6k|        {
  910|  39.6k|            indent_amount_ -= static_cast<uint8_t>(options_.indent_size());
  911|  39.6k|        }
_ZNK8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context14new_line_afterEv:
  132|  39.6k|            {
  133|  39.6k|                return new_line_after_;
  134|  39.6k|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E8new_lineEv:
  914|  6.19M|        {
  915|  6.19M|            sink_.append(options_.new_line_chars().data(),options_.new_line_chars().length());
  916|   814M|            for (int i = 0; i < indent_amount_; ++i)
  ------------------
  |  Branch (916:29): [True: 807M, False: 6.19M]
  ------------------
  917|   807M|            {
  918|   807M|                sink_.push_back(indent_char_);
  919|   807M|            }
  920|  6.19M|            column_ = indent_amount_;
  921|  6.19M|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E9end_valueEv:
  896|  6.11M|        {
  897|  6.11M|            if (!stack_.empty())
  ------------------
  |  Branch (897:17): [True: 6.11M, False: 1.80k]
  ------------------
  898|  6.11M|            {
  899|  6.11M|                stack_.back().increment_count();
  900|  6.11M|            }
  901|  6.11M|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context15increment_countEv:
  127|  6.11M|            {
  128|  6.11M|                ++count_;
  129|  6.11M|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  764|  3.46M|        {
  765|  3.46M|            if (!stack_.empty()) 
  ------------------
  |  Branch (765:17): [True: 3.46M, False: 227]
  ------------------
  766|  3.46M|            {
  767|  3.46M|                if (stack_.back().is_array())
  ------------------
  |  Branch (767:21): [True: 3.19M, False: 264k]
  ------------------
  768|  3.19M|                {
  769|  3.19M|                    begin_scalar_value();
  770|  3.19M|                }
  771|  3.46M|                if (!stack_.back().is_multi_line() && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (771:21): [True: 0, False: 3.46M]
  |  Branch (771:55): [True: 0, False: 0]
  ------------------
  772|      0|                {
  773|      0|                    break_line();
  774|      0|                }
  775|  3.46M|            }
  776|  3.46M|            std::size_t length = jsoncons::from_integer(value, sink_);
  777|  3.46M|            column_ += length;
  778|  3.46M|            end_value();
  779|  3.46M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.46M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  780|  3.46M|        }
_ZNK8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context8is_arrayEv:
  147|  6.18M|            {
  148|  6.18M|                return type_ == container_type::array;
  149|  6.18M|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E18begin_scalar_valueEv:
  812|  5.80M|        {
  813|  5.80M|            if (!stack_.empty())
  ------------------
  |  Branch (813:17): [True: 5.80M, False: 0]
  ------------------
  814|  5.80M|            {
  815|  5.80M|                if (stack_.back().count() > 0)
  ------------------
  |  Branch (815:21): [True: 5.78M, False: 24.3k]
  ------------------
  816|  5.78M|                {
  817|  5.78M|                    sink_.append(comma_str_.data(),comma_str_.length());
  818|  5.78M|                    column_ += comma_str_.length();
  819|  5.78M|                }
  820|  5.80M|                if (stack_.back().is_multi_line() || stack_.back().is_indent_once())
  ------------------
  |  Branch (820:21): [True: 5.80M, False: 0]
  |  Branch (820:54): [True: 0, False: 0]
  ------------------
  821|  5.80M|                {
  822|  5.80M|                    stack_.back().new_line_after(true);
  823|  5.80M|                    new_line();
  824|  5.80M|                }
  825|  5.80M|            }
  826|  5.80M|        }
_ZNK8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context5countEv:
  122|  6.45M|            {
  123|  6.45M|                return count_;
  124|  6.45M|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context14new_line_afterEb:
  137|  6.18M|            {
  138|  6.18M|                new_line_after_ = value;
  139|  6.18M|            }
_ZNK8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context13is_multi_lineEv:
  157|  12.1M|            {
  158|  12.1M|                return split_kind_ == line_split_kind::multi_line;
  159|  12.1M|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  742|   175k|        {
  743|   175k|            if (!stack_.empty()) 
  ------------------
  |  Branch (743:17): [True: 175k, False: 222]
  ------------------
  744|   175k|            {
  745|   175k|                if (stack_.back().is_array())
  ------------------
  |  Branch (745:21): [True: 174k, False: 306]
  ------------------
  746|   174k|                {
  747|   174k|                    begin_scalar_value();
  748|   174k|                }
  749|   175k|                if (!stack_.back().is_multi_line() && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (749:21): [True: 0, False: 175k]
  |  Branch (749:55): [True: 0, False: 0]
  ------------------
  750|      0|                {
  751|      0|                    break_line();
  752|      0|                }
  753|   175k|            }
  754|   175k|            std::size_t length = jsoncons::from_integer(value, sink_);
  755|   175k|            column_ += length;
  756|   175k|            end_value();
  757|   175k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   175k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  758|   175k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  661|  1.37M|        {
  662|  1.37M|            if (!stack_.empty()) 
  ------------------
  |  Branch (662:17): [True: 1.37M, False: 887]
  ------------------
  663|  1.37M|            {
  664|  1.37M|                if (stack_.back().is_array())
  ------------------
  |  Branch (664:21): [True: 1.37M, False: 288]
  ------------------
  665|  1.37M|                {
  666|  1.37M|                    begin_scalar_value();
  667|  1.37M|                }
  668|  1.37M|                if (!stack_.back().is_multi_line() && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (668:21): [True: 0, False: 1.37M]
  |  Branch (668:55): [True: 0, False: 0]
  ------------------
  669|      0|                {
  670|      0|                    break_line();
  671|      0|                }
  672|  1.37M|            }
  673|       |
  674|  1.37M|            if (!std::isfinite(value))
  ------------------
  |  Branch (674:17): [True: 0, False: 1.37M]
  ------------------
  675|      0|            {
  676|      0|                if ((std::isnan)(value))
  ------------------
  |  Branch (676:21): [True: 0, False: 0]
  ------------------
  677|      0|                {
  678|      0|                    if (options_.enable_nan_to_num())
  ------------------
  |  Branch (678:25): [True: 0, False: 0]
  ------------------
  679|      0|                    {
  680|      0|                        sink_.append(options_.nan_to_num().data(), options_.nan_to_num().length());
  681|      0|                        column_ += options_.nan_to_num().length();
  682|      0|                    }
  683|      0|                    else if (options_.enable_nan_to_str())
  ------------------
  |  Branch (683:30): [True: 0, False: 0]
  ------------------
  684|      0|                    {
  685|      0|                        write_string(options_.nan_to_str(), semantic_tag::none, context, ec);
  686|      0|                    }
  687|      0|                    else
  688|      0|                    {
  689|      0|                        sink_.append(null_literal().data(), null_literal().size());
  690|      0|                        column_ += null_literal().size();
  691|      0|                    }
  692|      0|                }
  693|      0|                else if (value == std::numeric_limits<double>::infinity())
  ------------------
  |  Branch (693:26): [True: 0, False: 0]
  ------------------
  694|      0|                {
  695|      0|                    if (options_.enable_inf_to_num())
  ------------------
  |  Branch (695:25): [True: 0, False: 0]
  ------------------
  696|      0|                    {
  697|      0|                        sink_.append(options_.inf_to_num().data(), options_.inf_to_num().length());
  698|      0|                        column_ += options_.inf_to_num().length();
  699|      0|                    }
  700|      0|                    else if (options_.enable_inf_to_str())
  ------------------
  |  Branch (700:30): [True: 0, False: 0]
  ------------------
  701|      0|                    {
  702|      0|                        write_string(options_.inf_to_str(), semantic_tag::none, context, ec);
  703|      0|                    }
  704|      0|                    else
  705|      0|                    {
  706|      0|                        sink_.append(null_literal().data(), null_literal().size());
  707|      0|                        column_ += null_literal().size();
  708|      0|                    }
  709|      0|                }
  710|      0|                else
  711|      0|                {
  712|      0|                    if (options_.enable_neginf_to_num())
  ------------------
  |  Branch (712:25): [True: 0, False: 0]
  ------------------
  713|      0|                    {
  714|      0|                        sink_.append(options_.neginf_to_num().data(), options_.neginf_to_num().length());
  715|      0|                        column_ += options_.neginf_to_num().length();
  716|      0|                    }
  717|      0|                    else if (options_.enable_neginf_to_str())
  ------------------
  |  Branch (717:30): [True: 0, False: 0]
  ------------------
  718|      0|                    {
  719|      0|                        write_string(options_.neginf_to_str(), semantic_tag::none, context, ec);
  720|      0|                    }
  721|      0|                    else
  722|      0|                    {
  723|      0|                        sink_.append(null_literal().data(), null_literal().size());
  724|      0|                        column_ += null_literal().size();
  725|      0|                    }
  726|      0|                }
  727|      0|            }
  728|  1.37M|            else
  729|  1.37M|            {
  730|  1.37M|                std::size_t length = fp_(value, sink_);
  731|  1.37M|                column_ += length;
  732|  1.37M|            }
  733|       |
  734|  1.37M|            end_value();
  735|  1.37M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.37M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  736|  1.37M|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E12write_stringERKNS2_17basic_string_viewIcS5_EENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  556|  45.3k|        {
  557|  45.3k|            if (JSONCONS_LIKELY(tag == semantic_tag::noesc && !options_.escape_all_non_ascii() && !options_.escape_solidus()))
  ------------------
  |  |   77|   130k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 19.8k, False: 25.5k]
  |  |  |  Branch (77:48): [True: 19.8k, False: 25.5k]
  |  |  |  Branch (77:48): [True: 19.8k, False: 0]
  |  |  |  Branch (77:48): [True: 19.8k, False: 0]
  |  |  ------------------
  ------------------
  558|  19.8k|            {
  559|       |                //std::cout << "noesc\n";
  560|  19.8k|                sink_.push_back('\"');
  561|  19.8k|                sink_.append(sv.data(), sv.length());
  562|  19.8k|                sink_.push_back('\"');
  563|  19.8k|                column_ += (sv.length()+2);
  564|  19.8k|            }
  565|  25.5k|            else if (tag == semantic_tag::bigint)
  ------------------
  |  Branch (565:22): [True: 23.4k, False: 2.09k]
  ------------------
  566|  23.4k|            {
  567|  23.4k|                write_bignum_value(sv);
  568|  23.4k|            }
  569|  2.09k|            else if (tag == semantic_tag::bigdec && options_.bignum_format() == bignum_format_kind::raw)
  ------------------
  |  Branch (569:22): [True: 929, False: 1.16k]
  |  Branch (569:53): [True: 929, False: 0]
  ------------------
  570|    929|            {
  571|    929|                write_bignum_value(sv);
  572|    929|            }
  573|  1.16k|            else
  574|  1.16k|            {
  575|       |                //if (tag != semantic_tag::bigdec)
  576|       |                //    std::cout << "esc\n";
  577|  1.16k|                sink_.push_back('\"');
  578|  1.16k|                std::size_t length = jsoncons::detail::escape_string(sv.data(), sv.length(),options_.escape_all_non_ascii(),options_.escape_solidus(),sink_);
  579|  1.16k|                sink_.push_back('\"');
  580|  1.16k|                column_ += (length+2);
  581|  1.16k|            }           
  582|  45.3k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E18write_bignum_valueERKNS2_17basic_string_viewIcS5_EE:
  829|  24.3k|        {
  830|  24.3k|            switch (options_.bignum_format())
  831|  24.3k|            {
  832|  24.3k|                case bignum_format_kind::raw:
  ------------------
  |  Branch (832:17): [True: 24.3k, False: 0]
  ------------------
  833|  24.3k|                {
  834|  24.3k|                    sink_.append(sv.data(),sv.size());
  835|  24.3k|                    column_ += sv.size();
  836|  24.3k|                    break;
  837|      0|                }
  838|      0|                case bignum_format_kind::base64:
  ------------------
  |  Branch (838:17): [True: 0, False: 24.3k]
  ------------------
  839|      0|                {
  840|      0|                    bigint n(sv.data(), sv.length());
  841|      0|                    bool is_neg = n < 0;
  842|      0|                    if (is_neg)
  ------------------
  |  Branch (842:25): [True: 0, False: 0]
  ------------------
  843|      0|                    {
  844|      0|                        n = - n -1;
  845|      0|                    }
  846|      0|                    int signum;
  847|      0|                    std::vector<uint8_t> v;
  848|      0|                    n.write_bytes_be(signum, v);
  849|       |
  850|      0|                    sink_.push_back('\"');
  851|      0|                    if (is_neg)
  ------------------
  |  Branch (851:25): [True: 0, False: 0]
  ------------------
  852|      0|                    {
  853|      0|                        sink_.push_back('~');
  854|      0|                        ++column_;
  855|      0|                    }
  856|      0|                    std::size_t length = bytes_to_base64(v.begin(), v.end(), sink_);
  857|      0|                    sink_.push_back('\"');
  858|      0|                    column_ += (length+2);
  859|      0|                    break;
  860|      0|                }
  861|      0|                case bignum_format_kind::base64url:
  ------------------
  |  Branch (861:17): [True: 0, False: 24.3k]
  ------------------
  862|      0|                {
  863|      0|                    bigint n(sv.data(), sv.length());
  864|      0|                    bool is_neg = n < 0;
  865|      0|                    if (is_neg)
  ------------------
  |  Branch (865:25): [True: 0, False: 0]
  ------------------
  866|      0|                    {
  867|      0|                        n = - n -1;
  868|      0|                    }
  869|      0|                    int signum;
  870|      0|                    std::vector<uint8_t> v;
  871|      0|                    n.write_bytes_be(signum, v);
  872|       |
  873|      0|                    sink_.push_back('\"');
  874|      0|                    if (is_neg)
  ------------------
  |  Branch (874:25): [True: 0, False: 0]
  ------------------
  875|      0|                    {
  876|      0|                        sink_.push_back('~');
  877|      0|                        ++column_;
  878|      0|                    }
  879|      0|                    std::size_t length = bytes_to_base64url(v.begin(), v.end(), sink_);
  880|      0|                    sink_.push_back('\"');
  881|      0|                    column_ += (length+2);
  882|      0|                    break;
  883|      0|                }
  884|      0|                default:
  ------------------
  |  Branch (884:17): [True: 0, False: 24.3k]
  ------------------
  885|      0|                {
  886|      0|                    sink_.push_back('\"');
  887|      0|                    sink_.append(sv.data(),sv.size());
  888|      0|                    sink_.push_back('\"');
  889|      0|                    column_ += (sv.size() + 2);
  890|      0|                    break;
  891|      0|                }
  892|  24.3k|            }
  893|  24.3k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E12null_literalEv:
   42|   734k|        {
   43|   734k|            static const jsoncons::basic_string_view<CharT> k = JSONCONS_STRING_VIEW_CONSTANT(CharT, "null");
  ------------------
  |  |  264|   734k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  260|   734k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  257|   734k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   44|   734k|            return k;
   45|   734k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E11visit_flushEv:
  288|  1.80k|        {
  289|  1.80k|            sink_.flush();
  290|  1.80k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  293|  34.5k|        {
  294|  34.5k|            if (JSONCONS_UNLIKELY(++nesting_depth_ > options_.max_nesting_depth()))
  ------------------
  |  |   78|  34.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 34.5k]
  |  |  ------------------
  ------------------
  295|      0|            {
  296|      0|                ec = json_errc::max_nesting_depth_exceeded;
  297|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  298|      0|            } 
  299|  34.5k|            if (!stack_.empty() && stack_.back().is_array() && stack_.back().count() > 0)
  ------------------
  |  Branch (299:17): [True: 34.0k, False: 463]
  |  Branch (299:36): [True: 33.1k, False: 938]
  |  Branch (299:64): [True: 31.9k, False: 1.17k]
  ------------------
  300|  31.9k|            {
  301|  31.9k|                sink_.append(comma_str_.data(),comma_str_.length());
  302|  31.9k|                column_ += comma_str_.length();
  303|  31.9k|            }
  304|       |
  305|  34.5k|            if (!stack_.empty()) // object or array
  ------------------
  |  Branch (305:17): [True: 34.0k, False: 463]
  ------------------
  306|  34.0k|            {
  307|  34.0k|                if (stack_.back().is_object())
  ------------------
  |  Branch (307:21): [True: 938, False: 33.1k]
  ------------------
  308|    938|                {
  309|    938|                    line_split_kind split_kind = static_cast<uint8_t>(options_.object_object_line_splits()) >= static_cast<uint8_t>(stack_.back().split_kind()) ? 
  ------------------
  |  Branch (309:50): [True: 938, False: 0]
  ------------------
  310|    938|                        options_.object_object_line_splits() : stack_.back().split_kind();
  311|    938|                    switch (split_kind)
  312|    938|                    {
  313|      0|                        case line_split_kind::same_line:
  ------------------
  |  Branch (313:25): [True: 0, False: 938]
  ------------------
  314|      0|                        case line_split_kind::new_line:
  ------------------
  |  Branch (314:25): [True: 0, False: 938]
  ------------------
  315|      0|                            if (column_ >= options_.line_length_limit())
  ------------------
  |  Branch (315:33): [True: 0, False: 0]
  ------------------
  316|      0|                            {
  317|      0|                                break_line();
  318|      0|                            }
  319|      0|                            break;
  320|    938|                        default: // multi_line
  ------------------
  |  Branch (320:25): [True: 938, False: 0]
  ------------------
  321|    938|                            break;
  322|    938|                    }
  323|    938|                    stack_.emplace_back(container_type::object,split_kind, false,
  324|    938|                                        column_, column_+open_brace_str_.length());
  325|    938|                }
  326|  33.1k|                else // array
  327|  33.1k|                {
  328|  33.1k|                    line_split_kind split_kind = static_cast<uint8_t>(options_.array_object_line_splits()) >= static_cast<uint8_t>(stack_.back().split_kind()) ? 
  ------------------
  |  Branch (328:50): [True: 33.1k, False: 0]
  ------------------
  329|  33.1k|                        options_.array_object_line_splits() : stack_.back().split_kind();
  330|  33.1k|                    switch (split_kind)
  331|  33.1k|                    {
  332|      0|                        case line_split_kind::same_line:
  ------------------
  |  Branch (332:25): [True: 0, False: 33.1k]
  ------------------
  333|      0|                            if (column_ >= options_.line_length_limit())
  ------------------
  |  Branch (333:33): [True: 0, False: 0]
  ------------------
  334|      0|                            {
  335|       |                                //stack_.back().new_line_after(true);
  336|      0|                                new_line();
  337|      0|                            }
  338|      0|                            else
  339|      0|                            {
  340|      0|                                stack_.back().new_line_after(true);
  341|      0|                                new_line();
  342|      0|                            }
  343|      0|                            break;
  344|      0|                        case line_split_kind::new_line:
  ------------------
  |  Branch (344:25): [True: 0, False: 33.1k]
  ------------------
  345|      0|                            stack_.back().new_line_after(true);
  346|      0|                            new_line();
  347|      0|                            break;
  348|  33.1k|                        default: // multi_line
  ------------------
  |  Branch (348:25): [True: 33.1k, False: 0]
  ------------------
  349|  33.1k|                            stack_.back().new_line_after(true);
  350|  33.1k|                            new_line();
  351|  33.1k|                            break;
  352|  33.1k|                    }
  353|  33.1k|                    stack_.emplace_back(container_type::object,split_kind, false,
  354|  33.1k|                                        column_, column_+open_brace_str_.length());
  355|  33.1k|                }
  356|  34.0k|            }
  357|    463|            else 
  358|    463|            {
  359|    463|                stack_.emplace_back(container_type::object, options_.root_line_splits(), false,
  360|    463|                                    column_, column_+open_brace_str_.length());
  361|    463|            }
  362|  34.5k|            indent();
  363|       |            
  364|  34.5k|            sink_.append(open_brace_str_.data(), open_brace_str_.length());
  365|  34.5k|            column_ += open_brace_str_.length();
  366|  34.5k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  34.5k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  367|  34.5k|        }
_ZNK8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context9is_objectEv:
  142|   109k|            {
  143|   109k|                return type_ == container_type::object;
  144|   109k|            }
_ZNK8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context10split_kindEv:
  152|   109k|            {
  153|   109k|                return split_kind_;
  154|   109k|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_contextC2ENSA_14container_typeENS_15line_split_kindEbmm:
   95|   112k|               : type_(type), split_kind_(split_lines), indent_before_(indent_once), new_line_after_(false),
   96|   112k|                 begin_pos_(begin_pos), data_pos_(data_pos)
   97|   112k|            {
   98|   112k|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E6indentEv:
  904|   112k|        {
  905|   112k|            indent_amount_ += static_cast<uint8_t>(options_.indent_size());
  906|   112k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16visit_end_objectERKNS_11ser_contextERNS2_10error_codeE:
  370|  32.7k|        {
  371|  32.7k|            JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   49|  32.7k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 32.7k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  372|  32.7k|            --nesting_depth_;
  373|       |
  374|  32.7k|            unindent();
  375|  32.7k|            if (stack_.back().new_line_after())
  ------------------
  |  Branch (375:17): [True: 2.50k, False: 30.2k]
  ------------------
  376|  2.50k|            {
  377|  2.50k|                new_line();
  378|  2.50k|            }
  379|  32.7k|            stack_.pop_back();
  380|  32.7k|            sink_.append(close_brace_str_.data(), close_brace_str_.length());
  381|  32.7k|            column_ += close_brace_str_.length();
  382|       |
  383|  32.7k|            end_value();
  384|  32.7k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  32.7k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  385|  32.7k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  388|  77.5k|        {
  389|  77.5k|            if (JSONCONS_UNLIKELY(++nesting_depth_ > options_.max_nesting_depth()))
  ------------------
  |  |   78|  77.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 77.5k]
  |  |  ------------------
  ------------------
  390|      0|            {
  391|      0|                ec = json_errc::max_nesting_depth_exceeded;
  392|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  393|      0|            } 
  394|  77.5k|            if (!stack_.empty() && stack_.back().is_array() && stack_.back().count() > 0)
  ------------------
  |  Branch (394:17): [True: 75.8k, False: 1.65k]
  |  Branch (394:36): [True: 75.4k, False: 394]
  |  Branch (394:64): [True: 24.9k, False: 50.5k]
  ------------------
  395|  24.9k|            {
  396|  24.9k|                sink_.append(comma_str_.data(),comma_str_.length());
  397|  24.9k|                column_ += comma_str_.length();
  398|  24.9k|            }
  399|  77.5k|            if (!stack_.empty())
  ------------------
  |  Branch (399:17): [True: 75.8k, False: 1.65k]
  ------------------
  400|  75.8k|            {
  401|  75.8k|                if (stack_.back().is_object())
  ------------------
  |  Branch (401:21): [True: 394, False: 75.4k]
  ------------------
  402|    394|                {
  403|    394|                    line_split_kind split_kind = static_cast<uint8_t>(options_.object_array_line_splits()) >= static_cast<uint8_t>(stack_.back().split_kind()) ? 
  ------------------
  |  Branch (403:50): [True: 394, False: 0]
  ------------------
  404|    394|                        options_.object_array_line_splits() : 
  405|    394|                        stack_.back().split_kind();
  406|    394|                    switch (split_kind)
  407|    394|                    {
  408|      0|                        case line_split_kind::same_line:
  ------------------
  |  Branch (408:25): [True: 0, False: 394]
  ------------------
  409|      0|                            stack_.emplace_back(container_type::array,split_kind,false,
  410|      0|                                                column_, column_ + open_bracket_str_.length());
  411|      0|                            break;
  412|      0|                        case line_split_kind::new_line:
  ------------------
  |  Branch (412:25): [True: 0, False: 394]
  ------------------
  413|      0|                        {
  414|      0|                            stack_.emplace_back(container_type::array,split_kind,true,
  415|      0|                                                column_, column_+open_bracket_str_.length());
  416|      0|                            break;
  417|      0|                        }
  418|    394|                        default: // multi_line
  ------------------
  |  Branch (418:25): [True: 394, False: 0]
  ------------------
  419|    394|                            stack_.emplace_back(container_type::array,split_kind,true,
  420|    394|                                                column_, column_+open_bracket_str_.length());
  421|    394|                            break;
  422|    394|                    }
  423|    394|                }
  424|  75.4k|                else // array
  425|  75.4k|                {
  426|  75.4k|                    line_split_kind split_kind = static_cast<uint8_t>(options_.array_array_line_splits()) >= static_cast<uint8_t>(stack_.back().split_kind()) ? 
  ------------------
  |  Branch (426:50): [True: 75.4k, False: 0]
  ------------------
  427|  75.4k|                        options_.array_array_line_splits() : stack_.back().split_kind();
  428|  75.4k|                    switch (split_kind)
  429|  75.4k|                    {
  430|      0|                        case line_split_kind::same_line:
  ------------------
  |  Branch (430:25): [True: 0, False: 75.4k]
  ------------------
  431|      0|                            if (stack_.back().is_multi_line())
  ------------------
  |  Branch (431:33): [True: 0, False: 0]
  ------------------
  432|      0|                            {
  433|      0|                                stack_.back().new_line_after(true);
  434|      0|                                new_line();
  435|      0|                            }
  436|      0|                            stack_.emplace_back(container_type::array,split_kind, false,
  437|      0|                                                column_, column_+open_bracket_str_.length());
  438|      0|                            break;
  439|      0|                        case line_split_kind::new_line:
  ------------------
  |  Branch (439:25): [True: 0, False: 75.4k]
  ------------------
  440|      0|                            stack_.back().new_line_after(true);
  441|      0|                            new_line();
  442|      0|                            stack_.emplace_back(container_type::array,split_kind, true,
  443|      0|                                                column_, column_+open_bracket_str_.length());
  444|      0|                            break;
  445|  75.4k|                        default: // multi_line
  ------------------
  |  Branch (445:25): [True: 75.4k, False: 0]
  ------------------
  446|  75.4k|                            stack_.back().new_line_after(true);
  447|  75.4k|                            new_line();
  448|  75.4k|                            stack_.emplace_back(container_type::array,split_kind, false,
  449|  75.4k|                                                column_, column_+open_bracket_str_.length());
  450|  75.4k|                            break;
  451|  75.4k|                    }
  452|  75.4k|                }
  453|  75.8k|            }
  454|  1.65k|            else 
  455|  1.65k|            {
  456|  1.65k|                stack_.emplace_back(container_type::array, options_.root_line_splits(), false,
  457|  1.65k|                                    column_, column_+open_bracket_str_.length());
  458|  1.65k|            }
  459|  77.5k|            indent();
  460|  77.5k|            sink_.append(open_bracket_str_.data(), open_bracket_str_.length());
  461|  77.5k|            column_ += open_bracket_str_.length();
  462|  77.5k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  77.5k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  463|  77.5k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E9visit_keyERKNS2_17basic_string_viewIcS5_EERKNS_11ser_contextERNS2_10error_codeE:
  483|   267k|        {
  484|   267k|            JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   49|   267k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 267k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  485|   267k|            if (stack_.back().count() > 0)
  ------------------
  |  Branch (485:17): [True: 263k, False: 4.08k]
  ------------------
  486|   263k|            {
  487|   263k|                sink_.append(comma_str_.data(),comma_str_.length());
  488|   263k|                column_ += comma_str_.length();
  489|   263k|            }
  490|       |
  491|   267k|            if (stack_.back().is_multi_line())
  ------------------
  |  Branch (491:17): [True: 267k, False: 0]
  ------------------
  492|   267k|            {
  493|   267k|                stack_.back().new_line_after(true);
  494|   267k|                new_line();
  495|   267k|            }
  496|      0|            else if (stack_.back().count() > 0 && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (496:22): [True: 0, False: 0]
  |  Branch (496:51): [True: 0, False: 0]
  ------------------
  497|      0|            {
  498|       |                //stack_.back().new_line_after(true);
  499|      0|                new_line(stack_.back().data_pos());
  500|      0|            }
  501|       |
  502|   267k|            if (stack_.back().count() == 0)
  ------------------
  |  Branch (502:17): [True: 4.08k, False: 263k]
  ------------------
  503|  4.08k|            {
  504|  4.08k|                stack_.back().set_position(column_);
  505|  4.08k|            }
  506|   267k|            sink_.push_back('\"');
  507|   267k|            std::size_t length = jsoncons::detail::escape_string(name.data(), name.length(),options_.escape_all_non_ascii(),options_.escape_solidus(),sink_);
  508|   267k|            sink_.push_back('\"');
  509|   267k|            sink_.append(colon_str_.data(),colon_str_.length());
  510|   267k|            column_ += (length+2+colon_str_.length());
  511|   267k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   267k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  512|   267k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E16encoding_context12set_positionEm:
  107|  4.08k|            {
  108|  4.08k|                data_pos_ = pos;
  109|  4.08k|            }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  515|   244k|        {
  516|   244k|            if (!stack_.empty()) 
  ------------------
  |  Branch (516:17): [True: 244k, False: 2]
  ------------------
  517|   244k|            {
  518|   244k|                if (stack_.back().is_array())
  ------------------
  |  Branch (518:21): [True: 244k, False: 203]
  ------------------
  519|   244k|                {
  520|   244k|                    begin_scalar_value();
  521|   244k|                }
  522|   244k|                if (!stack_.back().is_multi_line() && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (522:21): [True: 0, False: 244k]
  |  Branch (522:55): [True: 0, False: 0]
  ------------------
  523|      0|                {
  524|      0|                    break_line();
  525|      0|                }
  526|   244k|            }
  527|       |
  528|   244k|            sink_.append(null_literal().data(), null_literal().size());
  529|   244k|            column_ += null_literal().size();
  530|       |
  531|   244k|            end_value();
  532|   244k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   244k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  533|   244k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  783|   771k|        {
  784|   771k|            if (!stack_.empty()) 
  ------------------
  |  Branch (784:17): [True: 771k, False: 6]
  ------------------
  785|   771k|            {
  786|   771k|                if (stack_.back().is_array())
  ------------------
  |  Branch (786:21): [True: 771k, False: 194]
  ------------------
  787|   771k|                {
  788|   771k|                    begin_scalar_value();
  789|   771k|                }
  790|   771k|                if (!stack_.back().is_multi_line() && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (790:21): [True: 0, False: 771k]
  |  Branch (790:55): [True: 0, False: 0]
  ------------------
  791|      0|                {
  792|      0|                    break_line();
  793|      0|                }
  794|   771k|            }
  795|       |
  796|   771k|            if (value)
  ------------------
  |  Branch (796:17): [True: 467k, False: 304k]
  ------------------
  797|   467k|            {
  798|   467k|                sink_.append(true_literal().data(), true_literal().size());
  799|   467k|                column_ += true_literal().size();
  800|   467k|            }
  801|   304k|            else
  802|   304k|            {
  803|   304k|                sink_.append(false_literal().data(), false_literal().size());
  804|   304k|                column_ += false_literal().size();
  805|   304k|            }
  806|       |
  807|   771k|            end_value();
  808|   771k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   771k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  809|   771k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E12true_literalEv:
   47|  1.40M|        {
   48|  1.40M|            static const jsoncons::basic_string_view<CharT> k = JSONCONS_STRING_VIEW_CONSTANT(CharT, "true");
  ------------------
  |  |  264|  1.40M|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  260|  1.40M|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  257|  1.40M|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   49|  1.40M|            return k;
   50|  1.40M|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E13false_literalEv:
   52|   912k|        {
   53|   912k|            static const jsoncons::basic_string_view<CharT> k = JSONCONS_STRING_VIEW_CONSTANT(CharT, "false");
  ------------------
  |  |  264|   912k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  260|   912k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  257|   912k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   54|   912k|            return k;
   55|   912k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_E12visit_stringERKNS2_17basic_string_viewIcS5_EENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  536|  45.3k|        {
  537|  45.3k|            if (!stack_.empty()) 
  ------------------
  |  Branch (537:17): [True: 44.9k, False: 430]
  ------------------
  538|  44.9k|            {
  539|  44.9k|                if (stack_.back().is_array())
  ------------------
  |  Branch (539:21): [True: 44.6k, False: 254]
  ------------------
  540|  44.6k|                {
  541|  44.6k|                    begin_scalar_value();
  542|  44.6k|                }
  543|  44.9k|                if (!stack_.back().is_multi_line() && column_ >= options_.line_length_limit())
  ------------------
  |  Branch (543:21): [True: 0, False: 44.9k]
  |  Branch (543:55): [True: 0, False: 0]
  ------------------
  544|      0|                {
  545|      0|                    break_line();
  546|      0|                }
  547|  44.9k|            }
  548|       |            
  549|  45.3k|            write_string(sv, tag, context, ec);
  550|       |
  551|  45.3k|            end_value();
  552|  45.3k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  45.3k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  553|  45.3k|        }
_ZN8jsoncons18basic_json_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEES7_ED2Ev:
  258|  5.17k|        {
  259|  5.17k|            JSONCONS_TRY
  ------------------
  |  |   37|  5.17k|    #define JSONCONS_TRY try
  ------------------
  260|  5.17k|            {
  261|  5.17k|                sink_.flush();
  262|  5.17k|            }
  263|  5.17k|            JSONCONS_CATCH(...)
  264|  5.17k|            {
  265|      0|            }
  266|  5.17k|        }

_ZN8jsoncons6detail13escape_stringIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEmPKT_mbbRT0_:
   35|   268k|{
   36|   268k|    std::size_t count = 0;
   37|   268k|    const CharT* begin = s;
   38|   268k|    const CharT* end = s + length;
   39|  5.10M|    for (const CharT* it = begin; it != end; ++it)
  ------------------
  |  Branch (39:35): [True: 4.83M, False: 268k]
  ------------------
   40|  4.83M|    {
   41|  4.83M|        CharT c = *it;
   42|  4.83M|        switch (c)
   43|  4.83M|        {
   44|  1.30k|            case '\\':
  ------------------
  |  Branch (44:13): [True: 1.30k, False: 4.83M]
  ------------------
   45|  1.30k|                sink.push_back('\\');
   46|  1.30k|                sink.push_back('\\');
   47|  1.30k|                count += 2;
   48|  1.30k|                break;
   49|    605|            case '"':
  ------------------
  |  Branch (49:13): [True: 605, False: 4.83M]
  ------------------
   50|    605|                sink.push_back('\\');
   51|    605|                sink.push_back('\"');
   52|    605|                count += 2;
   53|    605|                break;
   54|  1.05k|            case '\b':
  ------------------
  |  Branch (54:13): [True: 1.05k, False: 4.83M]
  ------------------
   55|  1.05k|                sink.push_back('\\');
   56|  1.05k|                sink.push_back('b');
   57|  1.05k|                count += 2;
   58|  1.05k|                break;
   59|    196|            case '\f':
  ------------------
  |  Branch (59:13): [True: 196, False: 4.83M]
  ------------------
   60|    196|                sink.push_back('\\');
   61|    196|                sink.push_back('f');
   62|    196|                count += 2;
   63|    196|                break;
   64|    444|            case '\n':
  ------------------
  |  Branch (64:13): [True: 444, False: 4.83M]
  ------------------
   65|    444|                sink.push_back('\\');
   66|    444|                sink.push_back('n');
   67|    444|                count += 2;
   68|    444|                break;
   69|    199|            case '\r':
  ------------------
  |  Branch (69:13): [True: 199, False: 4.83M]
  ------------------
   70|    199|                sink.push_back('\\');
   71|    199|                sink.push_back('r');
   72|    199|                count += 2;
   73|    199|                break;
   74|    260|            case '\t':
  ------------------
  |  Branch (74:13): [True: 260, False: 4.83M]
  ------------------
   75|    260|                sink.push_back('\\');
   76|    260|                sink.push_back('t');
   77|    260|                count += 2;
   78|    260|                break;
   79|  4.83M|            default:
  ------------------
  |  Branch (79:13): [True: 4.83M, False: 4.06k]
  ------------------
   80|  4.83M|                if (escape_solidus && c == '/')
  ------------------
  |  Branch (80:21): [True: 0, False: 4.83M]
  |  Branch (80:39): [True: 0, False: 0]
  ------------------
   81|      0|                {
   82|      0|                    sink.push_back('\\');
   83|      0|                    sink.push_back('/');
   84|      0|                    count += 2;
   85|      0|                }
   86|  4.83M|                else if (is_control_character(c) || escape_all_non_ascii)
  ------------------
  |  Branch (86:26): [True: 10.4k, False: 4.82M]
  |  Branch (86:53): [True: 0, False: 4.82M]
  ------------------
   87|  10.4k|                {
   88|       |                    // convert to codepoint
   89|  10.4k|                    uint32_t cp;
   90|  10.4k|                    auto r = unicode_traits::to_codepoint(it, end, cp, unicode_traits::strict_flag::strict);
   91|  10.4k|                    if (r.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (91:25): [True: 0, False: 10.4k]
  ------------------
   92|      0|                    {
   93|      0|                        JSONCONS_THROW(ser_error(json_errc::illegal_codepoint));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
   94|      0|                    }
   95|  10.4k|                    it = r.ptr - 1;
   96|  10.4k|                    if (is_non_ascii_codepoint(cp) || is_control_character(c))
  ------------------
  |  Branch (96:25): [True: 0, False: 10.4k]
  |  Branch (96:55): [True: 10.4k, False: 0]
  ------------------
   97|  10.4k|                    {
   98|  10.4k|                        if (cp > 0xFFFF)
  ------------------
  |  Branch (98:29): [True: 0, False: 10.4k]
  ------------------
   99|      0|                        {
  100|      0|                            cp -= 0x10000;
  101|      0|                            uint32_t first = (cp >> 10) + 0xD800;
  102|      0|                            uint32_t second = ((cp & 0x03FF) + 0xDC00);
  103|       |
  104|      0|                            sink.push_back('\\');
  105|      0|                            sink.push_back('u');
  106|      0|                            sink.push_back(jsoncons::to_hex_character(first >> 12 & 0x000F));
  107|      0|                            sink.push_back(jsoncons::to_hex_character(first >> 8 & 0x000F));
  108|      0|                            sink.push_back(jsoncons::to_hex_character(first >> 4 & 0x000F));
  109|      0|                            sink.push_back(jsoncons::to_hex_character(first & 0x000F));
  110|      0|                            sink.push_back('\\');
  111|      0|                            sink.push_back('u');
  112|      0|                            sink.push_back(jsoncons::to_hex_character(second >> 12 & 0x000F));
  113|      0|                            sink.push_back(jsoncons::to_hex_character(second >> 8 & 0x000F));
  114|      0|                            sink.push_back(jsoncons::to_hex_character(second >> 4 & 0x000F));
  115|      0|                            sink.push_back(jsoncons::to_hex_character(second & 0x000F));
  116|      0|                            count += 12;
  117|      0|                        }
  118|  10.4k|                        else
  119|  10.4k|                        {
  120|  10.4k|                            sink.push_back('\\');
  121|  10.4k|                            sink.push_back('u');
  122|  10.4k|                            sink.push_back(jsoncons::to_hex_character(cp >> 12 & 0x000F));
  123|  10.4k|                            sink.push_back(jsoncons::to_hex_character(cp >> 8 & 0x000F));
  124|  10.4k|                            sink.push_back(jsoncons::to_hex_character(cp >> 4 & 0x000F));
  125|  10.4k|                            sink.push_back(jsoncons::to_hex_character(cp & 0x000F));
  126|  10.4k|                            count += 6;
  127|  10.4k|                        }
  128|  10.4k|                    }
  129|      0|                    else
  130|      0|                    {
  131|      0|                        sink.push_back(c);
  132|      0|                        ++count;
  133|      0|                    }
  134|  10.4k|                }
  135|  4.82M|                else
  136|  4.82M|                {
  137|  4.82M|                    sink.push_back(c);
  138|  4.82M|                    ++count;
  139|  4.82M|                }
  140|  4.83M|                break;
  141|  4.83M|        }
  142|  4.83M|    }
  143|   268k|    return count;
  144|   268k|}
_ZN8jsoncons6detail20is_control_characterEj:
   22|  4.84M|{
   23|  4.84M|    return c <= 0x1F || c == 0x7f;
  ------------------
  |  Branch (23:12): [True: 2.93k, False: 4.83M]
  |  Branch (23:25): [True: 17.9k, False: 4.82M]
  ------------------
   24|  4.84M|}
_ZN8jsoncons6detail22is_non_ascii_codepointEj:
   28|  10.4k|{
   29|  10.4k|    return cp >= 0x80;
   30|  10.4k|}

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

_ZN8jsoncons25basic_json_encode_optionsIcEC1Ev:
  345|  5.17k|        : escape_all_non_ascii_(false),
  346|  5.17k|          escape_solidus_(false),
  347|  5.17k|          pad_inside_object_braces_(false),
  348|  5.17k|          pad_inside_array_brackets_(false),
  349|  5.17k|          float_format_(float_chars_format::general),
  350|  5.17k|          byte_string_format_(byte_string_chars_format::none),
  351|  5.17k|          bignum_format_(bignum_format_kind::raw),
  352|  5.17k|          root_line_splits_(line_split_kind::multi_line),
  353|  5.17k|          object_object_line_splits_(line_split_kind::multi_line),
  354|  5.17k|          object_array_line_splits_(line_split_kind::multi_line),
  355|  5.17k|          array_array_line_splits_(line_split_kind::multi_line),
  356|  5.17k|          array_object_line_splits_(line_split_kind::multi_line),
  357|  5.17k|          spaces_around_colon_(spaces_option::space_after),
  358|  5.17k|          spaces_around_comma_(spaces_option::space_after),
  359|  5.17k|          indent_char_(' ')
  360|  5.17k|    {
  361|  5.17k|        new_line_chars_.push_back('\n');
  362|  5.17k|    }
_ZN8jsoncons25basic_json_options_commonIcEC2Ev:
  106|  10.3k|        enable_nan_to_num_(false),
  107|  10.3k|        enable_inf_to_num_(false),
  108|  10.3k|        enable_neginf_to_num_(false),
  109|  10.3k|        enable_nan_to_str_(false),
  110|  10.3k|        enable_inf_to_str_(false),
  111|  10.3k|        enable_neginf_to_str_(false),
  112|  10.3k|        enable_str_to_nan_(false),
  113|  10.3k|        enable_str_to_inf_(false),
  114|  10.3k|        enable_str_to_neginf_(false),
  115|  10.3k|        max_nesting_depth_(1024)
  116|  10.3k|    {}
_ZN8jsoncons25basic_json_options_commonIcED2Ev:
  118|  15.5k|    virtual ~basic_json_options_common() = default;
_ZN8jsoncons25basic_json_encode_optionsIcEC1ERKS1_:
  364|  5.17k|    basic_json_encode_options(const basic_json_encode_options&) = default;
_ZN8jsoncons25basic_json_options_commonIcEC2ERKS1_:
  120|  5.17k|    basic_json_options_common(const basic_json_options_common&) = default;
_ZNK8jsoncons25basic_json_encode_optionsIcE11indent_charEv:
  434|  5.17k|    {
  435|  5.17k|        return indent_char_;
  436|  5.17k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE12float_formatEv:
  459|  5.17k|    {
  460|  5.17k|        return float_format_;
  461|  5.17k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE9precisionEv:
  464|  5.17k|    {
  465|  5.17k|        return precision_;
  466|  5.17k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE19spaces_around_colonEv:
  424|  5.17k|    {
  425|  5.17k|        return spaces_around_colon_;
  426|  5.17k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE19spaces_around_commaEv:
  429|  5.17k|    {
  430|  5.17k|        return spaces_around_comma_;
  431|  5.17k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE24pad_inside_object_bracesEv:
  439|  5.17k|    {
  440|  5.17k|        return pad_inside_object_braces_;
  441|  5.17k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE25pad_inside_array_bracketsEv:
  444|  5.17k|    {
  445|  5.17k|        return pad_inside_array_brackets_;
  446|  5.17k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE11indent_sizeEv:
  419|   151k|    {
  420|   151k|        return indent_size_;
  421|   151k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE14new_line_charsEv:
  449|  12.3M|    {
  450|  12.3M|        return new_line_chars_;
  451|  12.3M|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE20escape_all_non_asciiEv:
  469|   288k|    {
  470|   288k|        return escape_all_non_ascii_;
  471|   288k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE14escape_solidusEv:
  474|   288k|    {
  475|   288k|        return escape_solidus_;
  476|   288k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE13bignum_formatEv:
  402|  25.2k|    bignum_format_kind bignum_format() const  {return bignum_format_;}
_ZNK8jsoncons25basic_json_options_commonIcE10nan_to_strEv:
  216|  5.17k|    {
  217|  5.17k|        return nan_to_str_;
  218|  5.17k|    }
_ZNK8jsoncons25basic_json_options_commonIcE10inf_to_strEv:
  221|  5.17k|    {
  222|  5.17k|        return inf_to_str_;
  223|  5.17k|    }
_ZNK8jsoncons25basic_json_options_commonIcE13neginf_to_strEv:
  226|  5.17k|    {
  227|  5.17k|        if (enable_neginf_to_str_)
  ------------------
  |  Branch (227:13): [True: 0, False: 5.17k]
  ------------------
  228|      0|        {
  229|      0|            return neginf_to_str_;
  230|      0|        }
  231|  5.17k|        else if (enable_inf_to_str_)
  ------------------
  |  Branch (231:18): [True: 0, False: 5.17k]
  ------------------
  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|  5.17k|        else
  239|  5.17k|        {
  240|  5.17k|            return neginf_to_str_; // empty string
  241|  5.17k|        }
  242|  5.17k|    }
_ZNK8jsoncons25basic_json_options_commonIcE17max_nesting_depthEv:
  245|   122k|    {
  246|   122k|        return max_nesting_depth_;
  247|   122k|    }
_ZNK8jsoncons25basic_json_encode_optionsIcE25object_object_line_splitsEv:
  410|  1.87k|    line_split_kind object_object_line_splits() const  {return object_object_line_splits_;}
_ZNK8jsoncons25basic_json_encode_optionsIcE24array_object_line_splitsEv:
  412|  66.2k|    line_split_kind array_object_line_splits() const  {return array_object_line_splits_;}
_ZNK8jsoncons25basic_json_encode_optionsIcE16root_line_splitsEv:
  408|  2.11k|    line_split_kind root_line_splits() const  {return root_line_splits_;}
_ZNK8jsoncons25basic_json_encode_optionsIcE24object_array_line_splitsEv:
  414|    788|    line_split_kind object_array_line_splits() const  {return object_array_line_splits_;}
_ZNK8jsoncons25basic_json_encode_optionsIcE23array_array_line_splitsEv:
  416|   150k|    line_split_kind array_array_line_splits() const  {return array_array_line_splits_;}
_ZN8jsoncons25basic_json_encode_optionsIcED2Ev:
  390|  10.3k|    ~basic_json_encode_options() = default;
_ZN8jsoncons25basic_json_decode_optionsIcEC1Ev:
  266|  5.17k|        : err_handler_(default_json_parsing())
  267|  5.17k|    {
  268|  5.17k|    }
_ZN8jsoncons20default_json_parsingclENS_9json_errcERKNS_11ser_contextE:
   48|  25.6k|    {
   49|  25.6k|        return ec == json_errc::illegal_comment;
   50|  25.6k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE20allow_trailing_commaEv:
  300|  5.17k|    {
  301|  5.17k|        return allow_trailing_comma_;
  302|  5.17k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE14allow_commentsEv:
  295|  5.17k|    {
  296|  5.17k|        return allow_comments_;
  297|  5.17k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE15lossless_numberEv:
  286|  5.17k|    {
  287|  5.17k|        return lossless_number_;
  288|  5.17k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE15lossless_bignumEv:
  290|  5.17k|    {
  291|  5.17k|        return lossless_bignum_;
  292|  5.17k|    }
_ZNK8jsoncons25basic_json_options_commonIcE17enable_str_to_infEv:
  158|  5.17k|    {
  159|  5.17k|        return enable_str_to_inf_;
  160|  5.17k|    }
_ZNK8jsoncons25basic_json_options_commonIcE20enable_str_to_neginfEv:
  168|  5.17k|    {
  169|  5.17k|        return enable_str_to_neginf_ || enable_str_to_inf_;
  ------------------
  |  Branch (169:16): [True: 0, False: 5.17k]
  |  Branch (169:41): [True: 0, False: 5.17k]
  ------------------
  170|  5.17k|    }
_ZNK8jsoncons25basic_json_options_commonIcE17enable_str_to_nanEv:
  148|  5.17k|    {
  149|  5.17k|        return enable_str_to_nan_;
  150|  5.17k|    }
_ZNK8jsoncons25basic_json_decode_optionsIcE11err_handlerEv:
  306|  5.17k|    {
  307|  5.17k|        return err_handler_;
  308|  5.17k|    }

_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEED2Ev:
  272|  5.17k|    {
  273|  5.17k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEEC2ERKNS_25basic_json_decode_optionsIcEERKS3_:
  183|  5.17k|       : max_nesting_depth_(options.max_nesting_depth()),
  184|  5.17k|         allow_trailing_comma_(options.allow_trailing_comma()),
  185|  5.17k|         allow_comments_(options.allow_comments()),
  186|  5.17k|         lossless_number_(options.lossless_number()),
  187|  5.17k|         lossless_bignum_(options.lossless_bignum()),
  188|  5.17k|         enable_str_to_inf_(options.enable_str_to_inf()),
  189|  5.17k|         enable_str_to_neginf_(options.enable_str_to_neginf()),
  190|  5.17k|         enable_str_to_nan_(options.enable_str_to_nan()),
  191|  5.17k|         inf_to_str_(options.inf_to_str()),
  192|  5.17k|         neginf_to_str_(options.neginf_to_str()),
  193|  5.17k|         nan_to_str_(options.nan_to_str()),
  194|       |#if !defined(JSONCONS_NO_DEPRECATED)
  195|  5.17k|         err_handler_(options.err_handler()),
  196|       |#else
  197|       |         err_handler_(default_json_parsing()),
  198|       |#endif
  199|  5.17k|         buffer_(temp_alloc),
  200|  5.17k|         state_stack_(temp_alloc)
  201|  5.17k|    {
  202|  5.17k|        buffer_.reserve(initial_buffer_capacity);
  203|       |
  204|  5.17k|        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: 5.17k]
  ------------------
  205|  5.17k|        state_stack_.reserve(initial_stack_capacity );
  206|  5.17k|        push_state(parse_state::root);
  207|  5.17k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10push_stateENS_11parse_stateE:
 2707|   442k|    {
 2708|   442k|        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|   442k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE5resetEv:
  494|  5.17k|    {
  495|  5.17k|        state_stack_.clear();
  496|  5.17k|        push_state(parse_state::root);
  497|  5.17k|        state_ = parse_state::start;
  498|  5.17k|        more_ = true;
  499|  5.17k|        done_ = false;
  500|  5.17k|        line_ = 1;
  501|  5.17k|        position_ = 0;
  502|  5.17k|        mark_position_ = 0;
  503|  5.17k|        level_ = 0;
  504|  5.17k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE7stoppedEv:
  297|  17.1k|    {
  298|  17.1k|        return !more_;
  299|  17.1k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE16source_exhaustedEv:
  262|  31.3k|    {
  263|  31.3k|        return input_ptr_ == input_end_;
  264|  31.3k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE6updateEPKcm:
  551|  10.6k|    {
  552|  10.6k|        input_end_ = data + length;
  553|  10.6k|        input_ptr_ = data;
  554|  10.6k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10parse_someERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  567|  15.2k|    {
  568|  15.2k|        parse_some_(visitor, ec);
  569|  15.2k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11parse_some_ERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  591|  15.2k|    {
  592|  15.2k|        if (state_ == parse_state::accept)
  ------------------
  |  Branch (592:13): [True: 1.65k, False: 13.6k]
  ------------------
  593|  1.65k|        {
  594|  1.65k|            visitor.flush();
  595|  1.65k|            done_ = true;
  596|  1.65k|            state_ = parse_state::done;
  597|  1.65k|            more_ = false;
  598|  1.65k|            return;
  599|  1.65k|        }
  600|  13.6k|        const char_type* local_input_end = input_end_;
  601|       |
  602|  13.6k|        if (input_ptr_ == local_input_end && more_)
  ------------------
  |  Branch (602:13): [True: 3.65k, False: 9.97k]
  |  Branch (602:46): [True: 3.65k, False: 0]
  ------------------
  603|  3.65k|        {
  604|  3.65k|            switch (state_)
  605|  3.65k|            {
  606|  2.13k|                case parse_state::number:  
  ------------------
  |  Branch (606:17): [True: 2.13k, False: 1.52k]
  ------------------
  607|  2.13k|                    if (number_state_ == parse_number_state::zero || number_state_ == parse_number_state::integer)
  ------------------
  |  Branch (607:25): [True: 0, False: 2.13k]
  |  Branch (607:70): [True: 926, False: 1.21k]
  ------------------
  608|    926|                    {
  609|    926|                        end_integer_value(visitor, ec);
  610|    926|                        if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|    926|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 926]
  |  |  ------------------
  ------------------
  611|    926|                    }
  612|  1.21k|                    else if (number_state_ == parse_number_state::fraction2 || number_state_ == parse_number_state::exp3)
  ------------------
  |  Branch (612:30): [True: 449, False: 762]
  |  Branch (612:80): [True: 677, False: 85]
  ------------------
  613|  1.12k|                    {
  614|  1.12k|                        end_fraction_value(visitor, ec);
  615|  1.12k|                        if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  1.12k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.12k]
  |  |  ------------------
  ------------------
  616|  1.12k|                    }
  617|     85|                    else
  618|     85|                    {
  619|     85|                        err_handler_(json_errc::unexpected_eof, *this);
  620|     85|                        ec = json_errc::unexpected_eof;
  621|     85|                        more_ = false;
  622|     85|                    }
  623|  2.13k|                    break;
  624|  2.13k|                case parse_state::accept:
  ------------------
  |  Branch (624:17): [True: 0, False: 3.65k]
  ------------------
  625|      0|                    visitor.flush();
  626|      0|                    done_ = true;
  627|      0|                    state_ = parse_state::done;
  628|      0|                    more_ = false;
  629|      0|                    break;
  630|     69|                case parse_state::start:
  ------------------
  |  Branch (630:17): [True: 69, False: 3.58k]
  ------------------
  631|     69|                    more_ = false;
  632|     69|                    ec = json_errc::unexpected_eof;
  633|     69|                    return;                
  634|      0|                case parse_state::done:
  ------------------
  |  Branch (634:17): [True: 0, False: 3.65k]
  ------------------
  635|      0|                    more_ = false;
  636|      0|                    break;
  637|     89|                case parse_state::cr:
  ------------------
  |  Branch (637:17): [True: 89, False: 3.56k]
  ------------------
  638|     89|                    state_ = pop_state();
  639|     89|                    break;
  640|  1.36k|                default:
  ------------------
  |  Branch (640:17): [True: 1.36k, False: 2.29k]
  ------------------
  641|  1.36k|                    err_handler_(json_errc::unexpected_eof, *this);
  642|  1.36k|                    ec = json_errc::unexpected_eof;
  643|  1.36k|                    more_ = false;
  644|  1.36k|                    return;
  645|  3.65k|            }
  646|  3.65k|        }
  647|       |
  648|  15.7M|        while ((input_ptr_ < local_input_end) && more_)
  ------------------
  |  Branch (648:16): [True: 15.7M, False: 10.9k]
  |  Branch (648:50): [True: 15.7M, False: 141]
  ------------------
  649|  15.7M|        {
  650|  15.7M|            switch (state_)
  651|  15.7M|            {
  652|    141|                case parse_state::accept:
  ------------------
  |  Branch (652:17): [True: 141, False: 15.7M]
  ------------------
  653|    141|                    visitor.flush();
  654|    141|                    done_ = true;
  655|    141|                    state_ = parse_state::done;
  656|    141|                    more_ = false;
  657|    141|                    break;
  658|  28.7k|                case parse_state::cr:
  ------------------
  |  Branch (658:17): [True: 28.7k, False: 15.7M]
  ------------------
  659|  28.7k|                    ++line_;
  660|  28.7k|                    switch (*input_ptr_)
  661|  28.7k|                    {
  662|    271|                        case '\n':
  ------------------
  |  Branch (662:25): [True: 271, False: 28.4k]
  ------------------
  663|    271|                            ++input_ptr_;
  664|    271|                            ++position_;
  665|    271|                            state_ = pop_state();
  666|    271|                            break;
  667|  28.4k|                        default:
  ------------------
  |  Branch (667:25): [True: 28.4k, False: 271]
  ------------------
  668|  28.4k|                            state_ = pop_state();
  669|  28.4k|                            break;
  670|  28.7k|                    }
  671|  28.7k|                    mark_position_ = position_;
  672|  28.7k|                    break;
  673|  9.26k|                case parse_state::start: 
  ------------------
  |  Branch (673:17): [True: 9.26k, False: 15.7M]
  ------------------
  674|  9.26k|                {
  675|  9.26k|                    switch (*input_ptr_)
  676|  9.26k|                    {
  677|  1.20k|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|     37|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 18, False: 9.24k]
  |  |  |  Branch (34:19): [True: 2, False: 9.26k]
  |  |  |  Branch (34:29): [True: 3, False: 9.26k]
  |  |  |  Branch (34:39): [True: 2, False: 9.26k]
  |  |  |  Branch (34:49): [True: 2, False: 9.26k]
  |  |  |  Branch (34:59): [True: 2, False: 9.26k]
  |  |  |  Branch (34:69): [True: 1, False: 9.26k]
  |  |  |  Branch (34:79): [True: 3, False: 9.26k]
  |  |  |  Branch (34:89): [True: 2, False: 9.26k]
  |  |  |  Branch (34:99): [True: 2, False: 9.26k]
  |  |  ------------------
  |  |   35|     48|        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: 9.26k]
  |  |  |  Branch (35:19): [True: 1, False: 9.26k]
  |  |  |  Branch (35:29): [True: 1, False: 9.26k]
  |  |  |  Branch (35:39): [True: 1, False: 9.26k]
  |  |  |  Branch (35:49): [True: 1, False: 9.26k]
  |  |  |  Branch (35:59): [True: 1, False: 9.26k]
  |  |  |  Branch (35:69): [True: 1, False: 9.26k]
  |  |  |  Branch (35:79): [True: 1, False: 9.26k]
  |  |  |  Branch (35:89): [True: 1, False: 9.26k]
  |  |  |  Branch (35:99): [True: 1, False: 9.26k]
  |  |  ------------------
  |  |   36|     61|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 1, False: 9.26k]
  |  |  |  Branch (36:19): [True: 2, False: 9.26k]
  |  |  |  Branch (36:29): [True: 1, False: 9.26k]
  |  |  |  Branch (36:39): [True: 1, False: 9.26k]
  |  |  |  Branch (36:49): [True: 1, False: 9.26k]
  |  |  |  Branch (36:59): [True: 2, False: 9.26k]
  |  |  |  Branch (36:69): [True: 2, False: 9.26k]
  |  |  |  Branch (36:79): [True: 1, False: 9.26k]
  |  |  ------------------
  ------------------
  678|  1.20k|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
  679|  1.20k|                            if (!more_)
  ------------------
  |  Branch (679:33): [True: 61, False: 0]
  ------------------
  680|     61|                            {
  681|     61|                                ec = json_errc::illegal_control_character;
  682|     61|                                return;
  683|     61|                            }
  684|      0|                            break;
  685|  2.14k|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (685:25): [True: 337, False: 8.92k]
  |  Branch (685:34): [True: 422, False: 8.84k]
  |  Branch (685:44): [True: 600, False: 8.66k]
  |  Branch (685:54): [True: 782, False: 8.48k]
  ------------------
  686|  2.14k|                            skip_space(&input_ptr_);
  687|  2.14k|                            break;
  688|  2.16k|                        case '/': 
  ------------------
  |  Branch (688:25): [True: 2.16k, False: 7.10k]
  ------------------
  689|  2.16k|                            ++input_ptr_;
  690|  2.16k|                            ++position_;
  691|  2.16k|                            push_state(state_);
  692|  2.16k|                            state_ = parse_state::slash;
  693|  2.16k|                            break;
  694|    463|                        case '{':
  ------------------
  |  Branch (694:25): [True: 463, False: 8.80k]
  ------------------
  695|    463|                            begin_position_ = position_;
  696|    463|                            ++input_ptr_;
  697|    463|                            ++position_;
  698|    463|                            begin_object(visitor, ec);
  699|    463|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|    463|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 463]
  |  |  ------------------
  ------------------
  700|    463|                            break;
  701|  1.65k|                        case '[':
  ------------------
  |  Branch (701:25): [True: 1.65k, False: 7.60k]
  ------------------
  702|  1.65k|                            begin_position_ = position_;
  703|  1.65k|                            ++input_ptr_;
  704|  1.65k|                            ++position_;
  705|  1.65k|                            begin_array(visitor, ec);
  706|  1.65k|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  1.65k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.65k]
  |  |  ------------------
  ------------------
  707|  1.65k|                            break;
  708|  1.65k|                        case '\"':
  ------------------
  |  Branch (708:25): [True: 851, False: 8.41k]
  ------------------
  709|    851|                            state_ = parse_state::string;
  710|    851|                            string_state_ = parse_string_state{};
  711|    851|                            begin_position_ = position_;
  712|    851|                            ++input_ptr_;
  713|    851|                            ++position_;
  714|    851|                            escape_tag_ = semantic_tag::noesc;
  715|    851|                            buffer_.clear();
  716|    851|                            input_ptr_ = parse_string(input_ptr_, visitor, ec);
  717|    851|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|    851|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 270, False: 581]
  |  |  ------------------
  ------------------
  718|    581|                            break;
  719|    581|                        case '-':
  ------------------
  |  Branch (719:25): [True: 443, False: 8.82k]
  ------------------
  720|    443|                            buffer_.clear();
  721|    443|                            buffer_.push_back('-');
  722|    443|                            begin_position_ = position_;
  723|    443|                            ++input_ptr_;
  724|    443|                            ++position_;
  725|    443|                            state_ = parse_state::number;
  726|    443|                            number_state_ = parse_number_state::minus;
  727|    443|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
  728|    443|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|    443|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 9, False: 434]
  |  |  ------------------
  ------------------
  729|    434|                            break;
  730|    434|                        case '0': 
  ------------------
  |  Branch (730:25): [True: 63, False: 9.20k]
  ------------------
  731|     63|                            buffer_.clear();
  732|     63|                            buffer_.push_back(static_cast<char>(*input_ptr_));
  733|     63|                            state_ = parse_state::number;
  734|     63|                            number_state_ = parse_number_state::zero;
  735|     63|                            begin_position_ = position_;
  736|     63|                            ++input_ptr_;
  737|     63|                            ++position_;
  738|     63|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
  739|     63|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|     63|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 56]
  |  |  ------------------
  ------------------
  740|     56|                            break;
  741|  1.10k|                        case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (741:25): [True: 251, False: 9.01k]
  |  Branch (741:34): [True: 133, False: 9.13k]
  |  Branch (741:43): [True: 65, False: 9.19k]
  |  Branch (741:52): [True: 71, False: 9.19k]
  |  Branch (741:61): [True: 59, False: 9.20k]
  |  Branch (741:70): [True: 60, False: 9.20k]
  |  Branch (741:79): [True: 94, False: 9.17k]
  |  Branch (741:88): [True: 154, False: 9.11k]
  |  Branch (741:98): [True: 220, False: 9.04k]
  ------------------
  742|  1.10k|                            buffer_.clear();
  743|  1.10k|                            buffer_.push_back(static_cast<char>(*input_ptr_));
  744|  1.10k|                            begin_position_ = position_;
  745|  1.10k|                            ++input_ptr_;
  746|  1.10k|                            ++position_;
  747|  1.10k|                            state_ = parse_state::number;
  748|  1.10k|                            number_state_ = parse_number_state::integer;
  749|  1.10k|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
  750|  1.10k|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  1.10k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 9, False: 1.09k]
  |  |  ------------------
  ------------------
  751|  1.09k|                            break;
  752|  1.09k|                        case 'n':
  ------------------
  |  Branch (752:25): [True: 65, False: 9.19k]
  ------------------
  753|     65|                            parse_null(visitor, ec);
  754|     65|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|     65|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 40, False: 25]
  |  |  ------------------
  ------------------
  755|     25|                            break;
  756|     72|                        case 't':
  ------------------
  |  Branch (756:25): [True: 72, False: 9.19k]
  ------------------
  757|     72|                            input_ptr_ = parse_true(input_ptr_, visitor, ec);
  758|     72|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|     72|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 43, False: 29]
  |  |  ------------------
  ------------------
  759|     29|                            break;
  760|     85|                        case 'f':
  ------------------
  |  Branch (760:25): [True: 85, False: 9.17k]
  ------------------
  761|     85|                            input_ptr_ = parse_false(input_ptr_, visitor, ec);
  762|     85|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|     85|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 44, False: 41]
  |  |  ------------------
  ------------------
  763|     41|                            break;
  764|     41|                        case '}':
  ------------------
  |  Branch (764:25): [True: 2, False: 9.26k]
  ------------------
  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: 9.26k]
  ------------------
  770|      1|                            err_handler_(json_errc::unexpected_rbracket, *this);
  771|      1|                            ec = json_errc::unexpected_rbracket;
  772|      1|                            more_ = false;
  773|      1|                            return;
  774|     91|                        default:
  ------------------
  |  Branch (774:25): [True: 91, False: 9.17k]
  ------------------
  775|     91|                            err_handler_(json_errc::syntax_error, *this);
  776|     91|                            ec = json_errc::syntax_error;
  777|     91|                            more_ = false;
  778|     91|                            return;
  779|  9.26k|                    }
  780|  8.68k|                    break;
  781|  9.26k|                }
  782|  6.12M|                case parse_state::expect_comma_or_end: 
  ------------------
  |  Branch (782:17): [True: 6.12M, False: 9.62M]
  ------------------
  783|  6.12M|                {
  784|  6.12M|                    switch (*input_ptr_)
  785|  6.12M|                    {
  786|    735|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|     20|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 9, False: 6.12M]
  |  |  |  Branch (34:19): [True: 2, False: 6.12M]
  |  |  |  Branch (34:29): [True: 2, False: 6.12M]
  |  |  |  Branch (34:39): [True: 1, False: 6.12M]
  |  |  |  Branch (34:49): [True: 1, False: 6.12M]
  |  |  |  Branch (34:59): [True: 1, False: 6.12M]
  |  |  |  Branch (34:69): [True: 1, False: 6.12M]
  |  |  |  Branch (34:79): [True: 1, False: 6.12M]
  |  |  |  Branch (34:89): [True: 1, False: 6.12M]
  |  |  |  Branch (34:99): [True: 1, False: 6.12M]
  |  |  ------------------
  |  |   35|     30|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 1, False: 6.12M]
  |  |  |  Branch (35:19): [True: 1, False: 6.12M]
  |  |  |  Branch (35:29): [True: 1, False: 6.12M]
  |  |  |  Branch (35:39): [True: 1, False: 6.12M]
  |  |  |  Branch (35:49): [True: 1, False: 6.12M]
  |  |  |  Branch (35:59): [True: 1, False: 6.12M]
  |  |  |  Branch (35:69): [True: 1, False: 6.12M]
  |  |  |  Branch (35:79): [True: 1, False: 6.12M]
  |  |  |  Branch (35:89): [True: 1, False: 6.12M]
  |  |  |  Branch (35:99): [True: 1, False: 6.12M]
  |  |  ------------------
  |  |   36|     41|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 2, False: 6.12M]
  |  |  |  Branch (36:19): [True: 1, False: 6.12M]
  |  |  |  Branch (36:29): [True: 1, False: 6.12M]
  |  |  |  Branch (36:39): [True: 1, False: 6.12M]
  |  |  |  Branch (36:49): [True: 1, False: 6.12M]
  |  |  |  Branch (36:59): [True: 2, False: 6.12M]
  |  |  |  Branch (36:69): [True: 1, False: 6.12M]
  |  |  |  Branch (36:79): [True: 1, False: 6.12M]
  |  |  ------------------
  ------------------
  787|    735|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
  788|    735|                            if (!more_)
  ------------------
  |  Branch (788:33): [True: 41, False: 0]
  ------------------
  789|     41|                            {
  790|     41|                                ec = json_errc::illegal_control_character;
  791|     41|                                return;
  792|     41|                            }
  793|      0|                            ++input_ptr_;
  794|      0|                            ++position_;
  795|      0|                            break;
  796|  9.28k|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (796:25): [True: 3.00k, False: 6.11M]
  |  Branch (796:34): [True: 3.03k, False: 6.11M]
  |  Branch (796:44): [True: 2.80k, False: 6.11M]
  |  Branch (796:54): [True: 450, False: 6.12M]
  ------------------
  797|  9.28k|                            skip_space(&input_ptr_);
  798|  9.28k|                            break;
  799|  2.11k|                        case '/':
  ------------------
  |  Branch (799:25): [True: 2.11k, False: 6.12M]
  ------------------
  800|  2.11k|                            ++input_ptr_;
  801|  2.11k|                            ++position_;
  802|  2.11k|                            push_state(state_); 
  803|  2.11k|                            state_ = parse_state::slash;
  804|  2.11k|                            break;
  805|  2.51k|                        case '}':
  ------------------
  |  Branch (805:25): [True: 2.51k, False: 6.12M]
  ------------------
  806|  2.51k|                            begin_position_ = position_;
  807|  2.51k|                            ++input_ptr_;
  808|  2.51k|                            ++position_;
  809|  2.51k|                            end_object(visitor, ec);
  810|  2.51k|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  2.51k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 6, False: 2.50k]
  |  |  ------------------
  ------------------
  811|  2.50k|                            break;
  812|  5.67k|                        case ']':
  ------------------
  |  Branch (812:25): [True: 5.67k, False: 6.11M]
  ------------------
  813|  5.67k|                            begin_position_ = position_;
  814|  5.67k|                            ++input_ptr_;
  815|  5.67k|                            ++position_;
  816|  5.67k|                            end_array(visitor, ec);
  817|  5.67k|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  5.67k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 5.67k]
  |  |  ------------------
  ------------------
  818|  5.67k|                            break;
  819|  6.10M|                        case ',':
  ------------------
  |  Branch (819:25): [True: 6.10M, False: 19.7k]
  ------------------
  820|  6.10M|                            begin_member_or_element(ec);
  821|  6.10M|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  6.10M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 6.10M]
  |  |  ------------------
  ------------------
  822|  6.10M|                            ++input_ptr_;
  823|  6.10M|                            ++position_;
  824|  6.10M|                            break;
  825|     99|                        default:
  ------------------
  |  Branch (825:25): [True: 99, False: 6.12M]
  ------------------
  826|     99|                            if (parent() == parse_state::array)
  ------------------
  |  Branch (826:33): [True: 89, False: 10]
  ------------------
  827|     89|                            {
  828|     89|                                more_ = err_handler_(json_errc::expected_comma_or_rbracket, *this);
  829|     89|                                if (!more_)
  ------------------
  |  Branch (829:37): [True: 89, False: 0]
  ------------------
  830|     89|                                {
  831|     89|                                    ec = json_errc::expected_comma_or_rbracket;
  832|     89|                                    return;
  833|     89|                                }
  834|     89|                            }
  835|     10|                            else if (parent() == parse_state::object)
  ------------------
  |  Branch (835:38): [True: 10, False: 0]
  ------------------
  836|     10|                            {
  837|     10|                                more_ = err_handler_(json_errc::expected_comma_or_rbrace, *this);
  838|     10|                                if (!more_)
  ------------------
  |  Branch (838:37): [True: 10, False: 0]
  ------------------
  839|     10|                                {
  840|     10|                                    ec = json_errc::expected_comma_or_rbrace;
  841|     10|                                    return;
  842|     10|                                }
  843|     10|                            }
  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|  6.12M|                    }
  857|  6.12M|                    break;
  858|  6.12M|                }
  859|  6.12M|                case parse_state::expect_member_name_or_end: 
  ------------------
  |  Branch (859:17): [True: 35.8k, False: 15.7M]
  ------------------
  860|  35.8k|                {
  861|  35.8k|                    if (input_ptr_ >= local_input_end)
  ------------------
  |  Branch (861:25): [True: 0, False: 35.8k]
  ------------------
  862|      0|                    {
  863|      0|                        return;
  864|      0|                    }
  865|  35.8k|                    switch (*input_ptr_)
  866|  35.8k|                    {
  867|    463|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|     11|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 1, False: 35.8k]
  |  |  |  Branch (34:19): [True: 2, False: 35.8k]
  |  |  |  Branch (34:29): [True: 1, False: 35.8k]
  |  |  |  Branch (34:39): [True: 1, False: 35.8k]
  |  |  |  Branch (34:49): [True: 1, False: 35.8k]
  |  |  |  Branch (34:59): [True: 1, False: 35.8k]
  |  |  |  Branch (34:69): [True: 1, False: 35.8k]
  |  |  |  Branch (34:79): [True: 1, False: 35.8k]
  |  |  |  Branch (34:89): [True: 1, False: 35.8k]
  |  |  |  Branch (34:99): [True: 1, False: 35.8k]
  |  |  ------------------
  |  |   35|     21|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 1, False: 35.8k]
  |  |  |  Branch (35:19): [True: 1, False: 35.8k]
  |  |  |  Branch (35:29): [True: 1, False: 35.8k]
  |  |  |  Branch (35:39): [True: 1, False: 35.8k]
  |  |  |  Branch (35:49): [True: 1, False: 35.8k]
  |  |  |  Branch (35:59): [True: 1, False: 35.8k]
  |  |  |  Branch (35:69): [True: 1, False: 35.8k]
  |  |  |  Branch (35:79): [True: 1, False: 35.8k]
  |  |  |  Branch (35:89): [True: 1, False: 35.8k]
  |  |  |  Branch (35:99): [True: 1, False: 35.8k]
  |  |  ------------------
  |  |   36|     30|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 1, False: 35.8k]
  |  |  |  Branch (36:19): [True: 1, False: 35.8k]
  |  |  |  Branch (36:29): [True: 1, False: 35.8k]
  |  |  |  Branch (36:39): [True: 1, False: 35.8k]
  |  |  |  Branch (36:49): [True: 1, False: 35.8k]
  |  |  |  Branch (36:59): [True: 1, False: 35.8k]
  |  |  |  Branch (36:69): [True: 1, False: 35.8k]
  |  |  |  Branch (36:79): [True: 1, False: 35.8k]
  |  |  ------------------
  ------------------
  868|    463|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
  869|    463|                            if (!more_)
  ------------------
  |  Branch (869:33): [True: 30, False: 0]
  ------------------
  870|     30|                            {
  871|     30|                                ec = json_errc::illegal_control_character;
  872|     30|                                return;
  873|     30|                            }
  874|      0|                            ++input_ptr_;
  875|      0|                            ++position_;
  876|      0|                            break;
  877|    852|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (877:25): [True: 204, False: 35.6k]
  |  Branch (877:34): [True: 201, False: 35.6k]
  |  Branch (877:44): [True: 195, False: 35.6k]
  |  Branch (877:54): [True: 252, False: 35.5k]
  ------------------
  878|    852|                            skip_space(&input_ptr_);
  879|    852|                            break;
  880|    577|                        case '/':
  ------------------
  |  Branch (880:25): [True: 577, False: 35.2k]
  ------------------
  881|    577|                            ++input_ptr_;
  882|    577|                            ++position_;
  883|    577|                            push_state(state_); 
  884|    577|                            state_ = parse_state::slash;
  885|    577|                            break;
  886|  30.2k|                        case '}':
  ------------------
  |  Branch (886:25): [True: 30.2k, False: 5.58k]
  ------------------
  887|  30.2k|                            begin_position_ = position_;
  888|  30.2k|                            ++input_ptr_;
  889|  30.2k|                            ++position_;
  890|  30.2k|                            end_object(visitor, ec);
  891|  30.2k|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  30.2k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 30.2k]
  |  |  ------------------
  ------------------
  892|  30.2k|                            break;
  893|  30.2k|                        case '\"':
  ------------------
  |  Branch (893:25): [True: 4.11k, False: 31.7k]
  ------------------
  894|  4.11k|                            begin_position_ = position_;
  895|  4.11k|                            ++input_ptr_;
  896|  4.11k|                            ++position_;
  897|  4.11k|                            push_state(parse_state::member_name);
  898|  4.11k|                            state_ = parse_state::string;
  899|  4.11k|                            string_state_ = parse_string_state{};
  900|  4.11k|                            escape_tag_ = semantic_tag::noesc;
  901|  4.11k|                            buffer_.clear();
  902|  4.11k|                            input_ptr_ = parse_string(input_ptr_, visitor, ec);
  903|  4.11k|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  4.11k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 5, False: 4.10k]
  |  |  ------------------
  ------------------
  904|  4.10k|                            break;
  905|  4.10k|                        case '\'':
  ------------------
  |  Branch (905:25): [True: 1, False: 35.8k]
  ------------------
  906|      1|                            more_ = err_handler_(json_errc::single_quote, *this);
  907|      1|                            if (!more_)
  ------------------
  |  Branch (907:33): [True: 1, False: 0]
  ------------------
  908|      1|                            {
  909|      1|                                ec = json_errc::single_quote;
  910|      1|                                return;
  911|      1|                            }
  912|      0|                            ++input_ptr_;
  913|      0|                            ++position_;
  914|      0|                            break;
  915|      6|                        default:
  ------------------
  |  Branch (915:25): [True: 6, False: 35.8k]
  ------------------
  916|      6|                            more_ = err_handler_(json_errc::expected_key, *this);
  917|      6|                            if (!more_)
  ------------------
  |  Branch (917:33): [True: 6, False: 0]
  ------------------
  918|      6|                            {
  919|      6|                                ec = json_errc::expected_key;
  920|      6|                                return;
  921|      6|                            }
  922|      0|                            ++input_ptr_;
  923|      0|                            ++position_;
  924|      0|                            break;
  925|  35.8k|                    }
  926|  35.8k|                    break;
  927|  35.8k|                }
  928|   265k|                case parse_state::expect_member_name: 
  ------------------
  |  Branch (928:17): [True: 265k, False: 15.4M]
  ------------------
  929|   265k|                {
  930|   265k|                    switch (*input_ptr_)
  931|   265k|                    {
  932|    435|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|     10|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 1, False: 265k]
  |  |  |  Branch (34:19): [True: 1, False: 265k]
  |  |  |  Branch (34:29): [True: 1, False: 265k]
  |  |  |  Branch (34:39): [True: 1, False: 265k]
  |  |  |  Branch (34:49): [True: 1, False: 265k]
  |  |  |  Branch (34:59): [True: 1, False: 265k]
  |  |  |  Branch (34:69): [True: 1, False: 265k]
  |  |  |  Branch (34:79): [True: 1, False: 265k]
  |  |  |  Branch (34:89): [True: 1, False: 265k]
  |  |  |  Branch (34:99): [True: 1, False: 265k]
  |  |  ------------------
  |  |   35|     20|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 1, False: 265k]
  |  |  |  Branch (35:19): [True: 1, False: 265k]
  |  |  |  Branch (35:29): [True: 1, False: 265k]
  |  |  |  Branch (35:39): [True: 1, False: 265k]
  |  |  |  Branch (35:49): [True: 1, False: 265k]
  |  |  |  Branch (35:59): [True: 1, False: 265k]
  |  |  |  Branch (35:69): [True: 1, False: 265k]
  |  |  |  Branch (35:79): [True: 1, False: 265k]
  |  |  |  Branch (35:89): [True: 1, False: 265k]
  |  |  |  Branch (35:99): [True: 1, False: 265k]
  |  |  ------------------
  |  |   36|     29|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 1, False: 265k]
  |  |  |  Branch (36:19): [True: 1, False: 265k]
  |  |  |  Branch (36:29): [True: 1, False: 265k]
  |  |  |  Branch (36:39): [True: 1, False: 265k]
  |  |  |  Branch (36:49): [True: 1, False: 265k]
  |  |  |  Branch (36:59): [True: 1, False: 265k]
  |  |  |  Branch (36:69): [True: 1, False: 265k]
  |  |  |  Branch (36:79): [True: 1, False: 265k]
  |  |  ------------------
  ------------------
  933|    435|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
  934|    435|                            if (!more_)
  ------------------
  |  Branch (934:33): [True: 29, False: 0]
  ------------------
  935|     29|                            {
  936|     29|                                ec = json_errc::illegal_control_character;
  937|     29|                                return;
  938|     29|                            }
  939|      0|                            ++input_ptr_;
  940|      0|                            ++position_;
  941|      0|                            break;
  942|    835|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (942:25): [True: 194, False: 264k]
  |  Branch (942:34): [True: 194, False: 264k]
  |  Branch (942:44): [True: 201, False: 264k]
  |  Branch (942:54): [True: 246, False: 264k]
  ------------------
  943|    835|                            skip_space(&input_ptr_);
  944|    835|                            break;
  945|    810|                        case '/': 
  ------------------
  |  Branch (945:25): [True: 810, False: 264k]
  ------------------
  946|    810|                            ++input_ptr_;
  947|    810|                            ++position_;
  948|    810|                            push_state(state_);
  949|    810|                            state_ = parse_state::slash;
  950|    810|                            break;
  951|   263k|                        case '\"':
  ------------------
  |  Branch (951:25): [True: 263k, False: 1.67k]
  ------------------
  952|   263k|                            begin_position_ = position_;
  953|   263k|                            ++input_ptr_;
  954|   263k|                            ++position_;
  955|   263k|                            push_state(parse_state::member_name);
  956|   263k|                            state_ = parse_state::string;
  957|   263k|                            string_state_ = parse_string_state{};
  958|   263k|                            escape_tag_ = semantic_tag::noesc;
  959|   263k|                            buffer_.clear();
  960|   263k|                            input_ptr_ = parse_string(input_ptr_, visitor, ec);
  961|   263k|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|   263k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 5, False: 263k]
  |  |  ------------------
  ------------------
  962|   263k|                            break;
  963|   263k|                        case '}':
  ------------------
  |  Branch (963:25): [True: 1, False: 265k]
  ------------------
  964|      1|                            begin_position_ = position_;
  965|      1|                            ++input_ptr_;
  966|      1|                            ++position_;
  967|      1|                            if (!allow_trailing_comma_)
  ------------------
  |  Branch (967:33): [True: 1, False: 0]
  ------------------
  968|      1|                            {
  969|      1|                                more_ = err_handler_(json_errc::extra_comma, *this);
  970|      1|                                if (!more_)
  ------------------
  |  Branch (970:37): [True: 1, False: 0]
  ------------------
  971|      1|                                {
  972|      1|                                    ec = json_errc::extra_comma;
  973|      1|                                    return;
  974|      1|                                }
  975|      1|                            }
  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|      1|                        case '\'':
  ------------------
  |  Branch (979:25): [True: 1, False: 265k]
  ------------------
  980|      1|                            more_ = err_handler_(json_errc::single_quote, *this);
  981|      1|                            if (!more_)
  ------------------
  |  Branch (981:33): [True: 1, False: 0]
  ------------------
  982|      1|                            {
  983|      1|                                ec = json_errc::single_quote;
  984|      1|                                return;
  985|      1|                            }
  986|      0|                            ++input_ptr_;
  987|      0|                            ++position_;
  988|      0|                            break;
  989|      2|                        default:
  ------------------
  |  Branch (989:25): [True: 2, False: 265k]
  ------------------
  990|      2|                            more_ = err_handler_(json_errc::expected_key, *this);
  991|      2|                            if (!more_)
  ------------------
  |  Branch (991:33): [True: 2, False: 0]
  ------------------
  992|      2|                            {
  993|      2|                                ec = json_errc::expected_key;
  994|      2|                                return;
  995|      2|                            }
  996|      0|                            ++input_ptr_;
  997|      0|                            ++position_;
  998|      0|                            break;
  999|   265k|                    }
 1000|   265k|                    break;
 1001|   265k|                }
 1002|   269k|                case parse_state::expect_colon: 
  ------------------
  |  Branch (1002:17): [True: 269k, False: 15.4M]
  ------------------
 1003|   269k|                {
 1004|   269k|                    switch (*input_ptr_)
 1005|   269k|                    {
 1006|    464|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|     11|        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: 269k]
  |  |  |  Branch (34:19): [True: 1, False: 269k]
  |  |  |  Branch (34:29): [True: 1, False: 269k]
  |  |  |  Branch (34:39): [True: 1, False: 269k]
  |  |  |  Branch (34:49): [True: 1, False: 269k]
  |  |  |  Branch (34:59): [True: 1, False: 269k]
  |  |  |  Branch (34:69): [True: 1, False: 269k]
  |  |  |  Branch (34:79): [True: 1, False: 269k]
  |  |  |  Branch (34:89): [True: 1, False: 269k]
  |  |  |  Branch (34:99): [True: 1, False: 269k]
  |  |  ------------------
  |  |   35|     21|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 1, False: 269k]
  |  |  |  Branch (35:19): [True: 1, False: 269k]
  |  |  |  Branch (35:29): [True: 1, False: 269k]
  |  |  |  Branch (35:39): [True: 1, False: 269k]
  |  |  |  Branch (35:49): [True: 1, False: 269k]
  |  |  |  Branch (35:59): [True: 1, False: 269k]
  |  |  |  Branch (35:69): [True: 1, False: 269k]
  |  |  |  Branch (35:79): [True: 1, False: 269k]
  |  |  |  Branch (35:89): [True: 1, False: 269k]
  |  |  |  Branch (35:99): [True: 1, False: 269k]
  |  |  ------------------
  |  |   36|     30|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 1, False: 269k]
  |  |  |  Branch (36:19): [True: 1, False: 269k]
  |  |  |  Branch (36:29): [True: 1, False: 269k]
  |  |  |  Branch (36:39): [True: 1, False: 269k]
  |  |  |  Branch (36:49): [True: 1, False: 269k]
  |  |  |  Branch (36:59): [True: 1, False: 269k]
  |  |  |  Branch (36:69): [True: 1, False: 269k]
  |  |  |  Branch (36:79): [True: 1, False: 269k]
  |  |  ------------------
  ------------------
 1007|    464|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
 1008|    464|                            if (!more_)
  ------------------
  |  Branch (1008:33): [True: 30, False: 0]
  ------------------
 1009|     30|                            {
 1010|     30|                                ec = json_errc::illegal_control_character;
 1011|     30|                                return;
 1012|     30|                            }
 1013|      0|                            ++input_ptr_;
 1014|      0|                            ++position_;
 1015|      0|                            break;
 1016|    887|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (1016:25): [True: 194, False: 268k]
  |  Branch (1016:34): [True: 194, False: 268k]
  |  Branch (1016:44): [True: 198, False: 268k]
  |  Branch (1016:54): [True: 301, False: 268k]
  ------------------
 1017|    887|                            skip_space(&input_ptr_);
 1018|    887|                            break;
 1019|    809|                        case '/': 
  ------------------
  |  Branch (1019:25): [True: 809, False: 268k]
  ------------------
 1020|    809|                            push_state(state_);
 1021|    809|                            state_ = parse_state::slash;
 1022|    809|                            ++input_ptr_;
 1023|    809|                            ++position_;
 1024|    809|                            break;
 1025|   267k|                        case ':':
  ------------------
  |  Branch (1025:25): [True: 267k, False: 1.73k]
  ------------------
 1026|   267k|                            state_ = parse_state::expect_value;
 1027|   267k|                            ++input_ptr_;
 1028|   267k|                            ++position_;
 1029|   267k|                            break;
 1030|      5|                        default:
  ------------------
  |  Branch (1030:25): [True: 5, False: 269k]
  ------------------
 1031|      5|                            more_ = err_handler_(json_errc::expected_colon, *this);
 1032|      5|                            if (!more_)
  ------------------
  |  Branch (1032:33): [True: 5, False: 0]
  ------------------
 1033|      5|                            {
 1034|      5|                                ec = json_errc::expected_colon;
 1035|      5|                                return;
 1036|      5|                            }
 1037|      0|                            ++input_ptr_;
 1038|      0|                            ++position_;
 1039|      0|                            break;
 1040|   269k|                    }
 1041|   269k|                    break;
 1042|   269k|                }
 1043|  6.11M|                case parse_state::expect_value: 
  ------------------
  |  Branch (1043:17): [True: 6.11M, False: 9.62M]
  ------------------
 1044|  6.11M|                {
 1045|  6.11M|                    switch (*input_ptr_)
 1046|  6.11M|                    {
 1047|    435|                        JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|     10|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 1, False: 6.11M]
  |  |  |  Branch (34:19): [True: 1, False: 6.11M]
  |  |  |  Branch (34:29): [True: 1, False: 6.11M]
  |  |  |  Branch (34:39): [True: 1, False: 6.11M]
  |  |  |  Branch (34:49): [True: 1, False: 6.11M]
  |  |  |  Branch (34:59): [True: 1, False: 6.11M]
  |  |  |  Branch (34:69): [True: 1, False: 6.11M]
  |  |  |  Branch (34:79): [True: 1, False: 6.11M]
  |  |  |  Branch (34:89): [True: 1, False: 6.11M]
  |  |  |  Branch (34:99): [True: 1, False: 6.11M]
  |  |  ------------------
  |  |   35|     20|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 1, False: 6.11M]
  |  |  |  Branch (35:19): [True: 1, False: 6.11M]
  |  |  |  Branch (35:29): [True: 1, False: 6.11M]
  |  |  |  Branch (35:39): [True: 1, False: 6.11M]
  |  |  |  Branch (35:49): [True: 1, False: 6.11M]
  |  |  |  Branch (35:59): [True: 1, False: 6.11M]
  |  |  |  Branch (35:69): [True: 1, False: 6.11M]
  |  |  |  Branch (35:79): [True: 1, False: 6.11M]
  |  |  |  Branch (35:89): [True: 1, False: 6.11M]
  |  |  |  Branch (35:99): [True: 1, False: 6.11M]
  |  |  ------------------
  |  |   36|     29|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 1, False: 6.11M]
  |  |  |  Branch (36:19): [True: 1, False: 6.11M]
  |  |  |  Branch (36:29): [True: 1, False: 6.11M]
  |  |  |  Branch (36:39): [True: 1, False: 6.11M]
  |  |  |  Branch (36:49): [True: 1, False: 6.11M]
  |  |  |  Branch (36:59): [True: 1, False: 6.11M]
  |  |  |  Branch (36:69): [True: 1, False: 6.11M]
  |  |  |  Branch (36:79): [True: 1, False: 6.11M]
  |  |  ------------------
  ------------------
 1048|    435|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
 1049|    435|                            if (!more_)
  ------------------
  |  Branch (1049:33): [True: 29, False: 0]
  ------------------
 1050|     29|                            {
 1051|     29|                                ec = json_errc::illegal_control_character;
 1052|     29|                                return;
 1053|     29|                            }
 1054|      0|                            ++input_ptr_;
 1055|      0|                            ++position_;
 1056|      0|                            break;
 1057|  7.19k|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (1057:25): [True: 1.01k, False: 6.11M]
  |  Branch (1057:34): [True: 282, False: 6.11M]
  |  Branch (1057:44): [True: 405, False: 6.11M]
  |  Branch (1057:54): [True: 5.49k, False: 6.10M]
  ------------------
 1058|  7.19k|                            skip_space(&input_ptr_);
 1059|  7.19k|                            break;
 1060|    495|                        case '/': 
  ------------------
  |  Branch (1060:25): [True: 495, False: 6.11M]
  ------------------
 1061|    495|                            push_state(state_);
 1062|    495|                            ++input_ptr_;
 1063|    495|                            ++position_;
 1064|    495|                            state_ = parse_state::slash;
 1065|    495|                            break;
 1066|  32.8k|                        case '{':
  ------------------
  |  Branch (1066:25): [True: 32.8k, False: 6.08M]
  ------------------
 1067|  32.8k|                            begin_position_ = position_;
 1068|  32.8k|                            ++input_ptr_;
 1069|  32.8k|                            ++position_;
 1070|  32.8k|                            begin_object(visitor, ec);
 1071|  32.8k|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  32.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 32.8k]
  |  |  ------------------
  ------------------
 1072|  32.8k|                            break;
 1073|  32.8k|                        case '[':
  ------------------
  |  Branch (1073:25): [True: 25.3k, False: 6.08M]
  ------------------
 1074|  25.3k|                            begin_position_ = position_;
 1075|  25.3k|                            ++input_ptr_;
 1076|  25.3k|                            ++position_;
 1077|  25.3k|                            begin_array(visitor, ec);
 1078|  25.3k|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  25.3k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 25.3k]
  |  |  ------------------
  ------------------
 1079|  25.3k|                            break;
 1080|  25.3k|                        case '\"':
  ------------------
  |  Branch (1080:25): [True: 20.3k, False: 6.09M]
  ------------------
 1081|  20.3k|                            begin_position_ = position_;
 1082|  20.3k|                            ++input_ptr_;
 1083|  20.3k|                            ++position_;
 1084|  20.3k|                            state_ = parse_state::string;
 1085|  20.3k|                            string_state_ = parse_string_state{};
 1086|  20.3k|                            escape_tag_ = semantic_tag::noesc;
 1087|  20.3k|                            buffer_.clear();
 1088|  20.3k|                            input_ptr_ = parse_string(input_ptr_, visitor, ec);
 1089|  20.3k|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  20.3k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 20.3k]
  |  |  ------------------
  ------------------
 1090|  20.3k|                            break;
 1091|   206k|                        case '-':
  ------------------
  |  Branch (1091:25): [True: 206k, False: 5.90M]
  ------------------
 1092|   206k|                            buffer_.clear();
 1093|   206k|                            buffer_.push_back('-');
 1094|   206k|                            begin_position_ = position_;
 1095|   206k|                            ++input_ptr_;
 1096|   206k|                            ++position_;
 1097|   206k|                            state_ = parse_state::number;
 1098|   206k|                            number_state_ = parse_number_state::minus;
 1099|   206k|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
 1100|   206k|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|   206k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 9, False: 206k]
  |  |  ------------------
  ------------------
 1101|   206k|                            break;
 1102|   569k|                        case '0': 
  ------------------
  |  Branch (1102:25): [True: 569k, False: 5.54M]
  ------------------
 1103|   569k|                            buffer_.clear();
 1104|   569k|                            buffer_.push_back(static_cast<char>(*input_ptr_));
 1105|   569k|                            begin_position_ = position_;
 1106|   569k|                            ++input_ptr_;
 1107|   569k|                            ++position_;
 1108|   569k|                            state_ = parse_state::number;
 1109|   569k|                            number_state_ = parse_number_state::zero;
 1110|   569k|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
 1111|   569k|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|   569k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 569k]
  |  |  ------------------
  ------------------
 1112|   569k|                            break;
 1113|  4.23M|                        case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (1113:25): [True: 129k, False: 5.98M]
  |  Branch (1113:34): [True: 122k, False: 5.99M]
  |  Branch (1113:43): [True: 326k, False: 5.78M]
  |  Branch (1113:52): [True: 56.4k, False: 6.05M]
  |  Branch (1113:61): [True: 532k, False: 5.58M]
  |  Branch (1113:70): [True: 1.07M, False: 5.04M]
  |  Branch (1113:79): [True: 484k, False: 5.62M]
  |  Branch (1113:88): [True: 177k, False: 5.93M]
  |  Branch (1113:98): [True: 1.33M, False: 4.77M]
  ------------------
 1114|  4.23M|                            buffer_.clear();
 1115|  4.23M|                            buffer_.push_back(static_cast<char>(*input_ptr_));
 1116|  4.23M|                            begin_position_ = position_;
 1117|  4.23M|                            ++input_ptr_;
 1118|  4.23M|                            ++position_;
 1119|  4.23M|                            state_ = parse_state::number;
 1120|  4.23M|                            number_state_ = parse_number_state::integer;
 1121|  4.23M|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
 1122|  4.23M|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  4.23M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 4.23M]
  |  |  ------------------
  ------------------
 1123|  4.23M|                            break;
 1124|  4.23M|                        case 'n':
  ------------------
  |  Branch (1124:25): [True: 241k, False: 5.87M]
  ------------------
 1125|   241k|                            parse_null(visitor, ec);
 1126|   241k|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|   241k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 241k]
  |  |  ------------------
  ------------------
 1127|   241k|                            break;
 1128|   466k|                        case 't':
  ------------------
  |  Branch (1128:25): [True: 466k, False: 5.64M]
  ------------------
 1129|   466k|                            input_ptr_ = parse_true(input_ptr_, visitor, ec);
 1130|   466k|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|   466k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 6, False: 466k]
  |  |  ------------------
  ------------------
 1131|   466k|                            break;
 1132|   466k|                        case 'f':
  ------------------
  |  Branch (1132:25): [True: 303k, False: 5.81M]
  ------------------
 1133|   303k|                            input_ptr_ = parse_false(input_ptr_, visitor, ec);
 1134|   303k|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|   303k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 9, False: 303k]
  |  |  ------------------
  ------------------
 1135|   303k|                            break;
 1136|   303k|                        case ']':
  ------------------
  |  Branch (1136:25): [True: 2, False: 6.11M]
  ------------------
 1137|      2|                            begin_position_ = position_;
 1138|      2|                            ++input_ptr_;
 1139|      2|                            ++position_;
 1140|      2|                            if (parent() == parse_state::array)
  ------------------
  |  Branch (1140:33): [True: 1, False: 1]
  ------------------
 1141|      1|                            {
 1142|      1|                                if (!allow_trailing_comma_)
  ------------------
  |  Branch (1142:37): [True: 1, False: 0]
  ------------------
 1143|      1|                                {
 1144|      1|                                    more_ = err_handler_(json_errc::extra_comma, *this);
 1145|      1|                                    if (!more_)
  ------------------
  |  Branch (1145:41): [True: 1, False: 0]
  ------------------
 1146|      1|                                    {
 1147|      1|                                        ec = json_errc::extra_comma;
 1148|      1|                                        return;
 1149|      1|                                    }
 1150|      1|                                }
 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|      1|                            else
 1155|      1|                            {
 1156|      1|                                more_ = err_handler_(json_errc::expected_value, *this);
 1157|      1|                                if (!more_)
  ------------------
  |  Branch (1157:37): [True: 1, False: 0]
  ------------------
 1158|      1|                                {
 1159|      1|                                    ec = json_errc::expected_value;
 1160|      1|                                    return;
 1161|      1|                                }
 1162|      1|                            }
 1163|       |                            
 1164|      0|                            break;
 1165|      1|                        case '\'':
  ------------------
  |  Branch (1165:25): [True: 1, False: 6.11M]
  ------------------
 1166|      1|                            more_ = err_handler_(json_errc::single_quote, *this);
 1167|      1|                            if (!more_)
  ------------------
  |  Branch (1167:33): [True: 1, False: 0]
  ------------------
 1168|      1|                            {
 1169|      1|                                ec = json_errc::single_quote;
 1170|      1|                                return;
 1171|      1|                            }
 1172|      0|                            ++input_ptr_;
 1173|      0|                            ++position_;
 1174|      0|                            break;
 1175|     19|                        default:
  ------------------
  |  Branch (1175:25): [True: 19, False: 6.11M]
  ------------------
 1176|     19|                            more_ = err_handler_(json_errc::expected_value, *this);
 1177|     19|                            if (!more_)
  ------------------
  |  Branch (1177:33): [True: 19, False: 0]
  ------------------
 1178|     19|                            {
 1179|     19|                                ec = json_errc::expected_value;
 1180|     19|                                return;
 1181|     19|                            }
 1182|      0|                            ++input_ptr_;
 1183|      0|                            ++position_;
 1184|      0|                            break;
 1185|  6.11M|                    }
 1186|  6.11M|                    break;
 1187|  6.11M|                }
 1188|  6.11M|                case parse_state::expect_value_or_end: 
  ------------------
  |  Branch (1188:17): [True: 110k, False: 15.6M]
  ------------------
 1189|   110k|                {
 1190|   110k|                    switch (*input_ptr_)
 1191|   110k|                    {
 1192|    500|                        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: 110k]
  |  |  |  Branch (34:19): [True: 1, False: 110k]
  |  |  |  Branch (34:29): [True: 1, False: 110k]
  |  |  |  Branch (34:39): [True: 1, False: 110k]
  |  |  |  Branch (34:49): [True: 2, False: 110k]
  |  |  |  Branch (34:59): [True: 1, False: 110k]
  |  |  |  Branch (34:69): [True: 1, False: 110k]
  |  |  |  Branch (34:79): [True: 1, False: 110k]
  |  |  |  Branch (34:89): [True: 1, False: 110k]
  |  |  |  Branch (34:99): [True: 1, False: 110k]
  |  |  ------------------
  |  |   35|     23|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 1, False: 110k]
  |  |  |  Branch (35:19): [True: 1, False: 110k]
  |  |  |  Branch (35:29): [True: 1, False: 110k]
  |  |  |  Branch (35:39): [True: 1, False: 110k]
  |  |  |  Branch (35:49): [True: 1, False: 110k]
  |  |  |  Branch (35:59): [True: 1, False: 110k]
  |  |  |  Branch (35:69): [True: 1, False: 110k]
  |  |  |  Branch (35:79): [True: 1, False: 110k]
  |  |  |  Branch (35:89): [True: 2, False: 110k]
  |  |  |  Branch (35:99): [True: 1, False: 110k]
  |  |  ------------------
  |  |   36|     32|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 1, False: 110k]
  |  |  |  Branch (36:19): [True: 1, False: 110k]
  |  |  |  Branch (36:29): [True: 1, False: 110k]
  |  |  |  Branch (36:39): [True: 1, False: 110k]
  |  |  |  Branch (36:49): [True: 1, False: 110k]
  |  |  |  Branch (36:59): [True: 1, False: 110k]
  |  |  |  Branch (36:69): [True: 1, False: 110k]
  |  |  |  Branch (36:79): [True: 1, False: 110k]
  |  |  ------------------
  ------------------
 1193|    500|                            more_ = err_handler_(json_errc::illegal_control_character, *this);
 1194|    500|                            if (!more_)
  ------------------
  |  Branch (1194:33): [True: 32, False: 0]
  ------------------
 1195|     32|                            {
 1196|     32|                                ec = json_errc::illegal_control_character;
 1197|     32|                                return;
 1198|     32|                            }
 1199|      0|                            ++input_ptr_;
 1200|      0|                            ++position_;
 1201|      0|                            break;
 1202|  17.3k|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (1202:25): [True: 368, False: 110k]
  |  Branch (1202:34): [True: 401, False: 110k]
  |  Branch (1202:44): [True: 15.9k, False: 94.7k]
  |  Branch (1202:54): [True: 551, False: 110k]
  ------------------
 1203|  17.3k|                            skip_space(&input_ptr_);
 1204|  17.3k|                            break;
 1205|  16.0k|                        case '/': 
  ------------------
  |  Branch (1205:25): [True: 16.0k, False: 94.6k]
  ------------------
 1206|  16.0k|                            ++input_ptr_;
 1207|  16.0k|                            ++position_;
 1208|  16.0k|                            push_state(state_);
 1209|  16.0k|                            state_ = parse_state::slash;
 1210|  16.0k|                            break;
 1211|  1.17k|                        case '{':
  ------------------
  |  Branch (1211:25): [True: 1.17k, False: 109k]
  ------------------
 1212|  1.17k|                            begin_position_ = position_;
 1213|  1.17k|                            ++input_ptr_;
 1214|  1.17k|                            ++position_;
 1215|  1.17k|                            begin_object(visitor, ec);
 1216|  1.17k|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  1.17k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 1.17k]
  |  |  ------------------
  ------------------
 1217|  1.17k|                            break;
 1218|  50.5k|                        case '[':
  ------------------
  |  Branch (1218:25): [True: 50.5k, False: 60.2k]
  ------------------
 1219|  50.5k|                            begin_position_ = position_;
 1220|  50.5k|                            ++input_ptr_;
 1221|  50.5k|                            ++position_;
 1222|  50.5k|                            begin_array(visitor, ec);
 1223|  50.5k|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  50.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 50.5k]
  |  |  ------------------
  ------------------
 1224|  50.5k|                            break;
 1225|  50.5k|                        case ']':
  ------------------
  |  Branch (1225:25): [True: 1.17k, False: 109k]
  ------------------
 1226|  1.17k|                            begin_position_ = position_;
 1227|  1.17k|                            ++input_ptr_;
 1228|  1.17k|                            ++position_;
 1229|  1.17k|                            end_array(visitor, ec);
 1230|  1.17k|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  1.17k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.17k]
  |  |  ------------------
  ------------------
 1231|  1.17k|                            break;
 1232|  1.17k|                        case '\"':
  ------------------
  |  Branch (1232:25): [True: 493, False: 110k]
  ------------------
 1233|    493|                            begin_position_ = position_;
 1234|    493|                            ++input_ptr_;
 1235|    493|                            ++position_;
 1236|    493|                            state_ = parse_state::string;
 1237|    493|                            string_state_ = parse_string_state{};
 1238|    493|                            escape_tag_ = semantic_tag::noesc;
 1239|    493|                            buffer_.clear();
 1240|    493|                            input_ptr_ = parse_string(input_ptr_, visitor, ec);
 1241|    493|                            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|    493|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 490]
  |  |  ------------------
  ------------------
 1242|    490|                            break;
 1243|  1.16k|                        case '-':
  ------------------
  |  Branch (1243:25): [True: 1.16k, False: 109k]
  ------------------
 1244|  1.16k|                            buffer_.clear();
 1245|  1.16k|                            buffer_.push_back('-');
 1246|  1.16k|                            begin_position_ = position_;
 1247|  1.16k|                            ++input_ptr_;
 1248|  1.16k|                            ++position_;
 1249|  1.16k|                            state_ = parse_state::number;
 1250|  1.16k|                            number_state_ = parse_number_state::minus;
 1251|  1.16k|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
 1252|  1.16k|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  1.16k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 1.16k]
  |  |  ------------------
  ------------------
 1253|  1.16k|                            break;
 1254|  2.52k|                        case '0': 
  ------------------
  |  Branch (1254:25): [True: 2.52k, False: 108k]
  ------------------
 1255|  2.52k|                            buffer_.clear();
 1256|  2.52k|                            buffer_.push_back(static_cast<char>(*input_ptr_));
 1257|  2.52k|                            begin_position_ = position_;
 1258|  2.52k|                            ++input_ptr_;
 1259|  2.52k|                            ++position_;
 1260|  2.52k|                            state_ = parse_state::number;
 1261|  2.52k|                            number_state_ = parse_number_state::zero;
 1262|  2.52k|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
 1263|  2.52k|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  2.52k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 2.52k]
  |  |  ------------------
  ------------------
 1264|  2.52k|                            break;
 1265|  15.6k|                        case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (1265:25): [True: 1.55k, False: 109k]
  |  Branch (1265:34): [True: 497, False: 110k]
  |  Branch (1265:43): [True: 4.41k, False: 106k]
  |  Branch (1265:52): [True: 771, False: 109k]
  |  Branch (1265:61): [True: 411, False: 110k]
  |  Branch (1265:70): [True: 598, False: 110k]
  |  Branch (1265:79): [True: 1.26k, False: 109k]
  |  Branch (1265:88): [True: 451, False: 110k]
  |  Branch (1265:98): [True: 5.67k, False: 105k]
  ------------------
 1266|  15.6k|                            buffer_.clear();
 1267|  15.6k|                            buffer_.push_back(static_cast<char>(*input_ptr_));
 1268|  15.6k|                            begin_position_ = position_;
 1269|  15.6k|                            ++input_ptr_;
 1270|  15.6k|                            ++position_;
 1271|  15.6k|                            state_ = parse_state::number;
 1272|  15.6k|                            number_state_ = parse_number_state::integer;
 1273|  15.6k|                            input_ptr_ = parse_number(input_ptr_, visitor, ec);
 1274|  15.6k|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  15.6k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 15.6k]
  |  |  ------------------
  ------------------
 1275|  15.6k|                            break;
 1276|  15.6k|                        case 'n':
  ------------------
  |  Branch (1276:25): [True: 3.47k, False: 107k]
  ------------------
 1277|  3.47k|                            parse_null(visitor, ec);
 1278|  3.47k|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|  3.47k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 3.47k]
  |  |  ------------------
  ------------------
 1279|  3.47k|                            break;
 1280|  3.47k|                        case 't':
  ------------------
  |  Branch (1280:25): [True: 697, False: 110k]
  ------------------
 1281|    697|                            input_ptr_ = parse_true(input_ptr_, visitor, ec);
 1282|    697|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|    697|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 696]
  |  |  ------------------
  ------------------
 1283|    696|                            break;
 1284|    696|                        case 'f':
  ------------------
  |  Branch (1284:25): [True: 412, False: 110k]
  ------------------
 1285|    412|                            input_ptr_ = parse_false(input_ptr_, visitor, ec);
 1286|    412|                            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|    412|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 411]
  |  |  ------------------
  ------------------
 1287|    411|                            break;
 1288|    411|                        case '\'':
  ------------------
  |  Branch (1288:25): [True: 1, False: 110k]
  ------------------
 1289|      1|                            more_ = err_handler_(json_errc::single_quote, *this);
 1290|      1|                            if (!more_)
  ------------------
  |  Branch (1290:33): [True: 1, False: 0]
  ------------------
 1291|      1|                            {
 1292|      1|                                ec = json_errc::single_quote;
 1293|      1|                                return;
 1294|      1|                            }
 1295|      0|                            ++input_ptr_;
 1296|      0|                            ++position_;
 1297|      0|                            break;
 1298|      9|                        default:
  ------------------
  |  Branch (1298:25): [True: 9, False: 110k]
  ------------------
 1299|      9|                            more_ = err_handler_(json_errc::expected_value, *this);
 1300|      9|                            if (!more_)
  ------------------
  |  Branch (1300:33): [True: 9, False: 0]
  ------------------
 1301|      9|                            {
 1302|      9|                                ec = json_errc::expected_value;
 1303|      9|                                return;
 1304|      9|                            }
 1305|      0|                            ++input_ptr_;
 1306|      0|                            ++position_;
 1307|      0|                            break;
 1308|   110k|                        }
 1309|   110k|                    }
 1310|   110k|                    break;
 1311|   373k|                case parse_state::string: 
  ------------------
  |  Branch (1311:17): [True: 373k, False: 15.3M]
  ------------------
 1312|   373k|                    input_ptr_ = parse_string(input_ptr_, visitor, ec);
 1313|   373k|                    if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|   373k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 43, False: 373k]
  |  |  ------------------
  ------------------
 1314|   373k|                    break;
 1315|   373k|                case parse_state::number:
  ------------------
  |  Branch (1315:17): [True: 1.98k, False: 15.7M]
  ------------------
 1316|  1.98k|                    input_ptr_ = parse_number(input_ptr_, visitor, ec);  
 1317|  1.98k|                    if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  1.98k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 1.97k]
  |  |  ------------------
  ------------------
 1318|  1.97k|                    break;
 1319|  1.97k|                case parse_state::t: 
  ------------------
  |  Branch (1319:17): [True: 204, False: 15.7M]
  ------------------
 1320|    204|                    switch (*input_ptr_)
 1321|    204|                    {
 1322|    192|                        case 'r':
  ------------------
  |  Branch (1322:25): [True: 192, False: 12]
  ------------------
 1323|    192|                            ++input_ptr_;
 1324|    192|                            ++position_;
 1325|    192|                            state_ = parse_state::tr;
 1326|    192|                            break;
 1327|     12|                        default:
  ------------------
  |  Branch (1327:25): [True: 12, False: 192]
  ------------------
 1328|     12|                            err_handler_(json_errc::invalid_value, *this);
 1329|     12|                            ec = json_errc::invalid_value;
 1330|     12|                            more_ = false;
 1331|     12|                            return;
 1332|    204|                    }
 1333|    192|                    break;
 1334|    192|                case parse_state::tr: 
  ------------------
  |  Branch (1334:17): [True: 190, False: 15.7M]
  ------------------
 1335|    190|                    switch (*input_ptr_)
 1336|    190|                    {
 1337|    179|                        case 'u':
  ------------------
  |  Branch (1337:25): [True: 179, False: 11]
  ------------------
 1338|    179|                            state_ = parse_state::tru;
 1339|    179|                            break;
 1340|     11|                        default:
  ------------------
  |  Branch (1340:25): [True: 11, False: 179]
  ------------------
 1341|     11|                            err_handler_(json_errc::invalid_value, *this);
 1342|     11|                            ec = json_errc::invalid_value;
 1343|     11|                            more_ = false;
 1344|     11|                            return;
 1345|    190|                    }
 1346|    179|                    ++input_ptr_;
 1347|    179|                    ++position_;
 1348|    179|                    break;
 1349|    168|                case parse_state::tru: 
  ------------------
  |  Branch (1349:17): [True: 168, False: 15.7M]
  ------------------
 1350|    168|                    switch (*input_ptr_)
 1351|    168|                    {
 1352|    163|                        case 'e':
  ------------------
  |  Branch (1352:25): [True: 163, False: 5]
  ------------------
 1353|    163|                            ++input_ptr_;
 1354|    163|                            ++position_;
 1355|    163|                            visitor.bool_value(true,  semantic_tag::none, *this, ec);
 1356|    163|                            if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|    163|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 163]
  |  |  ------------------
  ------------------
 1357|    163|                            if (level_ == 0)
  ------------------
  |  Branch (1357:33): [True: 1, False: 162]
  ------------------
 1358|      1|                            {
 1359|      1|                                state_ = parse_state::accept;
 1360|      1|                            }
 1361|    162|                            else
 1362|    162|                            {
 1363|    162|                                state_ = parse_state::expect_comma_or_end;
 1364|    162|                            }
 1365|    163|                            more_ = !cursor_mode_;
 1366|    163|                            break;
 1367|      5|                        default:
  ------------------
  |  Branch (1367:25): [True: 5, False: 163]
  ------------------
 1368|      5|                            err_handler_(json_errc::invalid_value, *this);
 1369|      5|                            ec = json_errc::invalid_value;
 1370|      5|                            more_ = false;
 1371|      5|                            return;
 1372|    168|                    }
 1373|    163|                    break;
 1374|    164|                case parse_state::f: 
  ------------------
  |  Branch (1374:17): [True: 164, False: 15.7M]
  ------------------
 1375|    164|                    switch (*input_ptr_)
 1376|    164|                    {
 1377|    153|                        case 'a':
  ------------------
  |  Branch (1377:25): [True: 153, False: 11]
  ------------------
 1378|    153|                            ++input_ptr_;
 1379|    153|                            ++position_;
 1380|    153|                            state_ = parse_state::fa;
 1381|    153|                            break;
 1382|     11|                        default:
  ------------------
  |  Branch (1382:25): [True: 11, False: 153]
  ------------------
 1383|     11|                            err_handler_(json_errc::invalid_value, *this);
 1384|     11|                            ec = json_errc::invalid_value;
 1385|     11|                            more_ = false;
 1386|     11|                            return;
 1387|    164|                    }
 1388|    153|                    break;
 1389|    153|                case parse_state::fa: 
  ------------------
  |  Branch (1389:17): [True: 151, False: 15.7M]
  ------------------
 1390|    151|                    switch (*input_ptr_)
 1391|    151|                    {
 1392|    139|                        case 'l':
  ------------------
  |  Branch (1392:25): [True: 139, False: 12]
  ------------------
 1393|    139|                            state_ = parse_state::fal;
 1394|    139|                            break;
 1395|     12|                        default:
  ------------------
  |  Branch (1395:25): [True: 12, False: 139]
  ------------------
 1396|     12|                            err_handler_(json_errc::invalid_value, *this);
 1397|     12|                            ec = json_errc::invalid_value;
 1398|     12|                            more_ = false;
 1399|     12|                            return;
 1400|    151|                    }
 1401|    139|                    ++input_ptr_;
 1402|    139|                    ++position_;
 1403|    139|                    break;
 1404|    136|                case parse_state::fal: 
  ------------------
  |  Branch (1404:17): [True: 136, False: 15.7M]
  ------------------
 1405|    136|                    switch (*input_ptr_)
 1406|    136|                    {
 1407|    126|                        case 's':
  ------------------
  |  Branch (1407:25): [True: 126, False: 10]
  ------------------
 1408|    126|                            state_ = parse_state::fals;
 1409|    126|                            break;
 1410|     10|                        default:
  ------------------
  |  Branch (1410:25): [True: 10, False: 126]
  ------------------
 1411|     10|                            err_handler_(json_errc::invalid_value, *this);
 1412|     10|                            ec = json_errc::invalid_value;
 1413|     10|                            more_ = false;
 1414|     10|                            return;
 1415|    136|                    }
 1416|    126|                    ++input_ptr_;
 1417|    126|                    ++position_;
 1418|    126|                    break;
 1419|    123|                case parse_state::fals: 
  ------------------
  |  Branch (1419:17): [True: 123, False: 15.7M]
  ------------------
 1420|    123|                    switch (*input_ptr_)
 1421|    123|                    {
 1422|    113|                        case 'e':
  ------------------
  |  Branch (1422:25): [True: 113, False: 10]
  ------------------
 1423|    113|                            ++input_ptr_;
 1424|    113|                            ++position_;
 1425|    113|                            visitor.bool_value(false, semantic_tag::none, *this, ec);
 1426|    113|                            if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|    113|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 113]
  |  |  ------------------
  ------------------
 1427|    113|                            if (level_ == 0)
  ------------------
  |  Branch (1427:33): [True: 1, False: 112]
  ------------------
 1428|      1|                            {
 1429|      1|                                state_ = parse_state::accept;
 1430|      1|                            }
 1431|    112|                            else
 1432|    112|                            {
 1433|    112|                                state_ = parse_state::expect_comma_or_end;
 1434|    112|                            }
 1435|    113|                            more_ = !cursor_mode_;
 1436|    113|                            break;
 1437|     10|                        default:
  ------------------
  |  Branch (1437:25): [True: 10, False: 113]
  ------------------
 1438|     10|                            err_handler_(json_errc::invalid_value, *this);
 1439|     10|                            ec = json_errc::invalid_value;
 1440|     10|                            more_ = false;
 1441|     10|                            return;
 1442|    123|                    }
 1443|    113|                    break;
 1444|    115|                case parse_state::n: 
  ------------------
  |  Branch (1444:17): [True: 115, False: 15.7M]
  ------------------
 1445|    115|                    switch (*input_ptr_)
 1446|    115|                    {
 1447|    105|                        case 'u':
  ------------------
  |  Branch (1447:25): [True: 105, False: 10]
  ------------------
 1448|    105|                            ++input_ptr_;
 1449|    105|                            ++position_;
 1450|    105|                            state_ = parse_state::nu;
 1451|    105|                            break;
 1452|     10|                        default:
  ------------------
  |  Branch (1452:25): [True: 10, False: 105]
  ------------------
 1453|     10|                            err_handler_(json_errc::invalid_value, *this);
 1454|     10|                            ec = json_errc::invalid_value;
 1455|     10|                            more_ = false;
 1456|     10|                            return;
 1457|    115|                    }
 1458|    105|                    break;
 1459|    105|                case parse_state::nu: 
  ------------------
  |  Branch (1459:17): [True: 101, False: 15.7M]
  ------------------
 1460|    101|                    switch (*input_ptr_)
 1461|    101|                    {
 1462|     90|                        case 'l':
  ------------------
  |  Branch (1462:25): [True: 90, False: 11]
  ------------------
 1463|     90|                            state_ = parse_state::nul;
 1464|     90|                            break;
 1465|     11|                        default:
  ------------------
  |  Branch (1465:25): [True: 11, False: 90]
  ------------------
 1466|     11|                            err_handler_(json_errc::invalid_value, *this);
 1467|     11|                            ec = json_errc::invalid_value;
 1468|     11|                            more_ = false;
 1469|     11|                            return;
 1470|    101|                    }
 1471|     90|                    ++input_ptr_;
 1472|     90|                    ++position_;
 1473|     90|                    break;
 1474|     84|                case parse_state::nul: 
  ------------------
  |  Branch (1474:17): [True: 84, False: 15.7M]
  ------------------
 1475|     84|                    ++position_;
 1476|     84|                    switch (*input_ptr_)
 1477|     84|                    {
 1478|     74|                        case 'l':
  ------------------
  |  Branch (1478:25): [True: 74, False: 10]
  ------------------
 1479|     74|                            visitor.null_value(semantic_tag::none, *this, ec);
 1480|     74|                            if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|     74|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 74]
  |  |  ------------------
  ------------------
 1481|     74|                            if (level_ == 0)
  ------------------
  |  Branch (1481:33): [True: 1, False: 73]
  ------------------
 1482|      1|                            {
 1483|      1|                                state_ = parse_state::accept;
 1484|      1|                            }
 1485|     73|                            else
 1486|     73|                            {
 1487|     73|                                state_ = parse_state::expect_comma_or_end;
 1488|     73|                            }
 1489|     74|                            more_ = !cursor_mode_;
 1490|     74|                            break;
 1491|     10|                        default:
  ------------------
  |  Branch (1491:25): [True: 10, False: 74]
  ------------------
 1492|     10|                            err_handler_(json_errc::invalid_value, *this);
 1493|     10|                            ec = json_errc::invalid_value;
 1494|     10|                            more_ = false;
 1495|     10|                            return;
 1496|     84|                    }
 1497|     74|                    ++input_ptr_;
 1498|     74|                    break;
 1499|  23.0k|                case parse_state::slash: 
  ------------------
  |  Branch (1499:17): [True: 23.0k, False: 15.7M]
  ------------------
 1500|  23.0k|                {
 1501|  23.0k|                    switch (*input_ptr_)
 1502|  23.0k|                    {
 1503|  1.81k|                        case '*':
  ------------------
  |  Branch (1503:25): [True: 1.81k, False: 21.1k]
  ------------------
 1504|  1.81k|                            if (!allow_comments_)
  ------------------
  |  Branch (1504:33): [True: 0, False: 1.81k]
  ------------------
 1505|      0|                            {
 1506|      0|                                ec = json_errc::illegal_comment;
 1507|      0|                                return;
 1508|      0|                            }
 1509|  1.81k|                            more_ = err_handler_(json_errc::illegal_comment, *this);
 1510|  1.81k|                            if (!more_)
  ------------------
  |  Branch (1510:33): [True: 0, False: 1.81k]
  ------------------
 1511|      0|                            {
 1512|      0|                                ec = json_errc::illegal_comment;
 1513|      0|                                return;
 1514|      0|                            }
 1515|  1.81k|                            state_ = parse_state::slash_star;
 1516|  1.81k|                            break;
 1517|  21.1k|                        case '/':
  ------------------
  |  Branch (1517:25): [True: 21.1k, False: 1.82k]
  ------------------
 1518|  21.1k|                            if (!allow_comments_)
  ------------------
  |  Branch (1518:33): [True: 0, False: 21.1k]
  ------------------
 1519|      0|                            {
 1520|      0|                                ec = json_errc::illegal_comment;
 1521|      0|                                return;
 1522|      0|                            }
 1523|  21.1k|                            more_ = err_handler_(json_errc::illegal_comment, *this);
 1524|  21.1k|                            if (!more_)
  ------------------
  |  Branch (1524:33): [True: 0, False: 21.1k]
  ------------------
 1525|      0|                            {
 1526|      0|                                ec = json_errc::illegal_comment;
 1527|      0|                                return;
 1528|      0|                            }
 1529|  21.1k|                            state_ = parse_state::slash_slash;
 1530|  21.1k|                            break;
 1531|      6|                        default:    
  ------------------
  |  Branch (1531:25): [True: 6, False: 22.9k]
  ------------------
 1532|      6|                            more_ = err_handler_(json_errc::syntax_error, *this);
 1533|      6|                            if (!more_)
  ------------------
  |  Branch (1533:33): [True: 6, False: 0]
  ------------------
 1534|      6|                            {
 1535|      6|                                ec = json_errc::syntax_error;
 1536|      6|                                return;
 1537|      6|                            }
 1538|      0|                            break;
 1539|  23.0k|                    }
 1540|  22.9k|                    ++input_ptr_;
 1541|  22.9k|                    ++position_;
 1542|  22.9k|                    break;
 1543|  23.0k|                }
 1544|   843k|                case parse_state::slash_star:  
  ------------------
  |  Branch (1544:17): [True: 843k, False: 14.8M]
  ------------------
 1545|   843k|                {
 1546|   843k|                    switch (*input_ptr_)
 1547|   843k|                    {
 1548|  28.6k|                        case '\r':
  ------------------
  |  Branch (1548:25): [True: 28.6k, False: 815k]
  ------------------
 1549|  28.6k|                            push_state(state_);
 1550|  28.6k|                            ++input_ptr_;
 1551|  28.6k|                            ++position_;
 1552|  28.6k|                            state_ = parse_state::cr;
 1553|  28.6k|                            break;
 1554|   229k|                        case '\n':
  ------------------
  |  Branch (1554:25): [True: 229k, False: 614k]
  ------------------
 1555|   229k|                            ++input_ptr_;
 1556|   229k|                            ++line_;
 1557|   229k|                            ++position_;
 1558|   229k|                            mark_position_ = position_;
 1559|   229k|                            break;
 1560|  2.48k|                        case '*':
  ------------------
  |  Branch (1560:25): [True: 2.48k, False: 841k]
  ------------------
 1561|  2.48k|                            ++input_ptr_;
 1562|  2.48k|                            ++position_;
 1563|  2.48k|                            state_ = parse_state::slash_star_star;
 1564|  2.48k|                            break;
 1565|   583k|                        default:
  ------------------
  |  Branch (1565:25): [True: 583k, False: 260k]
  ------------------
 1566|   583k|                            ++input_ptr_;
 1567|   583k|                            ++position_;
 1568|   583k|                            break;
 1569|   843k|                    }
 1570|   843k|                    break;
 1571|   843k|                }
 1572|  1.54M|                case parse_state::slash_slash: 
  ------------------
  |  Branch (1572:17): [True: 1.54M, False: 14.2M]
  ------------------
 1573|  1.54M|                {
 1574|  1.54M|                    switch (*input_ptr_)
 1575|  1.54M|                    {
 1576|  2.20k|                    case '\r':
  ------------------
  |  Branch (1576:21): [True: 2.20k, False: 1.53M]
  ------------------
 1577|  21.1k|                    case '\n':
  ------------------
  |  Branch (1577:21): [True: 18.9k, False: 1.52M]
  ------------------
 1578|  21.1k|                        state_ = pop_state();
 1579|  21.1k|                        break;
 1580|  1.51M|                    default:
  ------------------
  |  Branch (1580:21): [True: 1.51M, False: 21.1k]
  ------------------
 1581|  1.51M|                        ++input_ptr_;
 1582|  1.51M|                        ++position_;
 1583|  1.54M|                    }
 1584|  1.54M|                    break;
 1585|  1.54M|                }
 1586|  1.54M|                case parse_state::slash_star_star: 
  ------------------
  |  Branch (1586:17): [True: 2.48k, False: 15.7M]
  ------------------
 1587|  2.48k|                {
 1588|  2.48k|                    switch (*input_ptr_)
 1589|  2.48k|                    {
 1590|  1.73k|                    case '/':
  ------------------
  |  Branch (1590:21): [True: 1.73k, False: 746]
  ------------------
 1591|  1.73k|                        state_ = pop_state();
 1592|  1.73k|                        break;
 1593|    746|                    default:    
  ------------------
  |  Branch (1593:21): [True: 746, False: 1.73k]
  ------------------
 1594|    746|                        state_ = parse_state::slash_star;
 1595|    746|                        break;
 1596|  2.48k|                    }
 1597|  2.48k|                    ++input_ptr_;
 1598|  2.48k|                    ++position_;
 1599|  2.48k|                    break;
 1600|  2.48k|                }
 1601|      0|                default:
  ------------------
  |  Branch (1601:17): [True: 0, False: 15.7M]
  ------------------
 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|  15.7M|            }
 1605|  15.7M|        }
 1606|  12.2k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE17end_integer_valueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2448|  3.66M|    {
 2449|  3.66M|        if (buffer_[0] == '-')
  ------------------
  |  Branch (2449:13): [True: 194k, False: 3.46M]
  ------------------
 2450|   194k|        {
 2451|   194k|            end_negative_value(visitor, ec);
 2452|   194k|        }
 2453|  3.46M|        else
 2454|  3.46M|        {
 2455|  3.46M|            end_positive_value(visitor, ec);
 2456|  3.46M|        }
 2457|  3.66M|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE18end_negative_valueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2460|   194k|    {
 2461|   194k|        int64_t val;
 2462|   194k|        auto result = jsoncons::dec_to_integer(buffer_.data(), buffer_.length(), val);
 2463|   194k|        if (result)
  ------------------
  |  Branch (2463:13): [True: 175k, False: 19.7k]
  ------------------
 2464|   175k|        {
 2465|   175k|            visitor.int64_value(val, semantic_tag::none, *this, ec);
 2466|   175k|            if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|   175k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 175k]
  |  |  ------------------
  ------------------
 2467|   175k|        }
 2468|  19.7k|        else // Must be overflow
 2469|  19.7k|        {
 2470|  19.7k|            if (lossless_bignum_)
  ------------------
  |  Branch (2470:17): [True: 19.7k, False: 0]
  ------------------
 2471|  19.7k|            {
 2472|  19.7k|                visitor.string_value(buffer_, semantic_tag::bigint, *this, ec);
 2473|  19.7k|                if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|  19.7k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 19.7k]
  |  |  ------------------
  ------------------
 2474|  19.7k|            }
 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|  19.7k|        }
 2497|   194k|        more_ = !cursor_mode_;
 2498|   194k|        after_value(ec);
 2499|   194k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11after_valueERNS1_10error_codeE:
 2685|  5.03M|    {
 2686|  5.03M|        switch (parent())
 2687|  5.03M|        {
 2688|  4.76M|            case parse_state::array:
  ------------------
  |  Branch (2688:13): [True: 4.76M, False: 267k]
  ------------------
 2689|  5.03M|            case parse_state::object:
  ------------------
  |  Branch (2689:13): [True: 265k, False: 4.77M]
  ------------------
 2690|  5.03M|                state_ = parse_state::expect_comma_or_end;
 2691|  5.03M|                break;
 2692|  1.58k|            case parse_state::root:
  ------------------
  |  Branch (2692:13): [True: 1.58k, False: 5.03M]
  ------------------
 2693|  1.58k|                state_ = parse_state::accept;
 2694|  1.58k|                break;
 2695|      0|            default:
  ------------------
  |  Branch (2695:13): [True: 0, False: 5.03M]
  ------------------
 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|  5.03M|        }
 2704|  5.03M|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE18end_positive_valueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2502|  3.46M|    {
 2503|  3.46M|        uint64_t val;
 2504|  3.46M|        auto result = jsoncons::dec_to_integer(buffer_.data(), buffer_.length(), val);
 2505|  3.46M|        if (result)
  ------------------
  |  Branch (2505:13): [True: 3.46M, False: 3.69k]
  ------------------
 2506|  3.46M|        {
 2507|  3.46M|            visitor.uint64_value(val, semantic_tag::none, *this, ec);
 2508|  3.46M|            if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|  3.46M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.46M]
  |  |  ------------------
  ------------------
 2509|  3.46M|        }
 2510|  3.69k|        else // Must be overflow
 2511|  3.69k|        {
 2512|  3.69k|            if (lossless_bignum_)
  ------------------
  |  Branch (2512:17): [True: 3.69k, False: 0]
  ------------------
 2513|  3.69k|            {
 2514|  3.69k|                visitor.string_value(buffer_, semantic_tag::bigint, *this, ec);
 2515|  3.69k|                if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|  3.69k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.69k]
  |  |  ------------------
  ------------------
 2516|  3.69k|            }
 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|  3.69k|        }
 2539|  3.46M|        more_ = !cursor_mode_;
 2540|  3.46M|        after_value(ec);
 2541|  3.46M|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE18end_fraction_valueERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2544|  1.37M|    {
 2545|  1.37M|        if (lossless_number_)
  ------------------
  |  Branch (2545:13): [True: 0, False: 1.37M]
  ------------------
 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|  1.37M|        else
 2551|  1.37M|        {
 2552|  1.37M|            double d{0};
 2553|  1.37M|            auto result = jsoncons::decstr_to_double(&buffer_[0], buffer_.length(), d);
 2554|  1.37M|            if (JSONCONS_LIKELY(result))
  ------------------
  |  |   77|  1.37M|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 1.37M, False: 929]
  |  |  ------------------
  ------------------
 2555|  1.37M|            {
 2556|  1.37M|                visitor.double_value(d, semantic_tag::none, *this, ec);
 2557|  1.37M|                if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|  1.37M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.37M]
  |  |  ------------------
  ------------------
 2558|  1.37M|            }
 2559|    929|            else if (result.ec == std::errc::result_out_of_range)
  ------------------
  |  Branch (2559:22): [True: 929, False: 0]
  ------------------
 2560|    929|            {
 2561|    929|                if (lossless_bignum_)
  ------------------
  |  Branch (2561:21): [True: 929, False: 0]
  ------------------
 2562|    929|                {
 2563|    929|                    visitor.string_value(buffer_, semantic_tag::bigdec, *this, ec);
 2564|    929|                    if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|    929|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 929]
  |  |  ------------------
  ------------------
 2565|    929|                }
 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|    929|            }
 2572|      0|            else
 2573|      0|            {
 2574|      0|                ec = json_errc::invalid_number;
 2575|      0|                more_ = false;
 2576|      0|                return;
 2577|      0|            }
 2578|  1.37M|        }
 2579|       |
 2580|  1.37M|        more_ = !cursor_mode_;
 2581|  1.37M|        after_value(ec);
 2582|  1.37M|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE9pop_stateEv:
 2713|   359k|    {
 2714|   359k|        JSONCONS_ASSERT(!state_stack_.empty())
  ------------------
  |  |   49|   359k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 359k]
  |  |  ------------------
  |  |   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|   359k|        parse_state state = state_stack_.back();
 2716|   359k|        state_stack_.pop_back();
 2717|   359k|        return state;
 2718|   359k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10skip_spaceEPPKc:
 2399|  39.1k|    {
 2400|  39.1k|        const char_type* local_input_end = input_end_;
 2401|  39.1k|        const char_type* cur = *ptr;
 2402|       |
 2403|  14.2M|        while (cur < local_input_end) 
  ------------------
  |  Branch (2403:16): [True: 14.2M, False: 686]
  ------------------
 2404|  14.2M|        {
 2405|  14.2M|            if (*cur == ' ' || *cur == '\t')
  ------------------
  |  Branch (2405:17): [True: 3.75M, False: 10.5M]
  |  Branch (2405:32): [True: 1.41M, False: 9.09M]
  ------------------
 2406|  5.17M|            {
 2407|  5.17M|                ++cur;
 2408|  5.17M|                ++position_;
 2409|  5.17M|                continue;
 2410|  5.17M|            }
 2411|  9.09M|            if (*cur == '\n')
  ------------------
  |  Branch (2411:17): [True: 2.27M, False: 6.81M]
  ------------------
 2412|  2.27M|            {
 2413|  2.27M|                ++cur;
 2414|  2.27M|                ++line_;
 2415|  2.27M|                ++position_;
 2416|  2.27M|                mark_position_ = position_;
 2417|  2.27M|                continue;
 2418|  2.27M|            }
 2419|  6.81M|            if (*cur == '\r')
  ------------------
  |  Branch (2419:17): [True: 6.78M, False: 38.0k]
  ------------------
 2420|  6.78M|            {
 2421|  6.78M|                ++cur;
 2422|  6.78M|                ++position_;
 2423|  6.78M|                if (cur < local_input_end)
  ------------------
  |  Branch (2423:21): [True: 6.78M, False: 499]
  ------------------
 2424|  6.78M|                {
 2425|  6.78M|                    ++line_;
 2426|  6.78M|                    if (*cur == '\n')
  ------------------
  |  Branch (2426:25): [True: 500k, False: 6.28M]
  ------------------
 2427|   500k|                    {
 2428|   500k|                        ++cur;
 2429|   500k|                        ++position_;
 2430|   500k|                    }
 2431|  6.78M|                    mark_position_ = position_;
 2432|  6.78M|                }
 2433|    499|                else
 2434|    499|                {
 2435|    499|                    push_state(state_);
 2436|    499|                    state_ = parse_state::cr;
 2437|    499|                    *ptr = cur;
 2438|    499|                    return; 
 2439|    499|                }
 2440|  6.78M|                continue;
 2441|  6.78M|            }
 2442|  38.0k|            break;
 2443|  6.81M|        }
 2444|  38.7k|        *ptr = cur;
 2445|  38.7k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE12begin_objectERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  352|  34.5k|    {
  353|  34.5k|        if (JSONCONS_UNLIKELY(++level_ > max_nesting_depth_))
  ------------------
  |  |   78|  34.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 34.5k]
  |  |  ------------------
  ------------------
  354|      2|        {
  355|      2|            more_ = err_handler_(json_errc::max_nesting_depth_exceeded, *this);
  356|      2|            if (!more_)
  ------------------
  |  Branch (356:17): [True: 2, False: 0]
  ------------------
  357|      2|            {
  358|      2|                ec = json_errc::max_nesting_depth_exceeded;
  359|      2|                return;
  360|      2|            }
  361|      2|        } 
  362|       |
  363|  34.5k|        push_state(parse_state::object);
  364|  34.5k|        state_ = parse_state::expect_member_name_or_end;
  365|  34.5k|        visitor.begin_object(semantic_tag::none, *this, ec);
  366|  34.5k|        more_ = !cursor_mode_;
  367|  34.5k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11begin_arrayERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  416|  77.5k|    {
  417|  77.5k|        if (++level_ > max_nesting_depth_)
  ------------------
  |  Branch (417:13): [True: 3, False: 77.5k]
  ------------------
  418|      3|        {
  419|      3|            more_ = err_handler_(json_errc::max_nesting_depth_exceeded, *this);
  420|      3|            if (!more_)
  ------------------
  |  Branch (420:17): [True: 3, False: 0]
  ------------------
  421|      3|            {
  422|      3|                ec = json_errc::max_nesting_depth_exceeded;
  423|      3|                return;
  424|      3|            }
  425|      3|        }
  426|       |
  427|  77.5k|        push_state(parse_state::array);
  428|  77.5k|        state_ = parse_state::expect_value_or_end;
  429|  77.5k|        visitor.begin_array(semantic_tag::none, *this, ec);
  430|  77.5k|        if (JSONCONS_UNLIKELY(ec)){return;};
  ------------------
  |  |   78|  77.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 77.5k]
  |  |  ------------------
  ------------------
  431|       |
  432|  77.5k|        more_ = !cursor_mode_;
  433|  77.5k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE12parse_stringEPKcRNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1946|   663k|    {
 1947|   663k|        const char_type* local_input_end = input_end_;
 1948|   663k|        const char_type* sb = cur;
 1949|       |
 1950|   663k|        switch (string_state_)
 1951|   663k|        {
 1952|   662k|            case parse_string_state::text:
  ------------------
  |  Branch (1952:13): [True: 662k, False: 1.02k]
  ------------------
 1953|   662k|                goto text;
 1954|    129|            case parse_string_state::escape:
  ------------------
  |  Branch (1954:13): [True: 129, False: 663k]
  ------------------
 1955|    129|                goto escape;
 1956|     94|            case parse_string_state::escape_u1:
  ------------------
  |  Branch (1956:13): [True: 94, False: 663k]
  ------------------
 1957|     94|                goto escape_u1;
 1958|     98|            case parse_string_state::escape_u2:
  ------------------
  |  Branch (1958:13): [True: 98, False: 663k]
  ------------------
 1959|     98|                goto escape_u2;
 1960|    100|            case parse_string_state::escape_u3:
  ------------------
  |  Branch (1960:13): [True: 100, False: 663k]
  ------------------
 1961|    100|                goto escape_u3;
 1962|     85|            case parse_string_state::escape_u4:
  ------------------
  |  Branch (1962:13): [True: 85, False: 663k]
  ------------------
 1963|     85|                goto escape_u4;
 1964|     79|            case parse_string_state::escape_expect_surrogate_pair1:
  ------------------
  |  Branch (1964:13): [True: 79, False: 663k]
  ------------------
 1965|     79|                goto escape_expect_surrogate_pair1;
 1966|     97|            case parse_string_state::escape_expect_surrogate_pair2:
  ------------------
  |  Branch (1966:13): [True: 97, False: 663k]
  ------------------
 1967|     97|                goto escape_expect_surrogate_pair2;
 1968|     94|            case parse_string_state::escape_u5:
  ------------------
  |  Branch (1968:13): [True: 94, False: 663k]
  ------------------
 1969|     94|                goto escape_u5;
 1970|    107|            case parse_string_state::escape_u6:
  ------------------
  |  Branch (1970:13): [True: 107, False: 663k]
  ------------------
 1971|    107|                goto escape_u6;
 1972|     94|            case parse_string_state::escape_u7:
  ------------------
  |  Branch (1972:13): [True: 94, False: 663k]
  ------------------
 1973|     94|                goto escape_u7;
 1974|     45|            case parse_string_state::escape_u8:
  ------------------
  |  Branch (1974:13): [True: 45, False: 663k]
  ------------------
 1975|     45|                goto escape_u8;
 1976|      0|            default:
  ------------------
  |  Branch (1976:13): [True: 0, False: 663k]
  ------------------
 1977|      0|                JSONCONS_UNREACHABLE();               
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1978|   663k|        }
 1979|       |
 1980|  3.07M|text:
 1981|  23.6M|        while (cur < local_input_end)
  ------------------
  |  Branch (1981:16): [True: 23.6M, False: 1.11k]
  ------------------
 1982|  23.6M|        {
 1983|  23.6M|            switch (*cur)
 1984|  23.6M|            {
 1985|    655|                JSONCONS_ILLEGAL_CONTROL_CHARACTER:
  ------------------
  |  |   34|     17|        case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x0b: \
  |  |  ------------------
  |  |  |  Branch (34:9): [True: 6, False: 23.6M]
  |  |  |  Branch (34:19): [True: 2, False: 23.6M]
  |  |  |  Branch (34:29): [True: 1, False: 23.6M]
  |  |  |  Branch (34:39): [True: 1, False: 23.6M]
  |  |  |  Branch (34:49): [True: 1, False: 23.6M]
  |  |  |  Branch (34:59): [True: 1, False: 23.6M]
  |  |  |  Branch (34:69): [True: 1, False: 23.6M]
  |  |  |  Branch (34:79): [True: 1, False: 23.6M]
  |  |  |  Branch (34:89): [True: 1, False: 23.6M]
  |  |  |  Branch (34:99): [True: 2, False: 23.6M]
  |  |  ------------------
  |  |   35|     29|        case 0x0c:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16: \
  |  |  ------------------
  |  |  |  Branch (35:9): [True: 1, False: 23.6M]
  |  |  |  Branch (35:19): [True: 1, False: 23.6M]
  |  |  |  Branch (35:29): [True: 1, False: 23.6M]
  |  |  |  Branch (35:39): [True: 1, False: 23.6M]
  |  |  |  Branch (35:49): [True: 1, False: 23.6M]
  |  |  |  Branch (35:59): [True: 2, False: 23.6M]
  |  |  |  Branch (35:69): [True: 2, False: 23.6M]
  |  |  |  Branch (35:79): [True: 1, False: 23.6M]
  |  |  |  Branch (35:89): [True: 1, False: 23.6M]
  |  |  |  Branch (35:99): [True: 1, False: 23.6M]
  |  |  ------------------
  |  |   36|     38|        case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f 
  |  |  ------------------
  |  |  |  Branch (36:9): [True: 1, False: 23.6M]
  |  |  |  Branch (36:19): [True: 1, False: 23.6M]
  |  |  |  Branch (36:29): [True: 1, False: 23.6M]
  |  |  |  Branch (36:39): [True: 1, False: 23.6M]
  |  |  |  Branch (36:49): [True: 1, False: 23.6M]
  |  |  |  Branch (36:59): [True: 1, False: 23.6M]
  |  |  |  Branch (36:69): [True: 1, False: 23.6M]
  |  |  |  Branch (36:79): [True: 1, False: 23.6M]
  |  |  ------------------
  ------------------
 1986|    655|                {
 1987|    655|                    position_ += (cur - sb + 1);
 1988|    655|                    more_ = err_handler_(json_errc::illegal_control_character, *this);
 1989|    655|                    if (!more_)
  ------------------
  |  Branch (1989:25): [True: 38, False: 0]
  ------------------
 1990|     38|                    {
 1991|     38|                        ec = json_errc::illegal_control_character;
 1992|     38|                        string_state_ = parse_string_state{};
 1993|     38|                        return cur;
 1994|     38|                    }
 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|    655|                }
 2001|      3|                case '\n':
  ------------------
  |  Branch (2001:17): [True: 3, False: 23.6M]
  ------------------
 2002|      4|                case '\r':
  ------------------
  |  Branch (2002:17): [True: 1, False: 23.6M]
  ------------------
 2003|      5|                case '\t':
  ------------------
  |  Branch (2003:17): [True: 1, False: 23.6M]
  ------------------
 2004|      5|                {
 2005|      5|                    position_ += (cur - sb + 1);
 2006|      5|                    if (!err_handler_(json_errc::illegal_character_in_string, *this))
  ------------------
  |  Branch (2006:25): [True: 5, False: 0]
  ------------------
 2007|      5|                    {
 2008|      5|                        more_ = false;
 2009|      5|                        ec = json_errc::illegal_character_in_string;
 2010|      5|                        return cur;
 2011|      5|                    }
 2012|       |                    // recovery - skip
 2013|      0|                    buffer_.append(sb,cur-sb);
 2014|      0|                    sb = cur + 1;
 2015|      0|                    break;
 2016|      5|                }
 2017|  2.78M|                case '\\': 
  ------------------
  |  Branch (2017:17): [True: 2.78M, False: 20.8M]
  ------------------
 2018|  2.78M|                {
 2019|  2.78M|                    buffer_.append(sb,cur-sb);
 2020|  2.78M|                    position_ += (cur - sb + 1);
 2021|  2.78M|                    ++cur;
 2022|  2.78M|                    escape_tag_ = semantic_tag{};
 2023|  2.78M|                    goto escape;
 2024|      5|                }
 2025|   288k|                case '\"':
  ------------------
  |  Branch (2025:17): [True: 288k, False: 23.3M]
  ------------------
 2026|   288k|                {
 2027|   288k|                    position_ += (cur - sb + 1);
 2028|   288k|                    if (buffer_.empty())
  ------------------
  |  Branch (2028:25): [True: 287k, False: 1.25k]
  ------------------
 2029|   287k|                    {
 2030|   287k|                        end_string_value(sb,cur-sb, visitor, ec);
 2031|   287k|                        if (JSONCONS_UNLIKELY(ec)) {return cur;}
  ------------------
  |  |   78|   287k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 169, False: 287k]
  |  |  ------------------
  ------------------
 2032|   287k|                    }
 2033|  1.25k|                    else
 2034|  1.25k|                    {
 2035|  1.25k|                        buffer_.append(sb,cur-sb);
 2036|  1.25k|                        end_string_value(buffer_.data(), buffer_.length(), visitor, ec);
 2037|  1.25k|                        if (JSONCONS_UNLIKELY(ec)) {return cur;}
  ------------------
  |  |   78|  1.25k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 32, False: 1.22k]
  |  |  ------------------
  ------------------
 2038|  1.25k|                    }
 2039|   288k|                    ++cur;
 2040|   288k|                    return cur;
 2041|   288k|                }
 2042|  20.5M|            default:
  ------------------
  |  Branch (2042:13): [True: 20.5M, False: 3.07M]
  ------------------
 2043|  20.5M|                break;
 2044|  23.6M|            }
 2045|  20.5M|            ++cur;
 2046|  20.5M|        }
 2047|       |
 2048|       |        // Buffer exhausted               
 2049|  1.11k|        {
 2050|  1.11k|            buffer_.append(sb,cur-sb);
 2051|  1.11k|            position_ += (cur - sb);
 2052|  1.11k|            string_state_ = parse_string_state{};
 2053|  1.11k|            return cur;
 2054|  3.07M|        }
 2055|       |
 2056|  2.78M|escape:
 2057|  2.78M|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|  2.78M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 146, False: 2.78M]
  |  |  ------------------
  ------------------
 2058|    146|        {
 2059|    146|            string_state_ = parse_string_state::escape;
 2060|    146|            return cur;
 2061|    146|        }
 2062|  2.78M|        switch (*cur)
 2063|  2.78M|        {
 2064|   596k|        case '\"':
  ------------------
  |  Branch (2064:9): [True: 596k, False: 2.19M]
  ------------------
 2065|   596k|            buffer_.push_back('\"');
 2066|   596k|            sb = ++cur;
 2067|   596k|            ++position_;
 2068|   596k|            goto text;
 2069|  1.32M|        case '\\': 
  ------------------
  |  Branch (2069:9): [True: 1.32M, False: 1.46M]
  ------------------
 2070|  1.32M|            buffer_.push_back('\\');
 2071|  1.32M|            sb = ++cur;
 2072|  1.32M|            ++position_;
 2073|  1.32M|            goto text;
 2074|    397|        case '/':
  ------------------
  |  Branch (2074:9): [True: 397, False: 2.78M]
  ------------------
 2075|    397|            buffer_.push_back('/');
 2076|    397|            sb = ++cur;
 2077|    397|            ++position_;
 2078|    397|            goto text;
 2079|  9.19k|        case 'b':
  ------------------
  |  Branch (2079:9): [True: 9.19k, False: 2.77M]
  ------------------
 2080|  9.19k|            buffer_.push_back('\b');
 2081|  9.19k|            sb = ++cur;
 2082|  9.19k|            ++position_;
 2083|  9.19k|            goto text;
 2084|  5.70k|        case 'f':
  ------------------
  |  Branch (2084:9): [True: 5.70k, False: 2.78M]
  ------------------
 2085|  5.70k|            buffer_.push_back('\f');
 2086|  5.70k|            sb = ++cur;
 2087|  5.70k|            ++position_;
 2088|  5.70k|            goto text;
 2089|  1.17k|        case 'n':
  ------------------
  |  Branch (2089:9): [True: 1.17k, False: 2.78M]
  ------------------
 2090|  1.17k|            buffer_.push_back('\n');
 2091|  1.17k|            sb = ++cur;
 2092|  1.17k|            ++position_;
 2093|  1.17k|            goto text;
 2094|    294|        case 'r':
  ------------------
  |  Branch (2094:9): [True: 294, False: 2.78M]
  ------------------
 2095|    294|            buffer_.push_back('\r');
 2096|    294|            sb = ++cur;
 2097|    294|            ++position_;
 2098|    294|            goto text;
 2099|    542|        case 't':
  ------------------
  |  Branch (2099:9): [True: 542, False: 2.78M]
  ------------------
 2100|    542|            buffer_.push_back('\t');
 2101|    542|            sb = ++cur;
 2102|    542|            ++position_;
 2103|    542|            goto text;
 2104|   848k|        case 'u':
  ------------------
  |  Branch (2104:9): [True: 848k, False: 1.93M]
  ------------------
 2105|   848k|             cp_ = 0;
 2106|   848k|             ++cur;
 2107|   848k|             ++position_;
 2108|   848k|             goto escape_u1;
 2109|      4|        default:    
  ------------------
  |  Branch (2109:9): [True: 4, False: 2.78M]
  ------------------
 2110|      4|            err_handler_(json_errc::illegal_escaped_character, *this);
 2111|      4|            ec = json_errc::illegal_escaped_character;
 2112|      4|            more_ = false;
 2113|      4|            string_state_ = parse_string_state::escape;
 2114|      4|            return cur;
 2115|  2.78M|        }
 2116|       |
 2117|   848k|escape_u1:
 2118|   848k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   848k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 113, False: 848k]
  |  |  ------------------
  ------------------
 2119|    113|        {
 2120|    113|            string_state_ = parse_string_state::escape_u1;
 2121|    113|            return cur;
 2122|    113|        }
 2123|   848k|        {
 2124|   848k|            cp_ = append_to_codepoint(0, *cur, ec);
 2125|   848k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   848k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 34, False: 848k]
  |  |  ------------------
  ------------------
 2126|     34|            {
 2127|     34|                string_state_ = parse_string_state::escape_u1;
 2128|     34|                return cur;
 2129|     34|            }
 2130|   848k|            ++cur;
 2131|   848k|            ++position_;
 2132|   848k|            goto escape_u2;
 2133|   848k|        }
 2134|       |
 2135|   848k|escape_u2:
 2136|   848k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   848k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 117, False: 848k]
  |  |  ------------------
  ------------------
 2137|    117|        {
 2138|    117|            string_state_ = parse_string_state::escape_u2;
 2139|    117|            return cur;
 2140|    117|        }
 2141|   848k|        {
 2142|   848k|            cp_ = append_to_codepoint(cp_, *cur, ec);
 2143|   848k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   848k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 848k]
  |  |  ------------------
  ------------------
 2144|      1|            {
 2145|      1|                string_state_ = parse_string_state::escape_u2;
 2146|      1|                return cur;
 2147|      1|            }
 2148|   848k|            ++cur;
 2149|   848k|            ++position_;
 2150|   848k|            goto escape_u3;
 2151|   848k|        }
 2152|       |
 2153|   848k|escape_u3:
 2154|   848k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   848k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 117, False: 848k]
  |  |  ------------------
  ------------------
 2155|    117|        {
 2156|    117|            string_state_ = parse_string_state::escape_u3;
 2157|    117|            return cur;
 2158|    117|        }
 2159|   848k|        {
 2160|   848k|            cp_ = append_to_codepoint(cp_, *cur, ec);
 2161|   848k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   848k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 848k]
  |  |  ------------------
  ------------------
 2162|      2|            {
 2163|      2|                string_state_ = parse_string_state::escape_u3;
 2164|      2|                return cur;
 2165|      2|            }
 2166|   848k|            ++cur;
 2167|   848k|            ++position_;
 2168|   848k|            goto escape_u4;
 2169|   848k|        }
 2170|       |
 2171|   848k|escape_u4:
 2172|   848k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   848k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 101, False: 848k]
  |  |  ------------------
  ------------------
 2173|    101|        {
 2174|    101|            string_state_ = parse_string_state::escape_u4;
 2175|    101|            return cur;
 2176|    101|        }
 2177|   848k|        {
 2178|   848k|            cp_ = append_to_codepoint(cp_, *cur, ec);
 2179|   848k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   848k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 848k]
  |  |  ------------------
  ------------------
 2180|      2|            {
 2181|      2|                string_state_ = parse_string_state::escape_u4;
 2182|      2|                return cur;
 2183|      2|            }
 2184|   848k|            if (unicode_traits::is_high_surrogate(cp_))
  ------------------
  |  Branch (2184:17): [True: 476k, False: 371k]
  ------------------
 2185|   476k|            {
 2186|   476k|                ++cur;
 2187|   476k|                ++position_;
 2188|   476k|                goto escape_expect_surrogate_pair1;
 2189|   476k|            }
 2190|   371k|            else
 2191|   371k|            {
 2192|   371k|                unicode_traits::convert(&cp_, 1, buffer_);
 2193|   371k|                sb = ++cur;
 2194|   371k|                ++position_;
 2195|   371k|                string_state_ = parse_string_state{};
 2196|   371k|                return cur;
 2197|   371k|            }
 2198|   848k|        }
 2199|       |
 2200|   476k|escape_expect_surrogate_pair1:
 2201|   476k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   476k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 102, False: 476k]
  |  |  ------------------
  ------------------
 2202|    102|        {
 2203|    102|            string_state_ = parse_string_state::escape_expect_surrogate_pair1;
 2204|    102|            return cur;
 2205|    102|        }
 2206|   476k|        {
 2207|   476k|            switch (*cur)
 2208|   476k|            {
 2209|   476k|            case '\\': 
  ------------------
  |  Branch (2209:13): [True: 476k, False: 15]
  ------------------
 2210|   476k|                cp2_ = 0;
 2211|   476k|                ++cur;
 2212|   476k|                ++position_;
 2213|   476k|                goto escape_expect_surrogate_pair2;
 2214|     15|            default:
  ------------------
  |  Branch (2214:13): [True: 15, False: 476k]
  ------------------
 2215|     15|                err_handler_(json_errc::expected_codepoint_surrogate_pair, *this);
 2216|     15|                ec = json_errc::expected_codepoint_surrogate_pair;
 2217|     15|                more_ = false;
 2218|     15|                string_state_ = parse_string_state::escape_expect_surrogate_pair1;
 2219|     15|                return cur;
 2220|   476k|            }
 2221|   476k|        }
 2222|       |
 2223|   476k|escape_expect_surrogate_pair2:
 2224|   476k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   476k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 114, False: 476k]
  |  |  ------------------
  ------------------
 2225|    114|        {
 2226|    114|            string_state_ = parse_string_state::escape_expect_surrogate_pair2;
 2227|    114|            return cur;
 2228|    114|        }
 2229|   476k|        {
 2230|   476k|            switch (*cur)
 2231|   476k|            {
 2232|   476k|            case 'u':
  ------------------
  |  Branch (2232:13): [True: 476k, False: 20]
  ------------------
 2233|   476k|                ++cur;
 2234|   476k|                ++position_;
 2235|   476k|                goto escape_u5;
 2236|     20|            default:
  ------------------
  |  Branch (2236:13): [True: 20, False: 476k]
  ------------------
 2237|     20|                err_handler_(json_errc::expected_codepoint_surrogate_pair, *this);
 2238|     20|                ec = json_errc::expected_codepoint_surrogate_pair;
 2239|     20|                more_ = false;
 2240|     20|                string_state_ = parse_string_state::escape_expect_surrogate_pair2;
 2241|     20|                return cur;
 2242|   476k|            }
 2243|   476k|        }
 2244|       |
 2245|   476k|escape_u5:
 2246|   476k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   476k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 110, False: 476k]
  |  |  ------------------
  ------------------
 2247|    110|        {
 2248|    110|            string_state_ = parse_string_state::escape_u5;
 2249|    110|            return cur;
 2250|    110|        }
 2251|   476k|        {
 2252|   476k|            cp2_ = append_to_codepoint(0, *cur, ec);
 2253|   476k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   476k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 476k]
  |  |  ------------------
  ------------------
 2254|      1|            {
 2255|      1|                string_state_ = parse_string_state::escape_u5;
 2256|      1|                return cur;
 2257|      1|            }
 2258|   476k|        }
 2259|   476k|        ++cur;
 2260|   476k|        ++position_;
 2261|   476k|        goto escape_u6;
 2262|       |
 2263|   476k|escape_u6:
 2264|   476k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   476k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 121, False: 476k]
  |  |  ------------------
  ------------------
 2265|    121|        {
 2266|    121|            string_state_ = parse_string_state::escape_u6;
 2267|    121|            return cur;
 2268|    121|        }
 2269|   476k|        {
 2270|   476k|            cp2_ = append_to_codepoint(cp2_, *cur, ec);
 2271|   476k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   476k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 476k]
  |  |  ------------------
  ------------------
 2272|      1|            {
 2273|      1|                string_state_ = parse_string_state::escape_u6;
 2274|      1|                return cur;
 2275|      1|            }
 2276|   476k|            ++cur;
 2277|   476k|            ++position_;
 2278|   476k|            goto escape_u7;
 2279|   476k|        }
 2280|       |
 2281|   476k|escape_u7:
 2282|   476k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   476k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 111, False: 476k]
  |  |  ------------------
  ------------------
 2283|    111|        {
 2284|    111|            string_state_ = parse_string_state::escape_u7;
 2285|    111|            return cur;
 2286|    111|        }
 2287|   476k|        {
 2288|   476k|            cp2_ = append_to_codepoint(cp2_, *cur, ec);
 2289|   476k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   476k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 476k]
  |  |  ------------------
  ------------------
 2290|      2|            {
 2291|      2|                string_state_ = parse_string_state::escape_u7;
 2292|      2|                return cur;
 2293|      2|            }
 2294|   476k|            ++cur;
 2295|   476k|            ++position_;
 2296|   476k|            goto escape_u8;
 2297|   476k|        }
 2298|       |
 2299|   476k|escape_u8:
 2300|   476k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   476k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 56, False: 476k]
  |  |  ------------------
  ------------------
 2301|     56|        {
 2302|     56|            string_state_ = parse_string_state::escape_u8;
 2303|     56|            return cur;
 2304|     56|        }
 2305|   476k|        {
 2306|   476k|            cp2_ = append_to_codepoint(cp2_, *cur, ec);
 2307|   476k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   476k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 476k]
  |  |  ------------------
  ------------------
 2308|      1|            {
 2309|      1|                string_state_ = parse_string_state::escape_u8;
 2310|      1|                return cur;
 2311|      1|            }
 2312|   476k|            uint32_t cp = 0x10000 + ((cp_ & 0x3FF) << 10) + (cp2_ & 0x3FF);
 2313|   476k|            unicode_traits::convert(&cp, 1, buffer_);
 2314|   476k|            sb = ++cur;
 2315|   476k|            ++position_;
 2316|   476k|            goto text;
 2317|   476k|        }
 2318|       |
 2319|      0|        JSONCONS_UNREACHABLE();               
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 2320|   476k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE16end_string_valueEPKcmRNS_18basic_json_visitorIcEERNS1_10error_codeE:
 2585|   288k|    {
 2586|   288k|        string_view_type sv(s, length);
 2587|   288k|        auto result = unicode_traits::validate(s, length);
 2588|   288k|        if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (2588:13): [True: 201, False: 288k]
  ------------------
 2589|    201|        {
 2590|    201|            translate_conv_errc(result.ec,ec);
 2591|    201|            position_ += (result.ptr - s);
 2592|    201|            return;
 2593|    201|        }
 2594|   288k|        switch (parent())
 2595|   288k|        {
 2596|   267k|            case parse_state::member_name:
  ------------------
  |  Branch (2596:13): [True: 267k, False: 21.0k]
  ------------------
 2597|   267k|                visitor.key(sv, *this, ec);
 2598|   267k|                if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|   267k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 267k]
  |  |  ------------------
  ------------------
 2599|   267k|                more_ = !cursor_mode_;
 2600|   267k|                pop_state();
 2601|   267k|                state_ = parse_state::expect_colon;
 2602|   267k|                break;
 2603|    249|            case parse_state::object:
  ------------------
  |  Branch (2603:13): [True: 249, False: 288k]
  ------------------
 2604|  20.8k|            case parse_state::array:
  ------------------
  |  Branch (2604:13): [True: 20.5k, False: 268k]
  ------------------
 2605|  20.8k|            {
 2606|  20.8k|                if (enable_str_to_inf_ && sv == inf_to_str_)
  ------------------
  |  Branch (2606:21): [True: 0, False: 20.8k]
  |  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|  20.8k|                else if (enable_str_to_neginf_ && sv == neginf_to_str_)
  ------------------
  |  Branch (2610:26): [True: 0, False: 20.8k]
  |  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|  20.8k|                else if (enable_str_to_nan_ && sv == nan_to_str_)
  ------------------
  |  Branch (2614:26): [True: 0, False: 20.8k]
  |  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|  20.8k|                else
 2619|  20.8k|                {
 2620|  20.8k|                    visitor.string_value(sv, escape_tag_, *this, ec);
 2621|  20.8k|                }
 2622|  20.8k|                if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|  20.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 20.8k]
  |  |  ------------------
  ------------------
 2623|  20.8k|                more_ = !cursor_mode_;
 2624|  20.8k|                state_ = parse_state::expect_comma_or_end;
 2625|  20.8k|                break;
 2626|  20.8k|            }
 2627|    186|            case parse_state::root:
  ------------------
  |  Branch (2627:13): [True: 186, False: 288k]
  ------------------
 2628|    186|            {
 2629|    186|                if (enable_str_to_inf_ && sv == inf_to_str_)
  ------------------
  |  Branch (2629:21): [True: 0, False: 186]
  |  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|    186|                else if (enable_str_to_neginf_ && sv == neginf_to_str_)
  ------------------
  |  Branch (2633:26): [True: 0, False: 186]
  |  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|    186|                else if (enable_str_to_nan_ && sv == nan_to_str_)
  ------------------
  |  Branch (2637:26): [True: 0, False: 186]
  |  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|    186|                else
 2642|    186|                {
 2643|    186|                    visitor.string_value(sv, escape_tag_, *this, ec);
 2644|    186|                }
 2645|    186|                if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|    186|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 186]
  |  |  ------------------
  ------------------
 2646|    186|                more_ = !cursor_mode_;
 2647|    186|                state_ = parse_state::accept;
 2648|    186|                break;
 2649|    186|            }
 2650|      0|            default:
  ------------------
  |  Branch (2650:13): [True: 0, False: 288k]
  ------------------
 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|   288k|        }
 2659|   288k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE19translate_conv_errcENS_14unicode_traits12unicode_errcERNS1_10error_codeE:
 2323|    201|    {
 2324|    201|        switch (result)
 2325|    201|        {
 2326|      0|        case unicode_traits::unicode_errc():
  ------------------
  |  Branch (2326:9): [True: 0, False: 201]
  ------------------
 2327|      0|            break;
 2328|     23|        case unicode_traits::unicode_errc::over_long_utf8_sequence:
  ------------------
  |  Branch (2328:9): [True: 23, False: 178]
  ------------------
 2329|     23|            more_ = err_handler_(json_errc::over_long_utf8_sequence, *this);
 2330|     23|            if (!more_)
  ------------------
  |  Branch (2330:17): [True: 23, False: 0]
  ------------------
 2331|     23|            {
 2332|     23|                ec = json_errc::over_long_utf8_sequence;
 2333|     23|                return;
 2334|     23|            }
 2335|      0|            break;
 2336|      0|        case unicode_traits::unicode_errc::unpaired_high_surrogate:
  ------------------
  |  Branch (2336:9): [True: 0, False: 201]
  ------------------
 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|     66|        case unicode_traits::unicode_errc::bad_continuation_byte:
  ------------------
  |  Branch (2344:9): [True: 66, False: 135]
  ------------------
 2345|     66|            more_ = err_handler_(json_errc::bad_continuation_byte, *this);
 2346|     66|            if (!more_)
  ------------------
  |  Branch (2346:17): [True: 66, False: 0]
  ------------------
 2347|     66|            {
 2348|     66|                ec = json_errc::bad_continuation_byte;
 2349|     66|                return;
 2350|     66|            }
 2351|      0|            break;
 2352|      0|        case unicode_traits::unicode_errc::illegal_surrogate_value:
  ------------------
  |  Branch (2352:9): [True: 0, False: 201]
  ------------------
 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|    112|        default:
  ------------------
  |  Branch (2360:9): [True: 112, False: 89]
  ------------------
 2361|    112|            more_ = err_handler_(json_errc::illegal_codepoint, *this);
 2362|    112|            if (!more_)
  ------------------
  |  Branch (2362:17): [True: 112, False: 0]
  ------------------
 2363|    112|            {
 2364|    112|                ec = json_errc::illegal_codepoint;
 2365|    112|                return;
 2366|    112|            }
 2367|      0|            break;
 2368|    201|        }
 2369|    201|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE19append_to_codepointEjiRNS1_10error_codeE:
 2721|  5.29M|    {
 2722|  5.29M|        cp *= 16;
 2723|  5.29M|        if (c >= '0'  &&  c <= '9')
  ------------------
  |  Branch (2723:13): [True: 5.29M, False: 27]
  |  Branch (2723:27): [True: 1.46M, False: 3.82M]
  ------------------
 2724|  1.46M|        {
 2725|  1.46M|            cp += c - '0';
 2726|  1.46M|        }
 2727|  3.82M|        else if (c >= 'a'  &&  c <= 'f')
  ------------------
  |  Branch (2727:18): [True: 731k, False: 3.09M]
  |  Branch (2727:32): [True: 730k, False: 6]
  ------------------
 2728|   730k|        {
 2729|   730k|            cp += c - 'a' + 10;
 2730|   730k|        }
 2731|  3.09M|        else if (c >= 'A'  &&  c <= 'F')
  ------------------
  |  Branch (2731:18): [True: 3.09M, False: 32]
  |  Branch (2731:32): [True: 3.09M, False: 12]
  ------------------
 2732|  3.09M|        {
 2733|  3.09M|            cp += c - 'A' + 10;
 2734|  3.09M|        }
 2735|     44|        else
 2736|     44|        {
 2737|     44|            more_ = err_handler_(json_errc::invalid_unicode_escape_sequence, *this);
 2738|     44|            if (!more_)
  ------------------
  |  Branch (2738:17): [True: 44, False: 0]
  ------------------
 2739|     44|            {
 2740|     44|                ec = json_errc::invalid_unicode_escape_sequence;
 2741|     44|                return cp;
 2742|     44|            }
 2743|     44|        }
 2744|  5.29M|        return cp;
 2745|  5.29M|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE12parse_numberEPKcRNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1722|  5.03M|    {
 1723|  5.03M|        const char_type* cur = hdr;
 1724|  5.03M|        const char_type* local_input_end = input_end_;
 1725|       |
 1726|  5.03M|        switch (number_state_)
 1727|  5.03M|        {
 1728|   208k|            case parse_number_state::minus:
  ------------------
  |  Branch (1728:13): [True: 208k, False: 4.83M]
  ------------------
 1729|   208k|                goto minus_sign;
 1730|   572k|            case parse_number_state::zero:
  ------------------
  |  Branch (1730:13): [True: 572k, False: 4.46M]
  ------------------
 1731|   572k|                goto zero;
 1732|  4.25M|            case parse_number_state::integer:
  ------------------
  |  Branch (1732:13): [True: 4.25M, False: 781k]
  ------------------
 1733|  4.25M|                goto integer;
 1734|     70|            case parse_number_state::fraction1:
  ------------------
  |  Branch (1734:13): [True: 70, False: 5.03M]
  ------------------
 1735|     70|                goto fraction1;
 1736|    182|            case parse_number_state::fraction2:
  ------------------
  |  Branch (1736:13): [True: 182, False: 5.03M]
  ------------------
 1737|    182|                goto fraction2;
 1738|     92|            case parse_number_state::exp1:
  ------------------
  |  Branch (1738:13): [True: 92, False: 5.03M]
  ------------------
 1739|     92|                goto exp1;
 1740|     45|            case parse_number_state::exp2:
  ------------------
  |  Branch (1740:13): [True: 45, False: 5.03M]
  ------------------
 1741|     45|                goto exp2;
 1742|    296|            case parse_number_state::exp3:
  ------------------
  |  Branch (1742:13): [True: 296, False: 5.03M]
  ------------------
 1743|    296|                goto exp3;
 1744|      0|            default:
  ------------------
  |  Branch (1744:13): [True: 0, False: 5.03M]
  ------------------
 1745|      0|                JSONCONS_UNREACHABLE();               
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1746|  5.03M|        }
 1747|   208k|minus_sign:
 1748|   208k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   208k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 55, False: 208k]
  |  |  ------------------
  ------------------
 1749|     55|        {
 1750|     55|            number_state_ = parse_number_state::minus;
 1751|     55|            buffer_.append(hdr, cur);
 1752|     55|            position_ += (cur - hdr);
 1753|     55|            return cur;
 1754|     55|        }
 1755|   208k|        if (jsoncons::is_nonzero_digit(*cur))
  ------------------
  |  Branch (1755:13): [True: 202k, False: 5.74k]
  ------------------
 1756|   202k|        {
 1757|   202k|            ++cur;
 1758|   202k|            goto integer;
 1759|   202k|        }
 1760|  5.74k|        if (*cur == '0')
  ------------------
  |  Branch (1760:13): [True: 5.72k, False: 18]
  ------------------
 1761|  5.72k|        {
 1762|  5.72k|            ++cur;
 1763|  5.72k|            goto zero;
 1764|  5.72k|        }
 1765|     18|        err_handler_(json_errc::invalid_number, *this);
 1766|     18|        ec = json_errc::invalid_number;
 1767|     18|        more_ = false;
 1768|     18|        position_ += (cur - hdr);
 1769|     18|        return cur;
 1770|   577k|zero:
 1771|   577k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   577k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 215, False: 577k]
  |  |  ------------------
  ------------------
 1772|    215|        {
 1773|    215|            number_state_ = parse_number_state::integer;
 1774|    215|            buffer_.append(hdr, cur);
 1775|    215|            position_ += (cur - hdr);
 1776|    215|            return cur;
 1777|    215|        }
 1778|   577k|        if (*cur == '.')
  ------------------
  |  Branch (1778:13): [True: 5.19k, False: 572k]
  ------------------
 1779|  5.19k|        {
 1780|  5.19k|            ++cur;
 1781|  5.19k|            goto fraction1;
 1782|  5.19k|        }
 1783|   572k|        if (jsoncons::is_exp(*cur))
  ------------------
  |  Branch (1783:13): [True: 106k, False: 465k]
  ------------------
 1784|   106k|        {
 1785|   106k|            ++cur;
 1786|   106k|            goto exp1;
 1787|   106k|        }
 1788|   465k|        if (jsoncons::is_digit(*cur))
  ------------------
  |  Branch (1788:13): [True: 9, False: 465k]
  ------------------
 1789|      9|        {
 1790|      9|            err_handler_(json_errc::leading_zero, *this);
 1791|      9|            ec = json_errc::leading_zero;
 1792|      9|            more_ = false;
 1793|      9|            number_state_ = parse_number_state::zero;
 1794|       |
 1795|      9|            position_ += (cur - hdr);
 1796|      9|            return cur;
 1797|      9|        }
 1798|   465k|        buffer_.append(hdr, cur);
 1799|   465k|        position_ += (cur - hdr);
 1800|   465k|        end_integer_value(visitor, ec);
 1801|   465k|        return cur;
 1802|  4.46M|integer:
 1803|  20.7M|        while (true)
  ------------------
  |  Branch (1803:16): [True: 20.7M, Folded]
  ------------------
 1804|  20.7M|        {
 1805|  20.7M|            if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|  20.7M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.97k, False: 20.7M]
  |  |  ------------------
  ------------------
 1806|  1.97k|            {
 1807|  1.97k|                number_state_ = parse_number_state::integer;
 1808|  1.97k|                buffer_.append(hdr, cur);
 1809|  1.97k|                position_ += (cur - hdr);
 1810|  1.97k|                return cur;
 1811|  1.97k|            }
 1812|  20.7M|            if (JSONCONS_UNLIKELY(!jsoncons::is_digit(*cur)))
  ------------------
  |  |   78|  20.7M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4.45M, False: 16.3M]
  |  |  ------------------
  ------------------
 1813|  4.45M|            {
 1814|  4.45M|                break;
 1815|  4.45M|            }
 1816|  16.3M|            ++cur;
 1817|  16.3M|        }
 1818|  4.45M|        if (*cur == '.')
  ------------------
  |  Branch (1818:13): [True: 511k, False: 3.94M]
  ------------------
 1819|   511k|        {
 1820|   511k|            ++cur;
 1821|   511k|            goto fraction1;
 1822|   511k|        }
 1823|  3.94M|        if (jsoncons::is_exp(*cur))
  ------------------
  |  Branch (1823:13): [True: 751k, False: 3.19M]
  ------------------
 1824|   751k|        {
 1825|   751k|            ++cur;
 1826|   751k|            goto exp1;
 1827|   751k|        }
 1828|  3.19M|        buffer_.append(hdr, cur);
 1829|  3.19M|        position_ += (cur - hdr);
 1830|  3.19M|        end_integer_value(visitor, ec);
 1831|  3.19M|        return cur;
 1832|   516k|fraction1:
 1833|   516k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   516k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 91, False: 516k]
  |  |  ------------------
  ------------------
 1834|     91|        {
 1835|     91|            number_state_ = parse_number_state::fraction1;
 1836|     91|            buffer_.append(hdr, cur);
 1837|     91|            position_ += (cur - hdr);
 1838|     91|            return cur;
 1839|     91|        }
 1840|   516k|        if (jsoncons::is_digit(*cur))
  ------------------
  |  Branch (1840:13): [True: 516k, False: 5]
  ------------------
 1841|   516k|        {
 1842|   516k|            ++cur;
 1843|   516k|            goto fraction2;
 1844|   516k|        }
 1845|      5|        err_handler_(json_errc::invalid_number, *this);
 1846|      5|        ec = json_errc::invalid_number;
 1847|      5|        more_ = false;
 1848|      5|        number_state_ = parse_number_state::fraction1;
 1849|      5|        position_ += (cur - hdr);
 1850|      5|        return cur;
 1851|   516k|fraction2:
 1852|  3.03M|        while (true)
  ------------------
  |  Branch (1852:16): [True: 3.03M, Folded]
  ------------------
 1853|  3.03M|        {
 1854|  3.03M|            if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|  3.03M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 631, False: 3.03M]
  |  |  ------------------
  ------------------
 1855|    631|            {
 1856|    631|                number_state_ = parse_number_state::fraction2;
 1857|    631|                buffer_.append(hdr, cur);
 1858|    631|                position_ += (cur - hdr);
 1859|    631|                return cur;
 1860|    631|            }
 1861|  3.03M|            if (JSONCONS_UNLIKELY(!jsoncons::is_digit(*cur)))
  ------------------
  |  |   78|  3.03M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 515k, False: 2.52M]
  |  |  ------------------
  ------------------
 1862|   515k|            {
 1863|   515k|                break;
 1864|   515k|            }
 1865|  2.52M|            ++cur;
 1866|  2.52M|        }
 1867|   515k|        if (jsoncons::is_exp(*cur))
  ------------------
  |  Branch (1867:13): [True: 8.11k, False: 507k]
  ------------------
 1868|  8.11k|        {
 1869|  8.11k|            ++cur;
 1870|  8.11k|            goto exp1;
 1871|  8.11k|        }
 1872|   507k|        buffer_.append(hdr, cur);
 1873|   507k|        position_ += (cur - hdr);
 1874|   507k|        end_fraction_value(visitor, ec);
 1875|   507k|        return cur;
 1876|   866k|exp1:
 1877|   866k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   866k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 117, False: 866k]
  |  |  ------------------
  ------------------
 1878|    117|        {
 1879|    117|            number_state_ = parse_number_state::exp1;
 1880|    117|            buffer_.append(hdr, cur);
 1881|    117|            position_ += (cur - hdr);
 1882|    117|            return cur;
 1883|    117|        }
 1884|   866k|        if (*cur == '-')
  ------------------
  |  Branch (1884:13): [True: 153k, False: 712k]
  ------------------
 1885|   153k|        {
 1886|   153k|            ++cur;
 1887|   153k|            goto exp2;
 1888|   153k|        }
 1889|   712k|        if (jsoncons::is_digit(*cur))
  ------------------
  |  Branch (1889:13): [True: 704k, False: 7.90k]
  ------------------
 1890|   704k|        {
 1891|   704k|            ++cur;
 1892|   704k|            goto exp3;
 1893|   704k|        }
 1894|  7.90k|        if (*cur == '+')
  ------------------
  |  Branch (1894:13): [True: 7.89k, False: 12]
  ------------------
 1895|  7.89k|        {
 1896|  7.89k|            ++cur;
 1897|  7.89k|            goto exp2;
 1898|  7.89k|        }
 1899|     12|        err_handler_(json_errc::invalid_number, *this);
 1900|     12|        ec = json_errc::invalid_number;
 1901|     12|        more_ = false;
 1902|     12|        position_ += (cur - hdr);
 1903|     12|        return cur;
 1904|   161k|exp2:
 1905|   161k|        if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|   161k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 63, False: 161k]
  |  |  ------------------
  ------------------
 1906|     63|        {
 1907|     63|            number_state_ = parse_number_state::exp2;
 1908|     63|            buffer_.append(hdr, cur);
 1909|     63|            position_ += (cur - hdr);
 1910|     63|            return cur;
 1911|     63|        }
 1912|   161k|        if (jsoncons::is_digit(*cur))
  ------------------
  |  Branch (1912:13): [True: 161k, False: 4]
  ------------------
 1913|   161k|        {
 1914|   161k|            ++cur;
 1915|   161k|            goto exp3;
 1916|   161k|        }
 1917|      4|        err_handler_(json_errc::invalid_number, *this);
 1918|      4|        ec = json_errc::invalid_number;
 1919|      4|        more_ = false;
 1920|      4|        position_ += (cur - hdr);
 1921|      4|        return cur;
 1922|       |        
 1923|   866k|exp3:
 1924|  4.80M|        while (true)
  ------------------
  |  Branch (1924:16): [True: 4.80M, Folded]
  ------------------
 1925|  4.80M|        {
 1926|  4.80M|            if (JSONCONS_UNLIKELY(cur >= local_input_end)) // Buffer exhausted               
  ------------------
  |  |   78|  4.80M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 973, False: 4.80M]
  |  |  ------------------
  ------------------
 1927|    973|            {
 1928|    973|                number_state_ = parse_number_state::exp3;
 1929|    973|                buffer_.append(hdr, cur);
 1930|    973|                position_ += (cur - hdr);
 1931|    973|                return cur;
 1932|    973|            }
 1933|  4.80M|            if (JSONCONS_UNLIKELY(!jsoncons::is_digit(*cur)))
  ------------------
  |  |   78|  4.80M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 865k, False: 3.93M]
  |  |  ------------------
  ------------------
 1934|   865k|            {
 1935|   865k|                break;
 1936|   865k|            }
 1937|  3.93M|            ++cur;
 1938|  3.93M|        }
 1939|   865k|        buffer_.append(hdr, cur);
 1940|   865k|        position_ += (cur - hdr);
 1941|   865k|        end_fraction_value(visitor, ec);
 1942|   865k|        return cur;
 1943|   866k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10parse_nullERNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1647|   245k|    {
 1648|   245k|        begin_position_ = position_;
 1649|   245k|        if (JSONCONS_LIKELY(input_end_ - input_ptr_ >= 4))
  ------------------
  |  |   77|   245k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 244k, False: 142]
  |  |  ------------------
  ------------------
 1650|   244k|        {
 1651|   244k|            if (*(input_ptr_+1) == 'u' && *(input_ptr_+2) == 'l' && *(input_ptr_+3) == 'l')
  ------------------
  |  Branch (1651:17): [True: 244k, False: 20]
  |  Branch (1651:43): [True: 244k, False: 12]
  |  Branch (1651:69): [True: 244k, False: 15]
  ------------------
 1652|   244k|            {
 1653|   244k|                input_ptr_ += 4;
 1654|   244k|                position_ += 4;
 1655|   244k|                visitor.null_value(semantic_tag::none, *this, ec);
 1656|   244k|                if (JSONCONS_UNLIKELY(ec)){return;}
  ------------------
  |  |   78|   244k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 244k]
  |  |  ------------------
  ------------------
 1657|   244k|                more_ = !cursor_mode_;
 1658|   244k|                if (level_ == 0)
  ------------------
  |  Branch (1658:21): [True: 1, False: 244k]
  ------------------
 1659|      1|                {
 1660|      1|                    state_ = parse_state::accept;
 1661|      1|                }
 1662|   244k|                else
 1663|   244k|                {
 1664|   244k|                    state_ = parse_state::expect_comma_or_end;
 1665|   244k|                }
 1666|   244k|            }
 1667|     47|            else
 1668|     47|            {
 1669|     47|                err_handler_(json_errc::invalid_value, *this);
 1670|     47|                ec = json_errc::invalid_value;
 1671|     47|                more_ = false;
 1672|     47|                return;
 1673|     47|            }
 1674|   244k|        }
 1675|    142|        else
 1676|    142|        {
 1677|    142|            ++input_ptr_;
 1678|    142|            ++position_;
 1679|    142|            state_ = parse_state::n;
 1680|    142|        }
 1681|   245k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10parse_trueEPKcRNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1609|   467k|    {
 1610|   467k|        begin_position_ = position_;
 1611|   467k|        if (JSONCONS_LIKELY(input_end_ - cur >= 4))
  ------------------
  |  |   77|   467k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 467k, False: 233]
  |  |  ------------------
  ------------------
 1612|   467k|        {
 1613|   467k|            if (*(cur+1) == 'r' && *(cur+2) == 'u' && *(cur+3) == 'e')
  ------------------
  |  Branch (1613:17): [True: 467k, False: 21]
  |  Branch (1613:36): [True: 467k, False: 14]
  |  Branch (1613:55): [True: 467k, False: 15]
  ------------------
 1614|   467k|            {
 1615|   467k|                cur += 4;
 1616|   467k|                position_ += 4;
 1617|   467k|                visitor.bool_value(true, semantic_tag::none, *this, ec);
 1618|   467k|                if (JSONCONS_UNLIKELY(ec)){return cur;}
  ------------------
  |  |   78|   467k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 467k]
  |  |  ------------------
  ------------------
 1619|   467k|                if (level_ == 0)
  ------------------
  |  Branch (1619:21): [True: 2, False: 467k]
  ------------------
 1620|      2|                {
 1621|      2|                    state_ = parse_state::accept;
 1622|      2|                }
 1623|   467k|                else
 1624|   467k|                {
 1625|   467k|                    state_ = parse_state::expect_comma_or_end;
 1626|   467k|                }
 1627|   467k|                more_ = !cursor_mode_;
 1628|   467k|            }
 1629|     50|            else
 1630|     50|            {
 1631|     50|                err_handler_(json_errc::invalid_value, *this);
 1632|     50|                ec = json_errc::invalid_value;
 1633|     50|                more_ = false;
 1634|     50|                return cur;
 1635|     50|            }
 1636|   467k|        }
 1637|    233|        else
 1638|    233|        {
 1639|    233|            ++cur;
 1640|    233|            ++position_;
 1641|    233|            state_ = parse_state::t;
 1642|    233|        }
 1643|   467k|        return cur;
 1644|   467k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE11parse_falseEPKcRNS_18basic_json_visitorIcEERNS1_10error_codeE:
 1684|   304k|    {
 1685|   304k|        begin_position_ = position_;
 1686|   304k|        if (JSONCONS_LIKELY(input_end_ - cur >= 5))
  ------------------
  |  |   77|   304k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 304k, False: 193]
  |  |  ------------------
  ------------------
 1687|   304k|        {
 1688|   304k|            if (*(cur+1) == 'a' && *(cur+2) == 'l' && *(cur+3) == 's' && *(cur+4) == 'e')
  ------------------
  |  Branch (1688:17): [True: 304k, False: 22]
  |  Branch (1688:36): [True: 304k, False: 11]
  |  Branch (1688:55): [True: 304k, False: 11]
  |  Branch (1688:74): [True: 304k, False: 10]
  ------------------
 1689|   304k|            {
 1690|   304k|                cur += 5;
 1691|   304k|                position_ += 5;
 1692|   304k|                visitor.bool_value(false, semantic_tag::none, *this, ec);
 1693|   304k|                if (JSONCONS_UNLIKELY(ec)){return cur;}
  ------------------
  |  |   78|   304k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 304k]
  |  |  ------------------
  ------------------
 1694|   304k|                more_ = !cursor_mode_;
 1695|   304k|                if (level_ == 0)
  ------------------
  |  Branch (1695:21): [True: 2, False: 304k]
  ------------------
 1696|      2|                {
 1697|      2|                    state_ = parse_state::accept;
 1698|      2|                }
 1699|   304k|                else
 1700|   304k|                {
 1701|   304k|                    state_ = parse_state::expect_comma_or_end;
 1702|   304k|                }
 1703|   304k|            }
 1704|     54|            else
 1705|     54|            {
 1706|     54|                err_handler_(json_errc::invalid_value, *this);
 1707|     54|                ec = json_errc::invalid_value;
 1708|     54|                more_ = false;
 1709|     54|                return cur;
 1710|     54|            }
 1711|   304k|        }
 1712|    193|        else
 1713|    193|        {
 1714|    193|            ++cur;
 1715|    193|            ++position_;
 1716|    193|            state_ = parse_state::f;
 1717|    193|        }
 1718|   304k|        return cur;
 1719|   304k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10end_objectERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  370|  32.7k|    {
  371|  32.7k|        if (JSONCONS_UNLIKELY(level_ < 1))
  ------------------
  |  |   78|  32.7k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 32.7k]
  |  |  ------------------
  ------------------
  372|      0|        {
  373|      0|            err_handler_(json_errc::unexpected_rbrace, *this);
  374|      0|            ec = json_errc::unexpected_rbrace;
  375|      0|            more_ = false;
  376|      0|            return;
  377|      0|        }
  378|  32.7k|        state_ = pop_state();
  379|  32.7k|        if (state_ == parse_state::object)
  ------------------
  |  Branch (379:13): [True: 32.7k, False: 6]
  ------------------
  380|  32.7k|        {
  381|  32.7k|            visitor.end_object(*this, ec);
  382|  32.7k|            if (JSONCONS_UNLIKELY(ec)){return;};
  ------------------
  |  |   78|  32.7k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 32.7k]
  |  |  ------------------
  ------------------
  383|  32.7k|        }
  384|      6|        else if (state_ == parse_state::array)
  ------------------
  |  Branch (384:18): [True: 6, False: 0]
  ------------------
  385|      6|        {
  386|      6|            err_handler_(json_errc::expected_comma_or_rbracket, *this);
  387|      6|            ec = json_errc::expected_comma_or_rbracket;
  388|      6|            more_ = false;
  389|      6|            return;
  390|      6|        }
  391|      0|        else
  392|      0|        {
  393|      0|            err_handler_(json_errc::unexpected_rbrace, *this);
  394|      0|            ec = json_errc::unexpected_rbrace;
  395|      0|            more_ = false;
  396|      0|            return;
  397|      0|        }
  398|       |
  399|  32.7k|        more_ = !cursor_mode_;
  400|  32.7k|        if (level_ == mark_level_)
  ------------------
  |  Branch (400:13): [True: 0, False: 32.7k]
  ------------------
  401|      0|        {
  402|      0|            more_ = false;
  403|      0|        }
  404|  32.7k|        --level_;
  405|  32.7k|        if (level_ == 0)
  ------------------
  |  Branch (405:13): [True: 10, False: 32.7k]
  ------------------
  406|     10|        {
  407|     10|            state_ = parse_state::accept;
  408|     10|        }
  409|  32.7k|        else
  410|  32.7k|        {
  411|  32.7k|            state_ = parse_state::expect_comma_or_end;
  412|  32.7k|        }
  413|  32.7k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE9end_arrayERNS_18basic_json_visitorIcEERNS1_10error_codeE:
  436|  6.85k|    {
  437|  6.85k|        if (level_ < 1)
  ------------------
  |  Branch (437:13): [True: 0, False: 6.85k]
  ------------------
  438|      0|        {
  439|      0|            err_handler_(json_errc::unexpected_rbracket, *this);
  440|      0|            ec = json_errc::unexpected_rbracket;
  441|      0|            more_ = false;
  442|      0|            return;
  443|      0|        }
  444|  6.85k|        state_ = pop_state();
  445|  6.85k|        if (state_ == parse_state::array)
  ------------------
  |  Branch (445:13): [True: 6.85k, False: 1]
  ------------------
  446|  6.85k|        {
  447|  6.85k|            visitor.end_array(*this, ec);
  448|  6.85k|            if (JSONCONS_UNLIKELY(ec)){return;};
  ------------------
  |  |   78|  6.85k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 6.85k]
  |  |  ------------------
  ------------------
  449|  6.85k|        }
  450|      1|        else if (state_ == parse_state::object)
  ------------------
  |  Branch (450:18): [True: 1, False: 0]
  ------------------
  451|      1|        {
  452|      1|            err_handler_(json_errc::expected_comma_or_rbrace, *this);
  453|      1|            ec = json_errc::expected_comma_or_rbrace;
  454|      1|            more_ = false;
  455|      1|            return;
  456|      1|        }
  457|      0|        else
  458|      0|        {
  459|      0|            err_handler_(json_errc::unexpected_rbracket, *this);
  460|      0|            ec = json_errc::unexpected_rbracket;
  461|      0|            more_ = false;
  462|      0|            return;
  463|      0|        }
  464|       |
  465|  6.85k|        more_ = !cursor_mode_;
  466|  6.85k|        if (level_ == mark_level_)
  ------------------
  |  Branch (466:13): [True: 0, False: 6.85k]
  ------------------
  467|      0|        {
  468|      0|            more_ = false;
  469|      0|        }
  470|  6.85k|        --level_;
  471|       |
  472|  6.85k|        if (level_ == 0)
  ------------------
  |  Branch (472:13): [True: 16, False: 6.83k]
  ------------------
  473|     16|        {
  474|     16|            state_ = parse_state::accept;
  475|     16|        }
  476|  6.83k|        else
  477|  6.83k|        {
  478|  6.83k|            state_ = parse_state::expect_comma_or_end;
  479|  6.83k|        }
  480|  6.85k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE23begin_member_or_elementERNS1_10error_codeE:
 2662|  6.10M|    {
 2663|  6.10M|        switch (parent())
 2664|  6.10M|        {
 2665|   263k|            case parse_state::object:
  ------------------
  |  Branch (2665:13): [True: 263k, False: 5.83M]
  ------------------
 2666|   263k|                state_ = parse_state::expect_member_name;
 2667|   263k|                break;
 2668|  5.83M|            case parse_state::array:
  ------------------
  |  Branch (2668:13): [True: 5.83M, False: 263k]
  ------------------
 2669|  5.83M|                state_ = parse_state::expect_value;
 2670|  5.83M|                break;
 2671|      0|            case parse_state::root:
  ------------------
  |  Branch (2671:13): [True: 0, False: 6.10M]
  ------------------
 2672|      0|                break;
 2673|      0|            default:
  ------------------
  |  Branch (2673:13): [True: 0, False: 6.10M]
  ------------------
 2674|      0|                more_ = err_handler_(json_errc::syntax_error, *this);
 2675|      0|                if (!more_)
  ------------------
  |  Branch (2675:21): [True: 0, False: 0]
  ------------------
 2676|      0|                {
 2677|      0|                    ec = json_errc::syntax_error;
 2678|      0|                    return;
 2679|      0|                }
 2680|      0|                break;
 2681|  6.10M|        }
 2682|  6.10M|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE6parentEv:
  276|  11.4M|    {
  277|  11.4M|        JSONCONS_ASSERT(state_stack_.size() >= 1);
  ------------------
  |  |   49|  11.4M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 11.4M]
  |  |  ------------------
  |  |   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|  11.4M|        return state_stack_.back();
  279|  11.4M|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE5enterEv:
  287|  3.80k|    {
  288|  3.80k|        return state_ == parse_state::start;
  289|  3.80k|    }
_ZNK8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE6acceptEv:
  292|  3.78k|    {
  293|  3.78k|        return state_ == parse_state::accept || done_;
  ------------------
  |  Branch (293:16): [True: 1.44k, False: 2.33k]
  |  Branch (293:49): [True: 1.65k, False: 678]
  ------------------
  294|  3.78k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE15skip_whitespaceEv:
  312|  2.51k|    {
  313|  2.51k|        const char_type* local_input_end = input_end_;
  314|       |
  315|  3.44k|        while (input_ptr_ != local_input_end) 
  ------------------
  |  Branch (315:16): [True: 1.01k, False: 2.43k]
  ------------------
  316|  1.01k|        {
  317|  1.01k|            switch (state_)
  318|  1.01k|            {
  319|    242|                case parse_state::cr:
  ------------------
  |  Branch (319:17): [True: 242, False: 774]
  ------------------
  320|    242|                    ++line_;
  321|       |                    //++position_;
  322|    242|                    switch (*input_ptr_)
  323|    242|                    {
  324|     54|                        case '\n':
  ------------------
  |  Branch (324:25): [True: 54, False: 188]
  ------------------
  325|     54|                            ++input_ptr_;
  326|     54|                            ++position_;
  327|     54|                            mark_position_ = position_;
  328|     54|                            state_ = pop_state();
  329|     54|                            break;
  330|    188|                        default:
  ------------------
  |  Branch (330:25): [True: 188, False: 54]
  ------------------
  331|    188|                            mark_position_ = position_;
  332|    188|                            state_ = pop_state();
  333|    188|                            break;
  334|    242|                    }
  335|    242|                    break;
  336|       |
  337|    774|                default:
  ------------------
  |  Branch (337:17): [True: 774, False: 242]
  ------------------
  338|    774|                    switch (*input_ptr_)
  339|    774|                    {
  340|    694|                        case ' ':case '\t':case '\n':case '\r':
  ------------------
  |  Branch (340:25): [True: 160, False: 614]
  |  Branch (340:34): [True: 90, False: 684]
  |  Branch (340:44): [True: 173, False: 601]
  |  Branch (340:54): [True: 271, False: 503]
  ------------------
  341|    694|                            skip_space(&input_ptr_);
  342|    694|                            break;
  343|     80|                        default:
  ------------------
  |  Branch (343:25): [True: 80, False: 694]
  ------------------
  344|     80|                            return;
  345|    774|                    }
  346|    694|                    break;
  347|  1.01k|            }
  348|  1.01k|        }
  349|  2.51k|    }
_ZN8jsoncons17basic_json_parserIcNSt3__19allocatorIcEEE10check_doneERNS1_10error_codeE:
  522|  1.81k|    {
  523|  24.0k|        for (; input_ptr_ != input_end_; ++input_ptr_)
  ------------------
  |  Branch (523:16): [True: 22.3k, False: 1.74k]
  ------------------
  524|  22.3k|        {
  525|  22.3k|            char_type curr_char_ = *input_ptr_;
  526|  22.3k|            switch (curr_char_)
  527|  22.3k|            {
  528|  1.47k|                case '\n':
  ------------------
  |  Branch (528:17): [True: 1.47k, False: 20.8k]
  ------------------
  529|  10.1k|                case '\r':
  ------------------
  |  Branch (529:17): [True: 8.68k, False: 13.6k]
  ------------------
  530|  12.3k|                case '\t':
  ------------------
  |  Branch (530:17): [True: 2.16k, False: 20.1k]
  ------------------
  531|  22.2k|                case ' ':
  ------------------
  |  Branch (531:17): [True: 9.92k, False: 12.3k]
  ------------------
  532|  22.2k|                    break;
  533|     78|                default:
  ------------------
  |  Branch (533:17): [True: 78, False: 22.2k]
  ------------------
  534|     78|                    more_ = err_handler_(json_errc::extra_character, *this);
  535|     78|                    if (!more_)
  ------------------
  |  Branch (535:25): [True: 78, False: 0]
  ------------------
  536|     78|                    {
  537|     78|                        ec = json_errc::extra_character;
  538|     78|                        return;
  539|     78|                    }
  540|      0|                    break;
  541|  22.3k|            }
  542|  22.3k|        }
  543|  1.81k|    }

_ZN8jsoncons17basic_json_readerIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_EC2IRNS2_19basic_istringstreamIcNS2_11char_traitsIcEES4_EEEEOT_RNS_18basic_json_visitorIcEERKS4_:
  207|  5.17k|            : basic_json_reader(std::forward<Sourceable>(source),
  208|  5.17k|                                visitor,
  209|  5.17k|                                basic_json_decode_options<CharT>(),
  210|  5.17k|                                temp_alloc)
  211|  5.17k|        {
  212|  5.17k|        }
_ZN8jsoncons17basic_json_readerIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_EC2IRNS2_19basic_istringstreamIcNS2_11char_traitsIcEES4_EEEEOT_RNS_18basic_json_visitorIcEERKNS_25basic_json_decode_optionsIcEERKS4_:
  219|  5.17k|        : source_(std::forward<Sourceable>(source)),
  220|  5.17k|          visitor_(visitor),
  221|  5.17k|          parser_(options, temp_alloc)
  222|  5.17k|        {
  223|  5.17k|        }
_ZN8jsoncons17basic_json_readerIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E4readERNS2_10error_codeE:
  397|  5.17k|        {
  398|  5.17k|            read_next(ec);
  399|  5.17k|            if (!ec)
  ------------------
  |  Branch (399:17): [True: 1.81k, False: 3.35k]
  ------------------
  400|  1.81k|            {
  401|  1.81k|                check_done(ec);
  402|  1.81k|            }
  403|  5.17k|        }
_ZN8jsoncons17basic_json_readerIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E9read_nextERNS2_10error_codeE:
  275|  5.17k|        {
  276|  5.17k|            if (source_.is_error())
  ------------------
  |  Branch (276:17): [True: 0, False: 5.17k]
  ------------------
  277|      0|            {
  278|      0|                ec = json_errc::source_error;
  279|      0|                return;
  280|      0|            }        
  281|  5.17k|            parser_.reset();
  282|  17.1k|            while (!parser_.stopped())
  ------------------
  |  Branch (282:20): [True: 15.3k, False: 1.80k]
  ------------------
  283|  15.3k|            {
  284|  15.3k|                if (parser_.source_exhausted())
  ------------------
  |  Branch (284:21): [True: 15.3k, False: 0]
  ------------------
  285|  15.3k|                {
  286|  15.3k|                    auto s = source_.read_chunk(ec);
  287|  15.3k|                    if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  15.3k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 20, False: 15.2k]
  |  |  ------------------
  ------------------
  288|  15.2k|                    if (s.size() > 0)
  ------------------
  |  Branch (288:25): [True: 9.97k, False: 5.31k]
  ------------------
  289|  9.97k|                    {
  290|  9.97k|                        parser_.update(s.data(),s.size());
  291|  9.97k|                    }
  292|  15.2k|                }
  293|  15.2k|                bool eof = parser_.source_exhausted();
  294|  15.2k|                parser_.parse_some(visitor_, ec);
  295|  15.2k|                if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  15.2k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2.65k, False: 12.6k]
  |  |  ------------------
  ------------------
  296|  12.6k|                if (eof)
  ------------------
  |  Branch (296:21): [True: 3.80k, False: 8.83k]
  ------------------
  297|  3.80k|                {
  298|  3.80k|                    if (parser_.enter())
  ------------------
  |  Branch (298:25): [True: 19, False: 3.78k]
  ------------------
  299|     19|                    {
  300|     19|                        break;
  301|     19|                    }
  302|  3.78k|                    else if (!parser_.accept())
  ------------------
  |  Branch (302:30): [True: 678, False: 3.10k]
  ------------------
  303|    678|                    {
  304|    678|                        ec = json_errc::unexpected_eof;
  305|    678|                        return;
  306|    678|                    }
  307|  3.80k|                }
  308|  12.6k|            }
  309|       |            
  310|  1.81k|            parser_.skip_whitespace();
  311|  2.48k|            while (!source_.eof())
  ------------------
  |  Branch (311:20): [True: 693, False: 1.78k]
  ------------------
  312|    693|            {
  313|    693|                parser_.skip_whitespace();
  314|    693|                if (parser_.source_exhausted())
  ------------------
  |  Branch (314:21): [True: 661, False: 32]
  ------------------
  315|    661|                {
  316|    661|                    auto s = source_.read_chunk(ec);
  317|    661|                    if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|    661|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 661]
  |  |  ------------------
  ------------------
  318|    661|                    if (s.size() > 0)
  ------------------
  |  Branch (318:25): [True: 639, False: 22]
  ------------------
  319|    639|                    {
  320|    639|                        parser_.update(s.data(),s.size());
  321|    639|                    }
  322|    661|                }
  323|     32|                else
  324|     32|                {
  325|     32|                    break;
  326|     32|                }
  327|    693|            }
  328|  1.81k|        }
_ZN8jsoncons17basic_json_readerIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES4_E10check_doneERNS2_10error_codeE:
  351|  1.81k|        {
  352|  1.81k|            if (source_.is_error())
  ------------------
  |  Branch (352:17): [True: 0, False: 1.81k]
  ------------------
  353|      0|            {
  354|      0|                ec = json_errc::source_error;
  355|      0|                return;
  356|      0|            }   
  357|  1.81k|            if (source_.eof())
  ------------------
  |  Branch (357:17): [True: 1.78k, False: 32]
  ------------------
  358|  1.78k|            {
  359|  1.78k|                parser_.check_done(ec);
  360|  1.78k|                if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  1.78k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 46, False: 1.74k]
  |  |  ------------------
  ------------------
  361|  1.78k|            }
  362|     32|            else
  363|     32|            {
  364|     32|                do
  365|     32|                {
  366|     32|                    if (parser_.source_exhausted())
  ------------------
  |  Branch (366:25): [True: 0, False: 32]
  ------------------
  367|      0|                    {
  368|      0|                        auto s = source_.read_chunk(ec);
  369|      0|                        if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  370|      0|                        if (s.size() > 0)
  ------------------
  |  Branch (370:29): [True: 0, False: 0]
  ------------------
  371|      0|                        {
  372|      0|                            parser_.update(s.data(),s.size());
  373|      0|                        }
  374|      0|                    }
  375|     32|                    if (!parser_.source_exhausted())
  ------------------
  |  Branch (375:25): [True: 32, False: 0]
  ------------------
  376|     32|                    {
  377|     32|                        parser_.check_done(ec);
  378|     32|                        if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|     32|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 32, False: 0]
  |  |  ------------------
  ------------------
  379|     32|                    }
  380|     32|                }
  381|     32|                while (!eof());
  ------------------
  |  Branch (381:24): [True: 0, False: 0]
  ------------------
  382|     32|            }
  383|  1.81k|        }

_ZN8jsoncons19typed_array_visitorD2Ev:
   33|  10.3k|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|  10.3k|        basic_json_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|  3.46M|        {
  415|  3.46M|            visit_uint64(value, tag, context, ec);
  416|  3.46M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.46M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  417|  3.46M|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  351|  6.85k|        {
  352|  6.85k|            visit_end_array(context, ec);
  353|  6.85k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  6.85k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  354|  6.85k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|   175k|        {
  424|   175k|            visit_int64(value, tag, context, ec);
  425|   175k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   175k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  426|   175k|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|  1.37M|        {
  442|  1.37M|            visit_double(value, tag, context, ec);
  443|  1.37M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.37M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  444|  1.37M|        }
_ZN8jsoncons26basic_default_json_visitorIcEC2Ev:
  811|  5.17k|        basic_default_json_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|  1.80k|        {
  109|  1.80k|            visit_flush();
  110|  1.80k|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  383|  45.3k|        {
  384|  45.3k|            visit_string(value, tag, context, ec);
  385|  45.3k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  45.3k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  386|  45.3k|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  318|  34.5k|        {
  319|  34.5k|            visit_begin_object(tag, context, ec);
  320|  34.5k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  34.5k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  321|  34.5k|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  339|  77.5k|        {
  340|  77.5k|            visit_begin_array(tag, context, ec);
  341|  77.5k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  77.5k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  342|  77.5k|        }
_ZN8jsoncons18basic_json_visitorIcE3keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  357|   267k|        {
  358|   267k|            visit_key(name, context, ec);
  359|   267k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   267k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  360|   267k|        }
_ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  333|  32.7k|        {
  334|  32.7k|            visit_end_object(context, ec);
  335|  32.7k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  32.7k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  336|  32.7k|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  374|   771k|        {
  375|   771k|            visit_bool(value, tag, context, ec);
  376|   771k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   771k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  377|   771k|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  365|   244k|        {
  366|   244k|            visit_null(tag, context, ec);
  367|   244k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   244k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  368|   244k|        }

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

_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERS7_:
  256|  5.17k|            : buf_ptr(std::addressof(buf))
  257|  5.17k|        {
  258|  5.17k|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2EOS8_:
  251|  5.17k|        {
  252|  5.17k|            std::swap(buf_ptr,other.buf_ptr);
  253|  5.17k|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9push_backEc:
  287|   827M|        {
  288|   827M|            buf_ptr->push_back(ch);
  289|   827M|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6appendEPKcm:
  277|  13.7M|        {
  278|  13.7M|            buf_ptr->append(s, length);
  279|  13.7M|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE5flushEv:
  273|  6.97k|        {
  274|  6.97k|        }

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

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

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

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

_ZN8jsoncons14unicode_traits12to_codepointIcjEENSt3__19enable_ifIXaasr10ext_traits8is_char8IT_EE5valuesr10ext_traits9is_char32IT0_EE5valueENS0_14unicode_resultIS4_EEE4typeEPKS4_SB_RS5_NS0_11strict_flagE:
  389|  10.4k|    {
  390|  10.4k|        const uint8_t* it = reinterpret_cast<const uint8_t*>(first);
  391|  10.4k|        const uint8_t* end = reinterpret_cast<const uint8_t*>(last);
  392|       |
  393|  10.4k|        ch = 0;
  394|  10.4k|        if (it >= end)
  ------------------
  |  Branch (394:13): [True: 0, False: 10.4k]
  ------------------
  395|      0|        {
  396|      0|            return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), unicode_errc::source_exhausted};
  397|      0|        }
  398|  10.4k|        unicode_errc  result{};
  399|       |
  400|  10.4k|        uint16_t extra_bytes_to_read = trailing_bytes_for_utf8[*it];
  401|  10.4k|        if (extra_bytes_to_read >= end - it) 
  ------------------
  |  Branch (401:13): [True: 0, False: 10.4k]
  ------------------
  402|      0|        {
  403|      0|            result = unicode_errc::source_exhausted; 
  404|      0|            return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), result};
  405|      0|        }
  406|       |        // Do this check whether lenient or strict 
  407|  10.4k|        if ((result=is_legal_utf8(it, extra_bytes_to_read+1)) != unicode_errc()) 
  ------------------
  |  Branch (407:13): [True: 0, False: 10.4k]
  ------------------
  408|      0|        {
  409|      0|            return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), result};
  410|      0|        }
  411|       |        // The cases all fall through. See "Note A" below.
  412|  10.4k|        switch (extra_bytes_to_read) 
  ------------------
  |  Branch (412:17): [True: 10.4k, False: 0]
  ------------------
  413|  10.4k|        {
  414|      0|            case 5: 
  ------------------
  |  Branch (414:13): [True: 0, False: 10.4k]
  ------------------
  415|      0|                ch += *it++; 
  416|      0|                ch <<= 6;
  417|      0|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|      0|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  418|      0|            case 4: 
  ------------------
  |  Branch (418:13): [True: 0, False: 10.4k]
  ------------------
  419|      0|                ch += *it++; 
  420|      0|                ch <<= 6;
  421|      0|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|      0|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  422|      0|            case 3: 
  ------------------
  |  Branch (422:13): [True: 0, False: 10.4k]
  ------------------
  423|      0|                ch += *it++; 
  424|      0|                ch <<= 6;
  425|      0|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|      0|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  426|      0|            case 2: 
  ------------------
  |  Branch (426:13): [True: 0, False: 10.4k]
  ------------------
  427|      0|                ch += *it++; 
  428|      0|                ch <<= 6;
  429|      0|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|      0|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  430|      0|            case 1: 
  ------------------
  |  Branch (430:13): [True: 0, False: 10.4k]
  ------------------
  431|      0|                ch += *it++; 
  432|      0|                ch <<= 6;
  433|      0|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|      0|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  434|  10.4k|            case 0: 
  ------------------
  |  Branch (434:13): [True: 10.4k, False: 0]
  ------------------
  435|  10.4k|                ch += *it++;
  436|  10.4k|                break;
  437|  10.4k|        }
  438|  10.4k|        ch -= offsets_from_utf8[extra_bytes_to_read];
  439|       |
  440|  10.4k|        if (ch <= max_legal_utf32) {
  ------------------
  |  Branch (440:13): [True: 10.4k, False: 0]
  ------------------
  441|       |            /*
  442|       |             * UTF-16 surrogate values are illegal in UTF-32, and anything
  443|       |             * over Plane 17 (> 0x10FFFF) is illegal.
  444|       |             */
  445|  10.4k|            if (is_surrogate(ch) ) 
  ------------------
  |  Branch (445:17): [True: 0, False: 10.4k]
  ------------------
  446|      0|            {
  447|      0|                if (flags == strict_flag::strict) 
  ------------------
  |  Branch (447:21): [True: 0, False: 0]
  ------------------
  448|      0|                {
  449|      0|                    it -= (extra_bytes_to_read+1); // return to the illegal value itself
  450|      0|                    result = unicode_errc::source_illegal;
  451|      0|                    return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), result};
  452|      0|                } 
  453|      0|                else
  454|      0|                {
  455|      0|                    ch = replacement_char;
  456|      0|                }
  457|      0|            }
  458|  10.4k|        } 
  459|      0|        else // i.e., ch > max_legal_utf32
  460|      0|        { 
  461|      0|            result = unicode_errc::source_illegal;
  462|      0|            ch = replacement_char;
  463|      0|        }
  464|       |
  465|  10.4k|        return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
  466|  10.4k|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8EPKhm:
  305|  33.6k|    {
  306|  33.6k|        const uint8_t* it = reinterpret_cast<const uint8_t*>(bytes);
  307|  33.6k|        const uint8_t* end = it+length;
  308|       |
  309|  33.6k|        uint8_t byte;
  310|  33.6k|        switch (length) {
  311|     23|        default:
  ------------------
  |  Branch (311:9): [True: 23, False: 33.6k]
  ------------------
  312|     23|            return unicode_errc::over_long_utf8_sequence;
  313|    888|        case 4:
  ------------------
  |  Branch (313:9): [True: 888, False: 32.7k]
  ------------------
  314|    888|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 11, False: 877]
  ------------------
  315|     11|                return unicode_errc::bad_continuation_byte;
  316|    877|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|    877|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  317|  3.65k|        case 3:
  ------------------
  |  Branch (317:9): [True: 2.77k, False: 30.8k]
  ------------------
  318|  3.65k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (318:17): [True: 14, False: 3.63k]
  ------------------
  319|     14|                return unicode_errc::bad_continuation_byte;
  320|  3.63k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|  3.63k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  321|  6.37k|        case 2:
  ------------------
  |  Branch (321:9): [True: 2.73k, False: 30.9k]
  ------------------
  322|  6.37k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (322:17): [True: 41, False: 6.33k]
  ------------------
  323|     41|                return unicode_errc::bad_continuation_byte;
  324|       |
  325|  6.33k|            switch (*it) 
  326|  6.33k|            {
  327|       |                // no fall-through in this inner switch
  328|    574|                case 0xE0: if (byte < 0xA0) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (328:17): [True: 574, False: 5.75k]
  |  Branch (328:32): [True: 7, False: 567]
  ------------------
  329|    567|                case 0xED: if (byte > 0x9F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (329:17): [True: 540, False: 5.79k]
  |  Branch (329:32): [True: 2, False: 538]
  ------------------
  330|    538|                case 0xF0: if (byte < 0x90) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (330:17): [True: 353, False: 5.97k]
  |  Branch (330:32): [True: 7, False: 346]
  ------------------
  331|    475|                case 0xF4: if (byte > 0x8F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (331:17): [True: 475, False: 5.85k]
  |  Branch (331:32): [True: 5, False: 470]
  ------------------
  332|  4.39k|                default:   if (byte < 0x80) return unicode_errc::source_illegal;
  ------------------
  |  Branch (332:17): [True: 4.39k, False: 1.94k]
  |  Branch (332:32): [True: 0, False: 4.39k]
  ------------------
  333|  6.33k|            }
  334|       |
  335|  6.31k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|  6.31k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  336|  33.5k|        case 1:
  ------------------
  |  Branch (336:9): [True: 27.2k, False: 6.42k]
  ------------------
  337|  33.5k|            if (*it >= 0x80 && *it < 0xC2)
  ------------------
  |  Branch (337:17): [True: 6.36k, False: 27.1k]
  |  Branch (337:32): [True: 57, False: 6.31k]
  ------------------
  338|     57|                return unicode_errc::source_illegal;
  339|  33.4k|            break;
  340|  33.6k|        }
  341|  33.4k|        if (*it > 0xF4) 
  ------------------
  |  Branch (341:13): [True: 1, False: 33.4k]
  ------------------
  342|      1|            return unicode_errc::source_illegal;
  343|       |
  344|  33.4k|        return unicode_errc();
  345|  33.4k|    }
_ZN8jsoncons14unicode_traits12is_surrogateEj:
  221|   858k|    {
  222|   858k|        return (ch >= sur_high_start && ch <= sur_low_end);
  ------------------
  |  Branch (222:17): [True: 479k, False: 378k]
  |  Branch (222:41): [True: 3.46k, False: 476k]
  ------------------
  223|   858k|    }
_ZN8jsoncons14unicode_traits20detect_json_encodingIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m:
  109|  5.17k|    {
  110|  5.17k|        detect_encoding_result<CharT> r = detect_encoding_from_bom(data,length);
  111|  5.17k|        if (r.encoding != encoding_kind::undetected)
  ------------------
  |  Branch (111:13): [True: 27, False: 5.14k]
  ------------------
  112|     27|        {
  113|     27|            return r;
  114|     27|        }
  115|  5.14k|        else if (length < 4)
  ------------------
  |  Branch (115:18): [True: 567, False: 4.57k]
  ------------------
  116|    567|        {
  117|    567|            return detect_encoding_result<CharT>{data,encoding_kind::utf8};
  118|    567|        }
  119|  4.57k|        else if (*data == 0 && *(data+1) == 0 && *(data+2) == 0)
  ------------------
  |  Branch (119:18): [True: 22, False: 4.55k]
  |  Branch (119:32): [True: 12, False: 10]
  |  Branch (119:50): [True: 4, False: 8]
  ------------------
  120|      4|        {
  121|      4|            return detect_encoding_result<CharT>{data,encoding_kind::utf32be};
  122|      4|        }
  123|  4.57k|        else if (*data == 0 && *(data+2) == 0)
  ------------------
  |  Branch (123:18): [True: 18, False: 4.55k]
  |  Branch (123:32): [True: 3, False: 15]
  ------------------
  124|      3|        {
  125|      3|            return detect_encoding_result<CharT>{data,encoding_kind::utf16be};
  126|      3|        }
  127|  4.57k|        else if (*(data+1) == 0 && *(data+2) == 0 && *(data+3) == 0)
  ------------------
  |  Branch (127:18): [True: 22, False: 4.54k]
  |  Branch (127:36): [True: 10, False: 12]
  |  Branch (127:54): [True: 1, False: 9]
  ------------------
  128|      1|        {
  129|      1|            return detect_encoding_result<CharT>{data,encoding_kind::utf32le};
  130|      1|        }
  131|  4.57k|        else if (*(data+1) == 0 && *(data+3) == 0)
  ------------------
  |  Branch (131:18): [True: 21, False: 4.54k]
  |  Branch (131:36): [True: 4, False: 17]
  ------------------
  132|      4|        {
  133|      4|            return detect_encoding_result<CharT>{data,encoding_kind::utf16le};
  134|      4|        }
  135|  4.56k|        else
  136|  4.56k|        {
  137|  4.56k|            return detect_encoding_result<CharT>{data,encoding_kind::utf8};
  138|  4.56k|        }
  139|  5.17k|    }
_ZN8jsoncons14unicode_traits24detect_encoding_from_bomIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m:
   66|  5.17k|    {
   67|  5.17k|        static constexpr uint8_t bom_utf8[] = {0xef,0xbb,0xbf}; 
   68|  5.17k|        static constexpr uint8_t bom_utf16le[] = {0xff,0xfe}; 
   69|  5.17k|        static constexpr uint8_t bom_utf16be[] = {0xfe,0xff}; 
   70|  5.17k|        static constexpr uint8_t bom_utf32le[] = {0xff,0xfe,0x00,0x00}; 
   71|  5.17k|        static constexpr uint8_t bom_utf32be[] = {0x00,0x00,0xfe,0xff}; 
   72|       |
   73|  5.17k|        if (length >= 4 && !memcmp(data,bom_utf32le,4))
  ------------------
  |  Branch (73:13): [True: 4.60k, False: 570]
  |  Branch (73:28): [True: 1, False: 4.60k]
  ------------------
   74|      1|        {
   75|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32le};
   76|      1|        }
   77|  5.17k|        else if (length >= 4 && !memcmp(data,bom_utf32be,4))
  ------------------
  |  Branch (77:18): [True: 4.60k, False: 570]
  |  Branch (77:33): [True: 1, False: 4.60k]
  ------------------
   78|      1|        {
   79|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32be};
   80|      1|        }
   81|  5.17k|        else if (length >= 2 && !memcmp(data,bom_utf16le,2))
  ------------------
  |  Branch (81:18): [True: 5.11k, False: 54]
  |  Branch (81:33): [True: 5, False: 5.11k]
  ------------------
   82|      5|        {
   83|      5|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16le};
   84|      5|        }
   85|  5.16k|        else if (length >= 2 && !memcmp(data,bom_utf16be,2))
  ------------------
  |  Branch (85:18): [True: 5.11k, False: 54]
  |  Branch (85:33): [True: 1, False: 5.11k]
  ------------------
   86|      1|        {
   87|      1|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16be};
   88|      1|        }
   89|  5.16k|        else if (length >= 3 && !memcmp(data,bom_utf8,3))
  ------------------
  |  Branch (89:18): [True: 4.83k, False: 331]
  |  Branch (89:33): [True: 19, False: 4.81k]
  ------------------
   90|     19|        {
   91|     19|            return detect_encoding_result<CharT>{data+3,encoding_kind::utf8};
   92|     19|        }
   93|  5.14k|        else
   94|  5.14k|        {
   95|  5.14k|            return detect_encoding_result<CharT>{data,encoding_kind::undetected};
   96|  5.14k|        }
   97|  5.17k|    }
_ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_14unicode_resultIS4_EEE4typeEPKS4_m:
 1147|   288k|    {
 1148|   288k|        const uint8_t* it = reinterpret_cast<const uint8_t*>(data);
 1149|   288k|        const uint8_t* end = it + length;
 1150|       |
 1151|   288k|        unicode_errc  result{};
 1152|  1.15M|        while (it != end) 
  ------------------
  |  Branch (1152:16): [True: 861k, False: 288k]
  ------------------
 1153|   861k|        {
 1154|   861k|            if ((end - it) >= 8)
  ------------------
  |  Branch (1154:17): [True: 844k, False: 16.9k]
  ------------------
 1155|   844k|            {
 1156|  5.88M|                JSONCONS_REPEAT8({if (JSONCONS_LIKELY((*it & 0x80) == 0)) ++it; else goto non_ascii;})
  ------------------
  |  |  281|  1.68M|#define JSONCONS_REPEAT8(x)  { x x x x x x x x }
  |  |  ------------------
  |  |  |  Branch (281:32): [True: 842k, False: 2.00k]
  |  |  |  Branch (281:34): [True: 841k, False: 800]
  |  |  |  Branch (281:36): [True: 840k, False: 750]
  |  |  |  Branch (281:38): [True: 840k, False: 497]
  |  |  |  Branch (281:40): [True: 840k, False: 358]
  |  |  |  Branch (281:42): [True: 839k, False: 682]
  |  |  |  Branch (281:44): [True: 838k, False: 817]
  |  |  |  Branch (281:46): [True: 838k, False: 434]
  |  |  ------------------
  ------------------
 1157|   838k|                continue;
 1158|  5.88M|            }
 1159|  23.2k|    non_ascii:
 1160|  23.2k|            const std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[*it]) + 1;
 1161|  23.2k|            if (len > (std::size_t)(end - it))
  ------------------
  |  Branch (1161:17): [True: 33, False: 23.2k]
  ------------------
 1162|     33|            {
 1163|     33|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), unicode_errc::source_exhausted};
 1164|     33|            }
 1165|  23.2k|            if ((result=is_legal_utf8(it, len)) != unicode_errc())
  ------------------
  |  Branch (1165:17): [True: 168, False: 23.0k]
  ------------------
 1166|    168|            {
 1167|    168|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1168|    168|            }
 1169|  23.0k|            it += len;
 1170|  23.0k|        }
 1171|   288k|        return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1172|   288k|    }
_ZN8jsoncons14unicode_traits17is_high_surrogateEj:
  209|   848k|    {
  210|   848k|        return (ch >= sur_high_start && ch <= sur_high_end);
  ------------------
  |  Branch (210:17): [True: 479k, False: 368k]
  |  Branch (210:41): [True: 476k, False: 3.67k]
  ------------------
  211|   848k|    }
_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|   848k|    {
  981|   848k|        unicode_errc  result{};
  982|   848k|        const CharT* last = data + length;
  983|  1.69M|        while (data < last) 
  ------------------
  |  Branch (983:16): [True: 848k, False: 844k]
  ------------------
  984|   848k|        {
  985|   848k|            uint16_t bytes_to_write = 0;
  986|   848k|            static constexpr uint32_t byteMask = 0xBF;
  987|   848k|            static constexpr uint32_t byteMark = 0x80; 
  988|   848k|            uint32_t ch = *data++;
  989|   848k|            if (flags == strict_flag::strict ) 
  ------------------
  |  Branch (989:17): [True: 848k, False: 0]
  ------------------
  990|   848k|            {
  991|       |                /* UTF-16 surrogate values are illegal in UTF-32 */
  992|   848k|                if (is_surrogate(ch)) 
  ------------------
  |  Branch (992:21): [True: 3.46k, False: 844k]
  ------------------
  993|  3.46k|                {
  994|  3.46k|                    --data; /* return to the illegal value itself */
  995|  3.46k|                    result = unicode_errc::illegal_surrogate_value;
  996|  3.46k|                    break;
  997|  3.46k|                }
  998|   848k|            }
  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|   844k|            if (ch < (uint32_t)0x80) {      bytes_to_write = 1;
  ------------------
  |  Branch (1003:17): [True: 7.04k, False: 837k]
  ------------------
 1004|   837k|            } else if (ch < (uint32_t)0x800) {     bytes_to_write = 2;
  ------------------
  |  Branch (1004:24): [True: 683, False: 836k]
  ------------------
 1005|   836k|            } else if (ch < (uint32_t)0x10000) {   bytes_to_write = 3;
  ------------------
  |  Branch (1005:24): [True: 360k, False: 476k]
  ------------------
 1006|   476k|            } else if (ch <= max_legal_utf32) {  bytes_to_write = 4;
  ------------------
  |  Branch (1006:24): [True: 476k, False: 0]
  ------------------
 1007|   476k|            } else {                            
 1008|      0|                bytes_to_write = 3;
 1009|      0|                ch = replacement_char;
 1010|      0|                result = unicode_errc::source_illegal;
 1011|      0|            }
 1012|       |
 1013|   844k|            uint8_t byte1 = 0;
 1014|   844k|            uint8_t byte2 = 0;
 1015|   844k|            uint8_t byte3 = 0;
 1016|   844k|            uint8_t byte4 = 0;
 1017|       |
 1018|   844k|            switch (bytes_to_write) {
  ------------------
  |  Branch (1018:21): [True: 844k, False: 0]
  ------------------
 1019|   476k|            case 4:
  ------------------
  |  Branch (1019:13): [True: 476k, False: 368k]
  ------------------
 1020|   476k|                byte4 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1021|   476k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|   476k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
 1022|   836k|            case 3:
  ------------------
  |  Branch (1022:13): [True: 360k, False: 483k]
  ------------------
 1023|   836k|                byte3 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1024|   836k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|   836k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
 1025|   837k|            case 2:
  ------------------
  |  Branch (1025:13): [True: 683, False: 843k]
  ------------------
 1026|   837k|                byte2 = (uint8_t)((ch | byteMark) & byteMask); ch >>= 6;
 1027|   837k|                JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|   837k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
 1028|   844k|            case 1:
  ------------------
  |  Branch (1028:13): [True: 7.04k, False: 837k]
  ------------------
 1029|   844k|                byte1 = (uint8_t) (ch | first_byte_mark[bytes_to_write]);
 1030|   844k|                break;
 1031|   844k|            }
 1032|       |
 1033|   844k|            switch (bytes_to_write) 
  ------------------
  |  Branch (1033:21): [True: 844k, False: 0]
  ------------------
 1034|   844k|            {
 1035|   476k|            case 4: 
  ------------------
  |  Branch (1035:13): [True: 476k, False: 368k]
  ------------------
 1036|   476k|                target.push_back(byte1);
 1037|   476k|                target.push_back(byte2);
 1038|   476k|                target.push_back(byte3);
 1039|   476k|                target.push_back(byte4);
 1040|   476k|                break;
 1041|   360k|            case 3: 
  ------------------
  |  Branch (1041:13): [True: 360k, False: 483k]
  ------------------
 1042|   360k|                target.push_back(byte1);
 1043|   360k|                target.push_back(byte2);
 1044|   360k|                target.push_back(byte3);
 1045|   360k|                break;
 1046|    683|            case 2: 
  ------------------
  |  Branch (1046:13): [True: 683, False: 843k]
  ------------------
 1047|    683|                target.push_back(byte1);
 1048|    683|                target.push_back(byte2);
 1049|    683|                break;
 1050|  7.04k|            case 1: 
  ------------------
  |  Branch (1050:13): [True: 7.04k, False: 837k]
  ------------------
 1051|  7.04k|                target.push_back(byte1);
 1052|  7.04k|                break;
 1053|   844k|            }
 1054|   844k|        }
 1055|   848k|        return unicode_result<CharT>{data,result} ;
 1056|   848k|    }

_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|  5.17k|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|  5.17k|    {
  489|  5.17k|#if !defined(JSONCONS_NO_LOCALECONV)
  490|  5.17k|        struct lconv *lc = localeconv();
  491|  5.17k|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 5.17k, False: 0]
  |  Branch (491:30): [True: 5.17k, False: 0]
  ------------------
  492|  5.17k|        {
  493|  5.17k|            decimal_point_ = lc->decimal_point[0];
  494|  5.17k|        }
  495|  5.17k|#endif
  496|  5.17k|    }
_ZN8jsoncons12from_integerImNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEENS2_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeESB_RT0_:
   42|  3.46M|{
   43|  3.46M|    using char_type = typename Result::value_type;
   44|       |
   45|  3.46M|    char_type buf[255];
   46|  3.46M|    char_type *p = buf;
   47|  3.46M|    const char_type* last = buf+255;
   48|       |
   49|  3.46M|    bool is_negative = value < 0;
   50|       |
   51|  3.46M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 3.46M]
  ------------------
   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|  3.46M|    else
   60|  3.46M|    {
   61|       |
   62|  3.46M|        do
   63|  3.76M|        {
   64|  3.76M|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  3.76M|        }
   66|  3.76M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 303k, False: 3.46M]
  |  Branch (66:33): [True: 303k, False: 0]
  ------------------
   67|  3.46M|    }
   68|  3.46M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   49|  3.46M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 3.46M]
  |  |  ------------------
  |  |   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|  3.46M|    std::size_t count = (p - buf);
   71|  3.46M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 3.46M]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  7.23M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 3.76M, False: 3.46M]
  ------------------
   77|  3.76M|    {
   78|  3.76M|        result.push_back(*p);
   79|  3.76M|    }
   80|       |
   81|  3.46M|    return count;
   82|  3.46M|}
_ZN8jsoncons12from_integerIlNS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEENS2_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeESB_RT0_:
   42|   175k|{
   43|   175k|    using char_type = typename Result::value_type;
   44|       |
   45|   175k|    char_type buf[255];
   46|   175k|    char_type *p = buf;
   47|   175k|    const char_type* last = buf+255;
   48|       |
   49|   175k|    bool is_negative = value < 0;
   50|       |
   51|   175k|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 173k, False: 1.31k]
  ------------------
   52|   173k|    {
   53|   173k|        do
   54|   440k|        {
   55|   440k|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|   440k|        }
   57|   440k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 267k, False: 173k]
  |  Branch (57:33): [True: 267k, False: 0]
  ------------------
   58|   173k|    }
   59|  1.31k|    else
   60|  1.31k|    {
   61|       |
   62|  1.31k|        do
   63|  1.31k|        {
   64|  1.31k|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  1.31k|        }
   66|  1.31k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 0, False: 1.31k]
  |  Branch (66:33): [True: 0, False: 0]
  ------------------
   67|  1.31k|    }
   68|   175k|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   49|   175k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 175k]
  |  |  ------------------
  |  |   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|   175k|    std::size_t count = (p - buf);
   71|   175k|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 173k, False: 1.31k]
  ------------------
   72|   173k|    {
   73|   173k|        result.push_back('-');
   74|   173k|        ++count;
   75|   173k|    }
   76|   617k|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 442k, False: 175k]
  ------------------
   77|   442k|    {
   78|   442k|        result.push_back(*p);
   79|   442k|    }
   80|       |
   81|   175k|    return count;
   82|   175k|}
_ZN8jsoncons16to_hex_characterEh:
   33|  41.7k|{
   34|  41.7k|    return (char)((c < 10) ? ('0' + c) : ('A' - 10 + c));
  ------------------
  |  Branch (34:19): [True: 31.6k, False: 10.0k]
  ------------------
   35|  41.7k|}
_ZN8jsoncons12write_doubleclINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEmdRT_:
  503|  1.37M|    {
  504|  1.37M|        std::size_t count = 0;
  505|       |
  506|  1.37M|        char number_buffer[200];
  507|  1.37M|        int length = 0;
  508|       |
  509|  1.37M|        switch (float_format_)
  510|  1.37M|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 1.37M]
  ------------------
  512|      0|            {
  513|      0|                if (precision_ > 0)
  ------------------
  |  Branch (513:21): [True: 0, False: 0]
  ------------------
  514|      0|                {
  515|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*f", precision_, val);
  516|      0|                    if (length < 0)
  ------------------
  |  Branch (516:25): [True: 0, False: 0]
  ------------------
  517|      0|                    {
  518|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  519|      0|                    }
  520|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  521|      0|                }
  522|      0|                else
  523|      0|                {
  524|      0|                    if (!dtoa_fixed(val, decimal_point_, result))
  ------------------
  |  Branch (524:25): [True: 0, False: 0]
  ------------------
  525|      0|                    {
  526|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  527|      0|                    }
  528|      0|                }
  529|      0|            }
  530|      0|            break;
  531|      0|        case float_chars_format::scientific:
  ------------------
  |  Branch (531:9): [True: 0, False: 1.37M]
  ------------------
  532|      0|            {
  533|      0|                if (precision_ > 0)
  ------------------
  |  Branch (533:21): [True: 0, False: 0]
  ------------------
  534|      0|                {
  535|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*e", precision_, val);
  536|      0|                    if (length < 0)
  ------------------
  |  Branch (536:25): [True: 0, False: 0]
  ------------------
  537|      0|                    {
  538|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  539|      0|                    }
  540|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  541|      0|                }
  542|      0|                else
  543|      0|                {
  544|      0|                    if (!dtoa_scientific(val, decimal_point_, result))
  ------------------
  |  Branch (544:25): [True: 0, False: 0]
  ------------------
  545|      0|                    {
  546|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  547|      0|                    }
  548|      0|                }
  549|      0|            }
  550|      0|            break;
  551|  1.37M|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 1.37M, False: 0]
  ------------------
  552|  1.37M|            {
  553|  1.37M|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 1.37M]
  ------------------
  554|      0|                {
  555|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*g", precision_, val);
  556|      0|                    if (length < 0)
  ------------------
  |  Branch (556:25): [True: 0, False: 0]
  ------------------
  557|      0|                    {
  558|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  559|      0|                    }
  560|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  561|      0|                }
  562|  1.37M|                else
  563|  1.37M|                {
  564|  1.37M|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 1.37M]
  ------------------
  565|      0|                    {
  566|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  567|      0|                    }
  568|  1.37M|                }             
  569|  1.37M|                break;
  570|  1.37M|            }
  571|  1.37M|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 1.37M]
  ------------------
  572|      0|                JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  573|      0|                break;
  574|  1.37M|        }
  575|  1.37M|        return count;
  576|  1.37M|    }
_ZN8jsoncons11dump_bufferINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKcmcRT_:
  243|  2.78k|{
  244|  2.78k|    const char *sbeg = buffer;
  245|  2.78k|    const char *send = sbeg + length;
  246|       |
  247|  2.78k|    if (sbeg != send)
  ------------------
  |  Branch (247:9): [True: 2.78k, False: 0]
  ------------------
  248|  2.78k|    {
  249|  2.78k|        bool needs_dot = true;
  250|  41.0k|        for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (250:36): [True: 38.2k, False: 2.78k]
  ------------------
  251|  38.2k|        {
  252|  38.2k|            switch (*q)
  253|  38.2k|            {
  254|    388|            case '-':
  ------------------
  |  Branch (254:13): [True: 388, False: 37.8k]
  ------------------
  255|  3.81k|            case '0':
  ------------------
  |  Branch (255:13): [True: 3.42k, False: 34.8k]
  ------------------
  256|  7.85k|            case '1':
  ------------------
  |  Branch (256:13): [True: 4.03k, False: 34.2k]
  ------------------
  257|  10.1k|            case '2':
  ------------------
  |  Branch (257:13): [True: 2.34k, False: 35.9k]
  ------------------
  258|  14.2k|            case '3':
  ------------------
  |  Branch (258:13): [True: 4.02k, False: 34.2k]
  ------------------
  259|  15.1k|            case '4':
  ------------------
  |  Branch (259:13): [True: 920, False: 37.3k]
  ------------------
  260|  16.8k|            case '5':
  ------------------
  |  Branch (260:13): [True: 1.73k, False: 36.5k]
  ------------------
  261|  19.2k|            case '6':
  ------------------
  |  Branch (261:13): [True: 2.34k, False: 35.9k]
  ------------------
  262|  30.8k|            case '7':
  ------------------
  |  Branch (262:13): [True: 11.5k, False: 26.6k]
  ------------------
  263|  32.8k|            case '8':
  ------------------
  |  Branch (263:13): [True: 2.04k, False: 36.2k]
  ------------------
  264|  34.4k|            case '9':
  ------------------
  |  Branch (264:13): [True: 1.58k, False: 36.6k]
  ------------------
  265|  35.1k|            case '+':
  ------------------
  |  Branch (265:13): [True: 722, False: 37.5k]
  ------------------
  266|  35.1k|                result.push_back(*q);
  267|  35.1k|                break;
  268|    819|            case 'e':
  ------------------
  |  Branch (268:13): [True: 819, False: 37.4k]
  ------------------
  269|    819|            case 'E':
  ------------------
  |  Branch (269:13): [True: 0, False: 38.2k]
  ------------------
  270|    819|                result.push_back('e');
  271|    819|                needs_dot = false;
  272|    819|                break;
  273|  2.28k|            default:
  ------------------
  |  Branch (273:13): [True: 2.28k, False: 35.9k]
  ------------------
  274|  2.28k|                if (*q == decimal_point)
  ------------------
  |  Branch (274:21): [True: 2.28k, False: 0]
  ------------------
  275|  2.28k|                {
  276|  2.28k|                    needs_dot = false;
  277|  2.28k|                    result.push_back('.');
  278|  2.28k|                }
  279|  2.28k|                break;
  280|  38.2k|            }
  281|  38.2k|        }
  282|  2.78k|        if (needs_dot)
  ------------------
  |  Branch (282:13): [True: 223, False: 2.56k]
  ------------------
  283|    223|        {
  284|    223|            result.push_back('.');
  285|    223|            result.push_back('0');
  286|    223|        }
  287|  2.78k|    }
  288|  2.78k|}
_ZN8jsoncons15prettify_stringINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKciiiiRT_:
  171|  1.26M|{
  172|  1.26M|    int nb_digits = length;
  173|  1.26M|    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|  1.26M|    int kk = nb_digits + k;
  179|       |
  180|  1.26M|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 604k, False: 657k]
  |  Branch (180:28): [True: 560k, False: 43.2k]
  ------------------
  181|   560k|    {
  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|  1.17M|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 617k, False: 560k]
  ------------------
  186|   617k|        {
  187|   617k|            result.push_back(buffer[i]);
  188|   617k|        }
  189|  5.42M|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 4.86M, False: 560k]
  ------------------
  190|  4.86M|        {
  191|  4.86M|            result.push_back('0');
  192|  4.86M|        }
  193|   560k|        result.push_back('.');
  194|   560k|        result.push_back('0');
  195|   560k|    } 
  196|   700k|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 544k, False: 155k]
  |  Branch (196:24): [True: 501k, False: 43.2k]
  ------------------
  197|   501k|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|  1.02M|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 518k, False: 501k]
  ------------------
  200|   518k|        {
  201|   518k|            result.push_back(buffer[i]);
  202|   518k|        }
  203|   501k|        result.push_back('.');
  204|  1.05M|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 558k, False: 501k]
  ------------------
  205|   558k|        {
  206|   558k|            result.push_back(buffer[i]);
  207|   558k|        }
  208|   501k|    } 
  209|   198k|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 50.3k, False: 148k]
  |  Branch (209:30): [True: 7.18k, False: 43.2k]
  ------------------
  210|  7.18k|    {
  211|  7.18k|        offset = 2 - kk;
  212|       |
  213|  7.18k|        result.push_back('0');
  214|  7.18k|        result.push_back('.');
  215|  17.2k|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 10.0k, False: 7.18k]
  ------------------
  216|  10.0k|            result.push_back('0');
  217|  15.3k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 8.13k, False: 7.18k]
  ------------------
  218|  8.13k|        {
  219|  8.13k|            result.push_back(buffer[i]);
  220|  8.13k|        }
  221|  7.18k|    } 
  222|   191k|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 182k, False: 9.36k]
  ------------------
  223|   182k|    {
  224|   182k|        result.push_back(buffer[0]);
  225|   182k|        result.push_back('e');
  226|   182k|        fill_exponent(kk - 1, result);
  227|   182k|    } 
  228|  9.36k|    else
  229|  9.36k|    {
  230|  9.36k|        result.push_back(buffer[0]);
  231|  9.36k|        result.push_back('.');
  232|  23.4k|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 14.1k, False: 9.36k]
  ------------------
  233|  14.1k|        {
  234|  14.1k|            result.push_back(buffer[i]);
  235|  14.1k|        }
  236|  9.36k|        result.push_back('e');
  237|  9.36k|        fill_exponent(kk - 1, result);
  238|  9.36k|    }
  239|  1.26M|}
_ZN8jsoncons13fill_exponentINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEviRT_:
  136|   191k|{
  137|   191k|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 148k, False: 43.2k]
  ------------------
  138|   148k|    {
  139|   148k|        result.push_back('-');
  140|   148k|        K = -K;
  141|   148k|    }
  142|  43.2k|    else
  143|  43.2k|    {
  144|  43.2k|        result.push_back('+'); // compatibility with sprintf
  145|  43.2k|    }
  146|       |
  147|   191k|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 229, False: 191k]
  ------------------
  148|    229|    {
  149|    229|        result.push_back('0'); // compatibility with sprintf
  150|    229|        result.push_back((char)('0' + K));
  151|    229|    }
  152|   191k|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 47.7k, False: 143k]
  ------------------
  153|  47.7k|    {
  154|  47.7k|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|  47.7k|        result.push_back((char)('0' + K));
  156|  47.7k|    }
  157|   143k|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 143k, False: 0]
  ------------------
  158|   143k|    {
  159|   143k|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|   143k|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|   143k|        result.push_back((char)('0' + K));
  162|   143k|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|   191k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_:
  475|  1.37M|{
  476|  1.37M|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|  1.37M|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb1EEE:
  366|  1.37M|{
  367|  1.37M|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 109k, False: 1.26M]
  ------------------
  368|   109k|    {
  369|   109k|        result.push_back('0');
  370|   109k|        result.push_back('.');
  371|   109k|        result.push_back('0');
  372|   109k|        return true;
  373|   109k|    }
  374|       |
  375|  1.26M|    int length = 0;
  376|  1.26M|    int k;
  377|       |
  378|  1.26M|    char buffer[100];
  379|       |
  380|  1.26M|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 12.6k, False: 1.25M]
  ------------------
  381|  1.26M|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 1.26M, False: 2.78k]
  ------------------
  382|  1.26M|    {
  383|  1.26M|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 12.3k, False: 1.24M]
  ------------------
  384|  12.3k|        {
  385|  12.3k|            result.push_back('-');
  386|  12.3k|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|  1.26M|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|  1.26M|        return true;
  391|  1.26M|    }
  392|  2.78k|    else
  393|  2.78k|    {
  394|  2.78k|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|  2.78k|    }
  396|  1.26M|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb0EEE:
  329|  2.78k|{
  330|  2.78k|    if (val == 0)
  ------------------
  |  Branch (330:9): [True: 0, False: 2.78k]
  ------------------
  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|  2.78k|    char buffer[100];
  339|  2.78k|    int precision = std::numeric_limits<double>::digits10;
  340|  2.78k|    int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  341|  2.78k|    if (length < 0)
  ------------------
  |  Branch (341:9): [True: 0, False: 2.78k]
  ------------------
  342|      0|    {
  343|      0|        return false;
  344|      0|    }
  345|  2.78k|    double x{0};
  346|  2.78k|    auto res = decstr_to_double(buffer, length, x);
  347|  2.78k|    if (res.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (347:9): [True: 0, False: 2.78k]
  ------------------
  348|      0|    {
  349|      0|        return false;
  350|      0|    }
  351|  2.78k|    if (x != val)
  ------------------
  |  Branch (351:9): [True: 958, False: 1.82k]
  ------------------
  352|    958|    {
  353|    958|        const int precision2 = std::numeric_limits<double>::max_digits10;
  354|    958|        length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  355|    958|        if (length < 0)
  ------------------
  |  Branch (355:13): [True: 0, False: 958]
  ------------------
  356|      0|        {
  357|      0|            return false;
  358|      0|        }
  359|    958|    }
  360|  2.78k|    dump_buffer(buffer, length, decimal_point, result);
  361|  2.78k|    return true;
  362|  2.78k|}