LLVMFuzzerTestOneInput:
   11|  6.25k|{
   12|  6.25k|    std::string s(reinterpret_cast<const char*>(data), size);
   13|  6.25k|    std::istringstream is(s);
   14|  6.25k|    std::vector<uint8_t> s1;
   15|  6.25k|    msgpack_bytes_encoder encoder(s1);
   16|  6.25k|    msgpack_stream_reader reader(is, encoder);
   17|       |
   18|  6.25k|    std::error_code ec;
   19|  6.25k|    reader.read(ec);
   20|       |
   21|  6.25k|    return 0;
   22|  6.25k|}

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

_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1011|   332k|        {
 1012|   332k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1012:17): [True: 17.0k, False: 315k]
  ------------------
 1013|  17.0k|            {
 1014|  17.0k|                if (level_stack_.back().target() == target_t::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1014:21): [True: 13.8k, False: 3.19k]
  |  Branch (1014:73): [True: 11.6k, False: 2.20k]
  ------------------
 1015|  11.6k|                {
 1016|  11.6k|                    key_buffer_.push_back(',');
 1017|  11.6k|                }
 1018|  17.0k|                level_stack_.emplace_back(target_t::buffer, container_t::array);
 1019|  17.0k|                key_buffer_.push_back('[');
 1020|  17.0k|            }
 1021|   315k|            else
 1022|   315k|            {
 1023|   315k|                switch (level_stack_.back().target())
 1024|   315k|                {
 1025|   239k|                    case target_t::buffer:
  ------------------
  |  Branch (1025:21): [True: 239k, False: 75.3k]
  ------------------
 1026|   239k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1026:29): [True: 227k, False: 12.4k]
  |  Branch (1026:65): [True: 87.3k, False: 140k]
  ------------------
 1027|  87.3k|                        {
 1028|  87.3k|                            key_buffer_.push_back(',');
 1029|  87.3k|                        }
 1030|   239k|                        level_stack_.emplace_back(target_t::buffer, container_t::array);
 1031|   239k|                        key_buffer_.push_back('[');
 1032|   239k|                        break;
 1033|  75.3k|                    default:
  ------------------
  |  Branch (1033:21): [True: 75.3k, False: 239k]
  ------------------
 1034|  75.3k|                        level_stack_.emplace_back(target_t::destination, container_t::array);
 1035|  75.3k|                        destination_->begin_array(length, tag, context, ec);
 1036|  75.3k|                        break;
 1037|   315k|                }
 1038|   315k|            }
 1039|   332k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   332k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1040|   332k|        }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level6is_keyEv:
  814|   104M|            {
  815|   104M|                return even_odd_ == 0;
  816|   104M|            }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level6targetEv:
  824|  64.5M|            {
  825|  64.5M|                return state_;
  826|  64.5M|            }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level5countEv:
  829|  28.4M|            {
  830|  28.4M|                return count_;
  831|  28.4M|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5levelC2ENS4_8target_tENS4_11container_tE:
  797|   661k|                : state_(state), type_(type), even_odd_(type == container_t::object ? 0 : 1)
  ------------------
  |  Branch (797:57): [True: 322k, False: 338k]
  ------------------
  798|   661k|            {
  799|   661k|            }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level9is_objectEv:
  819|  63.2M|            {
  820|  63.2M|                return type_ == container_t::object;
  821|  63.2M|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE15visit_end_arrayERKNS_11ser_contextERNS1_10error_codeE:
 1043|   306k|        {
 1044|   306k|            switch (level_stack_.back().target())
 1045|   306k|            {
 1046|   245k|                case target_t::buffer:
  ------------------
  |  Branch (1046:17): [True: 245k, False: 60.6k]
  ------------------
 1047|   245k|                    key_buffer_.push_back(']');
 1048|   245k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   45|   245k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 245k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1049|   245k|                    level_stack_.pop_back();
 1050|   245k|                    if (level_stack_.back().target() == target_t::destination)
  ------------------
  |  Branch (1050:25): [True: 2.70k, False: 243k]
  ------------------
 1051|  2.70k|                    {
 1052|  2.70k|                        destination_->key(key_buffer_, context, ec);
 1053|  2.70k|                        key_buffer_.clear();
 1054|  2.70k|                    }
 1055|   243k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (1055:30): [True: 12.4k, False: 230k]
  ------------------
 1056|  12.4k|                    {
 1057|  12.4k|                        key_buffer_.push_back(':');
 1058|  12.4k|                    }
 1059|   245k|                    level_stack_.back().advance();
 1060|   245k|                    break;
 1061|  60.6k|                default:
  ------------------
  |  Branch (1061:17): [True: 60.6k, False: 245k]
  ------------------
 1062|  60.6k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   45|  60.6k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 60.6k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1063|  60.6k|                    level_stack_.pop_back();
 1064|  60.6k|                    level_stack_.back().advance();
 1065|  60.6k|                    destination_->end_array(context, ec);
 1066|  60.6k|                    break;
 1067|   306k|            }
 1068|   306k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   306k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1069|   306k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level7advanceEv:
  802|  34.8M|            {
  803|  34.8M|                if (!is_key())
  ------------------
  |  Branch (803:21): [True: 29.2M, False: 5.61M]
  ------------------
  804|  29.2M|                {
  805|  29.2M|                    ++count_;
  806|  29.2M|                }
  807|  34.8M|                if (is_object())
  ------------------
  |  Branch (807:21): [True: 11.2M, False: 23.6M]
  ------------------
  808|  11.2M|                {
  809|  11.2M|                    even_odd_ = !even_odd_;
  810|  11.2M|                }
  811|  34.8M|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1236|  13.1M|        {
 1237|  13.1M|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1237:17): [True: 3.32M, False: 9.80M]
  |  Branch (1237:49): [True: 9.54M, False: 262k]
  ------------------
 1238|  12.8M|            {
 1239|  12.8M|                key_.clear();
 1240|  12.8M|                jsoncons::from_integer(value,key_);
 1241|  12.8M|            }
 1242|       |
 1243|  13.1M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1243:17): [True: 3.32M, False: 9.80M]
  ------------------
 1244|  3.32M|            {
 1245|  3.32M|                switch (level_stack_.back().target())
 1246|  3.32M|                {
 1247|  3.30M|                    case target_t::buffer:
  ------------------
  |  Branch (1247:21): [True: 3.30M, False: 25.3k]
  ------------------
 1248|  3.30M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1248:29): [True: 3.29M, False: 5.68k]
  ------------------
 1249|  3.29M|                        {
 1250|  3.29M|                            key_buffer_.push_back(',');
 1251|  3.29M|                        }
 1252|  3.30M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1253|  3.30M|                        key_buffer_.push_back(':');
 1254|  3.30M|                        break;
 1255|  25.3k|                    default:
  ------------------
  |  Branch (1255:21): [True: 25.3k, False: 3.30M]
  ------------------
 1256|  25.3k|                        destination_->key(key_, context, ec);
 1257|  25.3k|                        break;
 1258|  3.32M|                }
 1259|  3.32M|            }
 1260|  9.80M|            else
 1261|  9.80M|            {
 1262|  9.80M|                switch (level_stack_.back().target())
 1263|  9.80M|                {
 1264|  9.54M|                    case target_t::buffer:
  ------------------
  |  Branch (1264:21): [True: 9.54M, False: 262k]
  ------------------
 1265|  9.54M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1265:29): [True: 6.23M, False: 3.30M]
  |  Branch (1265:65): [True: 6.22M, False: 4.05k]
  ------------------
 1266|  6.22M|                        {
 1267|  6.22M|                            key_buffer_.push_back(',');
 1268|  6.22M|                        }
 1269|  9.54M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1270|  9.54M|                        break;
 1271|   262k|                    default:
  ------------------
  |  Branch (1271:21): [True: 262k, False: 9.54M]
  ------------------
 1272|   262k|                        destination_->uint64_value(value, tag, context, ec);
 1273|   262k|                        break;
 1274|  9.80M|                }
 1275|  9.80M|            }
 1276|       |
 1277|  13.1M|            level_stack_.back().advance();
 1278|  13.1M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  13.1M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1279|  13.1M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1282|  2.06M|        {
 1283|  2.06M|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1283:17): [True: 188k, False: 1.87M]
  |  Branch (1283:49): [True: 1.74M, False: 126k]
  ------------------
 1284|  1.93M|            {
 1285|  1.93M|                key_.clear();
 1286|  1.93M|                jsoncons::from_integer(value,key_);
 1287|  1.93M|            }
 1288|       |
 1289|  2.06M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1289:17): [True: 188k, False: 1.87M]
  ------------------
 1290|   188k|            {
 1291|   188k|                switch (level_stack_.back().target())
 1292|   188k|                {
 1293|   168k|                    case target_t::buffer:
  ------------------
  |  Branch (1293:21): [True: 168k, False: 20.2k]
  ------------------
 1294|   168k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1294:29): [True: 166k, False: 1.59k]
  ------------------
 1295|   166k|                        {
 1296|   166k|                            key_buffer_.push_back(',');
 1297|   166k|                        }
 1298|   168k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1299|   168k|                        key_buffer_.push_back(':');
 1300|   168k|                        break;
 1301|  20.2k|                    default:
  ------------------
  |  Branch (1301:21): [True: 20.2k, False: 168k]
  ------------------
 1302|  20.2k|                        destination_->key(key_, context, ec);
 1303|  20.2k|                        break;
 1304|   188k|                }
 1305|   188k|            }
 1306|  1.87M|            else
 1307|  1.87M|            {
 1308|  1.87M|                switch (level_stack_.back().target())
 1309|  1.87M|                {
 1310|  1.74M|                    case target_t::buffer:
  ------------------
  |  Branch (1310:21): [True: 1.74M, False: 126k]
  ------------------
 1311|  1.74M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1311:29): [True: 1.58M, False: 169k]
  |  Branch (1311:65): [True: 1.57M, False: 1.76k]
  ------------------
 1312|  1.57M|                        {
 1313|  1.57M|                            key_buffer_.push_back(',');
 1314|  1.57M|                        }
 1315|  1.74M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1316|  1.74M|                        break;
 1317|   126k|                    default:
  ------------------
  |  Branch (1317:21): [True: 126k, False: 1.74M]
  ------------------
 1318|   126k|                        destination_->int64_value(value, tag, context, ec);
 1319|   126k|                        break;
 1320|  1.87M|                }
 1321|  1.87M|            }
 1322|       |
 1323|  2.06M|            level_stack_.back().advance();
 1324|  2.06M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  2.06M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1325|  2.06M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1377|  39.2k|        {
 1378|  39.2k|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1378:17): [True: 12.1k, False: 27.1k]
  |  Branch (1378:49): [True: 20.2k, False: 6.87k]
  ------------------
 1379|  32.4k|            {
 1380|  32.4k|                key_.clear();
 1381|  32.4k|                string_sink<string_type> sink(key_);
 1382|  32.4k|                jsoncons::write_double f{float_chars_format::general,0};
 1383|  32.4k|                f(value, sink);
 1384|  32.4k|            }
 1385|       |
 1386|  39.2k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1386:17): [True: 12.1k, False: 27.1k]
  ------------------
 1387|  12.1k|            {
 1388|  12.1k|                switch (level_stack_.back().target())
 1389|  12.1k|                {
 1390|  8.43k|                    case target_t::buffer:
  ------------------
  |  Branch (1390:21): [True: 8.43k, False: 3.70k]
  ------------------
 1391|  8.43k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1391:29): [True: 5.46k, False: 2.96k]
  ------------------
 1392|  5.46k|                        {
 1393|  5.46k|                            key_buffer_.push_back(',');
 1394|  5.46k|                        }
 1395|  8.43k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1396|  8.43k|                        key_buffer_.push_back(':');
 1397|  8.43k|                        break;
 1398|  3.70k|                    default:
  ------------------
  |  Branch (1398:21): [True: 3.70k, False: 8.43k]
  ------------------
 1399|  3.70k|                        destination_->key(key_, context, ec);
 1400|  3.70k|                        break;
 1401|  12.1k|                }
 1402|  12.1k|            }
 1403|  27.1k|            else
 1404|  27.1k|            {
 1405|  27.1k|                switch (level_stack_.back().target())
 1406|  27.1k|                {
 1407|  20.2k|                    case target_t::buffer:
  ------------------
  |  Branch (1407:21): [True: 20.2k, False: 6.87k]
  ------------------
 1408|  20.2k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1408:29): [True: 14.6k, False: 5.60k]
  |  Branch (1408:65): [True: 13.1k, False: 1.50k]
  ------------------
 1409|  13.1k|                        {
 1410|  13.1k|                            key_buffer_.push_back(',');
 1411|  13.1k|                        }
 1412|  20.2k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1413|  20.2k|                        break;
 1414|  6.87k|                    default:
  ------------------
  |  Branch (1414:21): [True: 6.87k, False: 20.2k]
  ------------------
 1415|  6.87k|                        destination_->double_value(value, tag, context, ec);
 1416|  6.87k|                        break;
 1417|  27.1k|                }
 1418|  27.1k|            }
 1419|       |
 1420|  39.2k|            level_stack_.back().advance();
 1421|  39.2k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  39.2k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1422|  39.2k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE11visit_flushEv:
  884|  1.61k|        {
  885|  1.61k|            destination_->flush();
  886|  1.61k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  917|   322k|        {
  918|   322k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (918:17): [True: 51.9k, False: 270k]
  ------------------
  919|  51.9k|            {
  920|  51.9k|                if (level_stack_.back().target() == target_t::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (920:21): [True: 38.9k, False: 13.0k]
  |  Branch (920:73): [True: 18.9k, False: 19.9k]
  ------------------
  921|  18.9k|                {
  922|  18.9k|                    key_buffer_.push_back(',');
  923|  18.9k|                }
  924|  51.9k|                level_stack_.emplace_back(target_t::buffer, container_t::object);
  925|  51.9k|                key_buffer_.push_back('{');
  926|  51.9k|            }
  927|   270k|            else
  928|   270k|            {
  929|   270k|                switch (level_stack_.back().target())
  930|   270k|                {
  931|   226k|                    case target_t::buffer:
  ------------------
  |  Branch (931:21): [True: 226k, False: 44.0k]
  ------------------
  932|   226k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (932:29): [True: 185k, False: 40.8k]
  |  Branch (932:65): [True: 184k, False: 1.59k]
  ------------------
  933|   184k|                        {
  934|   184k|                            key_buffer_.push_back(',');
  935|   184k|                        }
  936|   226k|                        level_stack_.emplace_back(target_t::buffer, container_t::object);
  937|   226k|                        key_buffer_.push_back('{');
  938|   226k|                        break;
  939|  44.0k|                    default:
  ------------------
  |  Branch (939:21): [True: 44.0k, False: 226k]
  ------------------
  940|  44.0k|                        level_stack_.emplace_back(target_t::destination, container_t::object);
  941|  44.0k|                        destination_->begin_object(length, tag, context, ec);
  942|  44.0k|                        break;
  943|   270k|                }
  944|   270k|            }
  945|   322k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   322k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  946|   322k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE16visit_end_objectERKNS_11ser_contextERNS1_10error_codeE:
  949|   302k|        {
  950|   302k|            switch (level_stack_.back().target())
  951|   302k|            {
  952|   266k|                case target_t::buffer:
  ------------------
  |  Branch (952:17): [True: 266k, False: 35.5k]
  ------------------
  953|   266k|                    key_buffer_.push_back('}');
  954|   266k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   45|   266k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 266k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  955|   266k|                    level_stack_.pop_back();
  956|       |                    
  957|   266k|                    if (level_stack_.back().target() == target_t::destination)
  ------------------
  |  Branch (957:25): [True: 12.2k, False: 254k]
  ------------------
  958|  12.2k|                    {
  959|  12.2k|                        destination_->key(key_buffer_,context, ec);
  960|  12.2k|                        key_buffer_.clear();
  961|  12.2k|                    }
  962|   254k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (962:30): [True: 34.3k, False: 220k]
  ------------------
  963|  34.3k|                    {
  964|  34.3k|                        key_buffer_.push_back(':');
  965|  34.3k|                    }
  966|   266k|                    level_stack_.back().advance();
  967|   266k|                    break;
  968|  35.5k|                default:
  ------------------
  |  Branch (968:17): [True: 35.5k, False: 266k]
  ------------------
  969|  35.5k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   45|  35.5k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 35.5k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  970|  35.5k|                    level_stack_.pop_back();
  971|  35.5k|                    level_stack_.back().advance();
  972|  35.5k|                    destination_->end_object(context, ec);
  973|  35.5k|                    break;
  974|   302k|            }
  975|   302k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   302k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  976|   302k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1478|   137k|        {
 1479|   137k|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1479:17): [True: 56.1k, False: 81.3k]
  |  Branch (1479:49): [True: 66.4k, False: 14.9k]
  ------------------
 1480|   122k|            {
 1481|   122k|                key_.clear(); 
 1482|   122k|                key_.insert(key_.begin(), null_constant.begin(), null_constant.end());
 1483|   122k|            }
 1484|       |
 1485|   137k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1485:17): [True: 56.1k, False: 81.3k]
  ------------------
 1486|  56.1k|            {
 1487|  56.1k|                switch (level_stack_.back().target())
 1488|  56.1k|                {
 1489|  50.1k|                    case target_t::buffer:
  ------------------
  |  Branch (1489:21): [True: 50.1k, False: 5.90k]
  ------------------
 1490|  50.1k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1490:29): [True: 45.7k, False: 4.40k]
  ------------------
 1491|  45.7k|                        {
 1492|  45.7k|                            key_buffer_.push_back(',');
 1493|  45.7k|                        }
 1494|  50.1k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1495|  50.1k|                        key_buffer_.push_back(':');
 1496|  50.1k|                        break;
 1497|  5.90k|                    default:
  ------------------
  |  Branch (1497:21): [True: 5.90k, False: 50.1k]
  ------------------
 1498|  5.90k|                        destination_->key(key_, context, ec);
 1499|  5.90k|                        break;
 1500|  56.1k|                }
 1501|  56.1k|            }
 1502|  81.3k|            else
 1503|  81.3k|            {
 1504|  81.3k|                switch (level_stack_.back().target())
 1505|  81.3k|                {
 1506|  66.4k|                    case target_t::buffer:
  ------------------
  |  Branch (1506:21): [True: 66.4k, False: 14.9k]
  ------------------
 1507|  66.4k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1507:29): [True: 20.6k, False: 45.8k]
  |  Branch (1507:65): [True: 20.2k, False: 416]
  ------------------
 1508|  20.2k|                        {
 1509|  20.2k|                            key_buffer_.push_back(',');
 1510|  20.2k|                        }
 1511|  66.4k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1512|  66.4k|                        break;
 1513|  14.9k|                    default:
  ------------------
  |  Branch (1513:21): [True: 14.9k, False: 66.4k]
  ------------------
 1514|  14.9k|                        destination_->null_value(tag, context, ec);
 1515|  14.9k|                        break;
 1516|  81.3k|                }
 1517|  81.3k|            }
 1518|       |
 1519|   137k|            level_stack_.back().advance();
 1520|   137k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   137k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1521|   137k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1425|  18.4M|        {
 1426|  18.4M|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1426:17): [True: 1.92M, False: 16.5M]
  |  Branch (1426:49): [True: 16.3M, False: 225k]
  ------------------
 1427|  18.2M|            {
 1428|  18.2M|                key_.clear(); 
 1429|  18.2M|                if (value)
  ------------------
  |  Branch (1429:21): [True: 78.6k, False: 18.1M]
  ------------------
 1430|  78.6k|                {
 1431|  78.6k|                    key_.insert(key_.begin(), true_constant.begin(), true_constant.end());
 1432|  78.6k|                }
 1433|  18.1M|                else
 1434|  18.1M|                {
 1435|  18.1M|                    key_.insert(key_.begin(), false_constant.begin(), false_constant.end());
 1436|  18.1M|                }
 1437|  18.2M|            }
 1438|       |
 1439|  18.4M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1439:17): [True: 1.92M, False: 16.5M]
  ------------------
 1440|  1.92M|            {
 1441|  1.92M|                switch (level_stack_.back().target())
 1442|  1.92M|                {
 1443|  1.88M|                    case target_t::buffer:
  ------------------
  |  Branch (1443:21): [True: 1.88M, False: 44.7k]
  ------------------
 1444|  1.88M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1444:29): [True: 1.86M, False: 18.2k]
  ------------------
 1445|  1.86M|                        {
 1446|  1.86M|                            key_buffer_.push_back(',');
 1447|  1.86M|                        }
 1448|  1.88M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1449|  1.88M|                        key_buffer_.push_back(':');
 1450|  1.88M|                        break;
 1451|  44.7k|                    default:
  ------------------
  |  Branch (1451:21): [True: 44.7k, False: 1.88M]
  ------------------
 1452|  44.7k|                        destination_->key(key_, context, ec);
 1453|  44.7k|                        break;
 1454|  1.92M|                }
 1455|  1.92M|            }
 1456|  16.5M|            else
 1457|  16.5M|            {
 1458|  16.5M|                switch (level_stack_.back().target())
 1459|  16.5M|                {
 1460|  16.3M|                    case target_t::buffer:
  ------------------
  |  Branch (1460:21): [True: 16.3M, False: 225k]
  ------------------
 1461|  16.3M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1461:29): [True: 14.4M, False: 1.88M]
  |  Branch (1461:65): [True: 14.4M, False: 3.64k]
  ------------------
 1462|  14.4M|                        {
 1463|  14.4M|                            key_buffer_.push_back(',');
 1464|  14.4M|                        }
 1465|  16.3M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1466|  16.3M|                        break;
 1467|   225k|                    default:
  ------------------
  |  Branch (1467:21): [True: 225k, False: 16.3M]
  ------------------
 1468|   225k|                        destination_->bool_value(value, tag, context, ec);
 1469|   225k|                        break;
 1470|  16.5M|                }
 1471|  16.5M|            }
 1472|       |
 1473|  18.4M|            level_stack_.back().advance();
 1474|  18.4M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  18.4M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1475|  18.4M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE12visit_stringERKNS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1075|   253k|        {
 1076|   253k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1076:17): [True: 26.7k, False: 227k]
  ------------------
 1077|  26.7k|            {
 1078|  26.7k|                switch (level_stack_.back().target())
 1079|  26.7k|                {
 1080|  25.4k|                    case target_t::buffer:
  ------------------
  |  Branch (1080:21): [True: 25.4k, False: 1.22k]
  ------------------
 1081|  25.4k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1081:29): [True: 24.2k, False: 1.25k]
  ------------------
 1082|  24.2k|                        {
 1083|  24.2k|                            key_buffer_.push_back(',');
 1084|  24.2k|                        }
 1085|  25.4k|                        key_buffer_.push_back('\"');
 1086|  25.4k|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1087|  25.4k|                        key_buffer_.push_back('\"');
 1088|  25.4k|                        key_buffer_.push_back(':');
 1089|  25.4k|                        break;
 1090|  1.22k|                    default:
  ------------------
  |  Branch (1090:21): [True: 1.22k, False: 25.4k]
  ------------------
 1091|  1.22k|                        destination_->key(value, context, ec);
 1092|  1.22k|                        break;
 1093|  26.7k|                }
 1094|  26.7k|            }
 1095|   227k|            else
 1096|   227k|            {
 1097|   227k|                switch (level_stack_.back().target())
 1098|   227k|                {
 1099|   196k|                    case target_t::buffer:
  ------------------
  |  Branch (1099:21): [True: 196k, False: 30.8k]
  ------------------
 1100|   196k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1100:29): [True: 171k, False: 24.5k]
  |  Branch (1100:65): [True: 170k, False: 826]
  ------------------
 1101|   170k|                        {
 1102|   170k|                            key_buffer_.push_back(',');
 1103|   170k|                        }
 1104|   196k|                        key_buffer_.push_back('\"');
 1105|   196k|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1106|   196k|                        key_buffer_.push_back('\"');
 1107|   196k|                        break;
 1108|  30.8k|                    default:
  ------------------
  |  Branch (1108:21): [True: 30.8k, False: 196k]
  ------------------
 1109|  30.8k|                        destination_->string_value(value, tag, context, ec);
 1110|  30.8k|                        break;
 1111|   227k|                }
 1112|   227k|            }
 1113|       |
 1114|   253k|            level_stack_.back().advance();
 1115|   253k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   253k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1116|   253k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1122|  17.4k|        {
 1123|  17.4k|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1123:17): [True: 5.48k, False: 11.9k]
  |  Branch (1123:49): [True: 9.69k, False: 2.29k]
  ------------------
 1124|  15.1k|            {
 1125|  15.1k|                key_.clear();
 1126|  15.1k|                switch (tag)
 1127|  15.1k|                {
 1128|      0|                    case semantic_tag::base64:
  ------------------
  |  Branch (1128:21): [True: 0, False: 15.1k]
  ------------------
 1129|      0|                        bytes_to_base64(value.begin(), value.end(), key_);
 1130|      0|                        break;
 1131|      0|                    case semantic_tag::base16:
  ------------------
  |  Branch (1131:21): [True: 0, False: 15.1k]
  ------------------
 1132|      0|                        bytes_to_base16(value.begin(), value.end(),key_);
 1133|      0|                        break;
 1134|  15.1k|                    default:
  ------------------
  |  Branch (1134:21): [True: 15.1k, False: 0]
  ------------------
 1135|  15.1k|                        bytes_to_base64url(value.begin(), value.end(),key_);
 1136|  15.1k|                        break;
 1137|  15.1k|                }
 1138|  15.1k|            }
 1139|       |
 1140|  17.4k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1140:17): [True: 5.48k, False: 11.9k]
  ------------------
 1141|  5.48k|            {
 1142|  5.48k|                switch (level_stack_.back().target())
 1143|  5.48k|                {
 1144|  4.49k|                    case target_t::buffer:
  ------------------
  |  Branch (1144:21): [True: 4.49k, False: 998]
  ------------------
 1145|  4.49k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1145:29): [True: 3.09k, False: 1.39k]
  ------------------
 1146|  3.09k|                        {
 1147|  3.09k|                            key_buffer_.push_back(',');
 1148|  3.09k|                        }
 1149|  4.49k|                        key_buffer_.push_back('\"');
 1150|  4.49k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1151|  4.49k|                        key_buffer_.push_back('\"');
 1152|  4.49k|                        key_buffer_.push_back(':');
 1153|  4.49k|                        break;
 1154|    998|                    default:
  ------------------
  |  Branch (1154:21): [True: 998, False: 4.49k]
  ------------------
 1155|    998|                        destination_->key(key_, context, ec);
 1156|    998|                        break;
 1157|  5.48k|                }
 1158|  5.48k|            }
 1159|  11.9k|            else
 1160|  11.9k|            {
 1161|  11.9k|                switch (level_stack_.back().target())
 1162|  11.9k|                {
 1163|  9.69k|                    case target_t::buffer:
  ------------------
  |  Branch (1163:21): [True: 9.69k, False: 2.29k]
  ------------------
 1164|  9.69k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1164:29): [True: 6.68k, False: 3.00k]
  |  Branch (1164:65): [True: 6.20k, False: 487]
  ------------------
 1165|  6.20k|                        {
 1166|  6.20k|                            key_buffer_.push_back(',');
 1167|  6.20k|                        }
 1168|  9.69k|                        key_buffer_.push_back('\"');
 1169|  9.69k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1170|  9.69k|                        key_buffer_.push_back('\"');
 1171|  9.69k|                        break;
 1172|  2.29k|                    default:
  ------------------
  |  Branch (1172:21): [True: 2.29k, False: 9.69k]
  ------------------
 1173|  2.29k|                        destination_->byte_string_value(value, tag, context, ec);
 1174|  2.29k|                        break;
 1175|  11.9k|                }
 1176|  11.9k|            }
 1177|       |
 1178|  17.4k|            level_stack_.back().advance();
 1179|  17.4k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  17.4k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1180|  17.4k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS1_10error_codeE:
 1186|   129k|        {
 1187|   129k|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1187:17): [True: 6.68k, False: 122k]
  |  Branch (1187:49): [True: 28.5k, False: 94.1k]
  ------------------
 1188|  35.2k|            {
 1189|  35.2k|                key_.clear();
 1190|  35.2k|                bytes_to_base64url(value.begin(), value.end(),key_);
 1191|  35.2k|            }
 1192|       |
 1193|   129k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1193:17): [True: 6.68k, False: 122k]
  ------------------
 1194|  6.68k|            {
 1195|  6.68k|                switch (level_stack_.back().target())
 1196|  6.68k|                {
 1197|  3.21k|                    case target_t::buffer:
  ------------------
  |  Branch (1197:21): [True: 3.21k, False: 3.47k]
  ------------------
 1198|  3.21k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1198:29): [True: 2.19k, False: 1.02k]
  ------------------
 1199|  2.19k|                        {
 1200|  2.19k|                            key_buffer_.push_back(',');
 1201|  2.19k|                        }
 1202|  3.21k|                        key_buffer_.push_back('\"');
 1203|  3.21k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1204|  3.21k|                        key_buffer_.push_back('\"');
 1205|  3.21k|                        key_buffer_.push_back(':');
 1206|  3.21k|                        break;
 1207|  3.47k|                    default:
  ------------------
  |  Branch (1207:21): [True: 3.47k, False: 3.21k]
  ------------------
 1208|  3.47k|                        destination_->key(key_, context, ec);
 1209|  3.47k|                        break;
 1210|  6.68k|                }
 1211|  6.68k|            }
 1212|   122k|            else
 1213|   122k|            {
 1214|   122k|                switch (level_stack_.back().target())
 1215|   122k|                {
 1216|  28.5k|                    case target_t::buffer:
  ------------------
  |  Branch (1216:21): [True: 28.5k, False: 94.1k]
  ------------------
 1217|  28.5k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1217:29): [True: 26.3k, False: 2.19k]
  |  Branch (1217:65): [True: 24.5k, False: 1.74k]
  ------------------
 1218|  24.5k|                        {
 1219|  24.5k|                            key_buffer_.push_back(',');
 1220|  24.5k|                        }
 1221|  28.5k|                        key_buffer_.push_back('\"');
 1222|  28.5k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1223|  28.5k|                        key_buffer_.push_back('\"');
 1224|  28.5k|                        break;
 1225|  94.1k|                    default:
  ------------------
  |  Branch (1225:21): [True: 94.1k, False: 28.5k]
  ------------------
 1226|  94.1k|                        destination_->byte_string_value(value, ext_tag, context, ec);
 1227|  94.1k|                        break;
 1228|   122k|                }
 1229|   122k|            }
 1230|       |
 1231|   129k|            level_stack_.back().advance();
 1232|   129k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   129k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1233|   129k|        }
_ZN8jsoncons24basic_item_event_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  293|   332k|        {
  294|   332k|            visit_begin_array(length, tag, context, ec);
  295|   332k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   332k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  296|   332k|        }
_ZN8jsoncons24basic_item_event_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  362|  13.1M|        {
  363|  13.1M|            visit_uint64(value, tag, context, ec);
  364|  13.1M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  13.1M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  365|  13.1M|        }
_ZN8jsoncons24basic_item_event_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  299|   306k|        {
  300|   306k|            visit_end_array(context, ec);
  301|   306k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   306k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  302|   306k|        }
_ZN8jsoncons24basic_item_event_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  371|  2.06M|        {
  372|  2.06M|            visit_int64(value, tag, context, ec);
  373|  2.06M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  2.06M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  374|  2.06M|        }
_ZN8jsoncons24basic_item_event_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  389|  39.2k|        {
  390|  39.2k|            visit_double(value, tag, context, ec);
  391|  39.2k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  39.2k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  392|  39.2k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEEC2ERNS_18basic_json_visitorIcEERKS3_:
  858|  6.25k|            : destination_(std::addressof(visitor)), 
  859|  6.25k|              key_(alloc), key_buffer_(alloc), level_stack_(alloc)
  860|  6.25k|        {
  861|  6.25k|            level_stack_.emplace_back(target_t::destination,container_t::root); // root
  862|  6.25k|        }
_ZN8jsoncons24basic_item_event_visitorIcEC2Ev:
   51|  6.25k|        basic_item_event_visitor() = default;
_ZN8jsoncons24basic_item_event_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  275|   322k|        {
  276|   322k|            visit_begin_object(length, tag, context, ec);
  277|   322k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   322k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  278|   322k|        }
_ZN8jsoncons24basic_item_event_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  331|   253k|        {
  332|   253k|            visit_string(value, tag, context, ec);
  333|   253k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   253k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  334|   253k|        }
_ZN8jsoncons24basic_item_event_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  313|   137k|        {
  314|   137k|            visit_null(tag, context, ec);
  315|   137k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   137k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  316|   137k|        }
_ZN8jsoncons24basic_item_event_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  322|  18.4M|        {
  323|  18.4M|            visit_bool(value, tag, context, ec);
  324|  18.4M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  18.4M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  325|  18.4M|        }
_ZN8jsoncons24basic_item_event_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  342|  17.4k|        {
  343|  17.4k|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  344|  17.4k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  17.4k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  345|  17.4k|        }
_ZN8jsoncons24basic_item_event_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  353|   129k|        {
  354|   129k|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), ext_tag, context, ec);
  355|   129k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   129k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  356|   129k|        }
_ZN8jsoncons24basic_item_event_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  281|   302k|        {
  282|   302k|            visit_end_object(context, ec);
  283|   302k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   302k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  284|   302k|        }
_ZN8jsoncons24basic_item_event_visitorIcE5flushEv:
   56|  1.61k|        {
   57|  1.61k|            visit_flush();
   58|  1.61k|        }

_ZN8jsoncons19typed_array_visitorD2Ev:
   33|  18.7k|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  345|  75.3k|        {
  346|  75.3k|            visit_begin_array(length, tag, context, ec);
  347|  75.3k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  75.3k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  348|  75.3k|        }
_ZN8jsoncons18basic_json_visitorIcE3keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  357|   120k|        {
  358|   120k|            visit_key(name, context, ec);
  359|   120k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   120k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  360|   120k|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  351|  60.6k|        {
  352|  60.6k|            visit_end_array(context, ec);
  353|  60.6k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  60.6k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  354|  60.6k|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|   262k|        {
  415|   262k|            visit_uint64(value, tag, context, ec);
  416|   262k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   262k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  417|   262k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|   126k|        {
  424|   126k|            visit_int64(value, tag, context, ec);
  425|   126k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   126k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  426|   126k|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|  6.87k|        {
  442|  6.87k|            visit_double(value, tag, context, ec);
  443|  6.87k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  6.87k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  444|  6.87k|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|  1.61k|        {
  109|  1.61k|            visit_flush();
  110|  1.61k|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  327|  44.0k|        {
  328|  44.0k|            visit_begin_object(length, tag, context, ec);
  329|  44.0k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  44.0k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  330|  44.0k|        }
_ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  333|  35.5k|        {
  334|  35.5k|            visit_end_object(context, ec);
  335|  35.5k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  35.5k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  336|  35.5k|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  365|  14.9k|        {
  366|  14.9k|            visit_null(tag, context, ec);
  367|  14.9k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  14.9k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  368|  14.9k|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  374|   225k|        {
  375|   225k|            visit_bool(value, tag, context, ec);
  376|   225k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   225k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  377|   225k|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  383|  30.8k|        {
  384|  30.8k|            visit_string(value, tag, context, ec);
  385|  30.8k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  30.8k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  386|  30.8k|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  394|  2.29k|        {
  395|  2.29k|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  396|  2.29k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  2.29k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  397|  2.29k|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  405|  94.1k|        {
  406|  94.1k|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), ext_tag, context, ec);
  407|  94.1k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  94.1k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  408|  94.1k|        }
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|  12.5k|        basic_json_visitor() = default;
_ZN8jsoncons26basic_default_json_visitorIcEC2Ev:
  811|  6.25k|        basic_default_json_visitor() = default;

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

_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERS7_:
  256|  32.4k|            : buf_ptr(std::addressof(buf))
  257|  32.4k|        {
  258|  32.4k|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9push_backEc:
  287|   571k|        {
  288|   571k|            buf_ptr->push_back(ch);
  289|   571k|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvEC2ERS5_:
  315|  6.25k|            : buf_ptr(std::addressof(buf))
  316|  6.25k|        {
  317|  6.25k|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE9push_backEh:
  329|  92.4M|        {
  330|  92.4M|            buf_ptr->push_back(static_cast<value_type>(ch));
  331|  92.4M|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE5flushEv:
  325|  7.86k|        {
  326|  7.86k|        }

_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev:
  188|  6.25k|        {
  189|  6.25k|            if (buffer_)
  ------------------
  |  Branch (189:17): [True: 6.25k, False: 0]
  ------------------
  190|  6.25k|            {
  191|  6.25k|                std::allocator_traits<char_allocator_type>::deallocate(alloc_, buffer_, buffer_size_);
  192|  6.25k|            }
  193|  6.25k|        }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  171|  6.25k|            : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  172|  6.25k|              buffer_size_(default_max_buffer_size)
  173|  6.25k|        {
  174|  6.25k|            buffer_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, buffer_size_);
  175|  6.25k|            data_ = buffer_;
  176|  6.25k|        }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   54|  6.25k|          : std::basic_istream<CharT>(&nb_)
   55|  6.25k|        {
   56|  6.25k|        }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   40|  6.25k|            null_buffer() = default;
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE8is_errorEv:
  276|  34.9M|        {
  277|  34.9M|            return stream_ptr_->bad();  
  278|  34.9M|        }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm:
  343|  40.6M|        {
  344|  40.6M|            std::size_t len = 0;
  345|  40.6M|            if (length_ > 0)
  ------------------
  |  Branch (345:17): [True: 40.6M, False: 12.8k]
  ------------------
  346|  40.6M|            {
  347|  40.6M|                len = (std::min)(length_, length);
  348|  40.6M|                std::memcpy(p, data_, len*sizeof(value_type));
  349|  40.6M|                data_ += len;
  350|  40.6M|                length_ -= len;
  351|  40.6M|                position_ += len;
  352|  40.6M|            }
  353|  40.6M|            if (length - len == 0)
  ------------------
  |  Branch (353:17): [True: 40.6M, False: 14.6k]
  ------------------
  354|  40.6M|            {
  355|  40.6M|                return len;
  356|  40.6M|            }
  357|  14.6k|            else if (length - len < buffer_size_)
  ------------------
  |  Branch (357:22): [True: 14.4k, False: 269]
  ------------------
  358|  14.4k|            {
  359|  14.4k|                fill_buffer();
  360|  14.4k|                if (length_ > 0)
  ------------------
  |  Branch (360:21): [True: 10.1k, False: 4.27k]
  ------------------
  361|  10.1k|                {
  362|  10.1k|                    std::size_t len2 = (std::min)(length_, length-len);
  363|  10.1k|                    std::memcpy(p+len, data_, len2*sizeof(value_type));
  364|  10.1k|                    data_ += len2;
  365|  10.1k|                    length_ -= len2;
  366|  10.1k|                    position_ += len2;
  367|  10.1k|                    len += len2;
  368|  10.1k|                }
  369|  14.4k|                return len;
  370|  14.4k|            }
  371|    269|            else
  372|    269|            {
  373|    269|                if (stream_ptr_->eof())
  ------------------
  |  Branch (373:21): [True: 0, False: 269]
  ------------------
  374|      0|                {
  375|      0|                    length_ = 0;
  376|      0|                    return 0;
  377|      0|                }
  378|    269|                JSONCONS_TRY
  ------------------
  |  |   37|    269|    #define JSONCONS_TRY try
  ------------------
  379|    269|                {
  380|    269|                    std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(p+len), length-len);
  381|    269|                    std::size_t len2 = static_cast<std::size_t>(count);
  382|    269|                    if (len2 < length-len)
  ------------------
  |  Branch (382:25): [True: 27, False: 242]
  ------------------
  383|     27|                    {
  384|     27|                        stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  385|     27|                    }
  386|    269|                    len += len2;
  387|    269|                    position_ += len2;
  388|    269|                    return len;
  389|    269|                }
  390|    269|                JSONCONS_CATCH(const std::exception&)     
  391|    269|                {
  392|      0|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  393|      0|                    return 0;
  394|      0|                }
  395|    269|            }
  396|  40.6M|        }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEv:
  399|  14.4k|        {
  400|  14.4k|            if (stream_ptr_->eof())
  ------------------
  |  Branch (400:17): [True: 4.26k, False: 10.1k]
  ------------------
  401|  4.26k|            {
  402|  4.26k|                length_ = 0;
  403|  4.26k|                return;
  404|  4.26k|            }
  405|       |
  406|  10.1k|            data_ = buffer_;
  407|  10.1k|            JSONCONS_TRY
  ------------------
  |  |   37|  10.1k|    #define JSONCONS_TRY try
  ------------------
  408|  10.1k|            {
  409|  10.1k|                std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(buffer_), buffer_size_);
  410|  10.1k|                length_ = static_cast<std::size_t>(count);
  411|       |
  412|  10.1k|                if (length_ < buffer_size_)
  ------------------
  |  Branch (412:21): [True: 6.21k, False: 3.94k]
  ------------------
  413|  6.21k|                {
  414|  6.21k|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  415|  6.21k|                }
  416|  10.1k|            }
  417|  10.1k|            JSONCONS_CATCH(const std::exception&)     
  418|  10.1k|            {
  419|      0|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  420|      0|                length_ = 0;
  421|      0|            }
  422|  10.1k|        }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_12basic_stringIcNS2_11char_traitsIcEENS3_IcEEEEEENS2_9enable_ifIXaaaasr3std14is_convertibleIhNT_10value_typeEEE5valuesr10ext_traits11has_reserveISE_EE5valuentsr10ext_traits14has_data_exactIPhSE_EE5valueEmE4typeERS5_RSE_m:
  882|   191k|        {
  883|   191k|            std::size_t unread = length;
  884|       |
  885|   191k|            std::size_t n = (std::min)(max_buffer_length, unread);
  886|   194k|            while (n > 0 && !source.eof())
  ------------------
  |  Branch (886:20): [True: 2.99k, False: 191k]
  |  Branch (886:29): [True: 2.85k, False: 140]
  ------------------
  887|  2.85k|            {
  888|  2.85k|                v.reserve(v.size()+n);
  889|  2.85k|                std::size_t actual = 0;
  890|  5.08M|                while (actual < n)
  ------------------
  |  Branch (890:24): [True: 5.08M, False: 2.77k]
  ------------------
  891|  5.08M|                {
  892|  5.08M|                    typename Source::value_type c{};
  893|  5.08M|                    if (source.read(&c,1) != 1)
  ------------------
  |  Branch (893:25): [True: 79, False: 5.08M]
  ------------------
  894|     79|                    {
  895|     79|                        break;
  896|     79|                    }
  897|  5.08M|                    v.push_back(c);
  898|  5.08M|                    ++actual;
  899|  5.08M|                }
  900|  2.85k|                unread -= actual;
  901|  2.85k|                n = (std::min)(max_buffer_length, unread);
  902|  2.85k|            }
  903|       |
  904|   191k|            return length - unread;
  905|   191k|        }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv:
  271|   136k|        {
  272|   136k|            return length_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:20): [True: 880, False: 135k]
  |  Branch (272:36): [True: 478, False: 402]
  ------------------
  273|   136k|        }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_6vectorIhS4_EEEENS2_9enable_ifIXaaaasr3std14is_convertibleIhNT_10value_typeEEE5valuesr10ext_traits11has_reserveISB_EE5valuesr10ext_traits14has_data_exactIPhSB_EE5valueEmE4typeERS5_RSB_m:
  859|   147k|        {
  860|   147k|            std::size_t unread = length;
  861|       |
  862|   147k|            std::size_t n = (std::min)(max_buffer_length, unread);
  863|   280k|            while (n > 0 && !source.eof())
  ------------------
  |  Branch (863:20): [True: 133k, False: 146k]
  |  Branch (863:29): [True: 133k, False: 338]
  ------------------
  864|   133k|            {
  865|   133k|                std::size_t offset = v.size();
  866|   133k|                v.resize(v.size()+n);
  867|   133k|                std::size_t actual = source.read(v.data()+offset, n);
  868|   133k|                unread -= actual;
  869|   133k|                n = (std::min)(max_buffer_length, unread);
  870|   133k|            }
  871|       |
  872|   147k|            return length - unread;
  873|   147k|        }

_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2Ev:
  626|  30.7k|    basic_bigint() = default;
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS4_:
  285|  92.1k|        : word_allocator_type(alloc)
  286|  92.1k|    {
  287|  92.1k|        ::new (&inlined_) inlined_storage();
  288|  92.1k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2Ev:
  112|  92.1k|            : is_allocated_(false),
  113|  92.1k|            is_negative_(false),
  114|  92.1k|            size_(0),
  115|  92.1k|            values_{0, 0}
  116|  92.1k|        {
  117|  92.1k|        }
_ZN8jsoncons9to_bigintIcEENS_16to_bigint_resultIT_EEPKS2_mRNS_12basic_bigintINSt3__19allocatorImEEEE:
 2067|  10.8k|{
 2068|  10.8k|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|  10.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 10.8k]
  |  |  ------------------
  ------------------
 2069|      0|    {
 2070|      0|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 2071|      0|    }
 2072|       |
 2073|  10.8k|    if (*data == '-')
  ------------------
  |  Branch (2073:9): [True: 4.52k, False: 6.28k]
  ------------------
 2074|  4.52k|    {
 2075|  4.52k|        return jsoncons::detail::to_bigint(data+1, length-1, true, value, std::allocator<uint64_t>{}); 
 2076|  4.52k|    }
 2077|  6.28k|    else
 2078|  6.28k|    {
 2079|  6.28k|        return jsoncons::detail::to_bigint(data, length, false, value, std::allocator<uint64_t>{}); 
 2080|  6.28k|    }
 2081|  10.8k|}
_ZN8jsoncons16to_bigint_resultIcEC2EPKcNSt3__14errcE:
  554|  10.8k|        : ptr(ptr_), ec(ec_)
  555|  10.8k|    {
  556|  10.8k|    }
_ZN8jsoncons6detail9to_bigintIcNSt3__19allocatorImEEEENS_16to_bigint_resultIT_EEPKS6_mbRNS_12basic_bigintIT0_EERKSB_:
 1975|  10.8k|{
 1976|  10.8k|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|  10.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 10.8k]
  |  |  ------------------
  ------------------
 1977|      0|    {
 1978|      0|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 1979|      0|    }
 1980|       |
 1981|  10.8k|    using word_type = typename basic_bigint<Allocator>::word_type;
 1982|       |
 1983|  10.8k|    const CharT* last = data + length;
 1984|  10.8k|    const CharT* p = data;
 1985|       |
 1986|  11.6k|    while (p < last && *p == '0')
  ------------------
  |  Branch (1986:12): [True: 10.8k, False: 822]
  |  Branch (1986:24): [True: 822, False: 9.99k]
  ------------------
 1987|    822|    {
 1988|    822|        ++p;
 1989|    822|    }
 1990|  10.8k|    if (p == last)
  ------------------
  |  Branch (1990:9): [True: 822, False: 9.99k]
  ------------------
 1991|    822|    {
 1992|    822|        value = std::move(basic_bigint<Allocator>{0, alloc});
 1993|    822|        return to_bigint_result<CharT>(last, std::errc{});
 1994|    822|    }
 1995|  9.99k|    std::size_t num_digits = last - data;
 1996|  9.99k|    std::size_t num_words;
 1997|  9.99k|    if (length < 10)
  ------------------
  |  Branch (1997:9): [True: 539, False: 9.45k]
  ------------------
 1998|    539|    {
 1999|    539|        num_words = 1;
 2000|    539|    }
 2001|  9.45k|    else
 2002|  9.45k|    {
 2003|  9.45k|        std::size_t num_bits = (std::size_t)(((num_digits * detail::bits_per_digit[10]) >> 10) + 1);
 2004|  9.45k|        num_words = (num_bits + 63) >> 6;
 2005|  9.45k|    }
 2006|       |
 2007|  9.99k|    basic_bigint<Allocator> v(0, alloc);
 2008|  9.99k|    v.reserve(num_words);
 2009|   240k|    for (std::size_t i = 0; i < length; i++)
  ------------------
  |  Branch (2009:29): [True: 230k, False: 9.99k]
  ------------------
 2010|   230k|    {
 2011|   230k|        CharT c = data[i];
 2012|   230k|        switch (c)
 2013|   230k|        {
 2014|   230k|            case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (2014:13): [True: 48.4k, False: 182k]
  |  Branch (2014:22): [True: 23.7k, False: 207k]
  |  Branch (2014:31): [True: 14.3k, False: 216k]
  |  Branch (2014:40): [True: 15.9k, False: 214k]
  |  Branch (2014:49): [True: 28.9k, False: 201k]
  |  Branch (2014:58): [True: 15.3k, False: 215k]
  |  Branch (2014:67): [True: 21.6k, False: 209k]
  |  Branch (2014:76): [True: 25.8k, False: 204k]
  |  Branch (2014:85): [True: 17.4k, False: 213k]
  |  Branch (2014:95): [True: 19.1k, False: 211k]
  ------------------
 2015|   230k|                v = (v * 10u) + (word_type)(c - '0');
 2016|   230k|                break;
 2017|      0|            default:
  ------------------
  |  Branch (2017:13): [True: 0, False: 230k]
  ------------------
 2018|      0|                return to_bigint_result<CharT>(data + i, std::errc::invalid_argument);
 2019|   230k|        }
 2020|   230k|    }
 2021|       |
 2022|       |    //auto view = v.get_storage_view();
 2023|       |    //if (num_words != view.size())
 2024|       |    //{
 2025|       |    //    std::cout << "Unexpected num_words! num_words: " << num_words << ", " << num_words << ", size: " << view.size() << "\n";
 2026|       |    //}
 2027|       |
 2028|  9.99k|    if (neg)
  ------------------
  |  Branch (2028:9): [True: 4.52k, False: 5.46k]
  ------------------
 2029|  4.52k|    {
 2030|  4.52k|        v.set_negative(true);
 2031|  4.52k|    }
 2032|       |
 2033|  9.99k|    value = std::move(v);
 2034|  9.99k|    return to_bigint_result<CharT>(last, std::errc{});
 2035|  9.99k|}
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IiEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  678|  21.6k|        : storage_(n, alloc)
  679|  21.6k|    {
  680|  21.6k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IiEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  345|  21.6k|        : word_allocator_type(alloc)
  346|  21.6k|    {
  347|  21.6k|        ::new (&inlined_) inlined_storage(n);
  348|  21.6k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IiEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  124|  21.6k|            : is_allocated_(false),
  125|  21.6k|            is_negative_(n < 0),
  126|  21.6k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (126:19): [True: 21.6k, False: 0]
  ------------------
  127|  21.6k|        {
  128|  21.6k|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (128:26): [True: 0, False: 21.6k]
  ------------------
  129|  21.6k|            values_[1] = 0;
  130|  21.6k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEaSERKS4_:
  844|   479k|    {
  845|   479k|        storage_ = y.storage_;
  846|   479k|        return *this;
  847|   479k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEaSERKS5_:
  351|   479k|    {
  352|   479k|        if (this != &other)
  ------------------
  |  Branch (352:13): [True: 479k, False: 0]
  ------------------
  353|   479k|        {
  354|   479k|            auto other_view = other.get_storage_view();
  355|   479k|            resize(other_view.size());
  356|   479k|            auto this_view = get_storage_view();
  357|   479k|            if (other_view.size() > 0)
  ------------------
  |  Branch (357:17): [True: 380k, False: 99.4k]
  ------------------
  358|   380k|            {
  359|   380k|                common_.is_negative_ = other.common_.is_negative_;
  360|   380k|                std::memcpy(this_view.data(), other_view.data(), size_type(other_view.size()*sizeof(word_type)));
  361|   380k|            }
  362|   479k|        }
  363|   479k|        return *this;
  364|   479k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  512|  1.16M|    {
  513|  1.16M|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (513:16): [True: 89.4k, False: 1.07M]
  ------------------
  514|  89.4k|            storage_view<const word_type>{allocated_.data_, allocated_.size_} :
  515|  1.16M|            storage_view<const word_type>{inlined_.values_, inlined_.size_};
  516|  1.16M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEC2EPS7_m:
   63|  1.16M|            : data_(data), size_(size)
   64|  1.16M|        {
   65|  1.16M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6resizeEm:
  519|  1.08M|    {
  520|  1.08M|        size_type old_length = common_.size_;
  521|  1.08M|        reserve(new_length);
  522|  1.08M|        common_.size_ = new_length;
  523|       |
  524|  1.08M|        if (old_length < new_length)
  ------------------
  |  Branch (524:13): [True: 691k, False: 389k]
  ------------------
  525|   691k|        {
  526|   691k|            if (is_allocated())
  ------------------
  |  Branch (526:17): [True: 94.9k, False: 596k]
  ------------------
  527|  94.9k|            {
  528|  94.9k|                std::memset(allocated_.data_+old_length, 0, size_type((new_length-old_length)*sizeof(word_type)));
  529|  94.9k|            }
  530|   596k|            else
  531|   596k|            {
  532|   596k|                JSONCONS_ASSERT(new_length <= inlined_capacity);
  ------------------
  |  |   45|   596k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 596k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  533|  1.31M|                for (size_type i = old_length; i < inlined_capacity; ++i)
  ------------------
  |  Branch (533:48): [True: 720k, False: 596k]
  ------------------
  534|   720k|                {
  535|   720k|                    inlined_.values_[i] = 0;
  536|   720k|                }
  537|   596k|            }
  538|   691k|        }
  539|  1.08M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7reserveEm:
  437|  1.09M|    {
  438|  1.09M|       if (capacity() < n)
  ------------------
  |  Branch (438:12): [True: 53.4k, False: 1.03M]
  ------------------
  439|  53.4k|       {
  440|  53.4k|           if (!is_allocated())
  ------------------
  |  Branch (440:16): [True: 53.4k, False: 0]
  ------------------
  441|  53.4k|           {
  442|  53.4k|               size_type size = inlined_.size_;
  443|  53.4k|               size_type is_neg = inlined_.is_negative_;
  444|  53.4k|               word_type values[inlined_capacity] = {inlined_.values_[0], inlined_.values_[1]};
  445|       |
  446|  53.4k|               ::new (&allocated_) allocated_storage();
  447|  53.4k|               allocated_.reserve(n, get_allocator());
  448|  53.4k|               allocated_.size_ = size;
  449|  53.4k|               allocated_.is_negative_ = is_neg;
  450|  53.4k|               if (n >= 1)
  ------------------
  |  Branch (450:20): [True: 53.4k, False: 0]
  ------------------
  451|  53.4k|               {
  452|  53.4k|                   allocated_.data_[0] = values[0];
  453|  53.4k|               }
  454|  53.4k|               if (n >= 2)
  ------------------
  |  Branch (454:20): [True: 53.4k, False: 0]
  ------------------
  455|  53.4k|               {
  456|  53.4k|                   allocated_.data_[1] = values[1];
  457|  53.4k|               }
  458|  53.4k|           }
  459|      0|           else
  460|      0|           {
  461|      0|               allocated_.reserve(n, get_allocator());
  462|      0|           }
  463|  53.4k|       }
  464|  1.09M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE8capacityEv:
  490|  1.09M|    {
  491|  1.09M|        return is_allocated() ? allocated_.capacity_ : inlined_capacity;
  ------------------
  |  Branch (491:16): [True: 59.5k, False: 1.03M]
  ------------------
  492|  1.09M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2Ev:
  201|  53.4k|            : is_allocated_(true),
  202|  53.4k|            is_negative_(false)
  203|  53.4k|        {
  204|  53.4k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7reserveEmRKS4_:
  253|  53.4k|        {
  254|  53.4k|            size_type capacity_new = round_up(n);
  255|       |
  256|  53.4k|            real_allocator_type alloc(a);
  257|  53.4k|            word_type* data_new = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_new);
  258|  53.4k|            if (size_ > 0)
  ------------------
  |  Branch (258:17): [True: 0, False: 53.4k]
  ------------------
  259|      0|            {
  260|      0|                std::memcpy(data_new, data_, size_type(size_ * sizeof(word_type)));
  261|      0|            }
  262|  53.4k|            if (data_ != nullptr)
  ------------------
  |  Branch (262:17): [True: 0, False: 53.4k]
  ------------------
  263|      0|            {
  264|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  265|      0|            }
  266|  53.4k|            capacity_ = capacity_new;
  267|  53.4k|            data_ = data_new;
  268|  53.4k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage8round_upEm:
  272|   175k|        {
  273|   175k|            return ((i + 1/3) / mem_unit + 1) * mem_unit;
  274|   175k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE13get_allocatorEv:
  467|  1.48M|    {
  468|  1.48M|        return static_cast<const word_allocator_type&>(*this);
  469|  1.48M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12is_allocatedEv:
  485|  4.62M|    {
  486|  4.62M|        return common_.is_allocated_;
  487|  4.62M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4sizeEv:
   83|  3.16M|        {
   84|  3.16M|            return size_;
   85|  3.16M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  505|  2.91M|    {
  506|  2.91M|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (506:16): [True: 330k, False: 2.58M]
  ------------------
  507|   330k|            storage_view<word_type>{allocated_.data_, allocated_.size_} :
  508|  2.91M|            storage_view<word_type>{inlined_.values_, inlined_.size_};
  509|  2.91M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEC2EPmm:
   63|  2.91M|            : data_(data), size_(size)
   64|  2.91M|        {
   65|  2.91M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4dataEv:
   78|   398k|        {
   79|   398k|            return data_;
   80|   398k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4dataEv:
   78|   380k|        {
   79|   380k|            return data_;
   80|   380k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE7reserveEm:
  825|  9.99k|    {
  826|  9.99k|        storage_.reserve(n);
  827|  9.99k|    }
_ZN8jsonconsplENS_12basic_bigintINSt3__19allocatorImEEEEl:
 1450|   230k|    {
 1451|   230k|        return x += y;
 1452|   230k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLERKS4_:
  850|   293k|    {
  851|   293k|        auto y_view = y.get_storage_view();
  852|       |        
  853|   293k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (853:14): [True: 0, False: 293k]
  ------------------
  854|      0|            return *this -= -y;
  855|   293k|        word_type d;
  856|   293k|        word_type carry = 0;
  857|       |
  858|   293k|        auto this_view = get_storage_view();
  859|   293k|        resize( (std::max)(y_view.size(), this_view.size()) + 1 );
  860|   293k|        this_view = get_storage_view();
  861|       |
  862|   498k|        for (size_type i = 0; i < this_view.size(); i++ )
  ------------------
  |  Branch (862:31): [True: 495k, False: 3.08k]
  ------------------
  863|   495k|        {
  864|   495k|            if ( i >= y_view.size() && carry == 0 )
  ------------------
  |  Branch (864:18): [True: 297k, False: 197k]
  |  Branch (864:40): [True: 290k, False: 7.51k]
  ------------------
  865|   290k|                break;
  866|   205k|            d = this_view[i] + carry;
  867|   205k|            carry = d < carry;
  868|   205k|            if ( i < y_view.size())
  ------------------
  |  Branch (868:18): [True: 197k, False: 7.51k]
  ------------------
  869|   197k|            {
  870|   197k|                this_view[i] = d + y_view[i];
  871|   197k|                if (this_view[i] < d)
  ------------------
  |  Branch (871:21): [True: 7.51k, False: 190k]
  ------------------
  872|  7.51k|                    carry = 1;
  873|   197k|            }
  874|  7.51k|            else
  875|  7.51k|            {
  876|  7.51k|                this_view[i] = d;
  877|  7.51k|            }
  878|   205k|        }
  879|   293k|        reduce();
  880|   293k|        return *this;
  881|   293k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  708|   680k|    {
  709|   680k|        return storage_.get_storage_view();
  710|   680k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11is_negativeEv:
  713|  1.51M|    {
  714|  1.51M|        return storage_.is_negative();
  715|  1.51M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE11is_negativeEv:
  495|  1.51M|    {
  496|  1.51M|        return common_.is_negative_;
  497|  1.51M|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEEngEv:
  837|  7.34k|    {
  838|  7.34k|        basic_bigint<Allocator> v(*this);
  839|  7.34k|        v.set_negative(!v.is_negative());
  840|  7.34k|        return v;
  841|  7.34k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmIERKS4_:
  884|  7.34k|    {
  885|  7.34k|        auto y_view = y.get_storage_view();
  886|       |
  887|  7.34k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (887:14): [True: 7.34k, False: 0]
  ------------------
  888|  7.34k|            return *this += -y;
  889|      0|        if ( (!is_negative() && y > *this) || (is_negative() && y < *this) )
  ------------------
  |  Branch (889:15): [True: 0, False: 0]
  |  Branch (889:33): [True: 0, False: 0]
  |  Branch (889:48): [True: 0, False: 0]
  |  Branch (889:65): [True: 0, False: 0]
  ------------------
  890|      0|            return *this = -(y - *this);
  891|      0|        word_type borrow = 0;
  892|      0|        word_type d;
  893|      0|        auto this_view = get_storage_view();
  894|      0|        for (size_type i = 0; i < this_view.size(); i++ )
  ------------------
  |  Branch (894:31): [True: 0, False: 0]
  ------------------
  895|      0|        {
  896|      0|            if ( i >= y_view.size() && borrow == 0 )
  ------------------
  |  Branch (896:18): [True: 0, False: 0]
  |  Branch (896:40): [True: 0, False: 0]
  ------------------
  897|      0|                break;
  898|      0|            d = this_view[i] - borrow;
  899|      0|            borrow = d > this_view[i];
  900|      0|            if ( i < y_view.size())
  ------------------
  |  Branch (900:18): [True: 0, False: 0]
  ------------------
  901|      0|            {
  902|      0|                this_view[i] = d - y_view[i];
  903|      0|                if ( this_view[i] > d )
  ------------------
  |  Branch (903:22): [True: 0, False: 0]
  ------------------
  904|      0|                    borrow = 1;
  905|      0|            }
  906|      0|            else 
  907|      0|            {
  908|      0|                this_view[i] = d;
  909|      0|            }
  910|      0|        }
  911|      0|        reduce();
  912|      0|        return *this;
  913|      0|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7compareERKS4_:
 1570|   147k|    {
 1571|   147k|        auto this_view = get_storage_view();
 1572|   147k|        auto y_view = y.get_storage_view();
 1573|       |
 1574|   147k|        if ( this_view.size() == 0 && y_view.size() == 0 )
  ------------------
  |  Branch (1574:14): [True: 1.58k, False: 146k]
  |  Branch (1574:39): [True: 1.58k, False: 0]
  ------------------
 1575|  1.58k|            return 0;
 1576|   146k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (1576:14): [True: 11.8k, False: 134k]
  ------------------
 1577|  11.8k|            return y.is_negative() - is_negative();
 1578|   134k|        int code = 0;
 1579|   134k|        if ( this_view.size() < y_view.size())
  ------------------
  |  Branch (1579:14): [True: 0, False: 134k]
  ------------------
 1580|      0|            code = -1;
 1581|   134k|        else if ( this_view.size() > y_view.size())
  ------------------
  |  Branch (1581:19): [True: 22.7k, False: 111k]
  ------------------
 1582|  22.7k|            code = +1;
 1583|   111k|        else
 1584|   111k|        {
 1585|   146k|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1585:50): [True: 111k, False: 35.0k]
  ------------------
 1586|   111k|            {
 1587|   111k|                if (this_view[i] > y_view[i])
  ------------------
  |  Branch (1587:21): [True: 14.5k, False: 96.9k]
  ------------------
 1588|  14.5k|                {
 1589|  14.5k|                    code = 1;
 1590|  14.5k|                    break;
 1591|  14.5k|                }
 1592|  96.9k|                else if (this_view[i] < y_view[i])
  ------------------
  |  Branch (1592:26): [True: 61.9k, False: 35.0k]
  ------------------
 1593|  61.9k|                {
 1594|  61.9k|                    code = -1;
 1595|  61.9k|                    break;
 1596|  61.9k|                }
 1597|   111k|            }
 1598|   111k|        }
 1599|   134k|        return is_negative() ? -code : code;
  ------------------
  |  Branch (1599:16): [True: 0, False: 134k]
  ------------------
 1600|   146k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEES6_:
 1405|   126k|    {
 1406|   126k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1406:15): [True: 61.9k, False: 64.5k]
  ------------------
 1407|   126k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  703|  1.80M|    {
  704|  1.80M|        return storage_.get_storage_view();
  705|  1.80M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6resizeEm:
  820|   601k|    {
  821|   601k|        storage_.resize(new_length);
  822|   601k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4sizeEv:
   83|  3.32M|        {
   84|  3.32M|            return size_;
   85|  3.32M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEixEm:
   68|  2.54M|        {
   69|  2.54M|            return data_[i];
   70|  2.54M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEixEm:
   68|   655k|        {
   69|   655k|            return data_[i];
   70|   655k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6reduceEv:
 1845|   629k|    {
 1846|   629k|        storage_.reduce();
 1847|   629k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6reduceEv:
  414|   629k|    {
  415|   629k|        if (common_.size_ > 0)
  ------------------
  |  Branch (415:13): [True: 629k, False: 0]
  ------------------
  416|   629k|        {
  417|   629k|            auto this_view = get_storage_view();
  418|   629k|            word_type* p = this_view.end() - 1;
  419|   629k|            word_type* first = this_view.begin();
  420|  1.21M|            while ( p >= first )
  ------------------
  |  Branch (420:21): [True: 1.20M, False: 13.3k]
  ------------------
  421|  1.20M|            {
  422|  1.20M|                if ( *p )
  ------------------
  |  Branch (422:22): [True: 616k, False: 587k]
  ------------------
  423|   616k|                {
  424|   616k|                    break;
  425|   616k|                }
  426|   587k|                --common_.size_;
  427|   587k|                --p;
  428|   587k|            }
  429|   629k|        }
  430|   629k|        if (common_.size_ == 0)
  ------------------
  |  Branch (430:13): [True: 13.3k, False: 616k]
  ------------------
  431|  13.3k|        {
  432|  13.3k|            common_.is_negative_ = false;
  433|  13.3k|        }
  434|   629k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE3endEv:
   92|   629k|        {
   93|   629k|            return data_ + size_;
   94|   629k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE5beginEv:
   87|   629k|        {
   88|   629k|            return data_;
   89|   629k|        }
_ZN8jsonconsmlENS_12basic_bigintINSt3__19allocatorImEEEEl:
 1475|   230k|    {
 1476|   230k|        return x *= y;
 1477|   230k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLIlEENS1_9enable_ifIXsr10ext_traits17is_signed_integerIT_EE5valueERS4_E4typeES7_:
  918|   230k|    {
  919|   230k|        *this *= word_type(y < 0 ? -y : y);
  ------------------
  |  Branch (919:28): [True: 0, False: 230k]
  ------------------
  920|   230k|        if ( y < 0 )
  ------------------
  |  Branch (920:14): [True: 0, False: 230k]
  ------------------
  921|      0|            set_negative(!is_negative());
  922|   230k|        return *this;
  923|   230k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLImEENS1_9enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
  928|   293k|    {
  929|   293k|        auto this_view = get_storage_view();
  930|   293k|        size_type len0 = this_view.size();
  931|   293k|        word_type dig = this_view[0];
  932|   293k|        word_type carry = 0;
  933|       |
  934|   293k|        resize(this_view.size() + 1);
  935|   293k|        this_view = get_storage_view();
  936|       |
  937|   293k|        size_type i = 0;
  938|   616k|        for (; i < len0; i++ )
  ------------------
  |  Branch (938:16): [True: 322k, False: 293k]
  ------------------
  939|   322k|        {
  940|   322k|            word_type hi;
  941|   322k|            word_type lo;
  942|   322k|            DDproduct( dig, y, hi, lo );
  943|   322k|            this_view[i] = lo + carry;
  944|   322k|            dig = this_view[i+1];
  945|   322k|            carry = hi + (this_view[i] < lo);
  946|   322k|        }
  947|   293k|        this_view[i] = carry;
  948|   293k|        reduce();
  949|   293k|        return *this;
  950|   293k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9DDproductEmmRmS5_:
 1709|   332k|    {
 1710|   332k|        word_type hiA = A >> word_type_half_bits, loA = A & r_mask,
 1711|   332k|                   hiB = B >> word_type_half_bits, loB = B & r_mask;
 1712|       |
 1713|   332k|        lo = loA * loB;
 1714|   332k|        hi = hiA * hiB;
 1715|   332k|        word_type mid1 = loA * hiB;
 1716|   332k|        word_type mid2 = hiA * loB;
 1717|   332k|        word_type old = lo;
 1718|   332k|        lo += mid1 << word_type_half_bits;
 1719|   332k|            hi += (lo < old) + (mid1 >> word_type_half_bits);
 1720|   332k|        old = lo;
 1721|   332k|        lo += mid2 << word_type_half_bits;
 1722|   332k|            hi += (lo < old) + (mid2 >> word_type_half_bits);
 1723|   332k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_:
  656|   762k|        : storage_(other.storage_)
  657|   762k|    {
  658|   762k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_:
  291|   762k|        : word_allocator_type(other.get_allocator())
  292|   762k|    {
  293|   762k|        if (!other.is_allocated())
  ------------------
  |  Branch (293:13): [True: 667k, False: 94.9k]
  ------------------
  294|   667k|        {
  295|   667k|            ::new (&inlined_) inlined_storage(other.inlined_);
  296|   667k|        }
  297|  94.9k|        else
  298|  94.9k|        {
  299|  94.9k|            ::new (&allocated_) allocated_storage(other.allocated_, get_allocator());
  300|  94.9k|        }
  301|   762k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ERKS6_:
  177|   912k|            : is_allocated_(false),
  178|   912k|            is_negative_(stor.is_negative_),
  179|   912k|            size_(stor.size_)
  180|   912k|        {
  181|   912k|            values_[0] = stor.values_[0];
  182|   912k|            values_[1] = stor.values_[1];
  183|   912k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2ERKS6_RKS4_:
  207|   121k|            : is_allocated_(true),
  208|   121k|              is_negative_(stor.is_negative_),
  209|   121k|              size_(stor.size_),
  210|   121k|              capacity_(round_up(stor.size_))
  211|   121k|        {
  212|   121k|            real_allocator_type alloc(a);
  213|       |
  214|   121k|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_);
  215|   121k|            JSONCONS_TRY
  ------------------
  |  |   37|   121k|    #define JSONCONS_TRY try
  ------------------
  216|   121k|            {
  217|   121k|                std::allocator_traits<real_allocator_type>::construct(alloc, ext_traits::to_plain_pointer(data_));
  218|   121k|            }
  219|   121k|            JSONCONS_CATCH(...)
  220|   121k|            {
  221|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  222|      0|                data_ = nullptr;
  223|      0|                JSONCONS_RETHROW;
  ------------------
  |  |   36|      0|    #define JSONCONS_RETHROW throw
  ------------------
  224|      0|            }
  225|   121k|            JSONCONS_ASSERT(stor.data_ != nullptr);
  ------------------
  |  |   45|   121k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 121k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  226|   121k|            std::memcpy(data_, stor.data_, size_type(stor.size_ * sizeof(word_type)));
  227|   121k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE12set_negativeEb:
  718|   517k|    {
  719|   517k|        storage_.set_negative(value);
  720|   517k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12set_negativeEb:
  500|   517k|    {
  501|   517k|        common_.is_negative_ = value;
  502|   517k|    }
_ZNK8jsoncons16to_bigint_resultIcEcvbEv:
  563|  10.8k|    {
  564|  10.8k|        return ec == std::errc{};
  565|  10.8k|    }
_ZN8jsonconsneERKNS_12basic_bigintINSt3__19allocatorImEEEEi:
 1400|  10.8k|    {
 1401|  10.8k|        return x.compare(basic_bigint<Allocator>(y)) != 0 ? true : false;
  ------------------
  |  Branch (1401:16): [True: 9.99k, False: 822]
  ------------------
 1402|  10.8k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE6divideERKS4_RS4_S7_b:
 1603|   126k|    {
 1604|   126k|        basic_bigint<Allocator> denom(denom_, get_allocator());
 1605|   126k|        auto denom_view = denom.get_storage_view();
 1606|       |
 1607|   126k|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1607:13): [True: 0, False: 126k]
  ------------------
 1608|      0|        {
 1609|      0|            JSONCONS_THROW(std::runtime_error( "Zero divide." ));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1610|      0|        }
 1611|   126k|        bool quot_neg = is_negative() ^ denom.is_negative();
 1612|   126k|        bool rem_neg = is_negative();
 1613|   126k|        basic_bigint<Allocator> num(*this, get_allocator());
 1614|   126k|        num.set_negative(false);
 1615|   126k|        denom.set_negative(false);
 1616|   126k|        if ( num < denom )
  ------------------
  |  Branch (1616:14): [True: 61.9k, False: 64.5k]
  ------------------
 1617|  61.9k|        {
 1618|  61.9k|            quot = word_type(0);
 1619|  61.9k|            quot.set_negative(quot_neg);
 1620|  61.9k|            rem = num;
 1621|  61.9k|            rem.set_negative(rem_neg);
 1622|  61.9k|            return;
 1623|  61.9k|        }
 1624|       |
 1625|  64.5k|        auto num_view = num.get_storage_view();
 1626|  64.5k|        auto quot_view = quot.get_storage_view();
 1627|  64.5k|        auto this_view = get_storage_view();
 1628|       |
 1629|  64.5k|        if ( denom_view.size() == 1 && num_view.size() == 1 )
  ------------------
  |  Branch (1629:14): [True: 64.5k, False: 0]
  |  Branch (1629:40): [True: 49.5k, False: 14.9k]
  ------------------
 1630|  49.5k|        {
 1631|  49.5k|            quot = word_type( num_view[0]/denom_view[0] );
 1632|  49.5k|            rem = word_type( num_view[0]%denom_view[0] );
 1633|  49.5k|            quot.set_negative(quot_neg);
 1634|  49.5k|            rem.set_negative(rem_neg);
 1635|  49.5k|            return;
 1636|  49.5k|        }
 1637|  14.9k|        if (denom_view.size() == 1 && (denom_view[0] & l_mask) == 0 )
  ------------------
  |  Branch (1637:13): [True: 14.9k, False: 0]
  |  Branch (1637:39): [True: 5.66k, False: 9.33k]
  ------------------
 1638|  5.66k|        {
 1639|       |            // Denominator fits into a half word
 1640|  5.66k|            word_type divisor = denom_view[0], dHi = 0, q1, r, q2, dividend;
 1641|  5.66k|            quot.resize(this_view.size());
 1642|  5.66k|            quot_view = quot.get_storage_view();
 1643|  16.9k|            for (size_type i=this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1643:48): [True: 11.3k, False: 5.66k]
  ------------------
 1644|  11.3k|            {
 1645|  11.3k|                dividend = (dHi << word_type_half_bits) | (this_view[i] >> word_type_half_bits);
 1646|  11.3k|                q1 = dividend/divisor;
 1647|  11.3k|                r = dividend % divisor;
 1648|  11.3k|                dividend = (r << word_type_half_bits) | (this_view[i] & r_mask);
 1649|  11.3k|                q2 = dividend/divisor;
 1650|  11.3k|                dHi = dividend % divisor;
 1651|  11.3k|                quot_view[i] = (q1 << word_type_half_bits) | q2;
 1652|  11.3k|            }
 1653|  5.66k|            quot.reduce();
 1654|  5.66k|            rem = dHi;
 1655|  5.66k|            quot.set_negative(quot_neg);
 1656|  5.66k|            rem.set_negative(rem_neg);
 1657|  5.66k|            return;
 1658|  5.66k|        }
 1659|  9.33k|        basic_bigint<Allocator> num0(num, get_allocator());
 1660|  9.33k|        basic_bigint<Allocator> denom0(denom, get_allocator());
 1661|  9.33k|        int x = 0;
 1662|  9.33k|        bool second_done = normalize(denom, num, x);
 1663|  9.33k|        denom_view = denom.get_storage_view();
 1664|  9.33k|        num_view = num.get_storage_view();
 1665|       |
 1666|  9.33k|        size_type l = denom_view.size() - 1;
 1667|  9.33k|        size_type n = num_view.size() - 1;
 1668|  9.33k|        quot.resize(n - l);
 1669|  9.33k|        quot_view = quot.get_storage_view();
 1670|  18.6k|        for (size_type i = quot_view.size(); i-- > 0; )
  ------------------
  |  Branch (1670:46): [True: 9.33k, False: 9.33k]
  ------------------
 1671|  9.33k|        {
 1672|  9.33k|            quot_view[i] = 0;
 1673|  9.33k|        }
 1674|  9.33k|        rem = num;
 1675|  9.33k|        auto rem_view = rem.get_storage_view();
 1676|  9.33k|        if ( rem_view[n] >= denom_view[l] )
  ------------------
  |  Branch (1676:14): [True: 0, False: 9.33k]
  ------------------
 1677|      0|        {
 1678|      0|            rem.resize(rem_view.size() + 1);
 1679|      0|            rem_view = rem.get_storage_view();
 1680|      0|            n++;
 1681|      0|            quot.resize(quot_view.size() + 1);
 1682|      0|            quot_view = quot.get_storage_view();
 1683|      0|        }
 1684|  9.33k|        word_type d = denom_view[l];
 1685|       |
 1686|  18.6k|        for ( size_type k = n; k > l; k-- )
  ------------------
  |  Branch (1686:32): [True: 9.33k, False: 9.33k]
  ------------------
 1687|  9.33k|        {
 1688|  9.33k|            word_type q = DDquotient(rem_view[k], rem_view[k-1], d);
 1689|  9.33k|            subtractmul( rem_view.data() + (k - l - 1), denom_view.data(), l + 1, q );
 1690|  9.33k|            quot_view[k - l - 1] = q;
 1691|  9.33k|        }
 1692|  9.33k|        quot.reduce();
 1693|  9.33k|        quot.set_negative(quot_neg);
 1694|  9.33k|        if (remDesired)
  ------------------
  |  Branch (1694:13): [True: 9.33k, False: 0]
  ------------------
 1695|  9.33k|        {
 1696|  9.33k|            unnormalize(rem, x, second_done);
 1697|  9.33k|            rem.set_negative(rem_neg);
 1698|  9.33k|        }
 1699|  9.33k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE13get_allocatorEv:
  698|   394k|    {
  699|   394k|        return storage_.get_allocator();
  700|   394k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_RKS3_:
  661|   271k|        : storage_(other.storage_, alloc)
  662|   271k|    {
  663|   271k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_RKS4_:
  304|   271k|        : word_allocator_type(alloc)
  305|   271k|    {
  306|   271k|        if (!other.is_allocated())
  ------------------
  |  Branch (306:13): [True: 244k, False: 27.0k]
  ------------------
  307|   244k|        {
  308|   244k|            ::new (&inlined_) inlined_storage(other.inlined_);
  309|   244k|        }
  310|  27.0k|        else
  311|  27.0k|        {
  312|  27.0k|            ::new (&allocated_) allocated_storage(other.allocated_, alloc);
  313|  27.0k|        }
  314|   271k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ImEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  678|   332k|        : storage_(n, alloc)
  679|   332k|    {
  680|   332k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ImEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  345|   332k|        : word_allocator_type(alloc)
  346|   332k|    {
  347|   332k|        ::new (&inlined_) inlined_storage(n);
  348|   332k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ImEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  137|   332k|            : is_allocated_(false),
  138|   332k|            is_negative_(false),
  139|   332k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (139:19): [True: 145k, False: 186k]
  ------------------
  140|   332k|        {
  141|   332k|            values_[0] = n;
  142|   332k|            values_[1] = 0;
  143|   332k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9normalizeERS4_S5_Ri:
 1800|  9.33k|    {
 1801|  9.33k|        auto denom_view = denom.get_storage_view();
 1802|  9.33k|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1802:13): [True: 0, False: 9.33k]
  ------------------
 1803|      0|        {
 1804|      0|            return false;
 1805|      0|        }
 1806|  9.33k|        size_type r = denom_view.size() - 1;
 1807|  9.33k|        word_type y = denom_view[r];
 1808|       |
 1809|  9.33k|        x = 0;
 1810|  9.33k|        while ( (y & l_bit) == 0 )
  ------------------
  |  Branch (1810:17): [True: 0, False: 9.33k]
  ------------------
 1811|      0|        {
 1812|      0|            y <<= 1;
 1813|      0|            x++;
 1814|      0|        }
 1815|  9.33k|        denom <<= x;
 1816|  9.33k|        num <<= x;
 1817|       |
 1818|  9.33k|        denom_view = denom.get_storage_view();
 1819|  9.33k|        if ( r > 0 && denom_view[r] < denom_view[r-1] )
  ------------------
  |  Branch (1819:14): [True: 0, False: 9.33k]
  |  Branch (1819:23): [True: 0, False: 0]
  ------------------
 1820|      0|        {
 1821|      0|            denom *= max_word;
 1822|      0|            num *= max_word;
 1823|      0|            return true;
 1824|      0|        }
 1825|  9.33k|        return false;
 1826|  9.33k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEElSEm:
 1046|  18.6k|    {
 1047|  18.6k|        auto this_view = get_storage_view();
 1048|  18.6k|        size_type q = k / word_type_bits;
 1049|  18.6k|        if ( q ) // Increase storage_.size() by q:
  ------------------
  |  Branch (1049:14): [True: 0, False: 18.6k]
  ------------------
 1050|      0|        {
 1051|      0|            resize(this_view.size() + q);
 1052|      0|            this_view = get_storage_view();
 1053|      0|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1053:50): [True: 0, False: 0]
  ------------------
 1054|      0|                this_view[i] = ( i < q ? 0 : this_view[i - q]);
  ------------------
  |  Branch (1054:34): [True: 0, False: 0]
  ------------------
 1055|      0|            k %= word_type_bits;
 1056|      0|        }
 1057|  18.6k|        if ( k )  // 0 < k < word_type_bits:
  ------------------
  |  Branch (1057:14): [True: 0, False: 18.6k]
  ------------------
 1058|      0|        {
 1059|      0|            size_type k1 = word_type_bits - k;
 1060|      0|            word_type mask = (word_type(1) << k) - word_type(1);
 1061|      0|            resize( this_view.size() + 1 );
 1062|      0|            this_view = get_storage_view();
 1063|      0|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1063:50): [True: 0, False: 0]
  ------------------
 1064|      0|            {
 1065|      0|                this_view[i] <<= k;
 1066|      0|                if ( i > 0 )
  ------------------
  |  Branch (1066:22): [True: 0, False: 0]
  ------------------
 1067|      0|                    this_view[i] |= (this_view[i-1] >> k1) & mask;
 1068|      0|            }
 1069|      0|        }
 1070|  18.6k|        reduce();
 1071|  18.6k|        return *this;
 1072|  18.6k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE10DDquotientEmmm:
 1727|  9.33k|    {
 1728|  9.33k|        word_type left, middle, right, qHi, qLo, x, dLo1,
 1729|  9.33k|                   dHi = d >> word_type_half_bits, dLo = d & r_mask;
 1730|  9.33k|        qHi = A/(dHi + 1);
 1731|       |        // This initial guess of qHi may be too small.
 1732|  9.33k|        middle = qHi * dLo;
 1733|  9.33k|        left = qHi * dHi;
 1734|  9.33k|        x = B - (middle << word_type_half_bits);
 1735|  9.33k|        A -= (middle >> word_type_half_bits) + left + (x > B);
 1736|  9.33k|        B = x;
 1737|  9.33k|        dLo1 = dLo << word_type_half_bits;
 1738|       |        // Increase qHi if necessary:
 1739|  9.33k|        while ( A > dHi || (A == dHi && B >= dLo1) )
  ------------------
  |  Branch (1739:17): [True: 0, False: 9.33k]
  |  Branch (1739:29): [True: 0, False: 9.33k]
  |  Branch (1739:41): [True: 0, False: 0]
  ------------------
 1740|      0|        {
 1741|      0|            x = B - dLo1;
 1742|      0|            A -= dHi + (x > B);
 1743|      0|            B = x;
 1744|      0|            qHi++;
 1745|      0|        }
 1746|  9.33k|        qLo = ((A << word_type_half_bits) | (B >> word_type_half_bits))/(dHi + 1);
 1747|       |        // This initial guess of qLo may be too small.
 1748|  9.33k|        right = qLo * dLo;
 1749|  9.33k|        middle = qLo * dHi;
 1750|  9.33k|        x = B - right;
 1751|  9.33k|        A -= (x > B);
 1752|  9.33k|        B = x;
 1753|  9.33k|        x = B - (middle << word_type_half_bits);
 1754|  9.33k|            A -= (middle >> word_type_half_bits) + (x > B);
 1755|  9.33k|        B = x;
 1756|       |        // Increase qLo if necessary:
 1757|  10.2k|        while ( A || B >= d )
  ------------------
  |  Branch (1757:17): [True: 0, False: 10.2k]
  |  Branch (1757:22): [True: 875, False: 9.33k]
  ------------------
 1758|    875|        {
 1759|    875|            x = B - d;
 1760|    875|            A -= (x > B);
 1761|    875|            B = x;
 1762|    875|            qLo++;
 1763|    875|        }
 1764|  9.33k|        return (qHi << word_type_half_bits) + qLo;
 1765|  9.33k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11subtractmulEPmS5_mRm:
 1769|  9.33k|    {
 1770|  9.33k|        word_type hi, lo, d, carry = 0;
 1771|  9.33k|        size_type i;
 1772|  18.6k|        for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1772:22): [True: 9.33k, False: 9.33k]
  ------------------
 1773|  9.33k|        {
 1774|  9.33k|            DDproduct( b[i], q, hi, lo );
 1775|  9.33k|            d = a[i];
 1776|  9.33k|            a[i] -= lo;
 1777|  9.33k|            if ( a[i] > d )
  ------------------
  |  Branch (1777:18): [True: 6.21k, False: 3.11k]
  ------------------
 1778|  6.21k|                carry++;
 1779|  9.33k|            d = a[i + 1];
 1780|  9.33k|            a[i + 1] -= hi + carry;
 1781|  9.33k|            carry = a[i + 1] > d;
 1782|  9.33k|        }
 1783|  9.33k|        if ( carry ) // q was too large
  ------------------
  |  Branch (1783:14): [True: 0, False: 9.33k]
  ------------------
 1784|      0|        {
 1785|      0|            q--;
 1786|      0|            carry = 0;
 1787|      0|            for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1787:26): [True: 0, False: 0]
  ------------------
 1788|      0|            {
 1789|      0|                d = a[i] + carry;
 1790|      0|                carry = d < carry;
 1791|      0|                a[i] = d + b[i];
 1792|      0|                if ( a[i] < d )
  ------------------
  |  Branch (1792:22): [True: 0, False: 0]
  ------------------
 1793|      0|                    carry = 1;
 1794|      0|            }
 1795|      0|            a[n] = 0;
 1796|      0|        }
 1797|  9.33k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11unnormalizeERS4_ib:
 1829|  9.33k|    {
 1830|  9.33k|        if (secondDone)
  ------------------
  |  Branch (1830:13): [True: 0, False: 9.33k]
  ------------------
 1831|      0|        {
 1832|      0|            rem /= max_word;
 1833|      0|        }
 1834|  9.33k|        if ( x > 0 )
  ------------------
  |  Branch (1834:14): [True: 0, False: 9.33k]
  ------------------
 1835|      0|        {
 1836|      0|            rem >>= x;
 1837|      0|        }
 1838|  9.33k|        else
 1839|  9.33k|        {
 1840|  9.33k|            rem.reduce();
 1841|  9.33k|        }
 1842|  9.33k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IlEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  678|   261k|        : storage_(n, alloc)
  679|   261k|    {
  680|   261k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IlEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  345|   261k|        : word_allocator_type(alloc)
  346|   261k|    {
  347|   261k|        ::new (&inlined_) inlined_storage(n);
  348|   261k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IlEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  124|   261k|            : is_allocated_(false),
  125|   261k|            is_negative_(n < 0),
  126|   261k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (126:19): [True: 59.6k, False: 202k]
  ------------------
  127|   261k|        {
  128|   261k|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (128:26): [True: 7.34k, False: 254k]
  ------------------
  129|   261k|            values_[1] = 0;
  130|   261k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEED2Ev:
  693|  1.75M|    {
  694|  1.75M|        storage_.destroy();
  695|  1.75M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7destroyEv:
  472|  1.75M|    {
  473|  1.75M|        if (is_allocated())
  ------------------
  |  Branch (473:13): [True: 175k, False: 1.57M]
  ------------------
  474|   175k|        {
  475|   175k|            allocated_.destroy(get_allocator());
  476|   175k|            allocated_.~allocated_storage();
  477|   175k|        }
  478|  1.57M|        else
  479|  1.57M|        {
  480|  1.57M|            inlined_.~inlined_storage();
  481|  1.57M|        }
  482|  1.75M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7destroyERKS4_:
  244|   175k|        {
  245|   175k|            if (data_ != nullptr)
  ------------------
  |  Branch (245:17): [True: 175k, False: 0]
  ------------------
  246|   175k|            {
  247|   175k|                real_allocator_type alloc(a);
  248|   175k|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  249|   175k|            }
  250|   175k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEEcvT_IlvEEv:
 1204|  19.9k|    {
 1205|  19.9k|        auto this_view = get_storage_view();
 1206|  19.9k|        Integer x = 0;
 1207|  19.9k|        if (this_view.size() > 0)
  ------------------
  |  Branch (1207:13): [True: 17.7k, False: 2.18k]
  ------------------
 1208|  17.7k|        {
 1209|  17.7k|            x = static_cast<Integer>(this_view[0]);
 1210|  17.7k|        }
 1211|       |
 1212|  19.9k|        return is_negative() ? x*(-1) : x;
  ------------------
  |  Branch (1212:16): [True: 9.05k, False: 10.9k]
  ------------------
 1213|  19.9k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE12write_stringIcNS1_11char_traitsIcEENS2_IcEEEEvRNS1_12basic_stringIT_T0_T1_EE:
 1288|  62.4k|    {
 1289|  62.4k|        basic_bigint<Allocator> v(*this);
 1290|  62.4k|        auto v_view = v.get_storage_view();
 1291|       |
 1292|  62.4k|        size_type len = (v_view.size() * word_type_bits / 3) + 2;
 1293|  62.4k|        data.reserve(len);
 1294|       |
 1295|  62.4k|        if ( v_view.size() == 0 )
  ------------------
  |  Branch (1295:14): [True: 1.01k, False: 61.4k]
  ------------------
 1296|  1.01k|        {
 1297|  1.01k|            data.push_back('0');
 1298|  1.01k|        }
 1299|  61.4k|        else
 1300|  61.4k|        {
 1301|  61.4k|            word_type r;
 1302|  61.4k|            basic_bigint<Allocator> R(get_allocator());
 1303|  61.4k|            basic_bigint<Allocator> LP10(max_unsigned_power_10, get_allocator()); 
 1304|       |
 1305|  61.4k|            do
 1306|   116k|            {
 1307|   116k|                v.divide( LP10, v, R, true );
 1308|   116k|                v_view = v.get_storage_view();
 1309|       |
 1310|   116k|                auto R_view = R.get_storage_view();
 1311|   116k|                r = (R_view.size() ? R_view[0] : 0);
  ------------------
  |  Branch (1311:22): [True: 80.9k, False: 35.5k]
  ------------------
 1312|  1.32M|                for ( size_type j=0; j < imax_unsigned_power_10; j++ )
  ------------------
  |  Branch (1312:38): [True: 1.27M, False: 55.1k]
  ------------------
 1313|  1.27M|                {
 1314|  1.27M|                    data.push_back(char(r % 10u + '0'));
 1315|  1.27M|                    r /= 10u;
 1316|  1.27M|                    if ( r + v_view.size() == 0 )
  ------------------
  |  Branch (1316:26): [True: 61.4k, False: 1.21M]
  ------------------
 1317|  61.4k|                        break;
 1318|  1.27M|                }
 1319|   116k|            } 
 1320|   116k|            while ( v_view.size() > 0);
  ------------------
  |  Branch (1320:21): [True: 55.1k, False: 61.4k]
  ------------------
 1321|       |
 1322|  61.4k|            if (is_negative())
  ------------------
  |  Branch (1322:17): [True: 7.34k, False: 54.0k]
  ------------------
 1323|  7.34k|            {
 1324|  7.34k|                data.push_back('-');
 1325|  7.34k|            }
 1326|  61.4k|            std::reverse(data.begin(),data.end());
 1327|  61.4k|        }
 1328|  62.4k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS3_:
  629|  61.4k|        : storage_(alloc)
  630|  61.4k|    {
  631|  61.4k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEEl:
 1410|  10.4k|    {
 1411|  10.4k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1411:15): [True: 7.34k, False: 3.05k]
  ------------------
 1412|  10.4k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IjEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  678|  10.4k|        : storage_(n, alloc)
  679|  10.4k|    {
  680|  10.4k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IjEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  345|  10.4k|        : word_allocator_type(alloc)
  346|  10.4k|    {
  347|  10.4k|        ::new (&inlined_) inlined_storage(n);
  348|  10.4k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IjEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  137|  10.4k|            : is_allocated_(false),
  138|  10.4k|            is_negative_(false),
  139|  10.4k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (139:19): [True: 1.55k, False: 8.84k]
  ------------------
  140|  10.4k|        {
  141|  10.4k|            values_[0] = n;
  142|  10.4k|            values_[1] = 0;
  143|  10.4k|        }

_ZN8jsoncons6binary13native_to_bigItNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  6.48k|    {
  128|  6.48k|        T val2 = byte_swap(val);
  129|  6.48k|        uint8_t buf[sizeof(T)];
  130|  6.48k|        std::memcpy(buf, &val2, sizeof(T));
  131|  6.48k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 12.9k, False: 6.48k]
  ------------------
  132|  12.9k|        {
  133|  12.9k|            *d_first++ = item;
  134|  12.9k|        }
  135|  6.48k|    }
_ZN8jsoncons6binary9byte_swapItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|  15.5k|    {
   29|  15.5k|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|  15.5k|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  466|  15.5k|#      define JSONCONS_BYTE_SWAP_16    __builtin_bswap16
  ------------------
   31|       |    #else
   32|       |        return (static_cast<uint16_t>(val) >> 8) | (static_cast<uint16_t>(val) << 8);
   33|       |    #endif
   34|  15.5k|    }
_ZN8jsoncons6binary13native_to_bigIjNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  16.9k|    {
  128|  16.9k|        T val2 = byte_swap(val);
  129|  16.9k|        uint8_t buf[sizeof(T)];
  130|  16.9k|        std::memcpy(buf, &val2, sizeof(T));
  131|  16.9k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 67.7k, False: 16.9k]
  ------------------
  132|  67.7k|        {
  133|  67.7k|            *d_first++ = item;
  134|  67.7k|        }
  135|  16.9k|    }
_ZN8jsoncons6binary9byte_swapIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|  79.8k|    {
   40|  79.8k|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|  79.8k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  462|  79.8k|#  define JSONCONS_BYTE_SWAP_32 __builtin_bswap32
  ------------------
   42|       |    #else
   43|       |        uint32_t tmp = ((static_cast<uint32_t>(val) << 8) & 0xff00ff00) | ((static_cast<uint32_t>(val) >> 8) & 0xff00ff);
   44|       |        return (tmp << 16) | (tmp >> 16);
   45|       |    #endif
   46|  79.8k|    }
_ZN8jsoncons6binary13native_to_bigImNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  17.8k|    {
  128|  17.8k|        T val2 = byte_swap(val);
  129|  17.8k|        uint8_t buf[sizeof(T)];
  130|  17.8k|        std::memcpy(buf, &val2, sizeof(T));
  131|  17.8k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 142k, False: 17.8k]
  ------------------
  132|   142k|        {
  133|   142k|            *d_first++ = item;
  134|   142k|        }
  135|  17.8k|    }
_ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|  83.8k|    {
   52|  83.8k|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|  83.8k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|  83.8k|#  define JSONCONS_BYTE_SWAP_64 __builtin_bswap64
  ------------------
   54|       |    #else
   55|       |        uint64_t tmp = ((static_cast<uint64_t>(val) & 0x00000000ffffffffull) << 32) | ((static_cast<uint64_t>(val) & 0xffffffff00000000ull) >> 32);
   56|       |        tmp = ((tmp & 0x0000ffff0000ffffull) << 16) | ((tmp & 0xffff0000ffff0000ull) >> 16);
   57|       |        return ((tmp & 0x00ff00ff00ff00ffull) << 8)  | ((tmp & 0xff00ff00ff00ff00ull) >> 8);
   58|       |    #endif
   59|  83.8k|    }
_ZN8jsoncons6binary13native_to_bigIaNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  97.4k|    {
  128|  97.4k|        T val2 = byte_swap(val);
  129|  97.4k|        uint8_t buf[sizeof(T)];
  130|  97.4k|        std::memcpy(buf, &val2, sizeof(T));
  131|  97.4k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 97.4k, False: 97.4k]
  ------------------
  132|  97.4k|        {
  133|  97.4k|            *d_first++ = item;
  134|  97.4k|        }
  135|  97.4k|    }
_ZN8jsoncons6binary9byte_swapIaEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_:
   21|   354k|    {
   22|   354k|        return val;
   23|   354k|    }
_ZN8jsoncons6binary13native_to_bigIsNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  12.4k|    {
  128|  12.4k|        T val2 = byte_swap(val);
  129|  12.4k|        uint8_t buf[sizeof(T)];
  130|  12.4k|        std::memcpy(buf, &val2, sizeof(T));
  131|  12.4k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 24.8k, False: 12.4k]
  ------------------
  132|  24.8k|        {
  133|  24.8k|            *d_first++ = item;
  134|  24.8k|        }
  135|  12.4k|    }
_ZN8jsoncons6binary9byte_swapIsEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|  32.6k|    {
   29|  32.6k|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|  32.6k|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  466|  32.6k|#      define JSONCONS_BYTE_SWAP_16    __builtin_bswap16
  ------------------
   31|       |    #else
   32|       |        return (static_cast<uint16_t>(val) >> 8) | (static_cast<uint16_t>(val) << 8);
   33|       |    #endif
   34|  32.6k|    }
_ZN8jsoncons6binary13native_to_bigIiNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  6.12k|    {
  128|  6.12k|        T val2 = byte_swap(val);
  129|  6.12k|        uint8_t buf[sizeof(T)];
  130|  6.12k|        std::memcpy(buf, &val2, sizeof(T));
  131|  6.12k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 24.4k, False: 6.12k]
  ------------------
  132|  24.4k|        {
  133|  24.4k|            *d_first++ = item;
  134|  24.4k|        }
  135|  6.12k|    }
_ZN8jsoncons6binary9byte_swapIiEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|  19.1k|    {
   40|  19.1k|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|  19.1k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  462|  19.1k|#  define JSONCONS_BYTE_SWAP_32 __builtin_bswap32
  ------------------
   42|       |    #else
   43|       |        uint32_t tmp = ((static_cast<uint32_t>(val) << 8) & 0xff00ff00) | ((static_cast<uint32_t>(val) >> 8) & 0xff00ff);
   44|       |        return (tmp << 16) | (tmp >> 16);
   45|       |    #endif
   46|  19.1k|    }
_ZN8jsoncons6binary13native_to_bigIlNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  2.15k|    {
  128|  2.15k|        T val2 = byte_swap(val);
  129|  2.15k|        uint8_t buf[sizeof(T)];
  130|  2.15k|        std::memcpy(buf, &val2, sizeof(T));
  131|  2.15k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 17.2k, False: 2.15k]
  ------------------
  132|  17.2k|        {
  133|  17.2k|            *d_first++ = item;
  134|  17.2k|        }
  135|  2.15k|    }
_ZN8jsoncons6binary9byte_swapIlEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|  28.9k|    {
   52|  28.9k|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|  28.9k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|  28.9k|#  define JSONCONS_BYTE_SWAP_64 __builtin_bswap64
  ------------------
   54|       |    #else
   55|       |        uint64_t tmp = ((static_cast<uint64_t>(val) & 0x00000000ffffffffull) << 32) | ((static_cast<uint64_t>(val) & 0xffffffff00000000ull) >> 32);
   56|       |        tmp = ((tmp & 0x0000ffff0000ffffull) << 16) | ((tmp & 0xffff0000ffff0000ull) >> 16);
   57|       |        return ((tmp & 0x00ff00ff00ff00ffull) << 8)  | ((tmp & 0xff00ff00ff00ff00ull) >> 8);
   58|       |    #endif
   59|  28.9k|    }
_ZN8jsoncons6binary13native_to_bigIfNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  4.51k|    {
  128|  4.51k|        T val2 = byte_swap(val);
  129|  4.51k|        uint8_t buf[sizeof(T)];
  130|  4.51k|        std::memcpy(buf, &val2, sizeof(T));
  131|  4.51k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 18.0k, False: 4.51k]
  ------------------
  132|  18.0k|        {
  133|  18.0k|            *d_first++ = item;
  134|  18.0k|        }
  135|  4.51k|    }
_ZN8jsoncons6binary9byte_swapIfEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   64|  35.4k|    {
   65|  35.4k|        uint32_t x;
   66|  35.4k|        std::memcpy(&x,&val,sizeof(uint32_t));
   67|  35.4k|        uint32_t y = byte_swap(x);
   68|  35.4k|        T val2;
   69|  35.4k|        std::memcpy(&val2,&y,sizeof(uint32_t));
   70|  35.4k|        return val2;
   71|  35.4k|    }
_ZN8jsoncons6binary13native_to_bigIdNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  2.35k|    {
  128|  2.35k|        T val2 = byte_swap(val);
  129|  2.35k|        uint8_t buf[sizeof(T)];
  130|  2.35k|        std::memcpy(buf, &val2, sizeof(T));
  131|  2.35k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 18.8k, False: 2.35k]
  ------------------
  132|  18.8k|        {
  133|  18.8k|            *d_first++ = item;
  134|  18.8k|        }
  135|  2.35k|    }
_ZN8jsoncons6binary9byte_swapIdEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   76|  10.7k|    {
   77|  10.7k|        uint64_t x;
   78|  10.7k|        std::memcpy(&x,&val,sizeof(uint64_t));
   79|  10.7k|        uint64_t y = byte_swap(x);
   80|  10.7k|        T val2;
   81|  10.7k|        std::memcpy(&val2,&y,sizeof(uint64_t));
   82|  10.7k|        return val2;
   83|  10.7k|    }
_ZN8jsoncons6binary13big_to_nativeIfNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  30.9k|    {
  183|  30.9k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 30.9k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  30.9k|        T val;
  188|  30.9k|        std::memcpy(&val,first,sizeof(T));
  189|  30.9k|        return byte_swap(val);
  190|  30.9k|    }
_ZN8jsoncons6binary13big_to_nativeIdNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  8.37k|    {
  183|  8.37k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 8.37k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  8.37k|        T val;
  188|  8.37k|        std::memcpy(&val,first,sizeof(T));
  189|  8.37k|        return byte_swap(val);
  190|  8.37k|    }
_ZN8jsoncons6binary13big_to_nativeItNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  9.08k|    {
  183|  9.08k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 9.08k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  9.08k|        T val;
  188|  9.08k|        std::memcpy(&val,first,sizeof(T));
  189|  9.08k|        return byte_swap(val);
  190|  9.08k|    }
_ZN8jsoncons6binary13big_to_nativeIjNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  27.5k|    {
  183|  27.5k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 27.5k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  27.5k|        T val;
  188|  27.5k|        std::memcpy(&val,first,sizeof(T));
  189|  27.5k|        return byte_swap(val);
  190|  27.5k|    }
_ZN8jsoncons6binary13big_to_nativeImNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  55.2k|    {
  183|  55.2k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 55.2k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  55.2k|        T val;
  188|  55.2k|        std::memcpy(&val,first,sizeof(T));
  189|  55.2k|        return byte_swap(val);
  190|  55.2k|    }
_ZN8jsoncons6binary13big_to_nativeIaNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|   257k|    {
  183|   257k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 257k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|   257k|        T val;
  188|   257k|        std::memcpy(&val,first,sizeof(T));
  189|   257k|        return byte_swap(val);
  190|   257k|    }
_ZN8jsoncons6binary13big_to_nativeIsNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  20.1k|    {
  183|  20.1k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 20.1k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  20.1k|        T val;
  188|  20.1k|        std::memcpy(&val,first,sizeof(T));
  189|  20.1k|        return byte_swap(val);
  190|  20.1k|    }
_ZN8jsoncons6binary13big_to_nativeIiNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  12.9k|    {
  183|  12.9k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 12.9k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  12.9k|        T val;
  188|  12.9k|        std::memcpy(&val,first,sizeof(T));
  189|  12.9k|        return byte_swap(val);
  190|  12.9k|    }
_ZN8jsoncons6binary13big_to_nativeIlNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  26.7k|    {
  183|  26.7k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 26.7k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  26.7k|        T val;
  188|  26.7k|        std::memcpy(&val,first,sizeof(T));
  189|  26.7k|        return byte_swap(val);
  190|  26.7k|    }
_ZN8jsoncons6binary13big_to_nativeIhNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  30.2k|    {
  183|  30.2k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 30.2k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  30.2k|        T val;
  188|  30.2k|        std::memcpy(&val,first,sizeof(T));
  189|  30.2k|        return byte_swap(val);
  190|  30.2k|    }
_ZN8jsoncons6binary9byte_swapIhEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_:
   21|  30.2k|    {
   22|  30.2k|        return val;
   23|  30.2k|    }

_ZN8jsoncons6detail23bytes_to_base64_genericIPKhNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS4_9enable_ifIXsr3std7is_sameINS4_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESD_SD_PKcRT0_:
   44|  50.3k|    {
   45|  50.3k|        std::size_t count = 0;
   46|  50.3k|        unsigned char a3[3];
   47|  50.3k|        unsigned char a4[4];
   48|  50.3k|        unsigned char fill = alphabet[64];
   49|  50.3k|        int i = 0;
   50|  50.3k|        int j = 0;
   51|       |
   52|  4.69M|        while (first != last)
  ------------------
  |  Branch (52:16): [True: 4.64M, False: 50.3k]
  ------------------
   53|  4.64M|        {
   54|  4.64M|            a3[i++] = *first++;
   55|  4.64M|            if (i == 3)
  ------------------
  |  Branch (55:17): [True: 1.52M, False: 3.11M]
  ------------------
   56|  1.52M|            {
   57|  1.52M|                a4[0] = (a3[0] & 0xfc) >> 2;
   58|  1.52M|                a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   59|  1.52M|                a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   60|  1.52M|                a4[3] = a3[2] & 0x3f;
   61|       |
   62|  7.63M|                for (i = 0; i < 4; i++) 
  ------------------
  |  Branch (62:29): [True: 6.10M, False: 1.52M]
  ------------------
   63|  6.10M|                {
   64|  6.10M|                    result.push_back(alphabet[a4[i]]);
   65|  6.10M|                    ++count;
   66|  6.10M|                }
   67|  1.52M|                i = 0;
   68|  1.52M|            }
   69|  4.64M|        }
   70|       |
   71|  50.3k|        if (i > 0)
  ------------------
  |  Branch (71:13): [True: 37.0k, False: 13.3k]
  ------------------
   72|  37.0k|        {
   73|  86.2k|            for (j = i; j < 3; ++j) 
  ------------------
  |  Branch (73:25): [True: 49.1k, False: 37.0k]
  ------------------
   74|  49.1k|            {
   75|  49.1k|                a3[j] = 0;
   76|  49.1k|            }
   77|       |
   78|  37.0k|            a4[0] = (a3[0] & 0xfc) >> 2;
   79|  37.0k|            a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   80|  37.0k|            a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   81|       |
   82|   136k|            for (j = 0; j < i + 1; ++j) 
  ------------------
  |  Branch (82:25): [True: 99.0k, False: 37.0k]
  ------------------
   83|  99.0k|            {
   84|  99.0k|                result.push_back(alphabet[a4[j]]);
   85|  99.0k|                ++count;
   86|  99.0k|            }
   87|       |
   88|  37.0k|            if (fill != 0)
  ------------------
  |  Branch (88:17): [True: 0, False: 37.0k]
  ------------------
   89|      0|            {
   90|      0|                while (i++ < 3) 
  ------------------
  |  Branch (90:24): [True: 0, False: 0]
  ------------------
   91|      0|                {
   92|      0|                    result.push_back(fill);
   93|      0|                    ++count;
   94|      0|                }
   95|      0|            }
   96|  37.0k|        }
   97|       |
   98|  50.3k|        return count;
   99|  50.3k|    }
_ZNK8jsoncons16byte_string_view5beginEv:
  409|   146k|        {
  410|   146k|            return data_;
  411|   146k|        }
_ZNK8jsoncons16byte_string_view3endEv:
  413|   146k|        {
  414|   146k|            return data_ + size_;
  415|   146k|        }
_ZN8jsoncons18bytes_to_base64urlIPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  177|  50.3k|    {
  178|  50.3k|        static constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  179|  50.3k|                                                      "abcdefghijklmnopqrstuvwxyz"
  180|  50.3k|                                                      "0123456789-_"
  181|  50.3k|                                                      "\0";
  182|  50.3k|        return detail::bytes_to_base64_generic(first, last, alphabet, result);
  183|  50.3k|    }
_ZNK8jsoncons16byte_string_view4dataEv:
  399|   243k|        {
  400|   243k|            return data_;
  401|   243k|        }
_ZNK8jsoncons16byte_string_view4sizeEv:
  403|   339k|        {
  404|   339k|            return size_;
  405|   339k|        }
_ZN8jsoncons16byte_string_viewC2EPKhm:
  362|   390k|            : data_(data), size_(length)
  363|   390k|        {
  364|   390k|        }

_ZN8jsoncons10ext_traits16to_plain_pointerImEEPT_S3_:
  241|   121k|    {       
  242|   121k|        return (ptr);
  243|   121k|    }  

_ZN8jsoncons16decstr_to_doubleEPKcmRd:
  866|  3.81k|{
  867|  3.81k|    const char* cur = s+length;
  868|  3.81k|    char *end = nullptr;
  869|  3.81k|    val = strtod(s, &end);
  870|  3.81k|    const char* str_end = end;
  871|  3.81k|    if (JSONCONS_UNLIKELY(end < cur))
  ------------------
  |  |   78|  3.81k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.81k]
  |  |  ------------------
  ------------------
  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|  3.81k|    if (JSONCONS_UNLIKELY(val <= -HUGE_VAL || val >= HUGE_VAL))
  ------------------
  |  |   78|  7.62k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.81k]
  |  |  |  Branch (78:50): [True: 0, False: 3.81k]
  |  |  |  Branch (78:50): [True: 0, False: 3.81k]
  |  |  ------------------
  ------------------
  888|      0|    {
  889|      0|        return to_number_result<char>{str_end, std::errc::result_out_of_range};
  890|      0|    }
  891|  3.81k|    return to_number_result<char>{str_end};
  892|  3.81k|}
_ZN8jsoncons16to_number_resultIcEC2EPKc:
  137|  3.81k|        : ptr(ptr_), ec(std::errc{})
  138|  3.81k|    {
  139|  3.81k|    }

_ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_14convert_resultIS4_EEE4typeEPKS4_m:
 1134|   332k|    {
 1135|   332k|        conv_errc  result = conv_errc();
 1136|   332k|        const CharT* last = data + length;
 1137|  77.4M|        while (data != last) 
  ------------------
  |  Branch (1137:16): [True: 77.0M, False: 332k]
  ------------------
 1138|  77.0M|        {
 1139|  77.0M|            std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[static_cast<uint8_t>(*data)]) + 1;
 1140|  77.0M|            if (len > (std::size_t)(last - data))
  ------------------
  |  Branch (1140:17): [True: 17, False: 77.0M]
  ------------------
 1141|     17|            {
 1142|     17|                return convert_result<CharT>{data, conv_errc::source_exhausted};
 1143|     17|            }
 1144|  77.0M|            if ((result=is_legal_utf8(data, len)) != conv_errc())
  ------------------
  |  Branch (1144:17): [True: 91, False: 77.0M]
  ------------------
 1145|     91|            {
 1146|     91|                return convert_result<CharT>{data,result} ;
 1147|     91|            }
 1148|  77.0M|            data += len;
 1149|  77.0M|        }
 1150|   332k|        return convert_result<CharT>{data,result} ;
 1151|   332k|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8IcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_9conv_errcEE4typeEPKS4_m:
  303|  77.0M|    {
  304|  77.0M|        uint8_t a;
  305|  77.0M|        const CharT* srcptr = first+length;
  306|  77.0M|        switch (length) {
  307|     10|        default:
  ------------------
  |  Branch (307:9): [True: 10, False: 77.0M]
  ------------------
  308|     10|            return conv_errc::over_long_utf8_sequence;
  309|    527|        case 4:
  ------------------
  |  Branch (309:9): [True: 527, False: 77.0M]
  ------------------
  310|    527|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (310:17): [True: 7, False: 520]
  ------------------
  311|      7|                return conv_errc::expected_continuation_byte;
  312|    520|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|    520|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  313|    985|        case 3:
  ------------------
  |  Branch (313:9): [True: 465, False: 77.0M]
  ------------------
  314|    985|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 5, False: 980]
  ------------------
  315|      5|                return conv_errc::expected_continuation_byte;
  316|    980|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|    980|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  317|  1.25k|        case 2:
  ------------------
  |  Branch (317:9): [True: 274, False: 77.0M]
  ------------------
  318|  1.25k|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (318:17): [True: 18, False: 1.23k]
  ------------------
  319|     18|                return conv_errc::expected_continuation_byte;
  320|       |
  321|  1.23k|            switch (static_cast<uint8_t>(*first)) 
  322|  1.23k|            {
  323|       |                // no fall-through in this inner switch
  324|    212|                case 0xE0: if (a < 0xA0) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (324:17): [True: 212, False: 1.02k]
  |  Branch (324:32): [True: 7, False: 205]
  ------------------
  325|    227|                case 0xED: if (a > 0x9F) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (325:17): [True: 227, False: 1.00k]
  |  Branch (325:32): [True: 4, False: 223]
  ------------------
  326|    236|                case 0xF0: if (a < 0x90) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (326:17): [True: 236, False: 1.00k]
  |  Branch (326:32): [True: 6, False: 230]
  ------------------
  327|    230|                case 0xF4: if (a > 0x8F) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (327:17): [True: 199, False: 1.03k]
  |  Branch (327:32): [True: 2, False: 197]
  ------------------
  328|    362|                default:   if (a < 0x80) return conv_errc::source_illegal;
  ------------------
  |  Branch (328:17): [True: 362, False: 874]
  |  Branch (328:32): [True: 0, False: 362]
  ------------------
  329|  1.23k|            }
  330|       |
  331|  1.21k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|  1.21k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  332|  77.0M|        case 1:
  ------------------
  |  Branch (332:9): [True: 77.0M, False: 1.27k]
  ------------------
  333|  77.0M|            if (static_cast<uint8_t>(*first) >= 0x80 && static_cast<uint8_t>(*first) < 0xC2)
  ------------------
  |  Branch (333:17): [True: 1.24k, False: 77.0M]
  |  Branch (333:57): [True: 30, False: 1.21k]
  ------------------
  334|     30|                return conv_errc::source_illegal;
  335|  77.0M|            break;
  336|  77.0M|        }
  337|  77.0M|        if (static_cast<uint8_t>(*first) > 0xF4) 
  ------------------
  |  Branch (337:13): [True: 2, False: 77.0M]
  ------------------
  338|      2|            return conv_errc::source_illegal;
  339|       |
  340|  77.0M|        return conv_errc();
  341|  77.0M|    }

_ZN8jsoncons12from_integerImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  12.8M|{
   43|  12.8M|    using char_type = typename Result::value_type;
   44|       |
   45|  12.8M|    char_type buf[255];
   46|  12.8M|    char_type *p = buf;
   47|  12.8M|    const char_type* last = buf+255;
   48|       |
   49|  12.8M|    bool is_negative = value < 0;
   50|       |
   51|  12.8M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 12.8M]
  ------------------
   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|  12.8M|    else
   60|  12.8M|    {
   61|       |
   62|  12.8M|        do
   63|  19.2M|        {
   64|  19.2M|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  19.2M|        }
   66|  19.2M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 6.34M, False: 12.8M]
  |  Branch (66:33): [True: 6.34M, False: 0]
  ------------------
   67|  12.8M|    }
   68|  12.8M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   45|  12.8M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 12.8M]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|  12.8M|    std::size_t count = (p - buf);
   71|  12.8M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 12.8M]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  32.0M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 19.2M, False: 12.8M]
  ------------------
   77|  19.2M|    {
   78|  19.2M|        result.push_back(*p);
   79|  19.2M|    }
   80|       |
   81|  12.8M|    return count;
   82|  12.8M|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  1.93M|{
   43|  1.93M|    using char_type = typename Result::value_type;
   44|       |
   45|  1.93M|    char_type buf[255];
   46|  1.93M|    char_type *p = buf;
   47|  1.93M|    const char_type* last = buf+255;
   48|       |
   49|  1.93M|    bool is_negative = value < 0;
   50|       |
   51|  1.93M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 1.93M, False: 4.38k]
  ------------------
   52|  1.93M|    {
   53|  1.93M|        do
   54|  2.38M|        {
   55|  2.38M|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|  2.38M|        }
   57|  2.38M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 448k, False: 1.93M]
  |  Branch (57:33): [True: 448k, False: 0]
  ------------------
   58|  1.93M|    }
   59|  4.38k|    else
   60|  4.38k|    {
   61|       |
   62|  4.38k|        do
   63|  70.9k|        {
   64|  70.9k|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  70.9k|        }
   66|  70.9k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 66.5k, False: 4.38k]
  |  Branch (66:33): [True: 66.5k, False: 0]
  ------------------
   67|  4.38k|    }
   68|  1.93M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   45|  1.93M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 1.93M]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|  1.93M|    std::size_t count = (p - buf);
   71|  1.93M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 1.93M, False: 4.38k]
  ------------------
   72|  1.93M|    {
   73|  1.93M|        result.push_back('-');
   74|  1.93M|        ++count;
   75|  1.93M|    }
   76|  4.39M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 2.45M, False: 1.93M]
  ------------------
   77|  2.45M|    {
   78|  2.45M|        result.push_back(*p);
   79|  2.45M|    }
   80|       |
   81|  1.93M|    return count;
   82|  1.93M|}
_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|  32.4k|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|  32.4k|    {
  489|  32.4k|#if !defined(JSONCONS_NO_LOCALECONV)
  490|  32.4k|        struct lconv *lc = localeconv();
  491|  32.4k|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 32.4k, False: 0]
  |  Branch (491:30): [True: 32.4k, False: 0]
  ------------------
  492|  32.4k|        {
  493|  32.4k|            decimal_point_ = lc->decimal_point[0];
  494|  32.4k|        }
  495|  32.4k|#endif
  496|  32.4k|    }
_ZN8jsoncons12write_doubleclINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEmdRT_:
  503|  32.4k|    {
  504|  32.4k|        std::size_t count = 0;
  505|       |
  506|  32.4k|        char number_buffer[200];
  507|  32.4k|        int length = 0;
  508|       |
  509|  32.4k|        switch (float_format_)
  510|  32.4k|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 32.4k]
  ------------------
  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: 32.4k]
  ------------------
  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|  32.4k|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 32.4k, False: 0]
  ------------------
  552|  32.4k|            {
  553|  32.4k|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 32.4k]
  ------------------
  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|  32.4k|                else
  563|  32.4k|                {
  564|  32.4k|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 32.4k]
  ------------------
  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|  32.4k|                }             
  569|  32.4k|                break;
  570|  32.4k|            }
  571|  32.4k|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 32.4k]
  ------------------
  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|  32.4k|        }
  575|  32.4k|        return count;
  576|  32.4k|    }
_ZN8jsoncons11dump_bufferINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKcmcRT_:
  243|  3.81k|{
  244|  3.81k|    const char *sbeg = buffer;
  245|  3.81k|    const char *send = sbeg + length;
  246|       |
  247|  3.81k|    if (sbeg != send)
  ------------------
  |  Branch (247:9): [True: 3.81k, False: 0]
  ------------------
  248|  3.81k|    {
  249|  3.81k|        bool needs_dot = true;
  250|  58.4k|        for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (250:36): [True: 54.6k, False: 3.81k]
  ------------------
  251|  54.6k|        {
  252|  54.6k|            switch (*q)
  253|  54.6k|            {
  254|  2.53k|            case '-':
  ------------------
  |  Branch (254:13): [True: 2.53k, False: 52.0k]
  ------------------
  255|  7.91k|            case '0':
  ------------------
  |  Branch (255:13): [True: 5.38k, False: 49.2k]
  ------------------
  256|  11.9k|            case '1':
  ------------------
  |  Branch (256:13): [True: 4.04k, False: 50.5k]
  ------------------
  257|  19.6k|            case '2':
  ------------------
  |  Branch (257:13): [True: 7.65k, False: 46.9k]
  ------------------
  258|  21.4k|            case '3':
  ------------------
  |  Branch (258:13): [True: 1.85k, False: 52.7k]
  ------------------
  259|  27.3k|            case '4':
  ------------------
  |  Branch (259:13): [True: 5.85k, False: 48.7k]
  ------------------
  260|  30.1k|            case '5':
  ------------------
  |  Branch (260:13): [True: 2.79k, False: 51.8k]
  ------------------
  261|  34.9k|            case '6':
  ------------------
  |  Branch (261:13): [True: 4.80k, False: 49.8k]
  ------------------
  262|  38.7k|            case '7':
  ------------------
  |  Branch (262:13): [True: 3.77k, False: 50.8k]
  ------------------
  263|  42.6k|            case '8':
  ------------------
  |  Branch (263:13): [True: 3.98k, False: 50.6k]
  ------------------
  264|  46.3k|            case '9':
  ------------------
  |  Branch (264:13): [True: 3.65k, False: 50.9k]
  ------------------
  265|  47.8k|            case '+':
  ------------------
  |  Branch (265:13): [True: 1.53k, False: 53.1k]
  ------------------
  266|  47.8k|                result.push_back(*q);
  267|  47.8k|                break;
  268|  2.54k|            case 'e':
  ------------------
  |  Branch (268:13): [True: 2.54k, False: 52.0k]
  ------------------
  269|  2.54k|            case 'E':
  ------------------
  |  Branch (269:13): [True: 0, False: 54.6k]
  ------------------
  270|  2.54k|                result.push_back('e');
  271|  2.54k|                needs_dot = false;
  272|  2.54k|                break;
  273|  4.22k|            default:
  ------------------
  |  Branch (273:13): [True: 4.22k, False: 50.4k]
  ------------------
  274|  4.22k|                if (*q == decimal_point)
  ------------------
  |  Branch (274:21): [True: 2.76k, False: 1.45k]
  ------------------
  275|  2.76k|                {
  276|  2.76k|                    needs_dot = false;
  277|  2.76k|                    result.push_back('.');
  278|  2.76k|                }
  279|  4.22k|                break;
  280|  54.6k|            }
  281|  54.6k|        }
  282|  3.81k|        if (needs_dot)
  ------------------
  |  Branch (282:13): [True: 1.04k, False: 2.76k]
  ------------------
  283|  1.04k|        {
  284|  1.04k|            result.push_back('.');
  285|  1.04k|            result.push_back('0');
  286|  1.04k|        }
  287|  3.81k|    }
  288|  3.81k|}
_ZN8jsoncons15prettify_stringINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKcmiiiRT_:
  171|  28.1k|{
  172|  28.1k|    int nb_digits = (int)length;
  173|  28.1k|    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|  28.1k|    int kk = nb_digits + k;
  179|       |
  180|  28.1k|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 15.8k, False: 12.2k]
  |  Branch (180:28): [True: 5.66k, False: 10.2k]
  ------------------
  181|  5.66k|    {
  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|  41.9k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 36.2k, False: 5.66k]
  ------------------
  186|  36.2k|        {
  187|  36.2k|            result.push_back(buffer[i]);
  188|  36.2k|        }
  189|  7.63k|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 1.96k, False: 5.66k]
  ------------------
  190|  1.96k|        {
  191|  1.96k|            result.push_back('0');
  192|  1.96k|        }
  193|  5.66k|        result.push_back('.');
  194|  5.66k|        result.push_back('0');
  195|  5.66k|    } 
  196|  22.4k|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 14.3k, False: 8.11k]
  |  Branch (196:24): [True: 4.16k, False: 10.2k]
  ------------------
  197|  4.16k|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|  16.3k|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 12.1k, False: 4.16k]
  ------------------
  200|  12.1k|        {
  201|  12.1k|            result.push_back(buffer[i]);
  202|  12.1k|        }
  203|  4.16k|        result.push_back('.');
  204|  56.5k|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 52.4k, False: 4.16k]
  ------------------
  205|  52.4k|        {
  206|  52.4k|            result.push_back(buffer[i]);
  207|  52.4k|        }
  208|  4.16k|    } 
  209|  18.3k|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 11.4k, False: 6.91k]
  |  Branch (209:30): [True: 1.20k, False: 10.2k]
  ------------------
  210|  1.20k|    {
  211|  1.20k|        offset = 2 - kk;
  212|       |
  213|  1.20k|        result.push_back('0');
  214|  1.20k|        result.push_back('.');
  215|  3.29k|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 2.09k, False: 1.20k]
  ------------------
  216|  2.09k|            result.push_back('0');
  217|  19.5k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 18.3k, False: 1.20k]
  ------------------
  218|  18.3k|        {
  219|  18.3k|            result.push_back(buffer[i]);
  220|  18.3k|        }
  221|  1.20k|    } 
  222|  17.1k|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 936, False: 16.1k]
  ------------------
  223|    936|    {
  224|    936|        result.push_back(buffer[0]);
  225|    936|        result.push_back('e');
  226|    936|        fill_exponent(kk - 1, result);
  227|    936|    } 
  228|  16.1k|    else
  229|  16.1k|    {
  230|  16.1k|        result.push_back(buffer[0]);
  231|  16.1k|        result.push_back('.');
  232|   257k|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 241k, False: 16.1k]
  ------------------
  233|   241k|        {
  234|   241k|            result.push_back(buffer[i]);
  235|   241k|        }
  236|  16.1k|        result.push_back('e');
  237|  16.1k|        fill_exponent(kk - 1, result);
  238|  16.1k|    }
  239|  28.1k|}
_ZN8jsoncons13fill_exponentINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEviRT_:
  136|  17.1k|{
  137|  17.1k|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 6.91k, False: 10.2k]
  ------------------
  138|  6.91k|    {
  139|  6.91k|        result.push_back('-');
  140|  6.91k|        K = -K;
  141|  6.91k|    }
  142|  10.2k|    else
  143|  10.2k|    {
  144|  10.2k|        result.push_back('+'); // compatibility with sprintf
  145|  10.2k|    }
  146|       |
  147|  17.1k|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 801, False: 16.3k]
  ------------------
  148|    801|    {
  149|    801|        result.push_back('0'); // compatibility with sprintf
  150|    801|        result.push_back((char)('0' + K));
  151|    801|    }
  152|  16.3k|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 6.05k, False: 10.2k]
  ------------------
  153|  6.05k|    {
  154|  6.05k|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|  6.05k|        result.push_back((char)('0' + K));
  156|  6.05k|    }
  157|  10.2k|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 10.2k, False: 0]
  ------------------
  158|  10.2k|    {
  159|  10.2k|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|  10.2k|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|  10.2k|        result.push_back((char)('0' + K));
  162|  10.2k|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|  17.1k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_:
  475|  32.4k|{
  476|  32.4k|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|  32.4k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb1EEE:
  366|  32.4k|{
  367|  32.4k|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 445, False: 31.9k]
  ------------------
  368|    445|    {
  369|    445|        result.push_back('0');
  370|    445|        result.push_back('.');
  371|    445|        result.push_back('0');
  372|    445|        return true;
  373|    445|    }
  374|       |
  375|  31.9k|    int length = 0;
  376|  31.9k|    int k;
  377|       |
  378|  31.9k|    char buffer[100];
  379|       |
  380|  31.9k|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 21.7k, False: 10.2k]
  ------------------
  381|  31.9k|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 28.1k, False: 3.81k]
  ------------------
  382|  28.1k|    {
  383|  28.1k|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 20.1k, False: 7.98k]
  ------------------
  384|  20.1k|        {
  385|  20.1k|            result.push_back('-');
  386|  20.1k|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|  28.1k|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|  28.1k|        return true;
  391|  28.1k|    }
  392|  3.81k|    else
  393|  3.81k|    {
  394|  3.81k|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|  3.81k|    }
  396|  31.9k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb0EEE:
  329|  3.81k|{
  330|  3.81k|    if (val == 0)
  ------------------
  |  Branch (330:9): [True: 0, False: 3.81k]
  ------------------
  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|  3.81k|    char buffer[100];
  339|  3.81k|    int precision = std::numeric_limits<double>::digits10;
  340|  3.81k|    int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  341|  3.81k|    if (length < 0)
  ------------------
  |  Branch (341:9): [True: 0, False: 3.81k]
  ------------------
  342|      0|    {
  343|      0|        return false;
  344|      0|    }
  345|  3.81k|    double x{0};
  346|  3.81k|    auto res = decstr_to_double(buffer, length, x);
  347|  3.81k|    if (res.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (347:9): [True: 0, False: 3.81k]
  ------------------
  348|      0|    {
  349|      0|        return false;
  350|      0|    }
  351|  3.81k|    if (x != val)
  ------------------
  |  Branch (351:9): [True: 2.27k, False: 1.54k]
  ------------------
  352|  2.27k|    {
  353|  2.27k|        const int precision2 = std::numeric_limits<double>::max_digits10;
  354|  2.27k|        length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  355|  2.27k|        if (length < 0)
  ------------------
  |  Branch (355:13): [True: 0, False: 2.27k]
  ------------------
  356|      0|        {
  357|      0|            return false;
  358|      0|        }
  359|  2.27k|    }
  360|  3.81k|    dump_buffer(buffer, length, decimal_point, result);
  361|  3.81k|    return true;
  362|  3.81k|}

_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEEC2EOS8_RKS9_:
   97|  6.25k|           : basic_msgpack_encoder(std::forward<Sink>(sink), msgpack_encode_options(), alloc)
   98|  6.25k|        {
   99|  6.25k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEEC2EOS8_RKNS0_22msgpack_encode_optionsERKS9_:
  104|  6.25k|           : sink_(std::forward<Sink>(sink)),
  105|  6.25k|             max_nesting_depth_(options.max_nesting_depth()),
  106|  6.25k|             alloc_(alloc)
  107|  6.25k|        {
  108|  6.25k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  204|  75.3k|        {
  205|  75.3k|            if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|  75.3k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 75.3k]
  |  |  ------------------
  ------------------
  206|      0|            {
  207|      0|                ec = msgpack_errc::max_nesting_depth_exceeded;
  208|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  209|      0|            } 
  210|  75.3k|            stack_.emplace_back(msgpack_container_type::array, length);
  211|  75.3k|            if (length <= 15)
  ------------------
  |  Branch (211:17): [True: 71.6k, False: 3.68k]
  ------------------
  212|  71.6k|            {
  213|       |                // fixarray
  214|  71.6k|                sink_.push_back(jsoncons::msgpack::msgpack_type::fixarray_base_type | (length & 0xf));
  215|  71.6k|            }
  216|  3.68k|            else if (length <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (216:22): [True: 1.65k, False: 2.02k]
  ------------------
  217|  1.65k|            {
  218|       |                // array 16
  219|  1.65k|                sink_.push_back(jsoncons::msgpack::msgpack_type::array16_type);
  220|  1.65k|                binary::native_to_big(static_cast<uint16_t>(length),std::back_inserter(sink_));
  221|  1.65k|            }
  222|  2.02k|            else if (length <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (222:22): [True: 2.02k, False: 0]
  ------------------
  223|  2.02k|            {
  224|       |                // array 32
  225|  2.02k|                sink_.push_back(jsoncons::msgpack::msgpack_type::array32_type);
  226|  2.02k|                binary::native_to_big(static_cast<uint32_t>(length),std::back_inserter(sink_));
  227|  2.02k|            }
  228|  75.3k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  75.3k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  229|  75.3k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_itemC2ENS0_22msgpack_container_typeEm:
   64|   119k|               : type_(type), length_(length)
   65|   119k|            {
   66|   119k|            }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE15visit_end_arrayERKNS_11ser_contextERNS3_10error_codeE:
  232|  60.6k|        {
  233|  60.6k|            JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   45|  60.6k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 60.6k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  234|       |
  235|  60.6k|            --nesting_depth_;
  236|       |
  237|  60.6k|            if (stack_.back().count() < stack_.back().length())
  ------------------
  |  Branch (237:17): [True: 498, False: 60.1k]
  ------------------
  238|    498|            {
  239|    498|                ec = msgpack_errc::too_few_items;
  240|    498|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    498|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  241|    498|            }
  242|  60.1k|            else if (stack_.back().count() > stack_.back().length())
  ------------------
  |  Branch (242:22): [True: 0, False: 60.1k]
  ------------------
  243|      0|            {
  244|      0|                ec = msgpack_errc::too_many_items;
  245|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  246|      0|            }
  247|       |
  248|  60.1k|            stack_.pop_back();
  249|  60.1k|            end_value();
  250|  60.1k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  60.1k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  251|  60.6k|        }
_ZNK8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item5countEv:
   74|   191k|            {
   75|   191k|                return is_object() ? index_/2 : index_;
  ------------------
  |  Branch (75:24): [True: 70.7k, False: 120k]
  ------------------
   76|   191k|            }
_ZNK8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item9is_objectEv:
   79|   191k|            {
   80|   191k|                return type_ == msgpack_container_type::object;
   81|   191k|            }
_ZNK8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item6lengthEv:
   69|   191k|            {
   70|   191k|                return length_;
   71|   191k|            }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9end_valueEv:
  755|   968k|        {
  756|   968k|            if (!stack_.empty())
  ------------------
  |  Branch (756:17): [True: 967k, False: 856]
  ------------------
  757|   967k|            {
  758|   967k|                ++stack_.back().index_;
  759|   967k|            }
  760|   968k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  663|   262k|        {
  664|   262k|            switch (tag)
  665|   262k|            {
  666|  1.13k|                case semantic_tag::epoch_second:
  ------------------
  |  Branch (666:17): [True: 1.13k, False: 261k]
  ------------------
  667|  1.13k|                    write_timestamp(static_cast<int64_t>(val), 0);
  668|  1.13k|                    break;
  669|      0|                case semantic_tag::epoch_milli:
  ------------------
  |  Branch (669:17): [True: 0, False: 262k]
  ------------------
  670|      0|                {
  671|      0|                    if (val != 0)
  ------------------
  |  Branch (671:25): [True: 0, False: 0]
  ------------------
  672|      0|                    {
  673|      0|                        auto dv = std::div(static_cast<int64_t>(val), static_cast<int64_t>(millis_in_second));
  674|      0|                        int64_t seconds = dv.quot;
  675|      0|                        int64_t nanoseconds = dv.rem*nanos_in_milli;
  676|      0|                        if (nanoseconds < 0)
  ------------------
  |  Branch (676:29): [True: 0, False: 0]
  ------------------
  677|      0|                        {
  678|      0|                            nanoseconds = -nanoseconds; 
  679|      0|                        }
  680|      0|                        write_timestamp(seconds, nanoseconds);
  681|      0|                    }
  682|      0|                    else
  683|      0|                    {
  684|      0|                        write_timestamp(0, 0);
  685|      0|                    }
  686|      0|                    break;
  687|      0|                }
  688|      0|                case semantic_tag::epoch_nano:
  ------------------
  |  Branch (688:17): [True: 0, False: 262k]
  ------------------
  689|      0|                {
  690|      0|                    if (val != 0)
  ------------------
  |  Branch (690:25): [True: 0, False: 0]
  ------------------
  691|      0|                    {
  692|      0|                        auto dv = std::div(static_cast<int64_t>(val), static_cast<int64_t>(nanos_in_second));
  693|      0|                        int64_t seconds = dv.quot;
  694|      0|                        int64_t nanoseconds = dv.rem;
  695|      0|                        if (nanoseconds < 0)
  ------------------
  |  Branch (695:29): [True: 0, False: 0]
  ------------------
  696|      0|                        {
  697|      0|                            nanoseconds = -nanoseconds; 
  698|      0|                        }
  699|      0|                        write_timestamp(seconds, nanoseconds);
  700|      0|                    }
  701|      0|                    else
  702|      0|                    {
  703|      0|                        write_timestamp(0, 0);
  704|      0|                    }
  705|      0|                    break;
  706|      0|                }
  707|   261k|                default:
  ------------------
  |  Branch (707:17): [True: 261k, False: 1.13k]
  ------------------
  708|   261k|                {
  709|   261k|                    if (val <= static_cast<uint64_t>((std::numeric_limits<int8_t>::max)()))
  ------------------
  |  Branch (709:25): [True: 241k, False: 20.0k]
  ------------------
  710|   241k|                    {
  711|       |                        // positive fixnum stores 7-bit positive integer
  712|   241k|                        sink_.push_back(static_cast<uint8_t>(val));
  713|   241k|                    }
  714|  20.0k|                    else if (val <= (std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (714:30): [True: 14.0k, False: 6.00k]
  ------------------
  715|  14.0k|                    {
  716|       |                        // uint 8 stores a 8-bit unsigned integer
  717|  14.0k|                        sink_.push_back(jsoncons::msgpack::msgpack_type::uint8_type);
  718|  14.0k|                        sink_.push_back(static_cast<uint8_t>(val));
  719|  14.0k|                    }
  720|  6.00k|                    else if (val <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (720:30): [True: 748, False: 5.25k]
  ------------------
  721|    748|                    {
  722|       |                        // uint 16 stores a 16-bit big-endian unsigned integer
  723|    748|                        sink_.push_back(jsoncons::msgpack::msgpack_type::uint16_type);
  724|    748|                        binary::native_to_big(static_cast<uint16_t>(val),std::back_inserter(sink_));
  725|    748|                    }
  726|  5.25k|                    else if (val <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (726:30): [True: 3.91k, False: 1.34k]
  ------------------
  727|  3.91k|                    {
  728|       |                        // uint 32 stores a 32-bit big-endian unsigned integer
  729|  3.91k|                        sink_.push_back(jsoncons::msgpack::msgpack_type::uint32_type);
  730|  3.91k|                        binary::native_to_big(static_cast<uint32_t>(val),std::back_inserter(sink_));
  731|  3.91k|                    }
  732|  1.34k|                    else if (val <= (std::numeric_limits<uint64_t>::max)())
  ------------------
  |  Branch (732:30): [True: 1.34k, False: 0]
  ------------------
  733|  1.34k|                    {
  734|       |                        // uint 64 stores a 64-bit big-endian unsigned integer
  735|  1.34k|                        sink_.push_back(jsoncons::msgpack::msgpack_type::uint64_type);
  736|  1.34k|                        binary::native_to_big(static_cast<uint64_t>(val),std::back_inserter(sink_));
  737|  1.34k|                    }
  738|   261k|                    break;
  739|      0|                }
  740|   262k|            }
  741|   262k|            end_value();
  742|   262k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   262k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  743|   262k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE15write_timestampEll:
  268|  11.9k|        {
  269|  11.9k|            if ((seconds >> 34) == 0) 
  ------------------
  |  Branch (269:17): [True: 4.53k, False: 7.40k]
  ------------------
  270|  4.53k|            {
  271|  4.53k|                uint64_t data64 = (nanoseconds << 34) | seconds;
  272|  4.53k|                if ((data64 & 0xffffffff00000000L) == 0) 
  ------------------
  |  Branch (272:21): [True: 1.99k, False: 2.54k]
  ------------------
  273|  1.99k|                {
  274|       |                    // timestamp 32
  275|  1.99k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext4_type);
  276|  1.99k|                    sink_.push_back(0xff);
  277|  1.99k|                    binary::native_to_big(static_cast<uint32_t>(data64), std::back_inserter(sink_));
  278|  1.99k|                }
  279|  2.54k|                else 
  280|  2.54k|                {
  281|       |                    // timestamp 64
  282|  2.54k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext8_type);
  283|  2.54k|                    sink_.push_back(0xff);
  284|  2.54k|                    binary::native_to_big(static_cast<uint64_t>(data64), std::back_inserter(sink_));
  285|  2.54k|                }
  286|  4.53k|            }
  287|  7.40k|            else 
  288|  7.40k|            {
  289|       |                // timestamp 96
  290|  7.40k|                sink_.push_back(jsoncons::msgpack::msgpack_type::ext8_type);
  291|  7.40k|                sink_.push_back(0x0c); // 12
  292|  7.40k|                sink_.push_back(0xff);
  293|  7.40k|                binary::native_to_big(static_cast<uint32_t>(nanoseconds), std::back_inserter(sink_));
  294|  7.40k|                binary::native_to_big(static_cast<uint64_t>(seconds), std::back_inserter(sink_));
  295|  7.40k|            }
  296|  11.9k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  542|   126k|        {
  543|   126k|            switch (tag)
  544|   126k|            {
  545|      0|                case semantic_tag::epoch_second:
  ------------------
  |  Branch (545:17): [True: 0, False: 126k]
  ------------------
  546|      0|                    write_timestamp(val, 0);
  547|      0|                    break;
  548|      0|                case semantic_tag::epoch_milli:
  ------------------
  |  Branch (548:17): [True: 0, False: 126k]
  ------------------
  549|      0|                {
  550|      0|                    if (val != 0)
  ------------------
  |  Branch (550:25): [True: 0, False: 0]
  ------------------
  551|      0|                    {
  552|      0|                        auto dv = std::div(val,millis_in_second);
  553|      0|                        int64_t seconds = dv.quot;
  554|      0|                        int64_t nanoseconds = dv.rem*nanos_in_milli;
  555|      0|                        if (nanoseconds < 0)
  ------------------
  |  Branch (555:29): [True: 0, False: 0]
  ------------------
  556|      0|                        {
  557|      0|                            nanoseconds = -nanoseconds; 
  558|      0|                        }
  559|      0|                        write_timestamp(seconds, nanoseconds);
  560|      0|                    }
  561|      0|                    else
  562|      0|                    {
  563|      0|                        write_timestamp(0, 0);
  564|      0|                    }
  565|      0|                    break;
  566|      0|                }
  567|      0|                case semantic_tag::epoch_nano:
  ------------------
  |  Branch (567:17): [True: 0, False: 126k]
  ------------------
  568|      0|                {
  569|      0|                    if (val != 0)
  ------------------
  |  Branch (569:25): [True: 0, False: 0]
  ------------------
  570|      0|                    {
  571|      0|                        auto dv = std::div(val,static_cast<int64_t>(nanos_in_second));
  572|      0|                        int64_t seconds = dv.quot;
  573|      0|                        int64_t nanoseconds = dv.rem;
  574|      0|                        if (nanoseconds < 0)
  ------------------
  |  Branch (574:29): [True: 0, False: 0]
  ------------------
  575|      0|                        {
  576|      0|                            nanoseconds = -nanoseconds; 
  577|      0|                        }
  578|      0|                        write_timestamp(seconds, nanoseconds);
  579|      0|                    }
  580|      0|                    else
  581|      0|                    {
  582|      0|                        write_timestamp(0, 0);
  583|      0|                    }
  584|      0|                    break;
  585|      0|                }
  586|   126k|                default:
  ------------------
  |  Branch (586:17): [True: 126k, False: 0]
  ------------------
  587|   126k|                {
  588|   126k|                    if (val >= 0)
  ------------------
  |  Branch (588:25): [True: 8.38k, False: 118k]
  ------------------
  589|  8.38k|                    {
  590|  8.38k|                        if (val <= 0x7f)
  ------------------
  |  Branch (590:29): [True: 345, False: 8.03k]
  ------------------
  591|    345|                        {
  592|       |                            // positive fixnum stores 7-bit positive integer
  593|    345|                            sink_.push_back(static_cast<uint8_t>(val));
  594|    345|                        }
  595|  8.03k|                        else if (val <= (std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (595:34): [True: 638, False: 7.40k]
  ------------------
  596|    638|                        {
  597|       |                            // uint 8 stores a 8-bit unsigned integer
  598|    638|                            sink_.push_back(jsoncons::msgpack::msgpack_type::uint8_type);
  599|    638|                            sink_.push_back(static_cast<uint8_t>(val));
  600|    638|                        }
  601|  7.40k|                        else if (val <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (601:34): [True: 523, False: 6.87k]
  ------------------
  602|    523|                        {
  603|       |                            // uint 16 stores a 16-bit big-endian unsigned integer
  604|    523|                            sink_.push_back(jsoncons::msgpack::msgpack_type::uint16_type);
  605|    523|                            binary::native_to_big(static_cast<uint16_t>(val),std::back_inserter(sink_));
  606|    523|                        }
  607|  6.87k|                        else if (val <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (607:34): [True: 328, False: 6.55k]
  ------------------
  608|    328|                        {
  609|       |                            // uint 32 stores a 32-bit big-endian unsigned integer
  610|    328|                            sink_.push_back(jsoncons::msgpack::msgpack_type::uint32_type);
  611|    328|                            binary::native_to_big(static_cast<uint32_t>(val),std::back_inserter(sink_));
  612|    328|                        }
  613|  6.55k|                        else if (val <= (std::numeric_limits<int64_t>::max)())
  ------------------
  |  Branch (613:34): [True: 6.55k, False: 0]
  ------------------
  614|  6.55k|                        {
  615|       |                            // int 64 stores a 64-bit big-endian signed integer
  616|  6.55k|                            sink_.push_back(jsoncons::msgpack::msgpack_type::uint64_type);
  617|  6.55k|                            binary::native_to_big(static_cast<uint64_t>(val),std::back_inserter(sink_));
  618|  6.55k|                        }
  619|  8.38k|                    }
  620|   118k|                    else
  621|   118k|                    {
  622|   118k|                        if (val >= -32)
  ------------------
  |  Branch (622:29): [True: 62.9k, False: 55.1k]
  ------------------
  623|  62.9k|                        {
  624|       |                            // negative fixnum stores 5-bit negative integer
  625|  62.9k|                            binary::native_to_big(static_cast<int8_t>(val), std::back_inserter(sink_));
  626|  62.9k|                        }
  627|  55.1k|                        else if (val >= (std::numeric_limits<int8_t>::lowest)())
  ------------------
  |  Branch (627:34): [True: 34.4k, False: 20.7k]
  ------------------
  628|  34.4k|                        {
  629|       |                            // int 8 stores a 8-bit signed integer
  630|  34.4k|                            sink_.push_back(jsoncons::msgpack::msgpack_type::int8_type);
  631|  34.4k|                            binary::native_to_big(static_cast<int8_t>(val),std::back_inserter(sink_));
  632|  34.4k|                        }
  633|  20.7k|                        else if (val >= (std::numeric_limits<int16_t>::lowest)())
  ------------------
  |  Branch (633:34): [True: 12.4k, False: 8.27k]
  ------------------
  634|  12.4k|                        {
  635|       |                            // int 16 stores a 16-bit big-endian signed integer
  636|  12.4k|                            sink_.push_back(jsoncons::msgpack::msgpack_type::int16_type);
  637|  12.4k|                            binary::native_to_big(static_cast<int16_t>(val),std::back_inserter(sink_));
  638|  12.4k|                        }
  639|  8.27k|                        else if (val >= (std::numeric_limits<int32_t>::lowest)())
  ------------------
  |  Branch (639:34): [True: 6.12k, False: 2.15k]
  ------------------
  640|  6.12k|                        {
  641|       |                            // int 32 stores a 32-bit big-endian signed integer
  642|  6.12k|                            sink_.push_back(jsoncons::msgpack::msgpack_type::int32_type);
  643|  6.12k|                            binary::native_to_big(static_cast<int32_t>(val),std::back_inserter(sink_));
  644|  6.12k|                        }
  645|  2.15k|                        else if (val >= (std::numeric_limits<int64_t>::lowest)())
  ------------------
  |  Branch (645:34): [True: 2.15k, False: 0]
  ------------------
  646|  2.15k|                        {
  647|       |                            // int 64 stores a 64-bit big-endian signed integer
  648|  2.15k|                            sink_.push_back(jsoncons::msgpack::msgpack_type::int64_type);
  649|  2.15k|                            binary::native_to_big(static_cast<int64_t>(val),std::back_inserter(sink_));
  650|  2.15k|                        }
  651|   118k|                    }
  652|   126k|                }
  653|   126k|                break;
  654|   126k|            }
  655|   126k|            end_value();
  656|   126k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   126k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  657|   126k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  517|  6.87k|        {
  518|  6.87k|            float valf = (float)val;
  519|  6.87k|            if ((double)valf == val)
  ------------------
  |  Branch (519:17): [True: 4.51k, False: 2.35k]
  ------------------
  520|  4.51k|            {
  521|       |                // float 32
  522|  4.51k|                sink_.push_back(jsoncons::msgpack::msgpack_type::float32_type);
  523|  4.51k|                binary::native_to_big(valf,std::back_inserter(sink_));
  524|  4.51k|            }
  525|  2.35k|            else
  526|  2.35k|            {
  527|       |                // float 64
  528|  2.35k|                sink_.push_back(jsoncons::msgpack::msgpack_type::float64_type);
  529|  2.35k|                binary::native_to_big(val,std::back_inserter(sink_));
  530|  2.35k|            }
  531|       |
  532|       |            // write double
  533|       |
  534|  6.87k|            end_value();
  535|  6.87k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  6.87k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  536|  6.87k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE11visit_flushEv:
  134|  1.61k|        {
  135|  1.61k|            sink_.flush();
  136|  1.61k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  145|  44.0k|        {
  146|  44.0k|            if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|  44.0k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 44.0k]
  |  |  ------------------
  ------------------
  147|      0|            {
  148|      0|                ec = msgpack_errc::max_nesting_depth_exceeded;
  149|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  150|      0|            } 
  151|  44.0k|            stack_.emplace_back(msgpack_container_type::object, length);
  152|       |
  153|  44.0k|            if (length <= 15)
  ------------------
  |  Branch (153:17): [True: 41.4k, False: 2.56k]
  ------------------
  154|  41.4k|            {
  155|       |                // fixmap
  156|  41.4k|                sink_.push_back(jsoncons::msgpack::msgpack_type::fixmap_base_type | (length & 0xf));
  157|  41.4k|            }
  158|  2.56k|            else if (length <= 65535)
  ------------------
  |  Branch (158:22): [True: 1.74k, False: 823]
  ------------------
  159|  1.74k|            {
  160|       |                // map 16
  161|  1.74k|                sink_.push_back(jsoncons::msgpack::msgpack_type::map16_type);
  162|  1.74k|                binary::native_to_big(static_cast<uint16_t>(length), 
  163|  1.74k|                                      std::back_inserter(sink_));
  164|  1.74k|            }
  165|    823|            else if (length <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (165:22): [True: 823, False: 0]
  ------------------
  166|    823|            {
  167|       |                // map 32
  168|    823|                sink_.push_back(jsoncons::msgpack::msgpack_type::map32_type);
  169|    823|                binary::native_to_big(static_cast<uint32_t>(length),
  170|    823|                                      std::back_inserter(sink_));
  171|    823|            }
  172|       |
  173|  44.0k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  44.0k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  174|  44.0k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE16visit_end_objectERKNS_11ser_contextERNS3_10error_codeE:
  177|  35.5k|        {
  178|  35.5k|            JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   45|  35.5k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 35.5k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  179|  35.5k|            --nesting_depth_;
  180|       |
  181|  35.5k|            if (stack_.back().count() < stack_.back().length())
  ------------------
  |  Branch (181:17): [True: 426, False: 35.1k]
  ------------------
  182|    426|            {
  183|    426|                ec = msgpack_errc::too_few_items;
  184|    426|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    426|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  185|    426|            }
  186|  35.1k|            else if (stack_.back().count() > stack_.back().length())
  ------------------
  |  Branch (186:22): [True: 0, False: 35.1k]
  ------------------
  187|      0|            {
  188|      0|                ec = msgpack_errc::too_many_items;
  189|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  190|      0|            }
  191|       |
  192|  35.1k|            stack_.pop_back();
  193|  35.1k|            end_value();
  194|  35.1k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  35.1k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  195|  35.5k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9visit_keyERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKNS_11ser_contextERNS3_10error_codeE:
  254|   120k|        {
  255|   120k|            visit_string(name, semantic_tag::none, context, ec);
  256|   120k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   120k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  257|   120k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  260|  14.9k|        {
  261|       |            // nil
  262|  14.9k|            sink_.push_back(jsoncons::msgpack::msgpack_type::nil_type);
  263|  14.9k|            end_value();
  264|  14.9k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  14.9k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  265|  14.9k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  746|   225k|        {
  747|       |            // true and false
  748|   225k|            sink_.push_back(static_cast<uint8_t>(val ? jsoncons::msgpack::msgpack_type::true_type : jsoncons::msgpack::msgpack_type::false_type));
  ------------------
  |  Branch (748:50): [True: 2.59k, False: 222k]
  ------------------
  749|       |
  750|   225k|            end_value();
  751|   225k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   225k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  752|   225k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  299|   151k|        {
  300|   151k|            switch (tag)
  301|   151k|            {
  302|      0|                case semantic_tag::epoch_second:
  ------------------
  |  Branch (302:17): [True: 0, False: 151k]
  ------------------
  303|      0|                {
  304|      0|                    int64_t seconds;
  305|      0|                    auto result = jsoncons::to_integer(sv.data(), sv.length(), seconds);
  306|      0|                    if (!result)
  ------------------
  |  Branch (306:25): [True: 0, False: 0]
  ------------------
  307|      0|                    {
  308|      0|                        ec = msgpack_errc::invalid_timestamp;
  309|      0|                        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  310|      0|                    }
  311|      0|                    write_timestamp(seconds, 0);
  312|      0|                    break;
  313|      0|                }
  314|      0|                case semantic_tag::epoch_milli:
  ------------------
  |  Branch (314:17): [True: 0, False: 151k]
  ------------------
  315|      0|                {
  316|      0|                    bigint n;
  317|      0|                    auto result = to_bigint(sv.data(), sv.length(), n);
  318|      0|                    if (!result)
  ------------------
  |  Branch (318:25): [True: 0, False: 0]
  ------------------
  319|      0|                    {
  320|      0|                        ec = msgpack_errc::invalid_timestamp;
  321|      0|                        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  322|      0|                    }
  323|      0|                    if (n != 0)
  ------------------
  |  Branch (323:25): [True: 0, False: 0]
  ------------------
  324|      0|                    {
  325|      0|                        bigint q;
  326|      0|                        bigint rem;
  327|      0|                        n.divide(millis_in_second, q, rem, true);
  328|      0|                        auto seconds = static_cast<int64_t>(q);
  329|      0|                        auto nanoseconds = static_cast<int64_t>(rem) * nanos_in_milli;
  330|      0|                        if (nanoseconds < 0)
  ------------------
  |  Branch (330:29): [True: 0, False: 0]
  ------------------
  331|      0|                        {
  332|      0|                            nanoseconds = -nanoseconds; 
  333|      0|                        }
  334|      0|                        write_timestamp(seconds, nanoseconds);
  335|      0|                    }
  336|      0|                    else
  337|      0|                    {
  338|      0|                        write_timestamp(0, 0);
  339|      0|                    }
  340|      0|                    break;
  341|      0|                }
  342|  10.8k|                case semantic_tag::epoch_nano:
  ------------------
  |  Branch (342:17): [True: 10.8k, False: 140k]
  ------------------
  343|  10.8k|                {
  344|  10.8k|                    bigint n;
  345|  10.8k|                    auto result = to_bigint(sv.data(), sv.length(), n);
  346|  10.8k|                    if (!result)
  ------------------
  |  Branch (346:25): [True: 0, False: 10.8k]
  ------------------
  347|      0|                    {
  348|      0|                        ec = msgpack_errc::invalid_timestamp;
  349|      0|                        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  350|      0|                    }
  351|  10.8k|                    if (n != 0)
  ------------------
  |  Branch (351:25): [True: 9.99k, False: 822]
  ------------------
  352|  9.99k|                    {
  353|  9.99k|                        bigint q;
  354|  9.99k|                        bigint rem;
  355|  9.99k|                        n.divide(nanos_in_second, q, rem, true);
  356|  9.99k|                        auto seconds = static_cast<int64_t>(q);
  357|  9.99k|                        auto nanoseconds = static_cast<int64_t>(rem);
  358|  9.99k|                        if (nanoseconds < 0)
  ------------------
  |  Branch (358:29): [True: 4.51k, False: 5.48k]
  ------------------
  359|  4.51k|                        {
  360|  4.51k|                            nanoseconds = -nanoseconds; 
  361|  4.51k|                        }
  362|  9.99k|                        write_timestamp(seconds, nanoseconds);
  363|  9.99k|                    }
  364|    822|                    else
  365|    822|                    {
  366|    822|                        write_timestamp(0, 0);
  367|    822|                    }
  368|  10.8k|                    break;
  369|  10.8k|                }
  370|   140k|                default:
  ------------------
  |  Branch (370:17): [True: 140k, False: 10.8k]
  ------------------
  371|   140k|                {
  372|   140k|                    write_string_value(sv);
  373|   140k|                    end_value();
  374|   140k|                    break;
  375|  10.8k|                }
  376|   151k|            }
  377|   151k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|   151k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  378|   151k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18write_string_valueERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEE:
  381|   140k|        {
  382|   140k|            auto sink = unicode_traits::validate(sv.data(), sv.size());
  383|   140k|            if (sink.ec != unicode_traits::conv_errc())
  ------------------
  |  Branch (383:17): [True: 0, False: 140k]
  ------------------
  384|      0|            {
  385|      0|                JSONCONS_THROW(ser_error(msgpack_errc::invalid_utf8_text_string));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  386|      0|            }
  387|       |
  388|   140k|            const size_t length = sv.length();
  389|   140k|            if (length <= 31)
  ------------------
  |  Branch (389:17): [True: 137k, False: 3.09k]
  ------------------
  390|   137k|            {
  391|       |                // fixstr stores a byte array whose length is upto 31 bytes
  392|   137k|                sink_.push_back(jsoncons::msgpack::msgpack_type::fixstr_base_type | static_cast<uint8_t>(length));
  393|   137k|            }
  394|  3.09k|            else if (length <= (std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (394:22): [True: 1.91k, False: 1.17k]
  ------------------
  395|  1.91k|            {
  396|       |                // str 8 stores a byte array whose length is upto (2^8)-1 bytes
  397|  1.91k|                sink_.push_back(jsoncons::msgpack::msgpack_type::str8_type);
  398|  1.91k|                sink_.push_back(static_cast<uint8_t>(length));
  399|  1.91k|            }
  400|  1.17k|            else if (length <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (400:22): [True: 861, False: 317]
  ------------------
  401|    861|            {
  402|       |                // str 16 stores a byte array whose length is upto (2^16)-1 bytes
  403|    861|                sink_.push_back(jsoncons::msgpack::msgpack_type::str16_type);
  404|    861|                binary::native_to_big(static_cast<uint16_t>(length), std::back_inserter(sink_));
  405|    861|            }
  406|    317|            else if (length <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (406:22): [True: 317, False: 0]
  ------------------
  407|    317|            {
  408|       |                // str 32 stores a byte array whose length is upto (2^32)-1 bytes
  409|    317|                sink_.push_back(jsoncons::msgpack::msgpack_type::str32_type);
  410|    317|                binary::native_to_big(static_cast<uint32_t>(length),std::back_inserter(sink_));
  411|    317|            }
  412|       |
  413|   140k|            for (auto c : sv)
  ------------------
  |  Branch (413:25): [True: 75.9M, False: 140k]
  ------------------
  414|  75.9M|            {
  415|  75.9M|                sink_.push_back(c);
  416|  75.9M|            }
  417|   140k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  423|  2.29k|        {
  424|       |
  425|  2.29k|            const std::size_t length = b.size();
  426|  2.29k|            if (length <= (std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (426:17): [True: 1.79k, False: 504]
  ------------------
  427|  1.79k|            {
  428|       |                // bin 8 stores a byte array whose length is upto (2^8)-1 bytes
  429|  1.79k|                sink_.push_back(jsoncons::msgpack::msgpack_type::bin8_type);
  430|  1.79k|                sink_.push_back(static_cast<uint8_t>(length));
  431|  1.79k|            }
  432|    504|            else if (length <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (432:22): [True: 434, False: 70]
  ------------------
  433|    434|            {
  434|       |                // bin 16 stores a byte array whose length is upto (2^16)-1 bytes
  435|    434|                sink_.push_back(jsoncons::msgpack::msgpack_type::bin16_type);
  436|    434|                binary::native_to_big(static_cast<uint16_t>(length), std::back_inserter(sink_));
  437|    434|            }
  438|     70|            else if (length <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (438:22): [True: 70, False: 0]
  ------------------
  439|     70|            {
  440|       |                // bin 32 stores a byte array whose length is upto (2^32)-1 bytes
  441|     70|                sink_.push_back(jsoncons::msgpack::msgpack_type::bin32_type);
  442|     70|                binary::native_to_big(static_cast<uint32_t>(length),std::back_inserter(sink_));
  443|     70|            }
  444|       |
  445|  2.29k|            for (auto c : b)
  ------------------
  |  Branch (445:25): [True: 7.33M, False: 2.29k]
  ------------------
  446|  7.33M|            {
  447|  7.33M|                sink_.push_back(c);
  448|  7.33M|            }
  449|       |
  450|  2.29k|            end_value();
  451|  2.29k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  2.29k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  452|  2.29k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS3_10error_codeE:
  458|  94.1k|        {
  459|  94.1k|            const std::size_t length = b.size();
  460|  94.1k|            switch (length)
  461|  94.1k|            {
  462|  1.35k|                case 1:
  ------------------
  |  Branch (462:17): [True: 1.35k, False: 92.8k]
  ------------------
  463|  1.35k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext1_type);
  464|  1.35k|                    sink_.push_back(static_cast<uint8_t>(ext_tag));
  465|  1.35k|                    break;
  466|  84.4k|                case 2:
  ------------------
  |  Branch (466:17): [True: 84.4k, False: 9.73k]
  ------------------
  467|  84.4k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext2_type);
  468|  84.4k|                    sink_.push_back(static_cast<uint8_t>(ext_tag));
  469|  84.4k|                    break;
  470|  2.10k|                case 4:
  ------------------
  |  Branch (470:17): [True: 2.10k, False: 92.0k]
  ------------------
  471|  2.10k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext4_type);
  472|  2.10k|                    sink_.push_back(static_cast<uint8_t>(ext_tag));
  473|  2.10k|                    break;
  474|  1.38k|                case 8:
  ------------------
  |  Branch (474:17): [True: 1.38k, False: 92.7k]
  ------------------
  475|  1.38k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext8_type);
  476|  1.38k|                    sink_.push_back(static_cast<uint8_t>(ext_tag));
  477|  1.38k|                    break;
  478|  2.58k|                case 16:
  ------------------
  |  Branch (478:17): [True: 2.58k, False: 91.5k]
  ------------------
  479|  2.58k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext16_type);
  480|  2.58k|                    sink_.push_back(static_cast<uint8_t>(ext_tag));
  481|  2.58k|                    break;
  482|  2.29k|                default:
  ------------------
  |  Branch (482:17): [True: 2.29k, False: 91.8k]
  ------------------
  483|  2.29k|                    if (length <= (std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (483:25): [True: 1.71k, False: 580]
  ------------------
  484|  1.71k|                    {
  485|  1.71k|                        sink_.push_back(jsoncons::msgpack::msgpack_type::ext8_type);
  486|  1.71k|                        sink_.push_back(static_cast<uint8_t>(length));
  487|  1.71k|                        sink_.push_back(static_cast<uint8_t>(ext_tag));
  488|  1.71k|                    }
  489|    580|                    else if (length <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (489:30): [True: 517, False: 63]
  ------------------
  490|    517|                    {
  491|    517|                        sink_.push_back(jsoncons::msgpack::msgpack_type::ext16_type);
  492|    517|                        binary::native_to_big(static_cast<uint16_t>(length), std::back_inserter(sink_));
  493|    517|                        sink_.push_back(static_cast<uint8_t>(ext_tag));
  494|    517|                    }
  495|     63|                    else if (length <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (495:30): [True: 63, False: 0]
  ------------------
  496|     63|                    {
  497|     63|                        sink_.push_back(jsoncons::msgpack::msgpack_type::ext32_type);
  498|     63|                        binary::native_to_big(static_cast<uint32_t>(length),std::back_inserter(sink_));
  499|     63|                        sink_.push_back(static_cast<uint8_t>(ext_tag));
  500|     63|                    }
  501|  2.29k|                    break;
  502|  94.1k|            }
  503|       |
  504|  94.1k|            for (auto c : b)
  ------------------
  |  Branch (504:25): [True: 7.70M, False: 94.1k]
  ------------------
  505|  7.70M|            {
  506|  7.70M|                sink_.push_back(c);
  507|  7.70M|            }
  508|       |
  509|  94.1k|            end_value();
  510|  94.1k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  94.1k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  511|  94.1k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEED2Ev:
  111|  6.25k|        {
  112|  6.25k|            sink_.flush();
  113|  6.25k|        }

_ZN8jsoncons7msgpack15make_error_codeENS0_12msgpack_errcE:
   82|  5.54k|{
   83|  5.54k|    return std::error_code(static_cast<int>(e),msgpack_error_category());
   84|  5.54k|}
_ZN8jsoncons7msgpack22msgpack_error_categoryEv:
   75|  5.54k|{
   76|  5.54k|  static msgpack_error_category_impl instance;
   77|  5.54k|  return instance;
   78|  5.54k|}

_ZN8jsoncons7msgpack22msgpack_decode_optionsC1Ev:
   40|  6.25k|    msgpack_decode_options() = default;
_ZN8jsoncons7msgpack22msgpack_options_commonC2Ev:
   23|  12.5k|    msgpack_options_common() = default;
_ZN8jsoncons7msgpack22msgpack_options_commonD2Ev:
   26|  12.5k|    virtual ~msgpack_options_common() = default;
_ZN8jsoncons7msgpack22msgpack_encode_optionsC1Ev:
   50|  6.25k|    msgpack_encode_options() = default;
_ZNK8jsoncons7msgpack22msgpack_options_common17max_nesting_depthEv:
   31|  12.5k|    {
   32|  12.5k|        return max_nesting_depth_;
   33|  12.5k|    }

_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RKNS0_22msgpack_decode_optionsERKS7_:
   86|  6.25k|       : source_(std::forward<Sourceable>(source)),
   87|  6.25k|         max_nesting_depth_(options.max_nesting_depth()),
   88|  6.25k|         text_buffer_(alloc),
   89|  6.25k|         bytes_buffer_(alloc),
   90|  6.25k|         state_stack_(alloc)
   91|  6.25k|    {
   92|  6.25k|        state_stack_.emplace_back(parse_mode::root,0);
   93|  6.25k|    }
_ZN8jsoncons7msgpack11parse_stateC2ENS0_10parse_modeEm:
   46|   667k|        : mode(mode), length(length)
   47|   667k|    {
   48|   667k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5resetEv:
  101|  6.25k|    {
  102|  6.25k|        more_ = true;
  103|  6.25k|        done_ = false;
  104|  6.25k|        text_buffer_.clear();
  105|  6.25k|        bytes_buffer_.clear();
  106|  6.25k|        state_stack_.clear();
  107|  6.25k|        state_stack_.emplace_back(parse_mode::root,0);
  108|  6.25k|        nesting_depth_ = 0;
  109|  6.25k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
  159|  6.25k|    {
  160|  35.5M|        while (!done_ && more_)
  ------------------
  |  Branch (160:16): [True: 35.5M, False: 1.61k]
  |  Branch (160:26): [True: 35.5M, False: 0]
  ------------------
  161|  35.5M|        {
  162|  35.5M|            switch (state_stack_.back().mode)
  ------------------
  |  Branch (162:21): [True: 35.5M, False: 0]
  ------------------
  163|  35.5M|            {
  164|  23.9M|                case parse_mode::array:
  ------------------
  |  Branch (164:17): [True: 23.9M, False: 11.5M]
  ------------------
  165|  23.9M|                {
  166|  23.9M|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (166:25): [True: 23.6M, False: 306k]
  ------------------
  167|  23.6M|                    {
  168|  23.6M|                        ++state_stack_.back().index;
  169|  23.6M|                        read_item(visitor, ec);
  170|  23.6M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  23.6M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.55k, False: 23.6M]
  |  |  ------------------
  ------------------
  171|  1.55k|                        {
  172|  1.55k|                            return;
  173|  1.55k|                        }
  174|  23.6M|                    }
  175|   306k|                    else
  176|   306k|                    {
  177|   306k|                        end_array(visitor, ec);
  178|   306k|                    }
  179|  23.9M|                    break;
  180|  23.9M|                }
  181|  23.9M|                case parse_mode::map_key:
  ------------------
  |  Branch (181:17): [True: 5.92M, False: 29.6M]
  ------------------
  182|  5.92M|                {
  183|  5.92M|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (183:25): [True: 5.62M, False: 302k]
  ------------------
  184|  5.62M|                    {
  185|  5.62M|                        ++state_stack_.back().index;
  186|  5.62M|                        state_stack_.back().mode = parse_mode::map_value;
  187|  5.62M|                        read_item(visitor, ec);
  188|  5.62M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  5.62M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 831, False: 5.62M]
  |  |  ------------------
  ------------------
  189|    831|                        {
  190|    831|                            return;
  191|    831|                        }
  192|  5.62M|                    }
  193|   302k|                    else
  194|   302k|                    {
  195|   302k|                        end_object(visitor, ec);
  196|   302k|                    }
  197|  5.92M|                    break;
  198|  5.92M|                }
  199|  5.92M|                case parse_mode::map_value:
  ------------------
  |  Branch (199:17): [True: 5.61M, False: 29.9M]
  ------------------
  200|  5.61M|                {
  201|  5.61M|                    state_stack_.back().mode = parse_mode::map_key;
  202|  5.61M|                    read_item(visitor, ec);
  203|  5.61M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  5.61M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.86k, False: 5.61M]
  |  |  ------------------
  ------------------
  204|  1.86k|                    {
  205|  1.86k|                        return;
  206|  1.86k|                    }
  207|  5.61M|                    break;
  208|  5.61M|                }
  209|  5.61M|                case parse_mode::root:
  ------------------
  |  Branch (209:17): [True: 6.25k, False: 35.5M]
  ------------------
  210|  6.25k|                {
  211|  6.25k|                    state_stack_.back().mode = parse_mode::accept;
  212|  6.25k|                    read_item(visitor, ec);
  213|  6.25k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  6.25k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 381, False: 5.87k]
  |  |  ------------------
  ------------------
  214|    381|                    {
  215|    381|                        return;
  216|    381|                    }
  217|  5.87k|                    break;
  218|  6.25k|                }
  219|  5.87k|                case parse_mode::accept:
  ------------------
  |  Branch (219:17): [True: 1.61k, False: 35.5M]
  ------------------
  220|  1.61k|                {
  221|  1.61k|                    JSONCONS_ASSERT(state_stack_.size() == 1);
  ------------------
  |  |   45|  1.61k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 1.61k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  222|  1.61k|                    state_stack_.clear();
  223|  1.61k|                    more_ = false;
  224|  1.61k|                    done_ = true;
  225|  1.61k|                    visitor.flush();
  226|  1.61k|                    break;
  227|  1.61k|                }
  228|  35.5M|            }
  229|  35.5M|        }
  230|  6.25k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_itemERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
  234|  34.9M|    {
  235|  34.9M|        if (source_.is_error())
  ------------------
  |  Branch (235:13): [True: 0, False: 34.9M]
  ------------------
  236|      0|        {
  237|      0|            ec = msgpack_errc::source_error;
  238|      0|            more_ = false;
  239|      0|            return;
  240|      0|        }   
  241|       |
  242|  34.9M|        uint8_t type;
  243|  34.9M|        if (source_.read(&type, 1) == 0)
  ------------------
  |  Branch (243:13): [True: 3.75k, False: 34.9M]
  ------------------
  244|  3.75k|        {
  245|  3.75k|            ec = msgpack_errc::unexpected_eof;
  246|  3.75k|            more_ = false;
  247|  3.75k|            return;
  248|  3.75k|        }
  249|       |
  250|  34.9M|        if (type <= 0xbf)
  ------------------
  |  Branch (250:13): [True: 13.9M, False: 20.9M]
  ------------------
  251|  13.9M|        {
  252|  13.9M|            if (type <= 0x7f) 
  ------------------
  |  Branch (252:17): [True: 13.0M, False: 834k]
  ------------------
  253|  13.0M|            {
  254|       |                // positive fixint
  255|  13.0M|                visitor.uint64_value(type, semantic_tag::none, *this, ec);
  256|  13.0M|                more_ = !cursor_mode_;
  257|  13.0M|            }
  258|   834k|            else if (type <= 0x8f) 
  ------------------
  |  Branch (258:22): [True: 319k, False: 515k]
  ------------------
  259|   319k|            {
  260|   319k|                begin_object(visitor,type,ec); // fixmap
  261|   319k|            }
  262|   515k|            else if (type <= 0x9f) 
  ------------------
  |  Branch (262:22): [True: 325k, False: 189k]
  ------------------
  263|   325k|            {
  264|   325k|                begin_array(visitor,type,ec); // fixarray
  265|   325k|            }
  266|   189k|            else 
  267|   189k|            {
  268|       |                // fixstr
  269|   189k|                const size_t len = type & 0x1f;
  270|       |
  271|   189k|                text_buffer_.clear();
  272|       |
  273|   189k|                if (source_reader<Source>::read(source_,text_buffer_,len) != static_cast<std::size_t>(len))
  ------------------
  |  Branch (273:21): [True: 29, False: 189k]
  ------------------
  274|     29|                {
  275|     29|                    ec = msgpack_errc::unexpected_eof;
  276|     29|                    more_ = false;
  277|     29|                    return;
  278|     29|                }
  279|       |
  280|   189k|                auto result = unicode_traits::validate(text_buffer_.data(),text_buffer_.size());
  281|   189k|                if (result.ec != unicode_traits::conv_errc())
  ------------------
  |  Branch (281:21): [True: 94, False: 189k]
  ------------------
  282|     94|                {
  283|     94|                    ec = msgpack_errc::invalid_utf8_text_string;
  284|     94|                    more_ = false;
  285|     94|                    return;
  286|     94|                }
  287|   189k|                visitor.string_value(jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()), semantic_tag::none, *this, ec);
  288|   189k|                more_ = !cursor_mode_;
  289|   189k|            }
  290|  13.9M|        }
  291|  20.9M|        else if (type >= 0xe0) 
  ------------------
  |  Branch (291:18): [True: 1.95M, False: 19.0M]
  ------------------
  292|  1.95M|        {
  293|       |            // negative fixint
  294|  1.95M|            visitor.int64_value(static_cast<int8_t>(type), semantic_tag::none, *this, ec);
  295|  1.95M|            more_ = !cursor_mode_;
  296|  1.95M|        }
  297|  19.0M|        else
  298|  19.0M|        {
  299|  19.0M|            switch (type)
  300|  19.0M|            {
  301|   137k|                case jsoncons::msgpack::msgpack_type::nil_type: 
  ------------------
  |  Branch (301:17): [True: 137k, False: 18.9M]
  ------------------
  302|   137k|                {
  303|   137k|                    visitor.null_value(semantic_tag::none, *this, ec);
  304|   137k|                    more_ = !cursor_mode_;
  305|   137k|                    break;
  306|      0|                }
  307|  81.2k|                case jsoncons::msgpack::msgpack_type::true_type:
  ------------------
  |  Branch (307:17): [True: 81.2k, False: 18.9M]
  ------------------
  308|  81.2k|                {
  309|  81.2k|                    visitor.bool_value(true, semantic_tag::none, *this, ec);
  310|  81.2k|                    more_ = !cursor_mode_;
  311|  81.2k|                    break;
  312|      0|                }
  313|  18.4M|                case jsoncons::msgpack::msgpack_type::false_type:
  ------------------
  |  Branch (313:17): [True: 18.4M, False: 638k]
  ------------------
  314|  18.4M|                {
  315|  18.4M|                    visitor.bool_value(false, semantic_tag::none, *this, ec);
  316|  18.4M|                    more_ = !cursor_mode_;
  317|  18.4M|                    break;
  318|      0|                }
  319|  30.9k|                case jsoncons::msgpack::msgpack_type::float32_type: 
  ------------------
  |  Branch (319:17): [True: 30.9k, False: 19.0M]
  ------------------
  320|  30.9k|                {
  321|  30.9k|                    uint8_t buf[sizeof(float)];
  322|  30.9k|                    if (source_.read(buf, sizeof(float)) != sizeof(float))
  ------------------
  |  Branch (322:25): [True: 12, False: 30.9k]
  ------------------
  323|     12|                    {
  324|     12|                        ec = msgpack_errc::unexpected_eof;
  325|     12|                        more_ = false;
  326|     12|                        return;
  327|     12|                    }
  328|  30.9k|                    float val = binary::big_to_native<float>(buf, sizeof(buf));
  329|  30.9k|                    visitor.double_value(val, semantic_tag::none, *this, ec);
  330|  30.9k|                    more_ = !cursor_mode_;
  331|  30.9k|                    break;
  332|  30.9k|                }
  333|       |
  334|  8.38k|                case jsoncons::msgpack::msgpack_type::float64_type: 
  ------------------
  |  Branch (334:17): [True: 8.38k, False: 19.0M]
  ------------------
  335|  8.38k|                {
  336|  8.38k|                    uint8_t buf[sizeof(double)];
  337|  8.38k|                    if (source_.read(buf, sizeof(double)) != sizeof(double))
  ------------------
  |  Branch (337:25): [True: 14, False: 8.37k]
  ------------------
  338|     14|                    {
  339|     14|                        ec = msgpack_errc::unexpected_eof;
  340|     14|                        more_ = false;
  341|     14|                        return;
  342|     14|                    }
  343|  8.37k|                    double val = binary::big_to_native<double>(buf, sizeof(buf));
  344|  8.37k|                    visitor.double_value(val, semantic_tag::none, *this, ec);
  345|  8.37k|                    more_ = !cursor_mode_;
  346|  8.37k|                    break;
  347|  8.38k|                }
  348|       |
  349|  29.5k|                case jsoncons::msgpack::msgpack_type::uint8_type: 
  ------------------
  |  Branch (349:17): [True: 29.5k, False: 19.0M]
  ------------------
  350|  29.5k|                {
  351|  29.5k|                    uint8_t b;
  352|  29.5k|                    if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (352:25): [True: 1, False: 29.5k]
  ------------------
  353|      1|                    {
  354|      1|                        ec = msgpack_errc::unexpected_eof;
  355|      1|                        more_ = false;
  356|      1|                        return;
  357|      1|                    }
  358|  29.5k|                    visitor.uint64_value(b, semantic_tag::none, *this, ec);
  359|  29.5k|                    more_ = !cursor_mode_;
  360|  29.5k|                    break;
  361|  29.5k|                }
  362|       |
  363|  1.25k|                case jsoncons::msgpack::msgpack_type::uint16_type: 
  ------------------
  |  Branch (363:17): [True: 1.25k, False: 19.0M]
  ------------------
  364|  1.25k|                {
  365|  1.25k|                    uint8_t buf[sizeof(uint16_t)];
  366|  1.25k|                    if (source_.read(buf, sizeof(uint16_t)) !=sizeof(uint16_t)) 
  ------------------
  |  Branch (366:25): [True: 6, False: 1.24k]
  ------------------
  367|      6|                    {
  368|      6|                        ec = msgpack_errc::unexpected_eof;
  369|      6|                        more_ = false;
  370|      6|                        return;
  371|      6|                    }
  372|  1.24k|                    uint16_t val = binary::big_to_native<uint16_t>(buf, sizeof(buf));
  373|  1.24k|                    visitor.uint64_value(val, semantic_tag::none, *this, ec);
  374|  1.24k|                    more_ = !cursor_mode_;
  375|  1.24k|                    break;
  376|  1.25k|                }
  377|       |
  378|  9.56k|                case jsoncons::msgpack::msgpack_type::uint32_type: 
  ------------------
  |  Branch (378:17): [True: 9.56k, False: 19.0M]
  ------------------
  379|  9.56k|                {
  380|  9.56k|                    uint8_t buf[sizeof(uint32_t)];
  381|  9.56k|                    if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (381:25): [True: 5, False: 9.55k]
  ------------------
  382|      5|                    {
  383|      5|                        ec = msgpack_errc::unexpected_eof;
  384|      5|                        more_ = false;
  385|      5|                        return;
  386|      5|                    }
  387|  9.55k|                    uint32_t val = binary::big_to_native<uint32_t>(buf, sizeof(buf));
  388|  9.55k|                    visitor.uint64_value(val, semantic_tag::none, *this, ec);
  389|  9.55k|                    more_ = !cursor_mode_;
  390|  9.55k|                    break;
  391|  9.56k|                }
  392|       |
  393|  3.29k|                case jsoncons::msgpack::msgpack_type::uint64_type: 
  ------------------
  |  Branch (393:17): [True: 3.29k, False: 19.0M]
  ------------------
  394|  3.29k|                {
  395|  3.29k|                    uint8_t buf[sizeof(uint64_t)];
  396|  3.29k|                    if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (396:25): [True: 8, False: 3.28k]
  ------------------
  397|      8|                    {
  398|      8|                        ec = msgpack_errc::unexpected_eof;
  399|      8|                        more_ = false;
  400|      8|                        return;
  401|      8|                    }
  402|  3.28k|                    uint64_t val = binary::big_to_native<uint64_t>(buf, sizeof(buf));
  403|  3.28k|                    visitor.uint64_value(val, semantic_tag::none, *this, ec);
  404|  3.28k|                    more_ = !cursor_mode_;
  405|  3.28k|                    break;
  406|  3.29k|                }
  407|       |
  408|  63.8k|                case jsoncons::msgpack::msgpack_type::int8_type: 
  ------------------
  |  Branch (408:17): [True: 63.8k, False: 18.9M]
  ------------------
  409|  63.8k|                {
  410|  63.8k|                    uint8_t buf[sizeof(int8_t)];
  411|  63.8k|                    if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (411:25): [True: 4, False: 63.8k]
  ------------------
  412|      4|                    {
  413|      4|                        ec = msgpack_errc::unexpected_eof;
  414|      4|                        more_ = false;
  415|      4|                        return;
  416|      4|                    }
  417|  63.8k|                    int8_t val = binary::big_to_native<int8_t>(buf, sizeof(buf));
  418|  63.8k|                    visitor.int64_value(val, semantic_tag::none, *this, ec);
  419|  63.8k|                    more_ = !cursor_mode_;
  420|  63.8k|                    break;
  421|  63.8k|                }
  422|       |
  423|  20.2k|                case jsoncons::msgpack::msgpack_type::int16_type: 
  ------------------
  |  Branch (423:17): [True: 20.2k, False: 19.0M]
  ------------------
  424|  20.2k|                {
  425|  20.2k|                    uint8_t buf[sizeof(int16_t)];
  426|  20.2k|                    if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t))
  ------------------
  |  Branch (426:25): [True: 5, False: 20.1k]
  ------------------
  427|      5|                    {
  428|      5|                        ec = msgpack_errc::unexpected_eof;
  429|      5|                        more_ = false;
  430|      5|                        return;
  431|      5|                    }
  432|  20.1k|                    int16_t val = binary::big_to_native<int16_t>(buf, sizeof(buf));
  433|  20.1k|                    visitor.int64_value(val, semantic_tag::none, *this, ec);
  434|  20.1k|                    more_ = !cursor_mode_;
  435|  20.1k|                    break;
  436|  20.2k|                }
  437|       |
  438|  13.0k|                case jsoncons::msgpack::msgpack_type::int32_type: 
  ------------------
  |  Branch (438:17): [True: 13.0k, False: 19.0M]
  ------------------
  439|  13.0k|                {
  440|  13.0k|                    uint8_t buf[sizeof(int32_t)];
  441|  13.0k|                    if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t))
  ------------------
  |  Branch (441:25): [True: 5, False: 12.9k]
  ------------------
  442|      5|                    {
  443|      5|                        ec = msgpack_errc::unexpected_eof;
  444|      5|                        more_ = false;
  445|      5|                        return;
  446|      5|                    }
  447|  12.9k|                    int32_t val = binary::big_to_native<int32_t>(buf, sizeof(buf));
  448|  12.9k|                    visitor.int64_value(val, semantic_tag::none, *this, ec);
  449|  12.9k|                    more_ = !cursor_mode_;
  450|  12.9k|                    break;
  451|  13.0k|                }
  452|       |
  453|  16.3k|                case jsoncons::msgpack::msgpack_type::int64_type: 
  ------------------
  |  Branch (453:17): [True: 16.3k, False: 19.0M]
  ------------------
  454|  16.3k|                {
  455|  16.3k|                    uint8_t buf[sizeof(int64_t)];
  456|  16.3k|                    if (source_.read(buf, sizeof(int64_t)) != sizeof(int64_t))
  ------------------
  |  Branch (456:25): [True: 16, False: 16.3k]
  ------------------
  457|     16|                    {
  458|     16|                        ec = msgpack_errc::unexpected_eof;
  459|     16|                        more_ = false;
  460|     16|                        return;
  461|     16|                    }
  462|  16.3k|                    int64_t val = binary::big_to_native<int64_t>(buf, sizeof(buf));
  463|  16.3k|                    visitor.int64_value(val, semantic_tag::none, *this, ec);
  464|  16.3k|                    more_ = !cursor_mode_;
  465|  16.3k|                    break;
  466|  16.3k|                }
  467|       |
  468|    849|                case jsoncons::msgpack::msgpack_type::str8_type: 
  ------------------
  |  Branch (468:17): [True: 849, False: 19.0M]
  ------------------
  469|  1.17k|                case jsoncons::msgpack::msgpack_type::str16_type: 
  ------------------
  |  Branch (469:17): [True: 329, False: 19.0M]
  ------------------
  470|  1.87k|                case jsoncons::msgpack::msgpack_type::str32_type: 
  ------------------
  |  Branch (470:17): [True: 692, False: 19.0M]
  ------------------
  471|  1.87k|                {
  472|  1.87k|                    std::size_t len = get_size(type, ec);
  473|  1.87k|                    if (!more_)
  ------------------
  |  Branch (473:25): [True: 28, False: 1.84k]
  ------------------
  474|     28|                    {
  475|     28|                        return;
  476|     28|                    }
  477|       |
  478|  1.84k|                    text_buffer_.clear();
  479|  1.84k|                    if (source_reader<Source>::read(source_,text_buffer_,len) != static_cast<std::size_t>(len))
  ------------------
  |  Branch (479:25): [True: 111, False: 1.73k]
  ------------------
  480|    111|                    {
  481|    111|                        ec = msgpack_errc::unexpected_eof;
  482|    111|                        more_ = false;
  483|    111|                        return;
  484|    111|                    }
  485|       |
  486|  1.73k|                    auto result = unicode_traits::validate(text_buffer_.data(),text_buffer_.size());
  487|  1.73k|                    if (result.ec != unicode_traits::conv_errc())
  ------------------
  |  Branch (487:25): [True: 14, False: 1.71k]
  ------------------
  488|     14|                    {
  489|     14|                        ec = msgpack_errc::invalid_utf8_text_string;
  490|     14|                        more_ = false;
  491|     14|                        return;
  492|     14|                    }
  493|  1.71k|                    visitor.string_value(jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()), semantic_tag::none, *this, ec);
  494|  1.71k|                    more_ = !cursor_mode_;
  495|  1.71k|                    break;
  496|  1.73k|                }
  497|       |
  498|  16.4k|                case jsoncons::msgpack::msgpack_type::bin8_type: 
  ------------------
  |  Branch (498:17): [True: 16.4k, False: 19.0M]
  ------------------
  499|  17.3k|                case jsoncons::msgpack::msgpack_type::bin16_type: 
  ------------------
  |  Branch (499:17): [True: 891, False: 19.0M]
  ------------------
  500|  17.6k|                case jsoncons::msgpack::msgpack_type::bin32_type: 
  ------------------
  |  Branch (500:17): [True: 365, False: 19.0M]
  ------------------
  501|  17.6k|                {
  502|  17.6k|                    std::size_t len = get_size(type,ec);
  503|  17.6k|                    if (!more_)
  ------------------
  |  Branch (503:25): [True: 23, False: 17.6k]
  ------------------
  504|     23|                    {
  505|     23|                        return;
  506|     23|                    }
  507|  17.6k|                    bytes_buffer_.clear();
  508|  17.6k|                    if (source_reader<Source>::read(source_,bytes_buffer_,len) != static_cast<std::size_t>(len))
  ------------------
  |  Branch (508:25): [True: 163, False: 17.4k]
  ------------------
  509|    163|                    {
  510|    163|                        ec = msgpack_errc::unexpected_eof;
  511|    163|                        more_ = false;
  512|    163|                        return;
  513|    163|                    }
  514|       |
  515|  17.4k|                    visitor.byte_string_value(byte_string_view(bytes_buffer_.data(),bytes_buffer_.size()), 
  516|  17.4k|                                                      semantic_tag::none, 
  517|  17.4k|                                                      *this,
  518|  17.4k|                                                      ec);
  519|  17.4k|                    more_ = !cursor_mode_;
  520|  17.4k|                    break;
  521|  17.6k|                }
  522|  6.35k|                case jsoncons::msgpack::msgpack_type::fixext1_type: 
  ------------------
  |  Branch (522:17): [True: 6.35k, False: 19.0M]
  ------------------
  523|   111k|                case jsoncons::msgpack::msgpack_type::fixext2_type: 
  ------------------
  |  Branch (523:17): [True: 105k, False: 18.9M]
  ------------------
  524|   115k|                case jsoncons::msgpack::msgpack_type::fixext4_type: 
  ------------------
  |  Branch (524:17): [True: 3.76k, False: 19.0M]
  ------------------
  525|   170k|                case jsoncons::msgpack::msgpack_type::fixext8_type: 
  ------------------
  |  Branch (525:17): [True: 55.0k, False: 18.9M]
  ------------------
  526|   178k|                case jsoncons::msgpack::msgpack_type::fixext16_type: 
  ------------------
  |  Branch (526:17): [True: 8.28k, False: 19.0M]
  ------------------
  527|   191k|                case jsoncons::msgpack::msgpack_type::ext8_type: 
  ------------------
  |  Branch (527:17): [True: 12.9k, False: 19.0M]
  ------------------
  528|   192k|                case jsoncons::msgpack::msgpack_type::ext16_type: 
  ------------------
  |  Branch (528:17): [True: 483, False: 19.0M]
  ------------------
  529|   193k|                case jsoncons::msgpack::msgpack_type::ext32_type: 
  ------------------
  |  Branch (529:17): [True: 1.04k, False: 19.0M]
  ------------------
  530|   193k|                {
  531|   193k|                    std::size_t len = get_size(type,ec);
  532|   193k|                    if (!more_)
  ------------------
  |  Branch (532:25): [True: 25, False: 193k]
  ------------------
  533|     25|                    {
  534|     25|                        return;
  535|     25|                    }
  536|       |
  537|       |                    // type
  538|   193k|                    uint8_t buf[sizeof(int8_t)];
  539|   193k|                    if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (539:25): [True: 50, False: 193k]
  ------------------
  540|     50|                    {
  541|     50|                        ec = msgpack_errc::unexpected_eof;
  542|     50|                        more_ = false;
  543|     50|                        return;
  544|     50|                    }
  545|       |
  546|   193k|                    int8_t ext_type = binary::big_to_native<int8_t>(buf, sizeof(buf));
  547|       |
  548|   193k|                    bool is_timestamp = false; 
  549|   193k|                    if (ext_type == -1)
  ------------------
  |  Branch (549:25): [True: 64.7k, False: 128k]
  ------------------
  550|  64.7k|                    {
  551|  64.7k|                        is_timestamp = true;;
  552|  64.7k|                    }
  553|       |
  554|       |                    // payload
  555|   193k|                    if (is_timestamp && len == 4)
  ------------------
  |  Branch (555:25): [True: 64.7k, False: 128k]
  |  Branch (555:41): [True: 1.40k, False: 63.3k]
  ------------------
  556|  1.40k|                    {
  557|  1.40k|                        uint8_t buf32[sizeof(uint32_t)];
  558|  1.40k|                        if (source_.read(buf32, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (558:29): [True: 3, False: 1.39k]
  ------------------
  559|      3|                        {
  560|      3|                            ec = msgpack_errc::unexpected_eof;
  561|      3|                            more_ = false;
  562|      3|                            return;
  563|      3|                        }
  564|  1.39k|                        uint32_t val = binary::big_to_native<uint32_t>(buf32, sizeof(buf32));
  565|  1.39k|                        visitor.uint64_value(val, semantic_tag::epoch_second, *this, ec);
  566|  1.39k|                        more_ = !cursor_mode_;
  567|  1.39k|                    }
  568|   192k|                    else if (is_timestamp && len == 8)
  ------------------
  |  Branch (568:30): [True: 63.3k, False: 128k]
  |  Branch (568:46): [True: 52.0k, False: 11.3k]
  ------------------
  569|  52.0k|                    {
  570|  52.0k|                        uint8_t buf64[sizeof(uint64_t)];
  571|  52.0k|                        if (source_.read(buf64, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (571:29): [True: 11, False: 52.0k]
  ------------------
  572|     11|                        {
  573|     11|                            ec = msgpack_errc::unexpected_eof;
  574|     11|                            more_ = false;
  575|     11|                            return;
  576|     11|                        }
  577|  52.0k|                        uint64_t data64 = binary::big_to_native<uint64_t>(buf64, sizeof(buf64));
  578|  52.0k|                        uint64_t sec = data64 & 0x00000003ffffffffL;
  579|  52.0k|                        uint64_t nsec = data64 >> 34;
  580|       |
  581|  52.0k|                        bigint nano(sec);
  582|  52.0k|                        nano *= uint64_t(nanos_in_second);
  583|  52.0k|                        nano += nsec;
  584|  52.0k|                        text_buffer_.clear();
  585|  52.0k|                        nano.write_string(text_buffer_);
  586|  52.0k|                        visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);
  587|  52.0k|                        more_ = !cursor_mode_;
  588|  52.0k|                        if (!more_) return;
  ------------------
  |  Branch (588:29): [True: 0, False: 52.0k]
  ------------------
  589|  52.0k|                    }
  590|   139k|                    else if (is_timestamp && len == 12)
  ------------------
  |  Branch (590:30): [True: 11.3k, False: 128k]
  |  Branch (590:46): [True: 10.4k, False: 945]
  ------------------
  591|  10.4k|                    {
  592|  10.4k|                        uint8_t buf1[sizeof(uint32_t)];
  593|  10.4k|                        if (source_.read(buf1, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (593:29): [True: 5, False: 10.4k]
  ------------------
  594|      5|                        {
  595|      5|                            ec = msgpack_errc::unexpected_eof;
  596|      5|                            more_ = false;
  597|      5|                            return;
  598|      5|                        }
  599|  10.4k|                        uint32_t nsec = binary::big_to_native<uint32_t>(buf1, sizeof(buf1));
  600|       |
  601|  10.4k|                        uint8_t buf2[sizeof(int64_t)];
  602|  10.4k|                        if (source_.read(buf2, sizeof(int64_t)) != sizeof(int64_t))
  ------------------
  |  Branch (602:29): [True: 11, False: 10.4k]
  ------------------
  603|     11|                        {
  604|     11|                            ec = msgpack_errc::unexpected_eof;
  605|     11|                            more_ = false;
  606|     11|                            return;
  607|     11|                        }
  608|  10.4k|                        int64_t sec = binary::big_to_native<int64_t>(buf2, sizeof(buf2));
  609|       |
  610|  10.4k|                        bigint nano(sec);
  611|       |
  612|  10.4k|                        nano *= uint64_t(nanos_in_second);
  613|       |
  614|  10.4k|                        if (nano < 0)
  ------------------
  |  Branch (614:29): [True: 7.34k, False: 3.05k]
  ------------------
  615|  7.34k|                        {
  616|  7.34k|                            nano -= nsec;
  617|  7.34k|                        }
  618|  3.05k|                        else
  619|  3.05k|                        {
  620|  3.05k|                            nano += nsec;
  621|  3.05k|                        }
  622|       |
  623|  10.4k|                        text_buffer_.clear();
  624|  10.4k|                        nano.write_string(text_buffer_);
  625|  10.4k|                        visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);
  626|  10.4k|                        more_ = !cursor_mode_;
  627|  10.4k|                        if (!more_) return;
  ------------------
  |  Branch (627:29): [True: 0, False: 10.4k]
  ------------------
  628|  10.4k|                    }
  629|   129k|                    else
  630|   129k|                    {
  631|   129k|                        bytes_buffer_.clear();
  632|   129k|                        if (source_reader<Source>::read(source_,bytes_buffer_,len) != static_cast<std::size_t>(len))
  ------------------
  |  Branch (632:29): [True: 175, False: 129k]
  ------------------
  633|    175|                        {
  634|    175|                            ec = msgpack_errc::unexpected_eof;
  635|    175|                            more_ = false;
  636|    175|                            return;
  637|    175|                        }
  638|       |
  639|   129k|                        visitor.byte_string_value(byte_string_view(bytes_buffer_.data(),bytes_buffer_.size()), 
  640|   129k|                                                          static_cast<uint8_t>(ext_type), 
  641|   129k|                                                          *this,
  642|   129k|                                                          ec);
  643|   129k|                        more_ = !cursor_mode_;
  644|   129k|                    }
  645|   193k|                    break;
  646|   193k|                }
  647|       |
  648|   193k|                case jsoncons::msgpack::msgpack_type::array16_type: 
  ------------------
  |  Branch (648:17): [True: 3.98k, False: 19.0M]
  ------------------
  649|  6.69k|                case jsoncons::msgpack::msgpack_type::array32_type: 
  ------------------
  |  Branch (649:17): [True: 2.70k, False: 19.0M]
  ------------------
  650|  6.69k|                {
  651|  6.69k|                    begin_array(visitor,type,ec);
  652|  6.69k|                    break;
  653|  3.98k|                }
  654|       |
  655|  2.19k|                case jsoncons::msgpack::msgpack_type::map16_type : 
  ------------------
  |  Branch (655:17): [True: 2.19k, False: 19.0M]
  ------------------
  656|  3.57k|                case jsoncons::msgpack::msgpack_type::map32_type : 
  ------------------
  |  Branch (656:17): [True: 1.38k, False: 19.0M]
  ------------------
  657|  3.57k|                {
  658|  3.57k|                    begin_object(visitor, type, ec);
  659|  3.57k|                    break;
  660|  2.19k|                }
  661|       |
  662|     12|                default:
  ------------------
  |  Branch (662:17): [True: 12, False: 19.0M]
  ------------------
  663|     12|                {
  664|     12|                    ec = msgpack_errc::unknown_type;
  665|     12|                    more_ = false;
  666|     12|                    return;
  667|  2.19k|                }
  668|  19.0M|            }
  669|  19.0M|        }
  670|  34.9M|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12begin_objectERNS_24basic_item_event_visitorIcEEhRNS3_10error_codeE:
  700|   322k|    {
  701|   322k|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|   322k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 322k]
  |  |  ------------------
  ------------------
  702|      1|        {
  703|      1|            ec = msgpack_errc::max_nesting_depth_exceeded;
  704|      1|            more_ = false;
  705|      1|            return;
  706|      1|        } 
  707|   322k|        std::size_t length = get_size(type, ec);
  708|   322k|        if (!more_)
  ------------------
  |  Branch (708:13): [True: 22, False: 322k]
  ------------------
  709|     22|        {
  710|     22|            return;
  711|     22|        }
  712|   322k|        state_stack_.emplace_back(parse_mode::map_key,length);
  713|   322k|        visitor.begin_object(length, semantic_tag::none, *this, ec);
  714|   322k|        more_ = !cursor_mode_;
  715|   322k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayERNS_24basic_item_event_visitorIcEEhRNS3_10error_codeE:
  673|   332k|    {
  674|   332k|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|   332k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 332k]
  |  |  ------------------
  ------------------
  675|      3|        {
  676|      3|            ec = msgpack_errc::max_nesting_depth_exceeded;
  677|      3|            more_ = false;
  678|      3|            return;
  679|      3|        } 
  680|   332k|        std::size_t length = get_size(type, ec);
  681|   332k|        if (!more_)
  ------------------
  |  Branch (681:13): [True: 15, False: 332k]
  ------------------
  682|     15|        {
  683|     15|            return;
  684|     15|        }
  685|   332k|        state_stack_.emplace_back(parse_mode::array,length);
  686|   332k|        visitor.begin_array(length, semantic_tag::none, *this, ec);
  687|   332k|        more_ = !cursor_mode_;
  688|   332k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE8get_sizeEhRNS3_10error_codeE:
  726|   868k|    {
  727|   868k|        switch (type)
  728|   868k|        {
  729|    849|            case jsoncons::msgpack::msgpack_type::str8_type: 
  ------------------
  |  Branch (729:13): [True: 849, False: 867k]
  ------------------
  730|  17.2k|            case jsoncons::msgpack::msgpack_type::bin8_type: 
  ------------------
  |  Branch (730:13): [True: 16.4k, False: 851k]
  ------------------
  731|  30.2k|            case jsoncons::msgpack::msgpack_type::ext8_type: 
  ------------------
  |  Branch (731:13): [True: 12.9k, False: 855k]
  ------------------
  732|  30.2k|            {
  733|  30.2k|                uint8_t buf[sizeof(int8_t)];
  734|  30.2k|                if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (734:21): [True: 24, False: 30.2k]
  ------------------
  735|     24|                {
  736|     24|                    ec = msgpack_errc::unexpected_eof;
  737|     24|                    more_ = false;
  738|     24|                    return 0;
  739|     24|                }
  740|  30.2k|                uint8_t len = binary::big_to_native<uint8_t>(buf, sizeof(buf));
  741|  30.2k|                return static_cast<std::size_t>(len);
  742|  30.2k|            }
  743|       |
  744|    329|            case jsoncons::msgpack::msgpack_type::str16_type: 
  ------------------
  |  Branch (744:13): [True: 329, False: 867k]
  ------------------
  745|  1.22k|            case jsoncons::msgpack::msgpack_type::bin16_type: 
  ------------------
  |  Branch (745:13): [True: 891, False: 867k]
  ------------------
  746|  1.70k|            case jsoncons::msgpack::msgpack_type::ext16_type: 
  ------------------
  |  Branch (746:13): [True: 483, False: 867k]
  ------------------
  747|  5.68k|            case jsoncons::msgpack::msgpack_type::array16_type: 
  ------------------
  |  Branch (747:13): [True: 3.98k, False: 864k]
  ------------------
  748|  7.87k|            case jsoncons::msgpack::msgpack_type::map16_type:
  ------------------
  |  Branch (748:13): [True: 2.19k, False: 865k]
  ------------------
  749|  7.87k|            {
  750|  7.87k|                uint8_t buf[sizeof(int16_t)];
  751|  7.87k|                if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t))
  ------------------
  |  Branch (751:21): [True: 43, False: 7.83k]
  ------------------
  752|     43|                {
  753|     43|                    ec = msgpack_errc::unexpected_eof;
  754|     43|                    more_ = false;
  755|     43|                    return 0;
  756|     43|                }
  757|  7.83k|                uint16_t len = binary::big_to_native<uint16_t>(buf, sizeof(buf));
  758|  7.83k|                return static_cast<std::size_t>(len);
  759|  7.87k|            }
  760|       |
  761|    692|            case jsoncons::msgpack::msgpack_type::str32_type: 
  ------------------
  |  Branch (761:13): [True: 692, False: 867k]
  ------------------
  762|  1.05k|            case jsoncons::msgpack::msgpack_type::bin32_type: 
  ------------------
  |  Branch (762:13): [True: 365, False: 867k]
  ------------------
  763|  2.09k|            case jsoncons::msgpack::msgpack_type::ext32_type: 
  ------------------
  |  Branch (763:13): [True: 1.04k, False: 867k]
  ------------------
  764|  4.80k|            case jsoncons::msgpack::msgpack_type::array32_type: 
  ------------------
  |  Branch (764:13): [True: 2.70k, False: 865k]
  ------------------
  765|  6.18k|            case jsoncons::msgpack::msgpack_type::map32_type : 
  ------------------
  |  Branch (765:13): [True: 1.38k, False: 866k]
  ------------------
  766|  6.18k|            {
  767|  6.18k|                uint8_t buf[sizeof(int32_t)];
  768|  6.18k|                if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t))
  ------------------
  |  Branch (768:21): [True: 46, False: 6.14k]
  ------------------
  769|     46|                {
  770|     46|                    ec = msgpack_errc::unexpected_eof;
  771|     46|                    more_ = false;
  772|     46|                    return 0;
  773|     46|                }
  774|  6.14k|                uint32_t len = binary::big_to_native<uint32_t>(buf, sizeof(buf));
  775|  6.14k|                return static_cast<std::size_t>(len);
  776|  6.18k|            }
  777|  6.35k|            case jsoncons::msgpack::msgpack_type::fixext1_type: 
  ------------------
  |  Branch (777:13): [True: 6.35k, False: 861k]
  ------------------
  778|  6.35k|                return 1;
  779|   105k|            case jsoncons::msgpack::msgpack_type::fixext2_type: 
  ------------------
  |  Branch (779:13): [True: 105k, False: 762k]
  ------------------
  780|   105k|                return 2;
  781|  3.76k|            case jsoncons::msgpack::msgpack_type::fixext4_type: 
  ------------------
  |  Branch (781:13): [True: 3.76k, False: 864k]
  ------------------
  782|  3.76k|                return 4;
  783|  55.0k|            case jsoncons::msgpack::msgpack_type::fixext8_type: 
  ------------------
  |  Branch (783:13): [True: 55.0k, False: 813k]
  ------------------
  784|  55.0k|                return 8;
  785|  8.28k|            case jsoncons::msgpack::msgpack_type::fixext16_type: 
  ------------------
  |  Branch (785:13): [True: 8.28k, False: 859k]
  ------------------
  786|  8.28k|                return 16;
  787|   644k|            default:
  ------------------
  |  Branch (787:13): [True: 644k, False: 223k]
  ------------------
  788|   644k|                if ((type > 0x8f && type <= 0x9f) // fixarray
  ------------------
  |  Branch (788:22): [True: 325k, False: 319k]
  |  Branch (788:37): [True: 325k, False: 0]
  ------------------
  789|   319k|                    || (type > 0x7f && type <= 0x8f) // fixmap
  ------------------
  |  Branch (789:25): [True: 319k, False: 0]
  |  Branch (789:40): [True: 319k, False: 0]
  ------------------
  790|   644k|        )
  791|   644k|                {
  792|   644k|                    return type & 0x0f;
  793|   644k|                }
  794|      0|                else
  795|      0|                {
  796|      0|                    ec = msgpack_errc::unknown_type;
  797|      0|                    more_ = false;
  798|      0|                    return 0;
  799|      0|                }
  800|      0|                break;
  801|   868k|        }
  802|   868k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9end_arrayERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
  691|   306k|    {
  692|   306k|        --nesting_depth_;
  693|       |
  694|   306k|        visitor.end_array(*this, ec);
  695|   306k|        more_ = !cursor_mode_;
  696|   306k|        state_stack_.pop_back();
  697|   306k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10end_objectERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
  718|   302k|    {
  719|   302k|        --nesting_depth_;
  720|   302k|        visitor.end_object(*this, ec);
  721|   302k|        more_ = !cursor_mode_;
  722|   302k|        state_stack_.pop_back();
  723|   302k|    }

_ZN8jsoncons7msgpack20basic_msgpack_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RNS_18basic_json_visitorIcEERKNS0_22msgpack_decode_optionsERKS7_:
   51|  6.25k|       : parser_(std::forward<Sourceable>(source), options, alloc),
   52|  6.25k|         adaptor_(visitor, alloc), visitor_(adaptor_)
   53|  6.25k|    {
   54|  6.25k|    }
_ZN8jsoncons7msgpack20basic_msgpack_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4readERNS3_10error_codeE:
   87|  6.25k|    {
   88|  6.25k|        parser_.reset();
   89|  6.25k|        parser_.parse(visitor_, ec);
   90|  6.25k|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  6.25k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4.68k, False: 1.56k]
  |  |  ------------------
  ------------------
   91|  4.68k|        {
   92|  4.68k|            return;
   93|  4.68k|        }
   94|  6.25k|    }