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

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

_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4sizeEv:
  116|  2.91M|        {
  117|  2.91M|            return size_;
  118|  2.91M|        }
_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2Ev:
   58|   363k|        {
   59|   363k|        }
_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2EPS2_m:
   61|   920k|            : data_(data), size_(size)
   62|   920k|        {
   63|   920k|        }
_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4dataEv:
  111|  1.63M|        {
  112|  1.63M|            return data_;
  113|  1.63M|        }

_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1008|   455k|        {
 1009|   455k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1009:17): [True: 29.8k, False: 425k]
  ------------------
 1010|  29.8k|            {
 1011|  29.8k|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1011:21): [True: 24.6k, False: 5.21k]
  |  Branch (1011:86): [True: 22.1k, False: 2.57k]
  ------------------
 1012|  22.1k|                {
 1013|  22.1k|                    key_buffer_.push_back(',');
 1014|  22.1k|                }
 1015|  29.8k|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
 1016|  29.8k|                key_buffer_.push_back('[');
 1017|  29.8k|            }
 1018|   425k|            else
 1019|   425k|            {
 1020|   425k|                switch (level_stack_.back().target_kind())
 1021|   425k|                {
 1022|   258k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1022:21): [True: 258k, False: 166k]
  ------------------
 1023|   258k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1023:29): [True: 235k, False: 22.9k]
  |  Branch (1023:65): [True: 54.0k, False: 181k]
  ------------------
 1024|  54.0k|                        {
 1025|  54.0k|                            key_buffer_.push_back(',');
 1026|  54.0k|                        }
 1027|   258k|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
 1028|   258k|                        key_buffer_.push_back('[');
 1029|   258k|                        break;
 1030|   166k|                    default:
  ------------------
  |  Branch (1030:21): [True: 166k, False: 258k]
  ------------------
 1031|   166k|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::array);
 1032|   166k|                        destination_->begin_array(length, tag, context, ec);
 1033|   166k|                        break;
 1034|   425k|                }
 1035|   425k|            }
 1036|   455k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   455k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1037|   455k|        }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure6is_keyEv:
  815|   136M|            {
  816|   136M|                return even_odd_ == 0;
  817|   136M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure11target_kindEv:
  825|  82.4M|            {
  826|  82.4M|                return target_kind_;
  827|  82.4M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure5countEv:
  830|  34.2M|            {
  831|  34.2M|                return count_;
  832|  34.2M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structureC2ENS4_16json_target_kindENS4_19json_structure_kindE:
  798|   690k|                : target_kind_(state), structure_kind_(type), even_odd_(type == json_structure_kind::object ? 0 : 1)
  ------------------
  |  Branch (798:73): [True: 229k, False: 461k]
  ------------------
  799|   690k|            {
  800|   690k|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure9is_objectEv:
  820|  79.8M|            {
  821|  79.8M|                return structure_kind_ == json_structure_kind::object;
  822|  79.8M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE15visit_end_arrayERKNS_11ser_contextERNS1_10error_codeE:
 1040|   419k|        {
 1041|   419k|            switch (level_stack_.back().target_kind())
 1042|   419k|            {
 1043|   269k|                case json_target_kind::buffer:
  ------------------
  |  Branch (1043:17): [True: 269k, False: 150k]
  ------------------
 1044|   269k|                    key_buffer_.push_back(']');
 1045|   269k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|   269k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 269k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1046|   269k|                    level_stack_.pop_back();
 1047|   269k|                    if (level_stack_.back().target_kind() == json_target_kind::destination)
  ------------------
  |  Branch (1047:25): [True: 4.68k, False: 265k]
  ------------------
 1048|  4.68k|                    {
 1049|  4.68k|                        destination_->key(key_buffer_, context, ec);
 1050|  4.68k|                        key_buffer_.clear();
 1051|  4.68k|                    }
 1052|   265k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (1052:30): [True: 23.0k, False: 242k]
  ------------------
 1053|  23.0k|                    {
 1054|  23.0k|                        key_buffer_.push_back(':');
 1055|  23.0k|                    }
 1056|   269k|                    level_stack_.back().advance();
 1057|   269k|                    break;
 1058|   150k|                default:
  ------------------
  |  Branch (1058:17): [True: 150k, False: 269k]
  ------------------
 1059|   150k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|   150k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 150k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1060|   150k|                    level_stack_.pop_back();
 1061|   150k|                    level_stack_.back().advance();
 1062|   150k|                    destination_->end_array(context, ec);
 1063|   150k|                    break;
 1064|   419k|            }
 1065|   419k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   419k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1066|   419k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure7advanceEv:
  803|  45.6M|            {
  804|  45.6M|                if (!is_key())
  ------------------
  |  Branch (804:21): [True: 36.4M, False: 9.12M]
  ------------------
  805|  36.4M|                {
  806|  36.4M|                    ++count_;
  807|  36.4M|                }
  808|  45.6M|                if (is_object())
  ------------------
  |  Branch (808:21): [True: 18.2M, False: 27.3M]
  ------------------
  809|  18.2M|                {
  810|  18.2M|                    even_odd_ = !even_odd_;
  811|  18.2M|                }
  812|  45.6M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1233|  14.8M|        {
 1234|  14.8M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1234:17): [True: 5.06M, False: 9.75M]
  |  Branch (1234:49): [True: 8.80M, False: 947k]
  ------------------
 1235|  13.8M|            {
 1236|  13.8M|                key_.clear();
 1237|  13.8M|                jsoncons::from_integer(value,key_);
 1238|  13.8M|            }
 1239|       |
 1240|  14.8M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1240:17): [True: 5.06M, False: 9.75M]
  ------------------
 1241|  5.06M|            {
 1242|  5.06M|                switch (level_stack_.back().target_kind())
 1243|  5.06M|                {
 1244|  4.87M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1244:21): [True: 4.87M, False: 189k]
  ------------------
 1245|  4.87M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1245:29): [True: 4.85M, False: 17.9k]
  ------------------
 1246|  4.85M|                        {
 1247|  4.85M|                            key_buffer_.push_back(',');
 1248|  4.85M|                        }
 1249|  4.87M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1250|  4.87M|                        key_buffer_.push_back(':');
 1251|  4.87M|                        break;
 1252|   189k|                    default:
  ------------------
  |  Branch (1252:21): [True: 189k, False: 4.87M]
  ------------------
 1253|   189k|                        destination_->key(key_, context, ec);
 1254|   189k|                        break;
 1255|  5.06M|                }
 1256|  5.06M|            }
 1257|  9.75M|            else
 1258|  9.75M|            {
 1259|  9.75M|                switch (level_stack_.back().target_kind())
 1260|  9.75M|                {
 1261|  8.80M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1261:21): [True: 8.80M, False: 947k]
  ------------------
 1262|  8.80M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1262:29): [True: 3.93M, False: 4.87M]
  |  Branch (1262:65): [True: 3.92M, False: 9.01k]
  ------------------
 1263|  3.92M|                        {
 1264|  3.92M|                            key_buffer_.push_back(',');
 1265|  3.92M|                        }
 1266|  8.80M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1267|  8.80M|                        break;
 1268|   947k|                    default:
  ------------------
  |  Branch (1268:21): [True: 947k, False: 8.80M]
  ------------------
 1269|   947k|                        destination_->uint64_value(value, tag, context, ec);
 1270|   947k|                        break;
 1271|  9.75M|                }
 1272|  9.75M|            }
 1273|       |
 1274|  14.8M|            level_stack_.back().advance();
 1275|  14.8M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  14.8M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1276|  14.8M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1279|  2.31M|        {
 1280|  2.31M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1280:17): [True: 683k, False: 1.63M]
  |  Branch (1280:49): [True: 1.41M, False: 220k]
  ------------------
 1281|  2.09M|            {
 1282|  2.09M|                key_.clear();
 1283|  2.09M|                jsoncons::from_integer(value,key_);
 1284|  2.09M|            }
 1285|       |
 1286|  2.31M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1286:17): [True: 683k, False: 1.63M]
  ------------------
 1287|   683k|            {
 1288|   683k|                switch (level_stack_.back().target_kind())
 1289|   683k|                {
 1290|   655k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1290:21): [True: 655k, False: 27.7k]
  ------------------
 1291|   655k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1291:29): [True: 651k, False: 4.00k]
  ------------------
 1292|   651k|                        {
 1293|   651k|                            key_buffer_.push_back(',');
 1294|   651k|                        }
 1295|   655k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1296|   655k|                        key_buffer_.push_back(':');
 1297|   655k|                        break;
 1298|  27.7k|                    default:
  ------------------
  |  Branch (1298:21): [True: 27.7k, False: 655k]
  ------------------
 1299|  27.7k|                        destination_->key(key_, context, ec);
 1300|  27.7k|                        break;
 1301|   683k|                }
 1302|   683k|            }
 1303|  1.63M|            else
 1304|  1.63M|            {
 1305|  1.63M|                switch (level_stack_.back().target_kind())
 1306|  1.63M|                {
 1307|  1.41M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1307:21): [True: 1.41M, False: 220k]
  ------------------
 1308|  1.41M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1308:29): [True: 753k, False: 657k]
  |  Branch (1308:65): [True: 748k, False: 5.34k]
  ------------------
 1309|   748k|                        {
 1310|   748k|                            key_buffer_.push_back(',');
 1311|   748k|                        }
 1312|  1.41M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1313|  1.41M|                        break;
 1314|   220k|                    default:
  ------------------
  |  Branch (1314:21): [True: 220k, False: 1.41M]
  ------------------
 1315|   220k|                        destination_->int64_value(value, tag, context, ec);
 1316|   220k|                        break;
 1317|  1.63M|                }
 1318|  1.63M|            }
 1319|       |
 1320|  2.31M|            level_stack_.back().advance();
 1321|  2.31M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  2.31M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1322|  2.31M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1374|   129k|        {
 1375|   129k|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1375:17): [True: 38.4k, False: 91.2k]
  |  Branch (1375:49): [True: 35.9k, False: 55.3k]
  ------------------
 1376|  74.4k|            {
 1377|  74.4k|                key_.clear();
 1378|  74.4k|                string_sink<string_type> sink(key_);
 1379|  74.4k|                jsoncons::write_double f{float_chars_format::general,0};
 1380|  74.4k|                f(value, sink);
 1381|  74.4k|            }
 1382|       |
 1383|   129k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1383:17): [True: 38.4k, False: 91.2k]
  ------------------
 1384|  38.4k|            {
 1385|  38.4k|                switch (level_stack_.back().target_kind())
 1386|  38.4k|                {
 1387|  16.5k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1387:21): [True: 16.5k, False: 21.9k]
  ------------------
 1388|  16.5k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1388:29): [True: 12.7k, False: 3.77k]
  ------------------
 1389|  12.7k|                        {
 1390|  12.7k|                            key_buffer_.push_back(',');
 1391|  12.7k|                        }
 1392|  16.5k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1393|  16.5k|                        key_buffer_.push_back(':');
 1394|  16.5k|                        break;
 1395|  21.9k|                    default:
  ------------------
  |  Branch (1395:21): [True: 21.9k, False: 16.5k]
  ------------------
 1396|  21.9k|                        destination_->key(key_, context, ec);
 1397|  21.9k|                        break;
 1398|  38.4k|                }
 1399|  38.4k|            }
 1400|  91.2k|            else
 1401|  91.2k|            {
 1402|  91.2k|                switch (level_stack_.back().target_kind())
 1403|  91.2k|                {
 1404|  35.9k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1404:21): [True: 35.9k, False: 55.3k]
  ------------------
 1405|  35.9k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1405:29): [True: 22.0k, False: 13.8k]
  |  Branch (1405:65): [True: 20.0k, False: 1.99k]
  ------------------
 1406|  20.0k|                        {
 1407|  20.0k|                            key_buffer_.push_back(',');
 1408|  20.0k|                        }
 1409|  35.9k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1410|  35.9k|                        break;
 1411|  55.3k|                    default:
  ------------------
  |  Branch (1411:21): [True: 55.3k, False: 35.9k]
  ------------------
 1412|  55.3k|                        destination_->double_value(value, tag, context, ec);
 1413|  55.3k|                        break;
 1414|  91.2k|                }
 1415|  91.2k|            }
 1416|       |
 1417|   129k|            level_stack_.back().advance();
 1418|   129k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   129k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1419|   129k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE11visit_flushEv:
  881|  1.51k|        {
  882|  1.51k|            destination_->flush();
  883|  1.51k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  914|   229k|        {
  915|   229k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (915:17): [True: 75.2k, False: 154k]
  ------------------
  916|  75.2k|            {
  917|  75.2k|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (917:21): [True: 70.2k, False: 4.96k]
  |  Branch (917:86): [True: 47.2k, False: 23.0k]
  ------------------
  918|  47.2k|                {
  919|  47.2k|                    key_buffer_.push_back(',');
  920|  47.2k|                }
  921|  75.2k|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  922|  75.2k|                key_buffer_.push_back('{');
  923|  75.2k|            }
  924|   154k|            else
  925|   154k|            {
  926|   154k|                switch (level_stack_.back().target_kind())
  927|   154k|                {
  928|   133k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (928:21): [True: 133k, False: 20.8k]
  ------------------
  929|   133k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (929:29): [True: 60.5k, False: 72.7k]
  |  Branch (929:65): [True: 58.0k, False: 2.47k]
  ------------------
  930|  58.0k|                        {
  931|  58.0k|                            key_buffer_.push_back(',');
  932|  58.0k|                        }
  933|   133k|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  934|   133k|                        key_buffer_.push_back('{');
  935|   133k|                        break;
  936|  20.8k|                    default:
  ------------------
  |  Branch (936:21): [True: 20.8k, False: 133k]
  ------------------
  937|  20.8k|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::object);
  938|  20.8k|                        destination_->begin_object(length, tag, context, ec);
  939|  20.8k|                        break;
  940|   154k|                }
  941|   154k|            }
  942|   229k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   229k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  943|   229k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE16visit_end_objectERKNS_11ser_contextERNS1_10error_codeE:
  946|   206k|        {
  947|   206k|            switch (level_stack_.back().target_kind())
  948|   206k|            {
  949|   193k|                case json_target_kind::buffer:
  ------------------
  |  Branch (949:17): [True: 193k, False: 12.4k]
  ------------------
  950|   193k|                    key_buffer_.push_back('}');
  951|   193k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|   193k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 193k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  952|   193k|                    level_stack_.pop_back();
  953|       |                    
  954|   193k|                    if (level_stack_.back().target_kind() == json_target_kind::destination)
  ------------------
  |  Branch (954:25): [True: 4.10k, False: 189k]
  ------------------
  955|  4.10k|                    {
  956|  4.10k|                        destination_->key(key_buffer_,context, ec);
  957|  4.10k|                        key_buffer_.clear();
  958|  4.10k|                    }
  959|   189k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (959:30): [True: 65.0k, False: 124k]
  ------------------
  960|  65.0k|                    {
  961|  65.0k|                        key_buffer_.push_back(':');
  962|  65.0k|                    }
  963|   193k|                    level_stack_.back().advance();
  964|   193k|                    break;
  965|  12.4k|                default:
  ------------------
  |  Branch (965:17): [True: 12.4k, False: 193k]
  ------------------
  966|  12.4k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|  12.4k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 12.4k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  967|  12.4k|                    level_stack_.pop_back();
  968|  12.4k|                    level_stack_.back().advance();
  969|  12.4k|                    destination_->end_object(context, ec);
  970|  12.4k|                    break;
  971|   206k|            }
  972|   206k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   206k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  973|   206k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1475|   563k|        {
 1476|   563k|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1476:17): [True: 257k, False: 305k]
  |  Branch (1476:49): [True: 295k, False: 10.4k]
  ------------------
 1477|   552k|            {
 1478|   552k|                key_.clear(); 
 1479|   552k|                key_.insert(key_.begin(), json_literals<char_type>::null_literal.begin(), json_literals<char_type>::null_literal.end());
 1480|   552k|            }
 1481|       |
 1482|   563k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1482:17): [True: 257k, False: 305k]
  ------------------
 1483|   257k|            {
 1484|   257k|                switch (level_stack_.back().target_kind())
 1485|   257k|                {
 1486|   256k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1486:21): [True: 256k, False: 1.11k]
  ------------------
 1487|   256k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1487:29): [True: 254k, False: 1.73k]
  ------------------
 1488|   254k|                        {
 1489|   254k|                            key_buffer_.push_back(',');
 1490|   254k|                        }
 1491|   256k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1492|   256k|                        key_buffer_.push_back(':');
 1493|   256k|                        break;
 1494|  1.11k|                    default:
  ------------------
  |  Branch (1494:21): [True: 1.11k, False: 256k]
  ------------------
 1495|  1.11k|                        destination_->key(key_, context, ec);
 1496|  1.11k|                        break;
 1497|   257k|                }
 1498|   257k|            }
 1499|   305k|            else
 1500|   305k|            {
 1501|   305k|                switch (level_stack_.back().target_kind())
 1502|   305k|                {
 1503|   295k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1503:21): [True: 295k, False: 10.4k]
  ------------------
 1504|   295k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1504:29): [True: 39.4k, False: 255k]
  |  Branch (1504:65): [True: 39.1k, False: 317]
  ------------------
 1505|  39.1k|                        {
 1506|  39.1k|                            key_buffer_.push_back(',');
 1507|  39.1k|                        }
 1508|   295k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1509|   295k|                        break;
 1510|  10.4k|                    default:
  ------------------
  |  Branch (1510:21): [True: 10.4k, False: 295k]
  ------------------
 1511|  10.4k|                        destination_->null_value(tag, context, ec);
 1512|  10.4k|                        break;
 1513|   305k|                }
 1514|   305k|            }
 1515|       |
 1516|   563k|            level_stack_.back().advance();
 1517|   563k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   563k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1518|   563k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1422|  25.7M|        {
 1423|  25.7M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1423:17): [True: 2.42M, False: 23.3M]
  |  Branch (1423:49): [True: 22.8M, False: 525k]
  ------------------
 1424|  25.2M|            {
 1425|  25.2M|                key_.clear(); 
 1426|  25.2M|                if (value)
  ------------------
  |  Branch (1426:21): [True: 68.8k, False: 25.1M]
  ------------------
 1427|  68.8k|                {
 1428|  68.8k|                    key_.insert(key_.begin(), json_literals<char_type>::true_literal.begin(), json_literals<char_type>::true_literal.end());
 1429|  68.8k|                }
 1430|  25.1M|                else
 1431|  25.1M|                {
 1432|  25.1M|                    key_.insert(key_.begin(), json_literals<char_type>::false_literal.begin(), json_literals<char_type>::false_literal.end());
 1433|  25.1M|                }
 1434|  25.2M|            }
 1435|       |
 1436|  25.7M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1436:17): [True: 2.42M, False: 23.3M]
  ------------------
 1437|  2.42M|            {
 1438|  2.42M|                switch (level_stack_.back().target_kind())
 1439|  2.42M|                {
 1440|  2.34M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1440:21): [True: 2.34M, False: 81.1k]
  ------------------
 1441|  2.34M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1441:29): [True: 2.32M, False: 21.8k]
  ------------------
 1442|  2.32M|                        {
 1443|  2.32M|                            key_buffer_.push_back(',');
 1444|  2.32M|                        }
 1445|  2.34M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1446|  2.34M|                        key_buffer_.push_back(':');
 1447|  2.34M|                        break;
 1448|  81.1k|                    default:
  ------------------
  |  Branch (1448:21): [True: 81.1k, False: 2.34M]
  ------------------
 1449|  81.1k|                        destination_->key(key_, context, ec);
 1450|  81.1k|                        break;
 1451|  2.42M|                }
 1452|  2.42M|            }
 1453|  23.3M|            else
 1454|  23.3M|            {
 1455|  23.3M|                switch (level_stack_.back().target_kind())
 1456|  23.3M|                {
 1457|  22.8M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1457:21): [True: 22.8M, False: 525k]
  ------------------
 1458|  22.8M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1458:29): [True: 20.4M, False: 2.33M]
  |  Branch (1458:65): [True: 20.4M, False: 3.61k]
  ------------------
 1459|  20.4M|                        {
 1460|  20.4M|                            key_buffer_.push_back(',');
 1461|  20.4M|                        }
 1462|  22.8M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1463|  22.8M|                        break;
 1464|   525k|                    default:
  ------------------
  |  Branch (1464:21): [True: 525k, False: 22.8M]
  ------------------
 1465|   525k|                        destination_->bool_value(value, tag, context, ec);
 1466|   525k|                        break;
 1467|  23.3M|                }
 1468|  23.3M|            }
 1469|       |
 1470|  25.7M|            level_stack_.back().advance();
 1471|  25.7M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  25.7M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1472|  25.7M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_stringERKNS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1072|   469k|        {
 1073|   469k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1073:17): [True: 156k, False: 312k]
  ------------------
 1074|   156k|            {
 1075|   156k|                switch (level_stack_.back().target_kind())
 1076|   156k|                {
 1077|   153k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1077:21): [True: 153k, False: 2.98k]
  ------------------
 1078|   153k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1078:29): [True: 151k, False: 2.24k]
  ------------------
 1079|   151k|                        {
 1080|   151k|                            key_buffer_.push_back(',');
 1081|   151k|                        }
 1082|   153k|                        key_buffer_.push_back('\"');
 1083|   153k|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1084|   153k|                        key_buffer_.push_back('\"');
 1085|   153k|                        key_buffer_.push_back(':');
 1086|   153k|                        break;
 1087|  2.98k|                    default:
  ------------------
  |  Branch (1087:21): [True: 2.98k, False: 153k]
  ------------------
 1088|  2.98k|                        destination_->key(value, context, ec);
 1089|  2.98k|                        break;
 1090|   156k|                }
 1091|   156k|            }
 1092|   312k|            else
 1093|   312k|            {
 1094|   312k|                switch (level_stack_.back().target_kind())
 1095|   312k|                {
 1096|   286k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1096:21): [True: 286k, False: 26.5k]
  ------------------
 1097|   286k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1097:29): [True: 125k, False: 160k]
  |  Branch (1097:65): [True: 124k, False: 1.89k]
  ------------------
 1098|   124k|                        {
 1099|   124k|                            key_buffer_.push_back(',');
 1100|   124k|                        }
 1101|   286k|                        key_buffer_.push_back('\"');
 1102|   286k|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1103|   286k|                        key_buffer_.push_back('\"');
 1104|   286k|                        break;
 1105|  26.5k|                    default:
  ------------------
  |  Branch (1105:21): [True: 26.5k, False: 286k]
  ------------------
 1106|  26.5k|                        destination_->string_value(value, tag, context, ec);
 1107|  26.5k|                        break;
 1108|   312k|                }
 1109|   312k|            }
 1110|       |
 1111|   469k|            level_stack_.back().advance();
 1112|   469k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   469k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1113|   469k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1119|  32.5k|        {
 1120|  32.5k|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1120:17): [True: 11.9k, False: 20.5k]
  |  Branch (1120:49): [True: 17.4k, False: 3.10k]
  ------------------
 1121|  29.4k|            {
 1122|  29.4k|                key_.clear();
 1123|  29.4k|                switch (tag)
 1124|  29.4k|                {
 1125|      0|                    case semantic_tag::base64:
  ------------------
  |  Branch (1125:21): [True: 0, False: 29.4k]
  ------------------
 1126|      0|                        bytes_to_base64(value.begin(), value.end(), key_);
 1127|      0|                        break;
 1128|      0|                    case semantic_tag::base16:
  ------------------
  |  Branch (1128:21): [True: 0, False: 29.4k]
  ------------------
 1129|      0|                        bytes_to_base16(value.begin(), value.end(),key_);
 1130|      0|                        break;
 1131|  29.4k|                    default:
  ------------------
  |  Branch (1131:21): [True: 29.4k, False: 0]
  ------------------
 1132|  29.4k|                        bytes_to_base64url(value.begin(), value.end(),key_);
 1133|  29.4k|                        break;
 1134|  29.4k|                }
 1135|  29.4k|            }
 1136|       |
 1137|  32.5k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1137:17): [True: 11.9k, False: 20.5k]
  ------------------
 1138|  11.9k|            {
 1139|  11.9k|                switch (level_stack_.back().target_kind())
 1140|  11.9k|                {
 1141|  10.7k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1141:21): [True: 10.7k, False: 1.27k]
  ------------------
 1142|  10.7k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1142:29): [True: 7.26k, False: 3.43k]
  ------------------
 1143|  7.26k|                        {
 1144|  7.26k|                            key_buffer_.push_back(',');
 1145|  7.26k|                        }
 1146|  10.7k|                        key_buffer_.push_back('\"');
 1147|  10.7k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1148|  10.7k|                        key_buffer_.push_back('\"');
 1149|  10.7k|                        key_buffer_.push_back(':');
 1150|  10.7k|                        break;
 1151|  1.27k|                    default:
  ------------------
  |  Branch (1151:21): [True: 1.27k, False: 10.7k]
  ------------------
 1152|  1.27k|                        destination_->key(key_, context, ec);
 1153|  1.27k|                        break;
 1154|  11.9k|                }
 1155|  11.9k|            }
 1156|  20.5k|            else
 1157|  20.5k|            {
 1158|  20.5k|                switch (level_stack_.back().target_kind())
 1159|  20.5k|                {
 1160|  17.4k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1160:21): [True: 17.4k, False: 3.10k]
  ------------------
 1161|  17.4k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1161:29): [True: 9.93k, False: 7.49k]
  |  Branch (1161:65): [True: 9.08k, False: 851]
  ------------------
 1162|  9.08k|                        {
 1163|  9.08k|                            key_buffer_.push_back(',');
 1164|  9.08k|                        }
 1165|  17.4k|                        key_buffer_.push_back('\"');
 1166|  17.4k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1167|  17.4k|                        key_buffer_.push_back('\"');
 1168|  17.4k|                        break;
 1169|  3.10k|                    default:
  ------------------
  |  Branch (1169:21): [True: 3.10k, False: 17.4k]
  ------------------
 1170|  3.10k|                        destination_->byte_string_value(value, tag, context, ec);
 1171|  3.10k|                        break;
 1172|  20.5k|                }
 1173|  20.5k|            }
 1174|       |
 1175|  32.5k|            level_stack_.back().advance();
 1176|  32.5k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  32.5k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1177|  32.5k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS1_10error_codeE:
 1183|   903k|        {
 1184|   903k|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1184:17): [True: 389k, False: 513k]
  |  Branch (1184:49): [True: 174k, False: 338k]
  ------------------
 1185|   564k|            {
 1186|   564k|                key_.clear();
 1187|   564k|                bytes_to_base64url(value.begin(), value.end(),key_);
 1188|   564k|            }
 1189|       |
 1190|   903k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1190:17): [True: 389k, False: 513k]
  ------------------
 1191|   389k|            {
 1192|   389k|                switch (level_stack_.back().target_kind())
 1193|   389k|                {
 1194|   150k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1194:21): [True: 150k, False: 239k]
  ------------------
 1195|   150k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1195:29): [True: 148k, False: 1.26k]
  ------------------
 1196|   148k|                        {
 1197|   148k|                            key_buffer_.push_back(',');
 1198|   148k|                        }
 1199|   150k|                        key_buffer_.push_back('\"');
 1200|   150k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1201|   150k|                        key_buffer_.push_back('\"');
 1202|   150k|                        key_buffer_.push_back(':');
 1203|   150k|                        break;
 1204|   239k|                    default:
  ------------------
  |  Branch (1204:21): [True: 239k, False: 150k]
  ------------------
 1205|   239k|                        destination_->key(key_, context, ec);
 1206|   239k|                        break;
 1207|   389k|                }
 1208|   389k|            }
 1209|   513k|            else
 1210|   513k|            {
 1211|   513k|                switch (level_stack_.back().target_kind())
 1212|   513k|                {
 1213|   174k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1213:21): [True: 174k, False: 338k]
  ------------------
 1214|   174k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1214:29): [True: 25.0k, False: 149k]
  |  Branch (1214:65): [True: 22.6k, False: 2.40k]
  ------------------
 1215|  22.6k|                        {
 1216|  22.6k|                            key_buffer_.push_back(',');
 1217|  22.6k|                        }
 1218|   174k|                        key_buffer_.push_back('\"');
 1219|   174k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1220|   174k|                        key_buffer_.push_back('\"');
 1221|   174k|                        break;
 1222|   338k|                    default:
  ------------------
  |  Branch (1222:21): [True: 338k, False: 174k]
  ------------------
 1223|   338k|                        destination_->byte_string_value(value, raw_tag, context, ec);
 1224|   338k|                        break;
 1225|   513k|                }
 1226|   513k|            }
 1227|       |
 1228|   903k|            level_stack_.back().advance();
 1229|   903k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   903k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1230|   903k|        }
_ZN8jsoncons21basic_generic_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  294|   455k|    {
  295|   455k|        visit_begin_array(length, tag, context, ec);
  296|   455k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   455k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  297|   455k|    }
_ZN8jsoncons21basic_generic_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  363|  14.8M|    {
  364|  14.8M|        visit_uint64(value, tag, context, ec);
  365|  14.8M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  14.8M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  366|  14.8M|    }
_ZN8jsoncons21basic_generic_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  300|   419k|    {
  301|   419k|        visit_end_array(context, ec);
  302|   419k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   419k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  303|   419k|    }
_ZN8jsoncons21basic_generic_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  372|  2.31M|    {
  373|  2.31M|        visit_int64(value, tag, context, ec);
  374|  2.31M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  2.31M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  375|  2.31M|    }
_ZN8jsoncons21basic_generic_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  390|   129k|    {
  391|   129k|        visit_double(value, tag, context, ec);
  392|   129k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   129k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  393|   129k|    }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEEC2ERNS_18basic_json_visitorIcEERKS3_:
  855|  6.23k|            : destination_(std::addressof(visitor)), 
  856|  6.23k|              key_(alloc), key_buffer_(alloc), level_stack_(alloc)
  857|  6.23k|        {
  858|  6.23k|            level_stack_.emplace_back(json_target_kind::destination,json_structure_kind::root); // root
  859|  6.23k|        }
_ZN8jsoncons21basic_generic_visitorIcEC2Ev:
   52|  6.23k|    basic_generic_visitor() = default;
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  276|   229k|    {
  277|   229k|        visit_begin_object(length, tag, context, ec);
  278|   229k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   229k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  279|   229k|    }
_ZN8jsoncons21basic_generic_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  332|   469k|    {
  333|   469k|        visit_string(value, tag, context, ec);
  334|   469k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   469k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  335|   469k|    }
_ZN8jsoncons21basic_generic_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  314|   563k|    {
  315|   563k|        visit_null(tag, context, ec);
  316|   563k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   563k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  317|   563k|    }
_ZN8jsoncons21basic_generic_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  323|  25.7M|    {
  324|  25.7M|        visit_bool(value, tag, context, ec);
  325|  25.7M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  25.7M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  326|  25.7M|    }
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  343|  32.5k|    {
  344|  32.5k|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  345|  32.5k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  32.5k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  346|  32.5k|    }
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  354|   903k|    {
  355|   903k|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), raw_tag, context, ec);
  356|   903k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   903k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  357|   903k|    }
_ZN8jsoncons21basic_generic_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  282|   206k|    {
  283|   206k|        visit_end_object(context, ec);
  284|   206k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   206k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  285|   206k|    }
_ZN8jsoncons21basic_generic_visitorIcE5flushEv:
   57|  1.51k|    {
   58|  1.51k|        visit_flush();
   59|  1.51k|    }

_ZN8jsoncons19typed_array_visitorD2Ev:
   33|  18.7k|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  345|   166k|        {
  346|   166k|            visit_begin_array(length, tag, context, ec);
  347|   166k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   166k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  348|   166k|        }
_ZN8jsoncons18basic_json_visitorIcE3keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  357|   574k|        {
  358|   574k|            visit_key(name, context, ec);
  359|   574k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   574k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  360|   574k|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  351|   150k|        {
  352|   150k|            visit_end_array(context, ec);
  353|   150k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   150k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  354|   150k|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|   947k|        {
  415|   947k|            visit_uint64(value, tag, context, ec);
  416|   947k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   947k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  417|   947k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|   220k|        {
  424|   220k|            visit_int64(value, tag, context, ec);
  425|   220k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   220k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  426|   220k|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|  55.3k|        {
  442|  55.3k|            visit_double(value, tag, context, ec);
  443|  55.3k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  55.3k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  444|  55.3k|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|  1.51k|        {
  109|  1.51k|            visit_flush();
  110|  1.51k|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  327|  20.8k|        {
  328|  20.8k|            visit_begin_object(length, tag, context, ec);
  329|  20.8k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  20.8k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  330|  20.8k|        }
_ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  333|  12.4k|        {
  334|  12.4k|            visit_end_object(context, ec);
  335|  12.4k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  12.4k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  336|  12.4k|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  365|  10.4k|        {
  366|  10.4k|            visit_null(tag, context, ec);
  367|  10.4k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  10.4k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  368|  10.4k|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  374|   525k|        {
  375|   525k|            visit_bool(value, tag, context, ec);
  376|   525k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   525k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  377|   525k|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  383|  26.5k|        {
  384|  26.5k|            visit_string(value, tag, context, ec);
  385|  26.5k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  26.5k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  386|  26.5k|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  394|  3.10k|        {
  395|  3.10k|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  396|  3.10k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.10k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  397|  3.10k|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  405|   338k|        {
  406|   338k|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), raw_tag, context, ec);
  407|   338k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   338k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  408|   338k|        }
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|  12.4k|        basic_json_visitor() = default;
_ZN8jsoncons26basic_default_json_visitorIcEC2Ev:
  811|  6.23k|        basic_default_json_visitor() = default;

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

_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERS7_:
  256|  74.4k|            : buf_ptr(std::addressof(buf))
  257|  74.4k|        {
  258|  74.4k|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9push_backEc:
  287|  1.43M|        {
  288|  1.43M|            buf_ptr->push_back(ch);
  289|  1.43M|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvEC2ERS5_:
  315|  6.23k|            : buf_ptr(std::addressof(buf))
  316|  6.23k|        {
  317|  6.23k|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE9push_backEh:
  334|   116M|        {
  335|   116M|            buf_ptr->push_back(static_cast<value_type>(ch));
  336|   116M|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE5flushEv:
  325|  7.75k|        {
  326|  7.75k|        }

_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev:
  193|  6.23k|    {
  194|  6.23k|        if (chunk_)
  ------------------
  |  Branch (194:13): [True: 6.23k, False: 0]
  ------------------
  195|  6.23k|        {
  196|  6.23k|            std::allocator_traits<char_allocator_type>::deallocate(alloc_, chunk_, chunk_size_);
  197|  6.23k|        }
  198|  6.23k|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  176|  6.23k|        : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  177|  6.23k|          chunk_size_(default_max_chunk_size)
  178|  6.23k|    {
  179|  6.23k|        chunk_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, chunk_size_);
  180|  6.23k|        data_end_ = chunk_;
  181|  6.23k|    }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   57|  6.23k|      : std::basic_istream<CharT>(&nb_)
   58|  6.23k|    {
   59|  6.23k|    }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   43|  6.23k|        null_buffer() = default;
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE8is_errorEv:
  276|  45.6M|    {
  277|  45.6M|        return stream_ptr_->bad();  
  278|  45.6M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm:
  377|  47.3M|    {
  378|  47.3M|        std::size_t len = 0;
  379|  47.3M|        if (remaining_ > 0)
  ------------------
  |  Branch (379:13): [True: 47.3M, False: 12.7k]
  ------------------
  380|  47.3M|        {
  381|  47.3M|            len = (std::min)(remaining_, length);
  382|  47.3M|            std::memcpy(p, data_end_, len*sizeof(value_type));
  383|  47.3M|            data_end_ += len;
  384|  47.3M|            remaining_ -= len;
  385|  47.3M|            position_ += len;
  386|  47.3M|        }
  387|  47.3M|        if (length - len == 0)
  ------------------
  |  Branch (387:13): [True: 47.3M, False: 15.2k]
  ------------------
  388|  47.3M|        {
  389|  47.3M|            return len;
  390|  47.3M|        }
  391|  15.2k|        else if (length - len < chunk_size_)
  ------------------
  |  Branch (391:18): [True: 15.2k, False: 0]
  ------------------
  392|  15.2k|        {
  393|  15.2k|            data_end_ = chunk_;
  394|  15.2k|            remaining_ = fill_buffer(chunk_, chunk_size_);
  395|  15.2k|            if (remaining_ > 0)
  ------------------
  |  Branch (395:17): [True: 11.0k, False: 4.24k]
  ------------------
  396|  11.0k|            {
  397|  11.0k|                std::size_t len2 = (std::min)(remaining_, length-len);
  398|  11.0k|                std::memcpy(p+len, data_end_, len2*sizeof(value_type));
  399|  11.0k|                data_end_ += len2;
  400|  11.0k|                remaining_ -= len2;
  401|  11.0k|                position_ += len2;
  402|  11.0k|                len += len2;
  403|  11.0k|            }
  404|  15.2k|            return len;
  405|  15.2k|        }
  406|      0|        else
  407|      0|        {
  408|      0|            if (stream_ptr_->eof())
  ------------------
  |  Branch (408:17): [True: 0, False: 0]
  ------------------
  409|      0|            {
  410|      0|                remaining_ = 0;
  411|      0|                return 0;
  412|      0|            }
  413|      0|            JSONCONS_TRY
  ------------------
  |  |   37|      0|    #define JSONCONS_TRY try
  ------------------
  414|      0|            {
  415|      0|                std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(p+len), length-len);
  416|      0|                std::size_t len2 = static_cast<std::size_t>(count);
  417|      0|                if (len2 < length-len)
  ------------------
  |  Branch (417:21): [True: 0, False: 0]
  ------------------
  418|      0|                {
  419|      0|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  420|      0|                }
  421|      0|                len += len2;
  422|      0|                position_ += len2;
  423|      0|                return len;
  424|      0|            }
  425|      0|            JSONCONS_CATCH(const std::exception&)     
  426|      0|            {
  427|      0|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  428|      0|                return 0;
  429|      0|            }
  430|      0|        }
  431|  47.3M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEPhm:
  442|  15.9k|    {
  443|  15.9k|        if (stream_ptr_->eof())
  ------------------
  |  Branch (443:13): [True: 4.31k, False: 11.6k]
  ------------------
  444|  4.31k|        {
  445|  4.31k|            return 0;
  446|  4.31k|        }
  447|       |
  448|  11.6k|        JSONCONS_TRY
  ------------------
  |  |   37|  11.6k|    #define JSONCONS_TRY try
  ------------------
  449|  11.6k|        {
  450|  11.6k|            std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(chunk), chunk_size);
  451|  11.6k|            std::size_t length = static_cast<std::size_t>(count);
  452|       |
  453|  11.6k|            if (length < chunk_size)
  ------------------
  |  Branch (453:17): [True: 6.21k, False: 5.45k]
  ------------------
  454|  6.21k|            {
  455|  6.21k|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  456|  6.21k|            }
  457|  11.6k|            return length;
  458|  11.6k|        }
  459|  11.6k|        JSONCONS_CATCH(const std::exception&)     
  460|  11.6k|        {
  461|      0|            stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  462|      0|            return 0;
  463|      0|        }
  464|  11.6k|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_6vectorIhS3_EEEENS_6detail4spanIKhLm18446744073709551615EEEmOT_:
  352|  1.28M|    {
  353|  1.28M|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|  1.28M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 363k, False: 920k]
  |  |  ------------------
  ------------------
  354|   363k|        {
  355|   363k|            return span<const value_type>{};
  356|   363k|        }
  357|   920k|        if (remaining_ == 0 && length <= chunk_size_)
  ------------------
  |  Branch (357:13): [True: 320, False: 920k]
  |  Branch (357:32): [True: 173, False: 147]
  ------------------
  358|    173|        {
  359|    173|            remaining_ = fill_buffer(chunk_, chunk_size_);
  360|    173|            data_end_ = chunk_;
  361|    173|        }
  362|   920k|        if (length > remaining_)
  ------------------
  |  Branch (362:13): [True: 998, False: 919k]
  ------------------
  363|    998|        {
  364|    998|            buffer.clear();
  365|    998|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  366|    998|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  367|    998|        }
  368|       |
  369|   919k|        const value_type* data = data_end_;
  370|   919k|        data_end_ += length;
  371|   919k|        remaining_ -= length;
  372|   919k|        position_ += length;
  373|   919k|        return span<const value_type>(data, length);
  374|   920k|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_6vectorIhS4_EEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr10ext_traits7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSD_m:
  746|    998|    {
  747|    998|        std::size_t unread = length;
  748|       |
  749|  4.05k|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (749:16): [True: 3.53k, False: 516]
  |  Branch (749:30): [True: 3.05k, False: 482]
  ------------------
  750|  3.05k|        {
  751|  3.05k|            if (source.remaining() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (751:17): [True: 534, False: 2.52k]
  |  Branch (751:44): [True: 533, False: 1]
  ------------------
  752|    533|            {
  753|    533|                std::size_t n = source.chunk_size();
  754|    533|                std::size_t offset = buffer.size();
  755|    533|                buffer.resize(offset+n);
  756|    533|                std::size_t actual = source.read_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  757|    533|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   78|    533|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 47, False: 486]
  |  |  ------------------
  ------------------
  758|     47|                {
  759|     47|                    buffer.resize(offset+actual);
  760|     47|                }
  761|    533|                unread -= actual;
  762|    533|            }
  763|  2.52k|            else
  764|  2.52k|            {
  765|  2.52k|                std::size_t n = (std::min)(source.chunk_size(), unread);
  766|  2.52k|                std::size_t offset = buffer.size();
  767|  2.52k|                buffer.resize(offset+n);
  768|  2.52k|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  769|  2.52k|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   78|  2.52k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 242, False: 2.27k]
  |  |  ------------------
  ------------------
  770|    242|                {
  771|    242|                    buffer.resize(offset + actual);
  772|    242|                }
  773|  2.52k|                unread -= actual;
  774|  2.52k|            }
  775|  3.05k|        }
  776|    998|        return length - unread;
  777|    998|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv:
  271|  3.53k|    {
  272|  3.53k|        return remaining_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:16): [True: 1.01k, False: 2.52k]
  |  Branch (272:35): [True: 482, False: 534]
  ------------------
  273|  3.53k|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9remainingEv:
  346|  3.05k|    {
  347|  3.05k|        return remaining_;
  348|  3.05k|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE10chunk_sizeEv:
  261|  3.58k|    {
  262|  3.58k|        return chunk_size_;
  263|  3.58k|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11read_bufferEPhm:
  435|    533|    {
  436|    533|        auto len = fill_buffer(chunk, chunk_size);
  437|    533|        position_ += len;
  438|    533|        return len;
  439|    533|    }

_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2Ev:
  641|  57.6k|    basic_bigint() = default;
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS4_:
  293|   176k|        : word_allocator_type(alloc)
  294|   176k|    {
  295|   176k|        ::new (&inlined_) inlined_storage();
  296|   176k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2Ev:
  113|   176k|            : is_allocated_(false),
  114|   176k|            is_negative_(false),
  115|   176k|            size_(0),
  116|   176k|            values_{0, 0}
  117|   176k|        {
  118|   176k|        }
_ZN8jsoncons9to_bigintIcEENS_16to_bigint_resultIT_EEPKS2_mRNS_12basic_bigintINSt3__19allocatorImEEEE:
 2135|  20.6k|{
 2136|  20.6k|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|  20.6k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 20.6k]
  |  |  ------------------
  ------------------
 2137|      0|    {
 2138|      0|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 2139|      0|    }
 2140|       |
 2141|  20.6k|    if (*data == '-')
  ------------------
  |  Branch (2141:9): [True: 2.95k, False: 17.7k]
  ------------------
 2142|  2.95k|    {
 2143|  2.95k|        return jsoncons::detail::to_bigint(data+1, length-1, true, value, std::allocator<uint64_t>{}); 
 2144|  2.95k|    }
 2145|  17.7k|    else
 2146|  17.7k|    {
 2147|  17.7k|        return jsoncons::detail::to_bigint(data, length, false, value, std::allocator<uint64_t>{}); 
 2148|  17.7k|    }
 2149|  20.6k|}
_ZN8jsoncons16to_bigint_resultIcEC2EPKcNSt3__14errcE:
  569|  20.6k|        : ptr(ptr_), ec(ec_)
  570|  20.6k|    {
  571|  20.6k|    }
_ZN8jsoncons6detail9to_bigintIcNSt3__19allocatorImEEEENS_16to_bigint_resultIT_EEPKS6_mbRNS_12basic_bigintIT0_EERKSB_:
 2048|  20.6k|{
 2049|  20.6k|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|  20.6k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 20.6k]
  |  |  ------------------
  ------------------
 2050|      0|    {
 2051|      0|        return to_bigint_result<CharT>(data, std::errc::invalid_argument);
 2052|      0|    }
 2053|       |
 2054|  20.6k|    using word_type = typename basic_bigint<Allocator>::word_type;
 2055|       |
 2056|  20.6k|    const CharT* last = data + length;
 2057|  20.6k|    const CharT* p = data;
 2058|       |
 2059|  22.8k|    while (p < last && *p == '0')
  ------------------
  |  Branch (2059:12): [True: 20.6k, False: 2.18k]
  |  Branch (2059:24): [True: 2.18k, False: 18.4k]
  ------------------
 2060|  2.18k|    {
 2061|  2.18k|        ++p;
 2062|  2.18k|    }
 2063|  20.6k|    if (p == last)
  ------------------
  |  Branch (2063:9): [True: 2.18k, False: 18.4k]
  ------------------
 2064|  2.18k|    {
 2065|  2.18k|        value = std::move(basic_bigint<Allocator>{0, alloc});
 2066|  2.18k|        return to_bigint_result<CharT>(last, std::errc{});
 2067|  2.18k|    }
 2068|  18.4k|    std::size_t num_digits = last - data;
 2069|  18.4k|    std::size_t num_words;
 2070|  18.4k|    if (length < 10)
  ------------------
  |  Branch (2070:9): [True: 677, False: 17.8k]
  ------------------
 2071|    677|    {
 2072|    677|        num_words = 1;
 2073|    677|    }
 2074|  17.8k|    else
 2075|  17.8k|    {
 2076|  17.8k|        std::size_t num_bits = (std::size_t)(((num_digits * detail::bits_per_digit[10]) >> 10) + 1);
 2077|  17.8k|        num_words = (num_bits + 63) >> 6;
 2078|  17.8k|    }
 2079|       |
 2080|  18.4k|    basic_bigint<Allocator> v(0, alloc);
 2081|  18.4k|    v.reserve(num_words);
 2082|   387k|    for (std::size_t i = 0; i < length; i++)
  ------------------
  |  Branch (2082:29): [True: 369k, False: 18.4k]
  ------------------
 2083|   369k|    {
 2084|   369k|        CharT c = data[i];
 2085|   369k|        if (JSONCONS_LIKELY(c >= '0' && c <= '9'))
  ------------------
  |  |   77|   738k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 369k, False: 0]
  |  |  |  Branch (77:48): [True: 369k, False: 0]
  |  |  |  Branch (77:48): [True: 369k, False: 0]
  |  |  ------------------
  ------------------
 2086|   369k|        {
 2087|   369k|            v *= 10u;
 2088|   369k|            v += (word_type)(c - '0');
 2089|   369k|        }
 2090|      0|        else
 2091|      0|        {
 2092|      0|            return to_bigint_result<CharT>(data + i, std::errc::invalid_argument);
 2093|      0|        }
 2094|   369k|    }
 2095|       |
 2096|  18.4k|    if (neg)
  ------------------
  |  Branch (2096:9): [True: 2.95k, False: 15.5k]
  ------------------
 2097|  2.95k|    {
 2098|  2.95k|        v.set_negative(true);
 2099|  2.95k|    }
 2100|       |
 2101|  18.4k|    value = std::move(v);
 2102|  18.4k|    return to_bigint_result<CharT>(last, std::errc{});
 2103|  18.4k|}
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IiEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  693|  41.3k|        : storage_(n, alloc)
  694|  41.3k|    {
  695|  41.3k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IiEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  360|  41.3k|        : word_allocator_type(alloc)
  361|  41.3k|    {
  362|  41.3k|        ::new (&inlined_) inlined_storage(n);
  363|  41.3k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IiEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  125|  41.3k|            : is_allocated_(false),
  126|  41.3k|            is_negative_(n < 0),
  127|  41.3k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (127:19): [True: 41.3k, False: 0]
  ------------------
  128|  41.3k|        {
  129|  41.3k|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (129:26): [True: 0, False: 41.3k]
  ------------------
  130|  41.3k|            values_[1] = 0;
  131|  41.3k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEaSERKS4_:
  842|   458k|    {
  843|   458k|        storage_ = y.storage_;
  844|   458k|        return *this;
  845|   458k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEaSERKS5_:
  366|   458k|    {
  367|   458k|        if (this != &other)
  ------------------
  |  Branch (367:13): [True: 458k, False: 0]
  ------------------
  368|   458k|        {
  369|   458k|            auto other_view = other.get_storage_view();
  370|   458k|            resize(other_view.size());
  371|   458k|            auto this_view = get_storage_view();
  372|   458k|            if (other_view.size() > 0)
  ------------------
  |  Branch (372:17): [True: 276k, False: 181k]
  ------------------
  373|   276k|            {
  374|   276k|                common_.is_negative_ = other.common_.is_negative_;
  375|   276k|                std::memcpy(this_view.data(), other_view.data(), size_type(other_view.size()*sizeof(word_type)));
  376|   276k|            }
  377|   458k|        }
  378|   458k|        return *this;
  379|   458k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  527|  1.13M|    {
  528|  1.13M|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (528:16): [True: 53.5k, False: 1.08M]
  ------------------
  529|  53.5k|            storage_view<const word_type>{allocated_.data_, allocated_.size_} :
  530|  1.13M|            storage_view<const word_type>{inlined_.values_, inlined_.size_};
  531|  1.13M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEC2EPS7_m:
   64|  1.13M|            : data_(data), size_(size)
   65|  1.13M|        {
   66|  1.13M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6resizeEm:
  534|  1.45M|    {
  535|  1.45M|        size_type old_length = common_.size_;
  536|  1.45M|        reserve(new_length);
  537|  1.45M|        common_.size_ = new_length;
  538|       |
  539|  1.45M|        if (old_length < new_length)
  ------------------
  |  Branch (539:13): [True: 1.15M, False: 300k]
  ------------------
  540|  1.15M|        {
  541|  1.15M|            if (is_allocated())
  ------------------
  |  Branch (541:17): [True: 63.8k, False: 1.09M]
  ------------------
  542|  63.8k|            {
  543|  63.8k|                std::memset(allocated_.data_+old_length, 0, size_type((new_length-old_length)*sizeof(word_type)));
  544|  63.8k|            }
  545|  1.09M|            else
  546|  1.09M|            {
  547|  1.09M|                JSONCONS_ASSERT(new_length <= inlined_capacity);
  ------------------
  |  |   49|  1.09M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 1.09M]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  548|  2.40M|                for (size_type i = old_length; i < inlined_capacity; ++i)
  ------------------
  |  Branch (548:48): [True: 1.31M, False: 1.09M]
  ------------------
  549|  1.31M|                {
  550|  1.31M|                    inlined_.values_[i] = 0;
  551|  1.31M|                }
  552|  1.09M|            }
  553|  1.15M|        }
  554|  1.45M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7reserveEm:
  452|  1.47M|    {
  453|  1.47M|       if (capacity() < n)
  ------------------
  |  Branch (453:12): [True: 13.8k, False: 1.46M]
  ------------------
  454|  13.8k|       {
  455|  13.8k|           if (!is_allocated())
  ------------------
  |  Branch (455:16): [True: 13.8k, False: 0]
  ------------------
  456|  13.8k|           {
  457|  13.8k|               size_type size = inlined_.size_;
  458|  13.8k|               size_type is_neg = inlined_.is_negative_;
  459|  13.8k|               word_type values[inlined_capacity] = {inlined_.values_[0], inlined_.values_[1]};
  460|       |
  461|  13.8k|               ::new (&allocated_) allocated_storage();
  462|  13.8k|               allocated_.reserve(n, get_allocator());
  463|  13.8k|               allocated_.size_ = size;
  464|  13.8k|               allocated_.is_negative_ = is_neg;
  465|  13.8k|               if (n >= 1)
  ------------------
  |  Branch (465:20): [True: 13.8k, False: 0]
  ------------------
  466|  13.8k|               {
  467|  13.8k|                   allocated_.data_[0] = values[0];
  468|  13.8k|               }
  469|  13.8k|               if (n >= 2)
  ------------------
  |  Branch (469:20): [True: 13.8k, False: 0]
  ------------------
  470|  13.8k|               {
  471|  13.8k|                   allocated_.data_[1] = values[1];
  472|  13.8k|               }
  473|  13.8k|           }
  474|      0|           else
  475|      0|           {
  476|      0|               allocated_.reserve(n, get_allocator());
  477|      0|           }
  478|  13.8k|       }
  479|  1.47M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE8capacityEv:
  505|  1.47M|    {
  506|  1.47M|        return is_allocated() ? allocated_.capacity_ : inlined_capacity;
  ------------------
  |  Branch (506:16): [True: 69.8k, False: 1.40M]
  ------------------
  507|  1.47M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2Ev:
  203|  13.8k|            : is_allocated_(true),
  204|  13.8k|            is_negative_(false)
  205|  13.8k|        {
  206|  13.8k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7reserveEmRKS4_:
  255|  13.8k|        {
  256|  13.8k|            JSONCONS_ASSERT(n < max_size);
  ------------------
  |  |   49|  13.8k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 13.8k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  257|  13.8k|            size_type capacity_new = round_up(n);
  258|       |
  259|  13.8k|            real_allocator_type alloc(a);
  260|  13.8k|            word_type* data_new = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_new);
  261|  13.8k|            if (size_ > 0)
  ------------------
  |  Branch (261:17): [True: 0, False: 13.8k]
  ------------------
  262|      0|            {
  263|      0|                std::memcpy(data_new, data_, size_type(size_ * sizeof(word_type)));
  264|      0|            }
  265|  13.8k|            if (data_ != nullptr)
  ------------------
  |  Branch (265:17): [True: 0, False: 13.8k]
  ------------------
  266|      0|            {
  267|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  268|      0|            }
  269|  13.8k|            capacity_ = capacity_new;
  270|  13.8k|            data_ = data_new;
  271|  13.8k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage8round_upEm:
  275|  13.8k|        {
  276|  13.8k|            size_type remainder = i % mem_unit;
  277|  13.8k|            size_type off = mem_unit - remainder;
  278|  13.8k|            bool testoff = i < max_size - off;
  279|  13.8k|            JSONCONS_ASSERT(testoff);
  ------------------
  |  |   49|  13.8k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 13.8k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  280|       |
  281|  13.8k|            return i + off;
  282|  13.8k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE13get_allocatorEv:
  482|   917k|    {
  483|   917k|        return static_cast<const word_allocator_type&>(*this);
  484|   917k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12is_allocatedEv:
  500|  4.65M|    {
  501|  4.65M|        return common_.is_allocated_;
  502|  4.65M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4sizeEv:
   84|  2.47M|        {
   85|  2.47M|            return size_;
   86|  2.47M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  520|  4.51M|    {
  521|  4.51M|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (521:16): [True: 286k, False: 4.23M]
  ------------------
  522|   286k|            storage_view<word_type>{allocated_.data_, allocated_.size_} :
  523|  4.51M|            storage_view<word_type>{inlined_.values_, inlined_.size_};
  524|  4.51M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEC2EPmm:
   64|  4.51M|            : data_(data), size_(size)
   65|  4.51M|        {
   66|  4.51M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4dataEv:
   79|   297k|        {
   80|   297k|            return data_;
   81|   297k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4dataEv:
   79|   276k|        {
   80|   276k|            return data_;
   81|   276k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE7reserveEm:
  823|  18.4k|    {
  824|  18.4k|        storage_.reserve(n);
  825|  18.4k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLIjEENS1_9enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
  998|   369k|    {
  999|   369k|        auto this_view = get_storage_view();
 1000|   369k|        size_type len0 = this_view.size();
 1001|   369k|        word_type dig = this_view[0];
 1002|   369k|        word_type carry = 0;
 1003|       |
 1004|   369k|        resize(this_view.size() + 1);
 1005|   369k|        this_view = get_storage_view();
 1006|       |
 1007|   369k|        size_type i = 0;
 1008|   746k|        for (; i < len0; i++ )
  ------------------
  |  Branch (1008:16): [True: 376k, False: 369k]
  ------------------
 1009|   376k|        {
 1010|   376k|            word_type hi;
 1011|   376k|            word_type lo;
 1012|   376k|            DDproduct( dig, y, hi, lo );
 1013|   376k|            this_view[i] = lo + carry;
 1014|   376k|            dig = this_view[i+1];
 1015|   376k|            carry = hi + (this_view[i] < lo);
 1016|   376k|        }
 1017|   369k|        this_view[i] = carry;
 1018|   369k|        reduce();
 1019|   369k|        return *this;
 1020|   369k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  718|  3.03M|    {
  719|  3.03M|        return storage_.get_storage_view();
  720|  3.03M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4sizeEv:
   84|  5.51M|        {
   85|  5.51M|            return size_;
   86|  5.51M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEixEm:
   69|  4.57M|        {
   70|  4.57M|            return data_[i];
   71|  4.57M|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6resizeEm:
  818|   998k|    {
  819|   998k|        storage_.resize(new_length);
  820|   998k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9DDproductEmmRmS5_:
 1781|   504k|    {
 1782|   504k|        word_type hiA = A >> word_type_half_bits, loA = A & r_mask,
 1783|   504k|                   hiB = B >> word_type_half_bits, loB = B & r_mask;
 1784|       |
 1785|   504k|        lo = loA * loB;
 1786|   504k|        hi = hiA * hiB;
 1787|   504k|        word_type mid1 = loA * hiB;
 1788|   504k|        word_type mid2 = hiA * loB;
 1789|   504k|        word_type old = lo;
 1790|   504k|        lo += mid1 << word_type_half_bits;
 1791|   504k|            hi += (lo < old) + (mid1 >> word_type_half_bits);
 1792|   504k|        old = lo;
 1793|   504k|        lo += mid2 << word_type_half_bits;
 1794|   504k|            hi += (lo < old) + (mid2 >> word_type_half_bits);
 1795|   504k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6reduceEv:
 1917|  1.02M|    {
 1918|  1.02M|        storage_.reduce();
 1919|  1.02M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6reduceEv:
  429|  1.02M|    {
  430|  1.02M|        if (common_.size_ > 0)
  ------------------
  |  Branch (430:13): [True: 1.02M, False: 0]
  ------------------
  431|  1.02M|        {
  432|  1.02M|            auto this_view = get_storage_view();
  433|  1.02M|            word_type* p = this_view.end() - 1;
  434|  1.02M|            word_type* first = this_view.begin();
  435|  1.99M|            while ( p >= first )
  ------------------
  |  Branch (435:21): [True: 1.96M, False: 27.5k]
  ------------------
  436|  1.96M|            {
  437|  1.96M|                if ( *p )
  ------------------
  |  Branch (437:22): [True: 1.00M, False: 964k]
  ------------------
  438|  1.00M|                {
  439|  1.00M|                    break;
  440|  1.00M|                }
  441|   964k|                --common_.size_;
  442|   964k|                --p;
  443|   964k|            }
  444|  1.02M|        }
  445|  1.02M|        if (common_.size_ == 0)
  ------------------
  |  Branch (445:13): [True: 27.5k, False: 1.00M]
  ------------------
  446|  27.5k|        {
  447|  27.5k|            common_.is_negative_ = false;
  448|  27.5k|        }
  449|  1.02M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE3endEv:
   93|  1.02M|        {
   94|  1.02M|            return data_ + size_;
   95|  1.02M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE5beginEv:
   88|  1.02M|        {
   89|  1.02M|            return data_;
   90|  1.02M|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLImEENS1_9enable_ifIXaasr10ext_traits19is_unsigned_integerIT_EE5valuelestS7_Lm8EERS4_E4typeES7_:
  889|   478k|    {
  890|   478k|        if ( is_negative())
  ------------------
  |  Branch (890:14): [True: 0, False: 478k]
  ------------------
  891|      0|            return *this -= -basic_bigint<Allocator>(y);
  892|       |
  893|   478k|        word_type d;
  894|   478k|        word_type carry = 0;
  895|       |
  896|   478k|        auto this_view = get_storage_view();
  897|   478k|        resize(this_view.size() + 1);
  898|       |
  899|   478k|        this_view = get_storage_view();
  900|   478k|        const size_type this_size = this_view.size();
  901|   478k|        size_type y_size = 1;
  902|       |
  903|   478k|        d = this_view[0] + carry;
  904|   478k|        carry = d < carry;
  905|   478k|        this_view[0] = d + y;
  906|   478k|        if (this_view[0] < d)
  ------------------
  |  Branch (906:13): [True: 1.34k, False: 476k]
  ------------------
  907|  1.34k|            carry = 1;
  908|       |
  909|   479k|        for (size_type i = y_size; i < this_size && carry != 0; ++i)
  ------------------
  |  Branch (909:36): [True: 456k, False: 22.5k]
  |  Branch (909:53): [True: 1.34k, False: 455k]
  ------------------
  910|  1.34k|        {
  911|  1.34k|            d = this_view[i] + carry;
  912|  1.34k|            carry = d < carry;
  913|  1.34k|            this_view[i] = d;
  914|  1.34k|        }
  915|   478k|        reduce();
  916|   478k|        return *this;
  917|   478k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11is_negativeEv:
  728|  2.13M|    {
  729|  2.13M|        return storage_.is_negative();
  730|  2.13M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE11is_negativeEv:
  510|  2.13M|    {
  511|  2.13M|        return common_.is_negative_;
  512|  2.13M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ImEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  693|   534k|        : storage_(n, alloc)
  694|   534k|    {
  695|   534k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ImEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  360|   534k|        : word_allocator_type(alloc)
  361|   534k|    {
  362|   534k|        ::new (&inlined_) inlined_storage(n);
  363|   534k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ImEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  138|   534k|            : is_allocated_(false),
  139|   534k|            is_negative_(false),
  140|   534k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (140:19): [True: 181k, False: 352k]
  ------------------
  141|   534k|        {
  142|   534k|            values_[0] = n;
  143|   534k|            values_[1] = 0;
  144|   534k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEEngEv:
  835|  7.43k|    {
  836|  7.43k|        basic_bigint<Allocator> v(*this);
  837|  7.43k|        v.set_negative(!v.is_negative());
  838|  7.43k|        return v;
  839|  7.43k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_:
  671|   129k|        : storage_(other.storage_)
  672|   129k|    {
  673|   129k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_:
  299|   129k|        : word_allocator_type(other.get_allocator())
  300|   129k|    {
  301|       |#if defined(__GNUC__) && JSONCONS_GCC_AVAILABLE(12,0,0)
  302|       |# pragma GCC diagnostic push
  303|       |# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
  304|       |#endif
  305|   129k|        if (!other.is_allocated())
  ------------------
  |  Branch (305:13): [True: 119k, False: 9.93k]
  ------------------
  306|   119k|        {
  307|   119k|            ::new (&inlined_) inlined_storage(other.inlined_);
  308|   119k|        }
  309|  9.93k|        else
  310|  9.93k|        {
  311|  9.93k|            ::new (&allocated_) allocated_storage(other.allocated_, get_allocator());
  312|  9.93k|        }
  313|       |#if defined(__GNUC__) && JSONCONS_GCC_AVAILABLE(12,0,0)
  314|       |# pragma GCC diagnostic pop
  315|       |#endif
  316|   129k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ERKS6_:
  178|   563k|            : is_allocated_(false),
  179|   563k|            is_negative_(stor.is_negative_),
  180|   563k|            size_(stor.size_)
  181|   563k|        {
  182|   563k|            values_[0] = stor.values_[0];
  183|   563k|            values_[1] = stor.values_[1];
  184|   563k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2ERKS6_RKS4_:
  209|  39.7k|            : is_allocated_(true),
  210|  39.7k|              is_negative_(stor.is_negative_),
  211|  39.7k|              size_(stor.size_),
  212|  39.7k|              capacity_(stor.capacity_)
  213|  39.7k|        {
  214|  39.7k|            real_allocator_type alloc(a);
  215|       |
  216|  39.7k|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_);
  217|  39.7k|            JSONCONS_TRY
  ------------------
  |  |   37|  39.7k|    #define JSONCONS_TRY try
  ------------------
  218|  39.7k|            {
  219|  39.7k|                std::allocator_traits<real_allocator_type>::construct(alloc, ext_traits::to_plain_pointer(data_));
  220|  39.7k|            }
  221|  39.7k|            JSONCONS_CATCH(...)
  222|  39.7k|            {
  223|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  224|      0|                data_ = nullptr;
  225|      0|                JSONCONS_RETHROW;
  ------------------
  |  |   36|      0|    #define JSONCONS_RETHROW throw
  ------------------
  226|      0|            }
  227|  39.7k|            JSONCONS_ASSERT(stor.data_ != nullptr);
  ------------------
  |  |   49|  39.7k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 39.7k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  228|  39.7k|            std::memcpy(data_, stor.data_, size_type(stor.size_ * sizeof(word_type)));
  229|  39.7k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmIERKS4_:
  954|  7.43k|    {
  955|  7.43k|        auto y_view = y.get_storage_view();
  956|       |
  957|  7.43k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (957:14): [True: 7.43k, False: 0]
  ------------------
  958|  7.43k|            return *this += -y;
  959|      0|        if ( (!is_negative() && y > *this) || (is_negative() && y < *this) )
  ------------------
  |  Branch (959:15): [True: 0, False: 0]
  |  Branch (959:33): [True: 0, False: 0]
  |  Branch (959:48): [True: 0, False: 0]
  |  Branch (959:65): [True: 0, False: 0]
  ------------------
  960|      0|            return *this = -(y - *this);
  961|      0|        word_type borrow = 0;
  962|      0|        word_type d;
  963|      0|        auto this_view = get_storage_view();
  964|      0|        const size_type this_size = this_view.size();
  965|      0|        const size_type y_size = y_view.size();
  966|       |
  967|      0|        for (size_type i = 0; i < y_size; i++ )
  ------------------
  |  Branch (967:31): [True: 0, False: 0]
  ------------------
  968|      0|        {
  969|      0|            d = this_view[i] - borrow;
  970|      0|            borrow = d > this_view[i];
  971|      0|            this_view[i] = d - y_view[i];
  972|      0|            if ( this_view[i] > d )
  ------------------
  |  Branch (972:18): [True: 0, False: 0]
  ------------------
  973|      0|                borrow = 1;
  974|      0|        }
  975|      0|        for (size_type i = y_size; i < this_size && borrow != 0; i++ )
  ------------------
  |  Branch (975:36): [True: 0, False: 0]
  |  Branch (975:53): [True: 0, False: 0]
  ------------------
  976|      0|        {
  977|      0|            d = this_view[i] - borrow;
  978|      0|            borrow = d > this_view[i];
  979|      0|            this_view[i] = d;
  980|      0|        }
  981|      0|        reduce();
  982|      0|        return *this;
  983|      0|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  723|   678k|    {
  724|   678k|        return storage_.get_storage_view();
  725|   678k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLERKS4_:
  920|  7.43k|    {
  921|  7.43k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (921:14): [True: 0, False: 7.43k]
  ------------------
  922|      0|            return *this -= -y;
  923|       |
  924|  7.43k|        auto y_view = y.get_storage_view();
  925|       |        
  926|  7.43k|        word_type d;
  927|  7.43k|        word_type carry = 0;
  928|       |
  929|  7.43k|        auto this_view = get_storage_view();
  930|  7.43k|        resize( (std::max)(y_view.size(), this_view.size()) + 1 );
  931|  7.43k|        this_view = get_storage_view();
  932|       |
  933|  7.43k|        const size_t this_size = this_view.size();
  934|  7.43k|        const size_t y_size = y_view.size();
  935|  14.5k|        for (size_type i = 0; i < y_size; i++ )
  ------------------
  |  Branch (935:31): [True: 7.07k, False: 7.43k]
  ------------------
  936|  7.07k|        {
  937|  7.07k|            d = this_view[i] + carry;
  938|  7.07k|            carry = d < carry;
  939|  7.07k|            this_view[i] = d + y_view[i];
  940|  7.07k|            if (this_view[i] < d)
  ------------------
  |  Branch (940:17): [True: 3.28k, False: 3.78k]
  ------------------
  941|  3.28k|                carry = 1;
  942|  7.07k|        }
  943|  10.7k|        for (size_type i = y_size; i < this_size && carry != 0; i++ )
  ------------------
  |  Branch (943:36): [True: 10.3k, False: 347]
  |  Branch (943:53): [True: 3.28k, False: 7.09k]
  ------------------
  944|  3.28k|        {
  945|  3.28k|            d = this_view[i] + carry;
  946|  3.28k|            carry = d < carry;
  947|  3.28k|            this_view[i] = d;
  948|  3.28k|        }
  949|  7.43k|        reduce();
  950|  7.43k|        return *this;
  951|  7.43k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7compareERKS4_:
 1641|   260k|    {
 1642|   260k|        auto this_view = get_storage_view();
 1643|   260k|        auto y_view = y.get_storage_view();
 1644|       |
 1645|   260k|        const size_type y_size = y_view.size();
 1646|   260k|        if ( this_view.size() == 0 && y_size == 0 )
  ------------------
  |  Branch (1646:14): [True: 4.37k, False: 255k]
  |  Branch (1646:39): [True: 4.37k, False: 0]
  ------------------
 1647|  4.37k|            return 0;
 1648|   255k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (1648:14): [True: 10.3k, False: 245k]
  ------------------
 1649|  10.3k|            return y.is_negative() - is_negative();
 1650|   245k|        int code = 0;
 1651|   245k|        if ( this_view.size() < y_size)
  ------------------
  |  Branch (1651:14): [True: 0, False: 245k]
  ------------------
 1652|      0|            code = -1;
 1653|   245k|        else if ( this_view.size() > y_size)
  ------------------
  |  Branch (1653:19): [True: 34.0k, False: 211k]
  ------------------
 1654|  34.0k|            code = +1;
 1655|   211k|        else
 1656|   211k|        {
 1657|   269k|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1657:50): [True: 211k, False: 57.8k]
  ------------------
 1658|   211k|            {
 1659|   211k|                if (this_view[i] > y_view[i])
  ------------------
  |  Branch (1659:21): [True: 34.1k, False: 177k]
  ------------------
 1660|  34.1k|                {
 1661|  34.1k|                    code = 1;
 1662|  34.1k|                    break;
 1663|  34.1k|                }
 1664|   177k|                else if (this_view[i] < y_view[i])
  ------------------
  |  Branch (1664:26): [True: 119k, False: 57.8k]
  ------------------
 1665|   119k|                {
 1666|   119k|                    code = -1;
 1667|   119k|                    break;
 1668|   119k|                }
 1669|   211k|            }
 1670|   211k|        }
 1671|   245k|        return is_negative() ? -code : code;
  ------------------
  |  Branch (1671:16): [True: 0, False: 245k]
  ------------------
 1672|   255k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEES6_:
 1476|   225k|    {
 1477|   225k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1477:15): [True: 119k, False: 106k]
  ------------------
 1478|   225k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEixEm:
   69|   834k|        {
   70|   834k|            return data_[i];
   71|   834k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE12set_negativeEb:
  733|   914k|    {
  734|   914k|        storage_.set_negative(value);
  735|   914k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12set_negativeEb:
  515|   914k|    {
  516|   914k|        common_.is_negative_ = value;
  517|   914k|    }
_ZNK8jsoncons16to_bigint_resultIcEcvbEv:
  578|  20.6k|    {
  579|  20.6k|        return ec == std::errc{};
  580|  20.6k|    }
_ZN8jsonconsneERKNS_12basic_bigintINSt3__19allocatorImEEEEi:
 1471|  20.6k|    {
 1472|  20.6k|        return x.compare(basic_bigint<Allocator>(y)) != 0 ? true : false;
  ------------------
  |  Branch (1472:16): [True: 18.4k, False: 2.18k]
  ------------------
 1473|  20.6k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE6divideERKS4_RS4_S7_b:
 1675|   225k|    {
 1676|   225k|        basic_bigint<Allocator> denom(denom_, get_allocator());
 1677|   225k|        auto denom_view = denom.get_storage_view();
 1678|       |
 1679|   225k|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1679:13): [True: 0, False: 225k]
  ------------------
 1680|      0|        {
 1681|      0|            JSONCONS_THROW(std::runtime_error( "Zero divide." ));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1682|      0|        }
 1683|   225k|        bool quot_neg = is_negative() ^ denom.is_negative();
 1684|   225k|        bool rem_neg = is_negative();
 1685|   225k|        basic_bigint<Allocator> num(*this, get_allocator());
 1686|   225k|        num.set_negative(false);
 1687|   225k|        denom.set_negative(false);
 1688|   225k|        if ( num < denom )
  ------------------
  |  Branch (1688:14): [True: 119k, False: 106k]
  ------------------
 1689|   119k|        {
 1690|   119k|            quot = word_type(0);
 1691|   119k|            quot.set_negative(quot_neg);
 1692|   119k|            rem = num;
 1693|   119k|            rem.set_negative(rem_neg);
 1694|   119k|            return;
 1695|   119k|        }
 1696|       |
 1697|   106k|        auto num_view = num.get_storage_view();
 1698|   106k|        auto quot_view = quot.get_storage_view();
 1699|   106k|        auto this_view = get_storage_view();
 1700|       |
 1701|   106k|        if ( denom_view.size() == 1 && num_view.size() == 1 )
  ------------------
  |  Branch (1701:14): [True: 106k, False: 0]
  |  Branch (1701:40): [True: 91.9k, False: 14.4k]
  ------------------
 1702|  91.9k|        {
 1703|  91.9k|            quot = word_type( num_view[0]/denom_view[0] );
 1704|  91.9k|            rem = word_type( num_view[0]%denom_view[0] );
 1705|  91.9k|            quot.set_negative(quot_neg);
 1706|  91.9k|            rem.set_negative(rem_neg);
 1707|  91.9k|            return;
 1708|  91.9k|        }
 1709|  14.4k|        if (denom_view.size() == 1 && (denom_view[0] & l_mask) == 0 )
  ------------------
  |  Branch (1709:13): [True: 14.4k, False: 0]
  |  Branch (1709:39): [True: 3.94k, False: 10.5k]
  ------------------
 1710|  3.94k|        {
 1711|       |            // Denominator fits into a half word
 1712|  3.94k|            word_type divisor = denom_view[0], dHi = 0, q1, r, q2, dividend;
 1713|  3.94k|            quot.resize(this_view.size());
 1714|  3.94k|            quot_view = quot.get_storage_view();
 1715|  11.8k|            for (size_type i=this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1715:48): [True: 7.88k, False: 3.94k]
  ------------------
 1716|  7.88k|            {
 1717|  7.88k|                dividend = (dHi << word_type_half_bits) | (this_view[i] >> word_type_half_bits);
 1718|  7.88k|                q1 = dividend/divisor;
 1719|  7.88k|                r = dividend % divisor;
 1720|  7.88k|                dividend = (r << word_type_half_bits) | (this_view[i] & r_mask);
 1721|  7.88k|                q2 = dividend/divisor;
 1722|  7.88k|                dHi = dividend % divisor;
 1723|  7.88k|                quot_view[i] = (q1 << word_type_half_bits) | q2;
 1724|  7.88k|            }
 1725|  3.94k|            quot.reduce();
 1726|  3.94k|            rem = dHi;
 1727|  3.94k|            quot.set_negative(quot_neg);
 1728|  3.94k|            rem.set_negative(rem_neg);
 1729|  3.94k|            return;
 1730|  3.94k|        }
 1731|  10.5k|        basic_bigint<Allocator> num0(num, get_allocator());
 1732|  10.5k|        basic_bigint<Allocator> denom0(denom, get_allocator());
 1733|  10.5k|        int x = 0;
 1734|  10.5k|        bool second_done = normalize(denom, num, x);
 1735|  10.5k|        denom_view = denom.get_storage_view();
 1736|  10.5k|        num_view = num.get_storage_view();
 1737|       |
 1738|  10.5k|        size_type l = denom_view.size() - 1;
 1739|  10.5k|        size_type n = num_view.size() - 1;
 1740|  10.5k|        quot.resize(n - l);
 1741|  10.5k|        quot_view = quot.get_storage_view();
 1742|  21.1k|        for (size_type i = quot_view.size(); i-- > 0; )
  ------------------
  |  Branch (1742:46): [True: 10.5k, False: 10.5k]
  ------------------
 1743|  10.5k|        {
 1744|  10.5k|            quot_view[i] = 0;
 1745|  10.5k|        }
 1746|  10.5k|        rem = num;
 1747|  10.5k|        auto rem_view = rem.get_storage_view();
 1748|  10.5k|        if ( rem_view[n] >= denom_view[l] )
  ------------------
  |  Branch (1748:14): [True: 0, False: 10.5k]
  ------------------
 1749|      0|        {
 1750|      0|            rem.resize(rem_view.size() + 1);
 1751|      0|            rem_view = rem.get_storage_view();
 1752|      0|            n++;
 1753|      0|            quot.resize(quot_view.size() + 1);
 1754|      0|            quot_view = quot.get_storage_view();
 1755|      0|        }
 1756|  10.5k|        word_type d = denom_view[l];
 1757|       |
 1758|  21.1k|        for ( size_type k = n; k > l; k-- )
  ------------------
  |  Branch (1758:32): [True: 10.5k, False: 10.5k]
  ------------------
 1759|  10.5k|        {
 1760|  10.5k|            word_type q = DDquotient(rem_view[k], rem_view[k-1], d);
 1761|  10.5k|            subtractmul( rem_view.data() + (k - l - 1), denom_view.data(), l + 1, q );
 1762|  10.5k|            quot_view[k - l - 1] = q;
 1763|  10.5k|        }
 1764|  10.5k|        quot.reduce();
 1765|  10.5k|        quot.set_negative(quot_neg);
 1766|  10.5k|        if (remDesired)
  ------------------
  |  Branch (1766:13): [True: 10.5k, False: 0]
  ------------------
 1767|  10.5k|        {
 1768|  10.5k|            unnormalize(rem, x, second_done);
 1769|  10.5k|            rem.set_negative(rem_neg);
 1770|  10.5k|        }
 1771|  10.5k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE13get_allocatorEv:
  713|   710k|    {
  714|   710k|        return storage_.get_allocator();
  715|   710k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_RKS3_:
  676|   472k|        : storage_(other.storage_, alloc)
  677|   472k|    {
  678|   472k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_RKS4_:
  319|   472k|        : word_allocator_type(alloc)
  320|   472k|    {
  321|   472k|        if (!other.is_allocated())
  ------------------
  |  Branch (321:13): [True: 443k, False: 29.7k]
  ------------------
  322|   443k|        {
  323|   443k|            ::new (&inlined_) inlined_storage(other.inlined_);
  324|   443k|        }
  325|  29.7k|        else
  326|  29.7k|        {
  327|  29.7k|            ::new (&allocated_) allocated_storage(other.allocated_, alloc);
  328|  29.7k|        }
  329|   472k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9normalizeERS4_S5_Ri:
 1872|  10.5k|    {
 1873|  10.5k|        auto denom_view = denom.get_storage_view();
 1874|  10.5k|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1874:13): [True: 0, False: 10.5k]
  ------------------
 1875|      0|        {
 1876|      0|            return false;
 1877|      0|        }
 1878|  10.5k|        size_type r = denom_view.size() - 1;
 1879|  10.5k|        word_type y = denom_view[r];
 1880|       |
 1881|  10.5k|        x = 0;
 1882|  10.5k|        while ( (y & l_bit) == 0 )
  ------------------
  |  Branch (1882:17): [True: 0, False: 10.5k]
  ------------------
 1883|      0|        {
 1884|      0|            y <<= 1;
 1885|      0|            x++;
 1886|      0|        }
 1887|  10.5k|        denom <<= x;
 1888|  10.5k|        num <<= x;
 1889|       |
 1890|  10.5k|        denom_view = denom.get_storage_view();
 1891|  10.5k|        if ( r > 0 && denom_view[r] < denom_view[r-1] )
  ------------------
  |  Branch (1891:14): [True: 0, False: 10.5k]
  |  Branch (1891:23): [True: 0, False: 0]
  ------------------
 1892|      0|        {
 1893|      0|            denom *= max_word;
 1894|      0|            num *= max_word;
 1895|      0|            return true;
 1896|      0|        }
 1897|  10.5k|        return false;
 1898|  10.5k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEElSEm:
 1117|  21.1k|    {
 1118|  21.1k|        auto this_view = get_storage_view();
 1119|  21.1k|        size_type q = k / word_type_bits;
 1120|  21.1k|        if ( q ) // Increase storage_.size() by q:
  ------------------
  |  Branch (1120:14): [True: 0, False: 21.1k]
  ------------------
 1121|      0|        {
 1122|      0|            resize(this_view.size() + q);
 1123|      0|            this_view = get_storage_view();
 1124|      0|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1124:50): [True: 0, False: 0]
  ------------------
 1125|      0|                this_view[i] = ( i < q ? 0 : this_view[i - q]);
  ------------------
  |  Branch (1125:34): [True: 0, False: 0]
  ------------------
 1126|      0|            k %= word_type_bits;
 1127|      0|        }
 1128|  21.1k|        if ( k )  // 0 < k < word_type_bits:
  ------------------
  |  Branch (1128:14): [True: 0, False: 21.1k]
  ------------------
 1129|      0|        {
 1130|      0|            size_type k1 = word_type_bits - k;
 1131|      0|            word_type mask = (word_type(1) << k) - word_type(1);
 1132|      0|            resize( this_view.size() + 1 );
 1133|      0|            this_view = get_storage_view();
 1134|      0|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1134:50): [True: 0, False: 0]
  ------------------
 1135|      0|            {
 1136|      0|                this_view[i] <<= k;
 1137|      0|                if ( i > 0 )
  ------------------
  |  Branch (1137:22): [True: 0, False: 0]
  ------------------
 1138|      0|                    this_view[i] |= (this_view[i-1] >> k1) & mask;
 1139|      0|            }
 1140|      0|        }
 1141|  21.1k|        reduce();
 1142|  21.1k|        return *this;
 1143|  21.1k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLImEENS1_9enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
  998|   122k|    {
  999|   122k|        auto this_view = get_storage_view();
 1000|   122k|        size_type len0 = this_view.size();
 1001|   122k|        word_type dig = this_view[0];
 1002|   122k|        word_type carry = 0;
 1003|       |
 1004|   122k|        resize(this_view.size() + 1);
 1005|   122k|        this_view = get_storage_view();
 1006|       |
 1007|   122k|        size_type i = 0;
 1008|   239k|        for (; i < len0; i++ )
  ------------------
  |  Branch (1008:16): [True: 117k, False: 122k]
  ------------------
 1009|   117k|        {
 1010|   117k|            word_type hi;
 1011|   117k|            word_type lo;
 1012|   117k|            DDproduct( dig, y, hi, lo );
 1013|   117k|            this_view[i] = lo + carry;
 1014|   117k|            dig = this_view[i+1];
 1015|   117k|            carry = hi + (this_view[i] < lo);
 1016|   117k|        }
 1017|   122k|        this_view[i] = carry;
 1018|   122k|        reduce();
 1019|   122k|        return *this;
 1020|   122k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE10DDquotientEmmm:
 1799|  10.5k|    {
 1800|  10.5k|        word_type left, middle, right, qHi, qLo, x, dLo1,
 1801|  10.5k|                   dHi = d >> word_type_half_bits, dLo = d & r_mask;
 1802|  10.5k|        qHi = A/(dHi + 1);
 1803|       |        // This initial guess of qHi may be too small.
 1804|  10.5k|        middle = qHi * dLo;
 1805|  10.5k|        left = qHi * dHi;
 1806|  10.5k|        x = B - (middle << word_type_half_bits);
 1807|  10.5k|        A -= (middle >> word_type_half_bits) + left + (x > B);
 1808|  10.5k|        B = x;
 1809|  10.5k|        dLo1 = dLo << word_type_half_bits;
 1810|       |        // Increase qHi if necessary:
 1811|  10.5k|        while ( A > dHi || (A == dHi && B >= dLo1) )
  ------------------
  |  Branch (1811:17): [True: 0, False: 10.5k]
  |  Branch (1811:29): [True: 0, False: 10.5k]
  |  Branch (1811:41): [True: 0, False: 0]
  ------------------
 1812|      0|        {
 1813|      0|            x = B - dLo1;
 1814|      0|            A -= dHi + (x > B);
 1815|      0|            B = x;
 1816|      0|            qHi++;
 1817|      0|        }
 1818|  10.5k|        qLo = ((A << word_type_half_bits) | (B >> word_type_half_bits))/(dHi + 1);
 1819|       |        // This initial guess of qLo may be too small.
 1820|  10.5k|        right = qLo * dLo;
 1821|  10.5k|        middle = qLo * dHi;
 1822|  10.5k|        x = B - right;
 1823|  10.5k|        A -= (x > B);
 1824|  10.5k|        B = x;
 1825|  10.5k|        x = B - (middle << word_type_half_bits);
 1826|  10.5k|            A -= (middle >> word_type_half_bits) + (x > B);
 1827|  10.5k|        B = x;
 1828|       |        // Increase qLo if necessary:
 1829|  11.6k|        while ( A || B >= d )
  ------------------
  |  Branch (1829:17): [True: 0, False: 11.6k]
  |  Branch (1829:22): [True: 1.11k, False: 10.5k]
  ------------------
 1830|  1.11k|        {
 1831|  1.11k|            x = B - d;
 1832|  1.11k|            A -= (x > B);
 1833|  1.11k|            B = x;
 1834|  1.11k|            qLo++;
 1835|  1.11k|        }
 1836|  10.5k|        return (qHi << word_type_half_bits) + qLo;
 1837|  10.5k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11subtractmulEPmS5_mRm:
 1841|  10.5k|    {
 1842|  10.5k|        word_type hi, lo, d, carry = 0;
 1843|  10.5k|        size_type i;
 1844|  21.1k|        for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1844:22): [True: 10.5k, False: 10.5k]
  ------------------
 1845|  10.5k|        {
 1846|  10.5k|            DDproduct( b[i], q, hi, lo );
 1847|  10.5k|            d = a[i];
 1848|  10.5k|            a[i] -= lo;
 1849|  10.5k|            if ( a[i] > d )
  ------------------
  |  Branch (1849:18): [True: 5.80k, False: 4.75k]
  ------------------
 1850|  5.80k|                carry++;
 1851|  10.5k|            d = a[i + 1];
 1852|  10.5k|            a[i + 1] -= hi + carry;
 1853|  10.5k|            carry = a[i + 1] > d;
 1854|  10.5k|        }
 1855|  10.5k|        if ( carry ) // q was too large
  ------------------
  |  Branch (1855:14): [True: 0, False: 10.5k]
  ------------------
 1856|      0|        {
 1857|      0|            q--;
 1858|      0|            carry = 0;
 1859|      0|            for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1859:26): [True: 0, False: 0]
  ------------------
 1860|      0|            {
 1861|      0|                d = a[i] + carry;
 1862|      0|                carry = d < carry;
 1863|      0|                a[i] = d + b[i];
 1864|      0|                if ( a[i] < d )
  ------------------
  |  Branch (1864:22): [True: 0, False: 0]
  ------------------
 1865|      0|                    carry = 1;
 1866|      0|            }
 1867|      0|            a[n] = 0;
 1868|      0|        }
 1869|  10.5k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11unnormalizeERS4_ib:
 1901|  10.5k|    {
 1902|  10.5k|        if (secondDone)
  ------------------
  |  Branch (1902:13): [True: 0, False: 10.5k]
  ------------------
 1903|      0|        {
 1904|      0|            rem /= max_word;
 1905|      0|        }
 1906|  10.5k|        if ( x > 0 )
  ------------------
  |  Branch (1906:14): [True: 0, False: 10.5k]
  ------------------
 1907|      0|        {
 1908|      0|            rem >>= x;
 1909|      0|        }
 1910|  10.5k|        else
 1911|  10.5k|        {
 1912|  10.5k|            rem.reduce();
 1913|  10.5k|        }
 1914|  10.5k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IlEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  693|  45.8k|        : storage_(n, alloc)
  694|  45.8k|    {
  695|  45.8k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IlEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  360|  45.8k|        : word_allocator_type(alloc)
  361|  45.8k|    {
  362|  45.8k|        ::new (&inlined_) inlined_storage(n);
  363|  45.8k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IlEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  125|  45.8k|            : is_allocated_(false),
  126|  45.8k|            is_negative_(n < 0),
  127|  45.8k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (127:19): [True: 15.8k, False: 29.9k]
  ------------------
  128|  45.8k|        {
  129|  45.8k|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (129:26): [True: 7.43k, False: 38.3k]
  ------------------
  130|  45.8k|            values_[1] = 0;
  131|  45.8k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEED2Ev:
  708|  1.40M|    {
  709|  1.40M|        storage_.destroy();
  710|  1.40M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7destroyEv:
  487|  1.40M|    {
  488|  1.40M|        if (is_allocated())
  ------------------
  |  Branch (488:13): [True: 53.5k, False: 1.35M]
  ------------------
  489|  53.5k|        {
  490|  53.5k|            allocated_.destroy(get_allocator());
  491|  53.5k|            allocated_.~allocated_storage();
  492|  53.5k|        }
  493|  1.35M|        else
  494|  1.35M|        {
  495|  1.35M|            inlined_.~inlined_storage();
  496|  1.35M|        }
  497|  1.40M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7destroyERKS4_:
  246|  53.5k|        {
  247|  53.5k|            if (data_ != nullptr)
  ------------------
  |  Branch (247:17): [True: 53.5k, False: 0]
  ------------------
  248|  53.5k|            {
  249|  53.5k|                real_allocator_type alloc(a);
  250|  53.5k|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  251|  53.5k|            }
  252|  53.5k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEEcvT_IlvEEv:
 1275|  36.9k|    {
 1276|  36.9k|        auto this_view = get_storage_view();
 1277|  36.9k|        Integer x = 0;
 1278|  36.9k|        if (this_view.size() > 0)
  ------------------
  |  Branch (1278:13): [True: 34.4k, False: 2.51k]
  ------------------
 1279|  34.4k|        {
 1280|  34.4k|            x = static_cast<Integer>(this_view[0]);
 1281|  34.4k|        }
 1282|       |
 1283|  36.9k|        return is_negative() ? x*(-1) : x;
  ------------------
  |  Branch (1283:16): [True: 5.91k, False: 31.0k]
  ------------------
 1284|  36.9k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE12write_stringIcNS1_11char_traitsIcEENS2_IcEEEEvRNS1_12basic_stringIT_T0_T1_EE:
 1359|   122k|    {
 1360|   122k|        basic_bigint<Allocator> v(*this);
 1361|   122k|        auto v_view = v.get_storage_view();
 1362|       |
 1363|   122k|        size_type len = (v_view.size() * word_type_bits / 3) + 2;
 1364|   122k|        data.reserve(len);
 1365|       |
 1366|   122k|        if ( v_view.size() == 0 )
  ------------------
  |  Branch (1366:14): [True: 3.57k, False: 118k]
  ------------------
 1367|  3.57k|        {
 1368|  3.57k|            data.push_back('0');
 1369|  3.57k|        }
 1370|   118k|        else
 1371|   118k|        {
 1372|   118k|            word_type r;
 1373|   118k|            basic_bigint<Allocator> R(get_allocator());
 1374|   118k|            basic_bigint<Allocator> LP10(max_unsigned_power_10, get_allocator()); 
 1375|       |
 1376|   118k|            do
 1377|   207k|            {
 1378|   207k|                v.divide( LP10, v, R, true );
 1379|   207k|                v_view = v.get_storage_view();
 1380|       |
 1381|   207k|                auto R_view = R.get_storage_view();
 1382|   207k|                r = (R_view.size() ? R_view[0] : 0);
  ------------------
  |  Branch (1382:22): [True: 149k, False: 58.3k]
  ------------------
 1383|  2.46M|                for ( size_type j=0; j < imax_unsigned_power_10; j++ )
  ------------------
  |  Branch (1383:38): [True: 2.37M, False: 88.6k]
  ------------------
 1384|  2.37M|                {
 1385|  2.37M|                    data.push_back(char(r % 10u + '0'));
 1386|  2.37M|                    r /= 10u;
 1387|  2.37M|                    if ( r + v_view.size() == 0 )
  ------------------
  |  Branch (1387:26): [True: 118k, False: 2.26M]
  ------------------
 1388|   118k|                        break;
 1389|  2.37M|                }
 1390|   207k|            } 
 1391|   207k|            while ( v_view.size() > 0);
  ------------------
  |  Branch (1391:21): [True: 88.6k, False: 118k]
  ------------------
 1392|       |
 1393|   118k|            if (is_negative())
  ------------------
  |  Branch (1393:17): [True: 7.43k, False: 111k]
  ------------------
 1394|  7.43k|            {
 1395|  7.43k|                data.push_back('-');
 1396|  7.43k|            }
 1397|   118k|            std::reverse(data.begin(),data.end());
 1398|   118k|        }
 1399|   122k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS3_:
  644|   118k|        : storage_(alloc)
  645|   118k|    {
  646|   118k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEEl:
 1481|  13.6k|    {
 1482|  13.6k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1482:15): [True: 7.43k, False: 6.21k]
  ------------------
 1483|  13.6k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IjEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  693|  7.43k|        : storage_(n, alloc)
  694|  7.43k|    {
  695|  7.43k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IjEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  360|  7.43k|        : word_allocator_type(alloc)
  361|  7.43k|    {
  362|  7.43k|        ::new (&inlined_) inlined_storage(n);
  363|  7.43k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IjEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  138|  7.43k|            : is_allocated_(false),
  139|  7.43k|            is_negative_(false),
  140|  7.43k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (140:19): [True: 366, False: 7.07k]
  ------------------
  141|  7.43k|        {
  142|  7.43k|            values_[0] = n;
  143|  7.43k|            values_[1] = 0;
  144|  7.43k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLIjEENS1_9enable_ifIXaasr10ext_traits19is_unsigned_integerIT_EE5valuelestS7_Lm8EERS4_E4typeES7_:
  889|  6.21k|    {
  890|  6.21k|        if ( is_negative())
  ------------------
  |  Branch (890:14): [True: 0, False: 6.21k]
  ------------------
  891|      0|            return *this -= -basic_bigint<Allocator>(y);
  892|       |
  893|  6.21k|        word_type d;
  894|  6.21k|        word_type carry = 0;
  895|       |
  896|  6.21k|        auto this_view = get_storage_view();
  897|  6.21k|        resize(this_view.size() + 1);
  898|       |
  899|  6.21k|        this_view = get_storage_view();
  900|  6.21k|        const size_type this_size = this_view.size();
  901|  6.21k|        size_type y_size = 1;
  902|       |
  903|  6.21k|        d = this_view[0] + carry;
  904|  6.21k|        carry = d < carry;
  905|  6.21k|        this_view[0] = d + y;
  906|  6.21k|        if (this_view[0] < d)
  ------------------
  |  Branch (906:13): [True: 475, False: 5.74k]
  ------------------
  907|    475|            carry = 1;
  908|       |
  909|  6.69k|        for (size_type i = y_size; i < this_size && carry != 0; ++i)
  ------------------
  |  Branch (909:36): [True: 4.22k, False: 2.46k]
  |  Branch (909:53): [True: 475, False: 3.75k]
  ------------------
  910|    475|        {
  911|    475|            d = this_view[i] + carry;
  912|    475|            carry = d < carry;
  913|    475|            this_view[i] = d;
  914|    475|        }
  915|  6.21k|        reduce();
  916|  6.21k|        return *this;
  917|  6.21k|    }

_ZN8jsoncons6binary13native_to_bigItNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  6.56k|    {
  128|  6.56k|        T val2 = byte_swap(val);
  129|  6.56k|        uint8_t buf[sizeof(T)];
  130|  6.56k|        std::memcpy(buf, &val2, sizeof(T));
  131|  6.56k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 13.1k, False: 6.56k]
  ------------------
  132|  13.1k|        {
  133|  13.1k|            *d_first++ = item;
  134|  13.1k|        }
  135|  6.56k|    }
_ZN8jsoncons6binary9byte_swapItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|  17.2k|    {
   29|  17.2k|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|  17.2k|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  466|  17.2k|#      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|  17.2k|    }
_ZN8jsoncons6binary13native_to_bigIjNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  17.3k|    {
  128|  17.3k|        T val2 = byte_swap(val);
  129|  17.3k|        uint8_t buf[sizeof(T)];
  130|  17.3k|        std::memcpy(buf, &val2, sizeof(T));
  131|  17.3k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 69.3k, False: 17.3k]
  ------------------
  132|  69.3k|        {
  133|  69.3k|            *d_first++ = item;
  134|  69.3k|        }
  135|  17.3k|    }
_ZN8jsoncons6binary9byte_swapIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|   148k|    {
   40|   148k|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|   148k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  462|   148k|#  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|   148k|    }
_ZN8jsoncons6binary13native_to_bigImNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  29.5k|    {
  128|  29.5k|        T val2 = byte_swap(val);
  129|  29.5k|        uint8_t buf[sizeof(T)];
  130|  29.5k|        std::memcpy(buf, &val2, sizeof(T));
  131|  29.5k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 236k, False: 29.5k]
  ------------------
  132|   236k|        {
  133|   236k|            *d_first++ = item;
  134|   236k|        }
  135|  29.5k|    }
_ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|   234k|    {
   52|   234k|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|   234k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|   234k|#  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|   234k|    }
_ZN8jsoncons6binary13native_to_bigIaNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|   187k|    {
  128|   187k|        T val2 = byte_swap(val);
  129|   187k|        uint8_t buf[sizeof(T)];
  130|   187k|        std::memcpy(buf, &val2, sizeof(T));
  131|   187k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 187k, False: 187k]
  ------------------
  132|   187k|        {
  133|   187k|            *d_first++ = item;
  134|   187k|        }
  135|   187k|    }
_ZN8jsoncons6binary9byte_swapIaEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_:
   21|  1.38M|    {
   22|  1.38M|        return val;
   23|  1.38M|    }
_ZN8jsoncons6binary13native_to_bigIsNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  12.7k|    {
  128|  12.7k|        T val2 = byte_swap(val);
  129|  12.7k|        uint8_t buf[sizeof(T)];
  130|  12.7k|        std::memcpy(buf, &val2, sizeof(T));
  131|  12.7k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 25.5k, False: 12.7k]
  ------------------
  132|  25.5k|        {
  133|  25.5k|            *d_first++ = item;
  134|  25.5k|        }
  135|  12.7k|    }
_ZN8jsoncons6binary9byte_swapIsEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|  40.9k|    {
   29|  40.9k|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|  40.9k|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  466|  40.9k|#      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|  40.9k|    }
_ZN8jsoncons6binary13native_to_bigIiNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  6.66k|    {
  128|  6.66k|        T val2 = byte_swap(val);
  129|  6.66k|        uint8_t buf[sizeof(T)];
  130|  6.66k|        std::memcpy(buf, &val2, sizeof(T));
  131|  6.66k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 26.6k, False: 6.66k]
  ------------------
  132|  26.6k|        {
  133|  26.6k|            *d_first++ = item;
  134|  26.6k|        }
  135|  6.66k|    }
_ZN8jsoncons6binary9byte_swapIiEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|  21.6k|    {
   40|  21.6k|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|  21.6k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  462|  21.6k|#  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|  21.6k|    }
_ZN8jsoncons6binary13native_to_bigIlNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  2.97k|    {
  128|  2.97k|        T val2 = byte_swap(val);
  129|  2.97k|        uint8_t buf[sizeof(T)];
  130|  2.97k|        std::memcpy(buf, &val2, sizeof(T));
  131|  2.97k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 23.7k, False: 2.97k]
  ------------------
  132|  23.7k|        {
  133|  23.7k|            *d_first++ = item;
  134|  23.7k|        }
  135|  2.97k|    }
_ZN8jsoncons6binary9byte_swapIlEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|  44.2k|    {
   52|  44.2k|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|  44.2k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|  44.2k|#  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|  44.2k|    }
_ZN8jsoncons6binary13native_to_bigIfNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  26.7k|    {
  128|  26.7k|        T val2 = byte_swap(val);
  129|  26.7k|        uint8_t buf[sizeof(T)];
  130|  26.7k|        std::memcpy(buf, &val2, sizeof(T));
  131|  26.7k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 106k, False: 26.7k]
  ------------------
  132|   106k|        {
  133|   106k|            *d_first++ = item;
  134|   106k|        }
  135|  26.7k|    }
_ZN8jsoncons6binary9byte_swapIfEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   64|  95.9k|    {
   65|  95.9k|        uint32_t x;
   66|  95.9k|        std::memcpy(&x,&val,sizeof(uint32_t));
   67|  95.9k|        uint32_t y = byte_swap(x);
   68|  95.9k|        T val2;
   69|  95.9k|        std::memcpy(&val2,&y,sizeof(uint32_t));
   70|  95.9k|        return val2;
   71|  95.9k|    }
_ZN8jsoncons6binary13native_to_bigIdNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  28.6k|    {
  128|  28.6k|        T val2 = byte_swap(val);
  129|  28.6k|        uint8_t buf[sizeof(T)];
  130|  28.6k|        std::memcpy(buf, &val2, sizeof(T));
  131|  28.6k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 228k, False: 28.6k]
  ------------------
  132|   228k|        {
  133|   228k|            *d_first++ = item;
  134|   228k|        }
  135|  28.6k|    }
_ZN8jsoncons6binary9byte_swapIdEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   76|  89.1k|    {
   77|  89.1k|        uint64_t x;
   78|  89.1k|        std::memcpy(&x,&val,sizeof(uint64_t));
   79|  89.1k|        uint64_t y = byte_swap(x);
   80|  89.1k|        T val2;
   81|  89.1k|        std::memcpy(&val2,&y,sizeof(uint64_t));
   82|  89.1k|        return val2;
   83|  89.1k|    }
_ZN8jsoncons6binary13big_to_nativeIfNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  69.2k|    {
  183|  69.2k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 69.2k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  69.2k|        T val;
  188|  69.2k|        std::memcpy(&val,first,sizeof(T));
  189|  69.2k|        return byte_swap(val);
  190|  69.2k|    }
_ZN8jsoncons6binary13big_to_nativeIdNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  60.5k|    {
  183|  60.5k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 60.5k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  60.5k|        T val;
  188|  60.5k|        std::memcpy(&val,first,sizeof(T));
  189|  60.5k|        return byte_swap(val);
  190|  60.5k|    }
_ZN8jsoncons6binary13big_to_nativeItNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  10.6k|    {
  183|  10.6k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 10.6k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  10.6k|        T val;
  188|  10.6k|        std::memcpy(&val,first,sizeof(T));
  189|  10.6k|        return byte_swap(val);
  190|  10.6k|    }
_ZN8jsoncons6binary13big_to_nativeIjNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  35.0k|    {
  183|  35.0k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 35.0k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  35.0k|        T val;
  188|  35.0k|        std::memcpy(&val,first,sizeof(T));
  189|  35.0k|        return byte_swap(val);
  190|  35.0k|    }
_ZN8jsoncons6binary13big_to_nativeImNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|   115k|    {
  183|   115k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 115k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|   115k|        T val;
  188|   115k|        std::memcpy(&val,first,sizeof(T));
  189|   115k|        return byte_swap(val);
  190|   115k|    }
_ZN8jsoncons6binary13big_to_nativeIaNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  1.19M|    {
  183|  1.19M|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 1.19M]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  1.19M|        T val;
  188|  1.19M|        std::memcpy(&val,first,sizeof(T));
  189|  1.19M|        return byte_swap(val);
  190|  1.19M|    }
_ZN8jsoncons6binary13big_to_nativeIsNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  28.2k|    {
  183|  28.2k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 28.2k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  28.2k|        T val;
  188|  28.2k|        std::memcpy(&val,first,sizeof(T));
  189|  28.2k|        return byte_swap(val);
  190|  28.2k|    }
_ZN8jsoncons6binary13big_to_nativeIiNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  14.9k|    {
  183|  14.9k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 14.9k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  14.9k|        T val;
  188|  14.9k|        std::memcpy(&val,first,sizeof(T));
  189|  14.9k|        return byte_swap(val);
  190|  14.9k|    }
_ZN8jsoncons6binary13big_to_nativeIlNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  41.2k|    {
  183|  41.2k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 41.2k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  41.2k|        T val;
  188|  41.2k|        std::memcpy(&val,first,sizeof(T));
  189|  41.2k|        return byte_swap(val);
  190|  41.2k|    }
_ZN8jsoncons6binary13big_to_nativeIhNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  50.5k|    {
  183|  50.5k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 50.5k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  50.5k|        T val;
  188|  50.5k|        std::memcpy(&val,first,sizeof(T));
  189|  50.5k|        return byte_swap(val);
  190|  50.5k|    }
_ZN8jsoncons6binary9byte_swapIhEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_:
   21|  50.5k|    {
   22|  50.5k|        return val;
   23|  50.5k|    }

_ZN8jsoncons6detail23bytes_to_base64_genericIPKhNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS4_9enable_ifIXsr3std7is_sameINS4_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESD_SD_PKcRT0_:
   44|   593k|    {
   45|   593k|        std::size_t count = 0;
   46|   593k|        unsigned char a3[3];
   47|   593k|        unsigned char a4[4];
   48|   593k|        unsigned char fill = alphabet[64];
   49|   593k|        int i = 0;
   50|   593k|        int j = 0;
   51|       |
   52|  4.59M|        while (first != last)
  ------------------
  |  Branch (52:16): [True: 4.00M, False: 593k]
  ------------------
   53|  4.00M|        {
   54|  4.00M|            a3[i++] = *first++;
   55|  4.00M|            if (i == 3)
  ------------------
  |  Branch (55:17): [True: 963k, False: 3.04M]
  ------------------
   56|   963k|            {
   57|   963k|                a4[0] = (a3[0] & 0xfc) >> 2;
   58|   963k|                a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   59|   963k|                a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   60|   963k|                a4[3] = a3[2] & 0x3f;
   61|       |
   62|  4.81M|                for (i = 0; i < 4; i++) 
  ------------------
  |  Branch (62:29): [True: 3.85M, False: 963k]
  ------------------
   63|  3.85M|                {
   64|  3.85M|                    result.push_back(alphabet[a4[i]]);
   65|  3.85M|                    ++count;
   66|  3.85M|                }
   67|   963k|                i = 0;
   68|   963k|            }
   69|  4.00M|        }
   70|       |
   71|   593k|        if (i > 0)
  ------------------
  |  Branch (71:13): [True: 570k, False: 22.8k]
  ------------------
   72|   570k|        {
   73|  1.16M|            for (j = i; j < 3; ++j) 
  ------------------
  |  Branch (73:25): [True: 598k, False: 570k]
  ------------------
   74|   598k|            {
   75|   598k|                a3[j] = 0;
   76|   598k|            }
   77|       |
   78|   570k|            a4[0] = (a3[0] & 0xfc) >> 2;
   79|   570k|            a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   80|   570k|            a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   81|       |
   82|  2.25M|            for (j = 0; j < i + 1; ++j) 
  ------------------
  |  Branch (82:25): [True: 1.68M, False: 570k]
  ------------------
   83|  1.68M|            {
   84|  1.68M|                result.push_back(alphabet[a4[j]]);
   85|  1.68M|                ++count;
   86|  1.68M|            }
   87|       |
   88|   570k|            if (fill != 0)
  ------------------
  |  Branch (88:17): [True: 0, False: 570k]
  ------------------
   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|   570k|        }
   97|       |
   98|   593k|        return count;
   99|   593k|    }
_ZNK8jsoncons16byte_string_view5beginEv:
  409|   935k|        {
  410|   935k|            return data_;
  411|   935k|        }
_ZNK8jsoncons16byte_string_view3endEv:
  413|   935k|        {
  414|   935k|            return data_ + size_;
  415|   935k|        }
_ZN8jsoncons18bytes_to_base64urlIPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  177|   593k|    {
  178|   593k|        static constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  179|   593k|                                                      "abcdefghijklmnopqrstuvwxyz"
  180|   593k|                                                      "0123456789-_"
  181|   593k|                                                      "\0";
  182|   593k|        return detail::bytes_to_base64_generic(first, last, alphabet, result);
  183|   593k|    }
_ZNK8jsoncons16byte_string_view4dataEv:
  399|  1.27M|        {
  400|  1.27M|            return data_;
  401|  1.27M|        }
_ZNK8jsoncons16byte_string_view4sizeEv:
  403|  1.61M|        {
  404|  1.61M|            return size_;
  405|  1.61M|        }
_ZN8jsoncons16byte_string_viewC2EPKhm:
  362|  2.21M|            : data_(data), size_(length)
  363|  2.21M|        {
  364|  2.21M|        }

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

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

_ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_14unicode_resultIS4_EEE4typeEPKS4_m:
 1147|   579k|    {
 1148|   579k|        const uint8_t* it = reinterpret_cast<const uint8_t*>(data);
 1149|   579k|        const uint8_t* end = it + length;
 1150|       |
 1151|   579k|        unicode_errc  result{};
 1152|  13.9M|        while (it != end) 
  ------------------
  |  Branch (1152:16): [True: 13.4M, False: 579k]
  ------------------
 1153|  13.4M|        {
 1154|  13.4M|            if ((end - it) >= 8)
  ------------------
  |  Branch (1154:17): [True: 11.8M, False: 1.57M]
  ------------------
 1155|  11.8M|            {
 1156|  82.8M|                JSONCONS_REPEAT8({if (JSONCONS_LIKELY((*it & 0x80) == 0)) ++it; else goto non_ascii;})
  ------------------
  |  |  281|  23.6M|#define JSONCONS_REPEAT8(x)  { x x x x x x x x }
  |  |  ------------------
  |  |  |  Branch (281:32): [True: 11.8M, False: 662]
  |  |  |  Branch (281:34): [True: 11.8M, False: 541]
  |  |  |  Branch (281:36): [True: 11.8M, False: 598]
  |  |  |  Branch (281:38): [True: 11.8M, False: 2.08k]
  |  |  |  Branch (281:40): [True: 11.8M, False: 755]
  |  |  |  Branch (281:42): [True: 11.8M, False: 557]
  |  |  |  Branch (281:44): [True: 11.8M, False: 413]
  |  |  |  Branch (281:46): [True: 11.8M, False: 332]
  |  |  ------------------
  ------------------
 1157|  11.8M|                continue;
 1158|  82.8M|            }
 1159|  1.57M|    non_ascii:
 1160|  1.57M|            const std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[*it]) + 1;
 1161|  1.57M|            if (len > (std::size_t)(end - it))
  ------------------
  |  Branch (1161:17): [True: 0, False: 1.57M]
  ------------------
 1162|      0|            {
 1163|      0|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), unicode_errc::source_exhausted};
 1164|      0|            }
 1165|  1.57M|            if ((result=is_legal_utf8(it, len)) != unicode_errc())
  ------------------
  |  Branch (1165:17): [True: 0, False: 1.57M]
  ------------------
 1166|      0|            {
 1167|      0|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1168|      0|            }
 1169|  1.57M|            it += len;
 1170|  1.57M|        }
 1171|   579k|        return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1172|   579k|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8EPKhm:
  305|  1.59M|    {
  306|  1.59M|        const uint8_t* it = reinterpret_cast<const uint8_t*>(bytes);
  307|  1.59M|        const uint8_t* end = it+length;
  308|       |
  309|  1.59M|        uint8_t byte;
  310|  1.59M|        switch (length) {
  311|     26|        default:
  ------------------
  |  Branch (311:9): [True: 26, False: 1.59M]
  ------------------
  312|     26|            return unicode_errc::over_long_utf8_sequence;
  313|  1.28k|        case 4:
  ------------------
  |  Branch (313:9): [True: 1.28k, False: 1.59M]
  ------------------
  314|  1.28k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 12, False: 1.27k]
  ------------------
  315|     12|                return unicode_errc::bad_continuation_byte;
  316|  1.27k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|  1.27k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  317|  9.70k|        case 3:
  ------------------
  |  Branch (317:9): [True: 8.42k, False: 1.59M]
  ------------------
  318|  9.70k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (318:17): [True: 10, False: 9.69k]
  ------------------
  319|     10|                return unicode_errc::bad_continuation_byte;
  320|  9.69k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|  9.69k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  321|  16.0k|        case 2:
  ------------------
  |  Branch (321:9): [True: 6.35k, False: 1.59M]
  ------------------
  322|  16.0k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (322:17): [True: 50, False: 15.9k]
  ------------------
  323|     50|                return unicode_errc::bad_continuation_byte;
  324|       |
  325|  15.9k|            switch (*it) 
  326|  15.9k|            {
  327|       |                // no fall-through in this inner switch
  328|    422|                case 0xE0: if (byte < 0xA0) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (328:17): [True: 422, False: 15.5k]
  |  Branch (328:32): [True: 2, False: 420]
  ------------------
  329|  7.74k|                case 0xED: if (byte > 0x9F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (329:17): [True: 7.74k, False: 8.24k]
  |  Branch (329:32): [True: 2, False: 7.74k]
  ------------------
  330|  7.74k|                case 0xF0: if (byte < 0x90) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (330:17): [True: 433, False: 15.5k]
  |  Branch (330:32): [True: 5, False: 428]
  ------------------
  331|    447|                case 0xF4: if (byte > 0x8F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (331:17): [True: 447, False: 15.5k]
  |  Branch (331:32): [True: 4, False: 443]
  ------------------
  332|  6.93k|                default:   if (byte < 0x80) return unicode_errc::source_illegal;
  ------------------
  |  Branch (332:17): [True: 6.93k, False: 9.05k]
  |  Branch (332:32): [True: 0, False: 6.93k]
  ------------------
  333|  15.9k|            }
  334|       |
  335|  15.9k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|  15.9k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  336|  1.59M|        case 1:
  ------------------
  |  Branch (336:9): [True: 1.58M, False: 16.0k]
  ------------------
  337|  1.59M|            if (*it >= 0x80 && *it < 0xC2)
  ------------------
  |  Branch (337:17): [True: 16.0k, False: 1.58M]
  |  Branch (337:32): [True: 52, False: 15.9k]
  ------------------
  338|     52|                return unicode_errc::source_illegal;
  339|  1.59M|            break;
  340|  1.59M|        }
  341|  1.59M|        if (*it > 0xF4) 
  ------------------
  |  Branch (341:13): [True: 1, False: 1.59M]
  ------------------
  342|      1|            return unicode_errc::source_illegal;
  343|       |
  344|  1.59M|        return unicode_errc();
  345|  1.59M|    }
_ZN8jsoncons14unicode_traits8validateIhEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_14unicode_resultIS4_EEE4typeEPKS4_m:
 1147|   347k|    {
 1148|   347k|        const uint8_t* it = reinterpret_cast<const uint8_t*>(data);
 1149|   347k|        const uint8_t* end = it + length;
 1150|       |
 1151|   347k|        unicode_errc  result{};
 1152|   517k|        while (it != end) 
  ------------------
  |  Branch (1152:16): [True: 169k, False: 347k]
  ------------------
 1153|   169k|        {
 1154|   169k|            if ((end - it) >= 8)
  ------------------
  |  Branch (1154:17): [True: 152k, False: 16.8k]
  ------------------
 1155|   152k|            {
 1156|  1.05M|                JSONCONS_REPEAT8({if (JSONCONS_LIKELY((*it & 0x80) == 0)) ++it; else goto non_ascii;})
  ------------------
  |  |  281|   305k|#define JSONCONS_REPEAT8(x)  { x x x x x x x x }
  |  |  ------------------
  |  |  |  Branch (281:32): [True: 152k, False: 809]
  |  |  |  Branch (281:34): [True: 151k, False: 380]
  |  |  |  Branch (281:36): [True: 150k, False: 753]
  |  |  |  Branch (281:38): [True: 150k, False: 375]
  |  |  |  Branch (281:40): [True: 150k, False: 272]
  |  |  |  Branch (281:42): [True: 149k, False: 348]
  |  |  |  Branch (281:44): [True: 149k, False: 218]
  |  |  |  Branch (281:46): [True: 149k, False: 263]
  |  |  ------------------
  ------------------
 1157|   149k|                continue;
 1158|  1.05M|            }
 1159|  20.2k|    non_ascii:
 1160|  20.2k|            const std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[*it]) + 1;
 1161|  20.2k|            if (len > (std::size_t)(end - it))
  ------------------
  |  Branch (1161:17): [True: 27, False: 20.2k]
  ------------------
 1162|     27|            {
 1163|     27|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), unicode_errc::source_exhausted};
 1164|     27|            }
 1165|  20.2k|            if ((result=is_legal_utf8(it, len)) != unicode_errc())
  ------------------
  |  Branch (1165:17): [True: 164, False: 20.0k]
  ------------------
 1166|    164|            {
 1167|    164|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1168|    164|            }
 1169|  20.0k|            it += len;
 1170|  20.0k|        }
 1171|   347k|        return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1172|   347k|    }

_ZN8jsoncons12from_integerImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  13.8M|{
   43|  13.8M|    using char_type = typename Result::value_type;
   44|       |
   45|  13.8M|    char_type buf[255];
   46|  13.8M|    char_type *p = buf;
   47|  13.8M|    const char_type* last = buf+255;
   48|       |
   49|  13.8M|    bool is_negative = value < 0;
   50|       |
   51|  13.8M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 13.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|  13.8M|    else
   60|  13.8M|    {
   61|       |
   62|  13.8M|        do
   63|  18.8M|        {
   64|  18.8M|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  18.8M|        }
   66|  18.8M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 4.99M, False: 13.8M]
  |  Branch (66:33): [True: 4.99M, False: 0]
  ------------------
   67|  13.8M|    }
   68|  13.8M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   49|  13.8M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 13.8M]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|  13.8M|    std::size_t count = (p - buf);
   71|  13.8M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 13.8M]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  32.7M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 18.8M, False: 13.8M]
  ------------------
   77|  18.8M|    {
   78|  18.8M|        result.push_back(*p);
   79|  18.8M|    }
   80|       |
   81|  13.8M|    return count;
   82|  13.8M|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  2.09M|{
   43|  2.09M|    using char_type = typename Result::value_type;
   44|       |
   45|  2.09M|    char_type buf[255];
   46|  2.09M|    char_type *p = buf;
   47|  2.09M|    const char_type* last = buf+255;
   48|       |
   49|  2.09M|    bool is_negative = value < 0;
   50|       |
   51|  2.09M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 2.07M, False: 22.9k]
  ------------------
   52|  2.07M|    {
   53|  2.07M|        do
   54|  2.65M|        {
   55|  2.65M|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|  2.65M|        }
   57|  2.65M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 587k, False: 2.07M]
  |  Branch (57:33): [True: 587k, False: 0]
  ------------------
   58|  2.07M|    }
   59|  22.9k|    else
   60|  22.9k|    {
   61|       |
   62|  22.9k|        do
   63|   170k|        {
   64|   170k|            *p++ = static_cast<char_type>(48 + value % 10);
   65|   170k|        }
   66|   170k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 147k, False: 22.9k]
  |  Branch (66:33): [True: 147k, False: 0]
  ------------------
   67|  22.9k|    }
   68|  2.09M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   49|  2.09M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 2.09M]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|  2.09M|    std::size_t count = (p - buf);
   71|  2.09M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 2.07M, False: 22.9k]
  ------------------
   72|  2.07M|    {
   73|  2.07M|        result.push_back('-');
   74|  2.07M|        ++count;
   75|  2.07M|    }
   76|  4.92M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 2.82M, False: 2.09M]
  ------------------
   77|  2.82M|    {
   78|  2.82M|        result.push_back(*p);
   79|  2.82M|    }
   80|       |
   81|  2.09M|    return count;
   82|  2.09M|}
_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|  74.4k|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|  74.4k|    {
  489|  74.4k|#if !defined(JSONCONS_NO_LOCALECONV)
  490|  74.4k|        struct lconv *lc = localeconv();
  491|  74.4k|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 74.4k, False: 0]
  |  Branch (491:30): [True: 74.4k, False: 0]
  ------------------
  492|  74.4k|        {
  493|  74.4k|            decimal_point_ = lc->decimal_point[0];
  494|  74.4k|        }
  495|  74.4k|#endif
  496|  74.4k|    }
_ZN8jsoncons12write_doubleclINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEmdRT_:
  503|  74.4k|    {
  504|  74.4k|        std::size_t count = 0;
  505|       |
  506|  74.4k|        char number_buffer[200];
  507|  74.4k|        int length = 0;
  508|       |
  509|  74.4k|        switch (float_format_)
  510|  74.4k|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 74.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: 74.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|  74.4k|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 74.4k, False: 0]
  ------------------
  552|  74.4k|            {
  553|  74.4k|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 74.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|  74.4k|                else
  563|  74.4k|                {
  564|  74.4k|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 74.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|  74.4k|                }             
  569|  74.4k|                break;
  570|  74.4k|            }
  571|  74.4k|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 74.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|  74.4k|        }
  575|  74.4k|        return count;
  576|  74.4k|    }
_ZN8jsoncons11dump_bufferINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKcmcRT_:
  243|  5.02k|{
  244|  5.02k|    const char *sbeg = buffer;
  245|  5.02k|    const char *send = sbeg + length;
  246|       |
  247|  5.02k|    if (sbeg != send)
  ------------------
  |  Branch (247:9): [True: 5.02k, False: 0]
  ------------------
  248|  5.02k|    {
  249|  5.02k|        bool needs_dot = true;
  250|  69.6k|        for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (250:36): [True: 64.6k, False: 5.02k]
  ------------------
  251|  64.6k|        {
  252|  64.6k|            switch (*q)
  253|  64.6k|            {
  254|  2.34k|            case '-':
  ------------------
  |  Branch (254:13): [True: 2.34k, False: 62.3k]
  ------------------
  255|  6.70k|            case '0':
  ------------------
  |  Branch (255:13): [True: 4.36k, False: 60.2k]
  ------------------
  256|  12.2k|            case '1':
  ------------------
  |  Branch (256:13): [True: 5.54k, False: 59.1k]
  ------------------
  257|  20.4k|            case '2':
  ------------------
  |  Branch (257:13): [True: 8.19k, False: 56.4k]
  ------------------
  258|  23.2k|            case '3':
  ------------------
  |  Branch (258:13): [True: 2.83k, False: 61.8k]
  ------------------
  259|  30.9k|            case '4':
  ------------------
  |  Branch (259:13): [True: 7.67k, False: 56.9k]
  ------------------
  260|  35.1k|            case '5':
  ------------------
  |  Branch (260:13): [True: 4.18k, False: 60.4k]
  ------------------
  261|  42.0k|            case '6':
  ------------------
  |  Branch (261:13): [True: 6.93k, False: 57.7k]
  ------------------
  262|  46.7k|            case '7':
  ------------------
  |  Branch (262:13): [True: 4.70k, False: 59.9k]
  ------------------
  263|  51.6k|            case '8':
  ------------------
  |  Branch (263:13): [True: 4.90k, False: 59.7k]
  ------------------
  264|  54.8k|            case '9':
  ------------------
  |  Branch (264:13): [True: 3.14k, False: 61.5k]
  ------------------
  265|  56.9k|            case '+':
  ------------------
  |  Branch (265:13): [True: 2.16k, False: 62.4k]
  ------------------
  266|  56.9k|                result.push_back(*q);
  267|  56.9k|                break;
  268|  2.76k|            case 'e':
  ------------------
  |  Branch (268:13): [True: 2.76k, False: 61.8k]
  ------------------
  269|  2.76k|            case 'E':
  ------------------
  |  Branch (269:13): [True: 0, False: 64.6k]
  ------------------
  270|  2.76k|                result.push_back('e');
  271|  2.76k|                needs_dot = false;
  272|  2.76k|                break;
  273|  4.88k|            default:
  ------------------
  |  Branch (273:13): [True: 4.88k, False: 59.7k]
  ------------------
  274|  4.88k|                if (*q == decimal_point)
  ------------------
  |  Branch (274:21): [True: 2.95k, False: 1.93k]
  ------------------
  275|  2.95k|                {
  276|  2.95k|                    needs_dot = false;
  277|  2.95k|                    result.push_back('.');
  278|  2.95k|                }
  279|  4.88k|                break;
  280|  64.6k|            }
  281|  64.6k|        }
  282|  5.02k|        if (needs_dot)
  ------------------
  |  Branch (282:13): [True: 2.06k, False: 2.96k]
  ------------------
  283|  2.06k|        {
  284|  2.06k|            result.push_back('.');
  285|  2.06k|            result.push_back('0');
  286|  2.06k|        }
  287|  5.02k|    }
  288|  5.02k|}
_ZN8jsoncons15prettify_stringINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKciiiiRT_:
  171|  68.9k|{
  172|  68.9k|    int nb_digits = length;
  173|  68.9k|    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|  68.9k|    int kk = nb_digits + k;
  179|       |
  180|  68.9k|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 46.0k, False: 22.8k]
  |  Branch (180:28): [True: 8.39k, False: 37.6k]
  ------------------
  181|  8.39k|    {
  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|  52.9k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 44.5k, False: 8.39k]
  ------------------
  186|  44.5k|        {
  187|  44.5k|            result.push_back(buffer[i]);
  188|  44.5k|        }
  189|  10.4k|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 2.09k, False: 8.39k]
  ------------------
  190|  2.09k|        {
  191|  2.09k|            result.push_back('0');
  192|  2.09k|        }
  193|  8.39k|        result.push_back('.');
  194|  8.39k|        result.push_back('0');
  195|  8.39k|    } 
  196|  60.5k|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 42.7k, False: 17.7k]
  |  Branch (196:24): [True: 5.11k, False: 37.6k]
  ------------------
  197|  5.11k|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|  20.0k|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 14.8k, False: 5.11k]
  ------------------
  200|  14.8k|        {
  201|  14.8k|            result.push_back(buffer[i]);
  202|  14.8k|        }
  203|  5.11k|        result.push_back('.');
  204|  67.9k|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 62.8k, False: 5.11k]
  ------------------
  205|  62.8k|        {
  206|  62.8k|            result.push_back(buffer[i]);
  207|  62.8k|        }
  208|  5.11k|    } 
  209|  55.3k|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 39.2k, False: 16.1k]
  |  Branch (209:30): [True: 1.56k, False: 37.6k]
  ------------------
  210|  1.56k|    {
  211|  1.56k|        offset = 2 - kk;
  212|       |
  213|  1.56k|        result.push_back('0');
  214|  1.56k|        result.push_back('.');
  215|  3.93k|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 2.37k, False: 1.56k]
  ------------------
  216|  2.37k|            result.push_back('0');
  217|  24.9k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 23.4k, False: 1.56k]
  ------------------
  218|  23.4k|        {
  219|  23.4k|            result.push_back(buffer[i]);
  220|  23.4k|        }
  221|  1.56k|    } 
  222|  53.8k|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 902, False: 52.9k]
  ------------------
  223|    902|    {
  224|    902|        result.push_back(buffer[0]);
  225|    902|        result.push_back('e');
  226|    902|        fill_exponent(kk - 1, result);
  227|    902|    } 
  228|  52.9k|    else
  229|  52.9k|    {
  230|  52.9k|        result.push_back(buffer[0]);
  231|  52.9k|        result.push_back('.');
  232|   848k|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 795k, False: 52.9k]
  ------------------
  233|   795k|        {
  234|   795k|            result.push_back(buffer[i]);
  235|   795k|        }
  236|  52.9k|        result.push_back('e');
  237|  52.9k|        fill_exponent(kk - 1, result);
  238|  52.9k|    }
  239|  68.9k|}
_ZN8jsoncons13fill_exponentINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEviRT_:
  136|  53.8k|{
  137|  53.8k|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 16.1k, False: 37.6k]
  ------------------
  138|  16.1k|    {
  139|  16.1k|        result.push_back('-');
  140|  16.1k|        K = -K;
  141|  16.1k|    }
  142|  37.6k|    else
  143|  37.6k|    {
  144|  37.6k|        result.push_back('+'); // compatibility with sprintf
  145|  37.6k|    }
  146|       |
  147|  53.8k|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 450, False: 53.3k]
  ------------------
  148|    450|    {
  149|    450|        result.push_back('0'); // compatibility with sprintf
  150|    450|        result.push_back((char)('0' + K));
  151|    450|    }
  152|  53.3k|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 38.0k, False: 15.3k]
  ------------------
  153|  38.0k|    {
  154|  38.0k|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|  38.0k|        result.push_back((char)('0' + K));
  156|  38.0k|    }
  157|  15.3k|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 15.3k, False: 0]
  ------------------
  158|  15.3k|    {
  159|  15.3k|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|  15.3k|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|  15.3k|        result.push_back((char)('0' + K));
  162|  15.3k|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|  53.8k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_:
  475|  74.4k|{
  476|  74.4k|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|  74.4k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb1EEE:
  366|  74.4k|{
  367|  74.4k|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 498, False: 73.9k]
  ------------------
  368|    498|    {
  369|    498|        result.push_back('0');
  370|    498|        result.push_back('.');
  371|    498|        result.push_back('0');
  372|    498|        return true;
  373|    498|    }
  374|       |
  375|  73.9k|    int length = 0;
  376|  73.9k|    int k;
  377|       |
  378|  73.9k|    char buffer[100];
  379|       |
  380|  73.9k|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 58.4k, False: 15.4k]
  ------------------
  381|  73.9k|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 68.9k, False: 5.02k]
  ------------------
  382|  68.9k|    {
  383|  68.9k|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 56.7k, False: 12.1k]
  ------------------
  384|  56.7k|        {
  385|  56.7k|            result.push_back('-');
  386|  56.7k|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|  68.9k|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|  68.9k|        return true;
  391|  68.9k|    }
  392|  5.02k|    else
  393|  5.02k|    {
  394|  5.02k|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|  5.02k|    }
  396|  73.9k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb0EEE:
  329|  5.02k|{
  330|  5.02k|    if (val == 0)
  ------------------
  |  Branch (330:9): [True: 0, False: 5.02k]
  ------------------
  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|  5.02k|    char buffer[100];
  339|  5.02k|    int precision = std::numeric_limits<double>::digits10;
  340|  5.02k|    int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  341|  5.02k|    if (length < 0)
  ------------------
  |  Branch (341:9): [True: 0, False: 5.02k]
  ------------------
  342|      0|    {
  343|      0|        return false;
  344|      0|    }
  345|  5.02k|    double x{0};
  346|  5.02k|    auto res = decstr_to_double(buffer, length, x);
  347|  5.02k|    if (res.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (347:9): [True: 0, False: 5.02k]
  ------------------
  348|      0|    {
  349|      0|        return false;
  350|      0|    }
  351|  5.02k|    if (x != val)
  ------------------
  |  Branch (351:9): [True: 2.84k, False: 2.17k]
  ------------------
  352|  2.84k|    {
  353|  2.84k|        const int precision2 = std::numeric_limits<double>::max_digits10;
  354|  2.84k|        length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  355|  2.84k|        if (length < 0)
  ------------------
  |  Branch (355:13): [True: 0, False: 2.84k]
  ------------------
  356|      0|        {
  357|      0|            return false;
  358|      0|        }
  359|  2.84k|    }
  360|  5.02k|    dump_buffer(buffer, length, decimal_point, result);
  361|  5.02k|    return true;
  362|  5.02k|}

_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEEC2EOS8_RKS9_:
   97|  6.23k|           : basic_msgpack_encoder(std::forward<Sink>(sink), msgpack_encode_options(), alloc)
   98|  6.23k|        {
   99|  6.23k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEEC2EOS8_RKNS0_22msgpack_encode_optionsERKS9_:
  104|  6.23k|           : sink_(std::forward<Sink>(sink)),
  105|  6.23k|             max_nesting_depth_(options.max_nesting_depth()),
  106|  6.23k|             alloc_(alloc)
  107|  6.23k|        {
  108|  6.23k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  204|   166k|        {
  205|   166k|            if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|   166k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 166k]
  |  |  ------------------
  ------------------
  206|      0|            {
  207|      0|                ec = msgpack_errc::max_nesting_depth_exceeded;
  208|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  209|      0|            } 
  210|   166k|            stack_.emplace_back(msgpack_container_type::array, length);
  211|   166k|            if (length <= 15)
  ------------------
  |  Branch (211:17): [True: 161k, False: 5.06k]
  ------------------
  212|   161k|            {
  213|       |                // fixarray
  214|   161k|                sink_.push_back(jsoncons::msgpack::msgpack_type::fixarray_base_type | (length & 0xf));
  215|   161k|            }
  216|  5.06k|            else if (length <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (216:22): [True: 2.02k, False: 3.03k]
  ------------------
  217|  2.02k|            {
  218|       |                // array 16
  219|  2.02k|                sink_.push_back(jsoncons::msgpack::msgpack_type::array16_type);
  220|  2.02k|                binary::native_to_big(static_cast<uint16_t>(length),std::back_inserter(sink_));
  221|  2.02k|            }
  222|  3.03k|            else if (length <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (222:22): [True: 3.03k, False: 0]
  ------------------
  223|  3.03k|            {
  224|       |                // array 32
  225|  3.03k|                sink_.push_back(jsoncons::msgpack::msgpack_type::array32_type);
  226|  3.03k|                binary::native_to_big(static_cast<uint32_t>(length),std::back_inserter(sink_));
  227|  3.03k|            }
  228|   166k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   166k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  229|   166k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_itemC2ENS0_22msgpack_container_typeEm:
   64|   187k|               : type_(type), length_(length)
   65|   187k|            {
   66|   187k|            }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE15visit_end_arrayERKNS_11ser_contextERNS3_10error_codeE:
  232|   150k|        {
  233|   150k|            JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   49|   150k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 150k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  234|       |
  235|   150k|            --nesting_depth_;
  236|       |
  237|   150k|            if (stack_.back().count() < stack_.back().length())
  ------------------
  |  Branch (237:17): [True: 497, False: 149k]
  ------------------
  238|    497|            {
  239|    497|                ec = msgpack_errc::too_few_items;
  240|    497|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    497|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  241|    497|            }
  242|   149k|            else if (stack_.back().count() > stack_.back().length())
  ------------------
  |  Branch (242:22): [True: 0, False: 149k]
  ------------------
  243|      0|            {
  244|      0|                ec = msgpack_errc::too_many_items;
  245|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  246|      0|            }
  247|       |
  248|   149k|            stack_.pop_back();
  249|   149k|            end_value();
  250|   149k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   149k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  251|   150k|        }
_ZNK8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item5countEv:
   74|   323k|            {
   75|   323k|                return is_object() ? index_/2 : index_;
  ------------------
  |  Branch (75:24): [True: 24.3k, False: 299k]
  ------------------
   76|   323k|            }
_ZNK8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item9is_objectEv:
   79|   323k|            {
   80|   323k|                return type_ == msgpack_container_type::object;
   81|   323k|            }
_ZNK8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item6lengthEv:
   69|   323k|            {
   70|   323k|                return length_;
   71|   323k|            }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9end_valueEv:
  755|  2.84M|        {
  756|  2.84M|            if (!stack_.empty())
  ------------------
  |  Branch (756:17): [True: 2.84M, False: 775]
  ------------------
  757|  2.84M|            {
  758|  2.84M|                ++stack_.back().index_;
  759|  2.84M|            }
  760|  2.84M|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  663|   947k|        {
  664|   947k|            switch (tag)
  665|   947k|            {
  666|  1.49k|                case semantic_tag::epoch_second:
  ------------------
  |  Branch (666:17): [True: 1.49k, False: 946k]
  ------------------
  667|  1.49k|                    write_timestamp(static_cast<int64_t>(val), 0);
  668|  1.49k|                    break;
  669|      0|                case semantic_tag::epoch_milli:
  ------------------
  |  Branch (669:17): [True: 0, False: 947k]
  ------------------
  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: 947k]
  ------------------
  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|   946k|                default:
  ------------------
  |  Branch (707:17): [True: 946k, False: 1.49k]
  ------------------
  708|   946k|                {
  709|   946k|                    if (val <= static_cast<uint64_t>((std::numeric_limits<int8_t>::max)()))
  ------------------
  |  Branch (709:25): [True: 932k, False: 13.9k]
  ------------------
  710|   932k|                    {
  711|       |                        // positive fixnum stores 7-bit positive integer
  712|   932k|                        sink_.push_back(static_cast<uint8_t>(val));
  713|   932k|                    }
  714|  13.9k|                    else if (val <= (std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (714:30): [True: 7.84k, False: 6.08k]
  ------------------
  715|  7.84k|                    {
  716|       |                        // uint 8 stores a 8-bit unsigned integer
  717|  7.84k|                        sink_.push_back(jsoncons::msgpack::msgpack_type::uint8_type);
  718|  7.84k|                        sink_.push_back(static_cast<uint8_t>(val));
  719|  7.84k|                    }
  720|  6.08k|                    else if (val <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (720:30): [True: 757, False: 5.33k]
  ------------------
  721|    757|                    {
  722|       |                        // uint 16 stores a 16-bit big-endian unsigned integer
  723|    757|                        sink_.push_back(jsoncons::msgpack::msgpack_type::uint16_type);
  724|    757|                        binary::native_to_big(static_cast<uint16_t>(val),std::back_inserter(sink_));
  725|    757|                    }
  726|  5.33k|                    else if (val <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (726:30): [True: 2.62k, False: 2.70k]
  ------------------
  727|  2.62k|                    {
  728|       |                        // uint 32 stores a 32-bit big-endian unsigned integer
  729|  2.62k|                        sink_.push_back(jsoncons::msgpack::msgpack_type::uint32_type);
  730|  2.62k|                        binary::native_to_big(static_cast<uint32_t>(val),std::back_inserter(sink_));
  731|  2.62k|                    }
  732|  2.70k|                    else if (val <= (std::numeric_limits<uint64_t>::max)())
  ------------------
  |  Branch (732:30): [True: 2.70k, False: 0]
  ------------------
  733|  2.70k|                    {
  734|       |                        // uint 64 stores a 64-bit big-endian unsigned integer
  735|  2.70k|                        sink_.push_back(jsoncons::msgpack::msgpack_type::uint64_type);
  736|  2.70k|                        binary::native_to_big(static_cast<uint64_t>(val),std::back_inserter(sink_));
  737|  2.70k|                    }
  738|   946k|                    break;
  739|      0|                }
  740|   947k|            }
  741|   947k|            end_value();
  742|   947k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   947k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  743|   947k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE15write_timestampEll:
  268|  22.1k|        {
  269|  22.1k|            if ((seconds >> 34) == 0) 
  ------------------
  |  Branch (269:17): [True: 16.3k, False: 5.86k]
  ------------------
  270|  16.3k|            {
  271|  16.3k|                uint64_t data64 = (nanoseconds << 34) | seconds;
  272|  16.3k|                if ((data64 & 0xffffffff00000000L) == 0) 
  ------------------
  |  Branch (272:21): [True: 3.81k, False: 12.4k]
  ------------------
  273|  3.81k|                {
  274|       |                    // timestamp 32
  275|  3.81k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext4_type);
  276|  3.81k|                    sink_.push_back(0xff);
  277|  3.81k|                    binary::native_to_big(static_cast<uint32_t>(data64), std::back_inserter(sink_));
  278|  3.81k|                }
  279|  12.4k|                else 
  280|  12.4k|                {
  281|       |                    // timestamp 64
  282|  12.4k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext8_type);
  283|  12.4k|                    sink_.push_back(0xff);
  284|  12.4k|                    binary::native_to_big(static_cast<uint64_t>(data64), std::back_inserter(sink_));
  285|  12.4k|                }
  286|  16.3k|            }
  287|  5.86k|            else 
  288|  5.86k|            {
  289|       |                // timestamp 96
  290|  5.86k|                sink_.push_back(jsoncons::msgpack::msgpack_type::ext8_type);
  291|  5.86k|                sink_.push_back(0x0c); // 12
  292|  5.86k|                sink_.push_back(0xff);
  293|  5.86k|                binary::native_to_big(static_cast<uint32_t>(nanoseconds), std::back_inserter(sink_));
  294|  5.86k|                binary::native_to_big(static_cast<uint64_t>(seconds), std::back_inserter(sink_));
  295|  5.86k|            }
  296|  22.1k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  542|   220k|        {
  543|   220k|            switch (tag)
  544|   220k|            {
  545|      0|                case semantic_tag::epoch_second:
  ------------------
  |  Branch (545:17): [True: 0, False: 220k]
  ------------------
  546|      0|                    write_timestamp(val, 0);
  547|      0|                    break;
  548|      0|                case semantic_tag::epoch_milli:
  ------------------
  |  Branch (548:17): [True: 0, False: 220k]
  ------------------
  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: 220k]
  ------------------
  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|   220k|                default:
  ------------------
  |  Branch (586:17): [True: 220k, False: 0]
  ------------------
  587|   220k|                {
  588|   220k|                    if (val >= 0)
  ------------------
  |  Branch (588:25): [True: 10.5k, False: 209k]
  ------------------
  589|  10.5k|                    {
  590|  10.5k|                        if (val <= 0x7f)
  ------------------
  |  Branch (590:29): [True: 376, False: 10.1k]
  ------------------
  591|    376|                        {
  592|       |                            // positive fixnum stores 7-bit positive integer
  593|    376|                            sink_.push_back(static_cast<uint8_t>(val));
  594|    376|                        }
  595|  10.1k|                        else if (val <= (std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (595:34): [True: 704, False: 9.44k]
  ------------------
  596|    704|                        {
  597|       |                            // uint 8 stores a 8-bit unsigned integer
  598|    704|                            sink_.push_back(jsoncons::msgpack::msgpack_type::uint8_type);
  599|    704|                            sink_.push_back(static_cast<uint8_t>(val));
  600|    704|                        }
  601|  9.44k|                        else if (val <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (601:34): [True: 594, False: 8.84k]
  ------------------
  602|    594|                        {
  603|       |                            // uint 16 stores a 16-bit big-endian unsigned integer
  604|    594|                            sink_.push_back(jsoncons::msgpack::msgpack_type::uint16_type);
  605|    594|                            binary::native_to_big(static_cast<uint16_t>(val),std::back_inserter(sink_));
  606|    594|                        }
  607|  8.84k|                        else if (val <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (607:34): [True: 314, False: 8.53k]
  ------------------
  608|    314|                        {
  609|       |                            // uint 32 stores a 32-bit big-endian unsigned integer
  610|    314|                            sink_.push_back(jsoncons::msgpack::msgpack_type::uint32_type);
  611|    314|                            binary::native_to_big(static_cast<uint32_t>(val),std::back_inserter(sink_));
  612|    314|                        }
  613|  8.53k|                        else if (val <= (std::numeric_limits<int64_t>::max)())
  ------------------
  |  Branch (613:34): [True: 8.53k, False: 0]
  ------------------
  614|  8.53k|                        {
  615|       |                            // int 64 stores a 64-bit big-endian signed integer
  616|  8.53k|                            sink_.push_back(jsoncons::msgpack::msgpack_type::uint64_type);
  617|  8.53k|                            binary::native_to_big(static_cast<uint64_t>(val),std::back_inserter(sink_));
  618|  8.53k|                        }
  619|  10.5k|                    }
  620|   209k|                    else
  621|   209k|                    {
  622|   209k|                        if (val >= -32)
  ------------------
  |  Branch (622:29): [True: 144k, False: 65.2k]
  ------------------
  623|   144k|                        {
  624|       |                            // negative fixnum stores 5-bit negative integer
  625|   144k|                            binary::native_to_big(static_cast<int8_t>(val), std::back_inserter(sink_));
  626|   144k|                        }
  627|  65.2k|                        else if (val >= (std::numeric_limits<int8_t>::lowest)())
  ------------------
  |  Branch (627:34): [True: 42.8k, False: 22.3k]
  ------------------
  628|  42.8k|                        {
  629|       |                            // int 8 stores a 8-bit signed integer
  630|  42.8k|                            sink_.push_back(jsoncons::msgpack::msgpack_type::int8_type);
  631|  42.8k|                            binary::native_to_big(static_cast<int8_t>(val),std::back_inserter(sink_));
  632|  42.8k|                        }
  633|  22.3k|                        else if (val >= (std::numeric_limits<int16_t>::lowest)())
  ------------------
  |  Branch (633:34): [True: 12.7k, False: 9.63k]
  ------------------
  634|  12.7k|                        {
  635|       |                            // int 16 stores a 16-bit big-endian signed integer
  636|  12.7k|                            sink_.push_back(jsoncons::msgpack::msgpack_type::int16_type);
  637|  12.7k|                            binary::native_to_big(static_cast<int16_t>(val),std::back_inserter(sink_));
  638|  12.7k|                        }
  639|  9.63k|                        else if (val >= (std::numeric_limits<int32_t>::lowest)())
  ------------------
  |  Branch (639:34): [True: 6.66k, False: 2.97k]
  ------------------
  640|  6.66k|                        {
  641|       |                            // int 32 stores a 32-bit big-endian signed integer
  642|  6.66k|                            sink_.push_back(jsoncons::msgpack::msgpack_type::int32_type);
  643|  6.66k|                            binary::native_to_big(static_cast<int32_t>(val),std::back_inserter(sink_));
  644|  6.66k|                        }
  645|  2.97k|                        else if (val >= (std::numeric_limits<int64_t>::lowest)())
  ------------------
  |  Branch (645:34): [True: 2.97k, False: 0]
  ------------------
  646|  2.97k|                        {
  647|       |                            // int 64 stores a 64-bit big-endian signed integer
  648|  2.97k|                            sink_.push_back(jsoncons::msgpack::msgpack_type::int64_type);
  649|  2.97k|                            binary::native_to_big(static_cast<int64_t>(val),std::back_inserter(sink_));
  650|  2.97k|                        }
  651|   209k|                    }
  652|   220k|                }
  653|   220k|                break;
  654|   220k|            }
  655|   220k|            end_value();
  656|   220k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   220k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  657|   220k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  517|  55.3k|        {
  518|  55.3k|            float valf = (float)val;
  519|  55.3k|            if ((double)valf == val)
  ------------------
  |  Branch (519:17): [True: 26.7k, False: 28.6k]
  ------------------
  520|  26.7k|            {
  521|       |                // float 32
  522|  26.7k|                sink_.push_back(jsoncons::msgpack::msgpack_type::float32_type);
  523|  26.7k|                binary::native_to_big(valf,std::back_inserter(sink_));
  524|  26.7k|            }
  525|  28.6k|            else
  526|  28.6k|            {
  527|       |                // float 64
  528|  28.6k|                sink_.push_back(jsoncons::msgpack::msgpack_type::float64_type);
  529|  28.6k|                binary::native_to_big(val,std::back_inserter(sink_));
  530|  28.6k|            }
  531|       |
  532|       |            // write double
  533|       |
  534|  55.3k|            end_value();
  535|  55.3k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  55.3k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  536|  55.3k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE11visit_flushEv:
  134|  1.51k|        {
  135|  1.51k|            sink_.flush();
  136|  1.51k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  145|  20.8k|        {
  146|  20.8k|            if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|  20.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 20.8k]
  |  |  ------------------
  ------------------
  147|      0|            {
  148|      0|                ec = msgpack_errc::max_nesting_depth_exceeded;
  149|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  150|      0|            } 
  151|  20.8k|            stack_.emplace_back(msgpack_container_type::object, length);
  152|       |
  153|  20.8k|            if (length <= 15)
  ------------------
  |  Branch (153:17): [True: 18.8k, False: 2.04k]
  ------------------
  154|  18.8k|            {
  155|       |                // fixmap
  156|  18.8k|                sink_.push_back(jsoncons::msgpack::msgpack_type::fixmap_base_type | (length & 0xf));
  157|  18.8k|            }
  158|  2.04k|            else if (length <= 65535)
  ------------------
  |  Branch (158:22): [True: 899, False: 1.14k]
  ------------------
  159|    899|            {
  160|       |                // map 16
  161|    899|                sink_.push_back(jsoncons::msgpack::msgpack_type::map16_type);
  162|    899|                binary::native_to_big(static_cast<uint16_t>(length), 
  163|    899|                                      std::back_inserter(sink_));
  164|    899|            }
  165|  1.14k|            else if (length <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (165:22): [True: 1.14k, False: 0]
  ------------------
  166|  1.14k|            {
  167|       |                // map 32
  168|  1.14k|                sink_.push_back(jsoncons::msgpack::msgpack_type::map32_type);
  169|  1.14k|                binary::native_to_big(static_cast<uint32_t>(length),
  170|  1.14k|                                      std::back_inserter(sink_));
  171|  1.14k|            }
  172|       |
  173|  20.8k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  20.8k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  174|  20.8k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE16visit_end_objectERKNS_11ser_contextERNS3_10error_codeE:
  177|  12.4k|        {
  178|  12.4k|            JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   49|  12.4k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 12.4k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  179|  12.4k|            --nesting_depth_;
  180|       |
  181|  12.4k|            if (stack_.back().count() < stack_.back().length())
  ------------------
  |  Branch (181:17): [True: 423, False: 11.9k]
  ------------------
  182|    423|            {
  183|    423|                ec = msgpack_errc::too_few_items;
  184|    423|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    423|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  185|    423|            }
  186|  11.9k|            else if (stack_.back().count() > stack_.back().length())
  ------------------
  |  Branch (186:22): [True: 0, False: 11.9k]
  ------------------
  187|      0|            {
  188|      0|                ec = msgpack_errc::too_many_items;
  189|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  190|      0|            }
  191|       |
  192|  11.9k|            stack_.pop_back();
  193|  11.9k|            end_value();
  194|  11.9k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  11.9k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  195|  12.4k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9visit_keyERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKNS_11ser_contextERNS3_10error_codeE:
  254|   574k|        {
  255|   574k|            visit_string(name, semantic_tag::none, context, ec);
  256|   574k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   574k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  257|   574k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  260|  10.4k|        {
  261|       |            // nil
  262|  10.4k|            sink_.push_back(jsoncons::msgpack::msgpack_type::nil_type);
  263|  10.4k|            end_value();
  264|  10.4k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  10.4k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  265|  10.4k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  746|   525k|        {
  747|       |            // true and false
  748|   525k|            sink_.push_back(static_cast<uint8_t>(val ? jsoncons::msgpack::msgpack_type::true_type : jsoncons::msgpack::msgpack_type::false_type));
  ------------------
  |  Branch (748:50): [True: 6.84k, False: 518k]
  ------------------
  749|       |
  750|   525k|            end_value();
  751|   525k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   525k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  752|   525k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  299|   600k|        {
  300|   600k|            switch (tag)
  301|   600k|            {
  302|      0|                case semantic_tag::epoch_second:
  ------------------
  |  Branch (302:17): [True: 0, False: 600k]
  ------------------
  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;
  ------------------
  |  |  276|      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: 600k]
  ------------------
  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;
  ------------------
  |  |  276|      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|  20.6k|                case semantic_tag::epoch_nano:
  ------------------
  |  Branch (342:17): [True: 20.6k, False: 579k]
  ------------------
  343|  20.6k|                {
  344|  20.6k|                    bigint n;
  345|  20.6k|                    auto result = to_bigint(sv.data(), sv.length(), n);
  346|  20.6k|                    if (!result)
  ------------------
  |  Branch (346:25): [True: 0, False: 20.6k]
  ------------------
  347|      0|                    {
  348|      0|                        ec = msgpack_errc::invalid_timestamp;
  349|      0|                        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  350|      0|                    }
  351|  20.6k|                    if (n != 0)
  ------------------
  |  Branch (351:25): [True: 18.4k, False: 2.18k]
  ------------------
  352|  18.4k|                    {
  353|  18.4k|                        bigint q;
  354|  18.4k|                        bigint rem;
  355|  18.4k|                        n.divide(nanos_in_second, q, rem, true);
  356|  18.4k|                        auto seconds = static_cast<int64_t>(q);
  357|  18.4k|                        auto nanoseconds = static_cast<int64_t>(rem);
  358|  18.4k|                        if (nanoseconds < 0)
  ------------------
  |  Branch (358:29): [True: 2.84k, False: 15.6k]
  ------------------
  359|  2.84k|                        {
  360|  2.84k|                            nanoseconds = -nanoseconds; 
  361|  2.84k|                        }
  362|  18.4k|                        write_timestamp(seconds, nanoseconds);
  363|  18.4k|                    }
  364|  2.18k|                    else
  365|  2.18k|                    {
  366|  2.18k|                        write_timestamp(0, 0);
  367|  2.18k|                    }
  368|  20.6k|                    break;
  369|  20.6k|                }
  370|   579k|                default:
  ------------------
  |  Branch (370:17): [True: 579k, False: 20.6k]
  ------------------
  371|   579k|                {
  372|   579k|                    write_string_value(sv);
  373|   579k|                    end_value();
  374|   579k|                    break;
  375|  20.6k|                }
  376|   600k|            }
  377|   600k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   600k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  378|   600k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18write_string_valueERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEE:
  381|   579k|        {
  382|   579k|            auto sink = unicode_traits::validate(sv.data(), sv.size());
  383|   579k|            if (sink.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (383:17): [True: 0, False: 579k]
  ------------------
  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|   579k|            const size_t length = sv.length();
  389|   579k|            if (length <= 31)
  ------------------
  |  Branch (389:17): [True: 577k, False: 2.75k]
  ------------------
  390|   577k|            {
  391|       |                // fixstr stores a byte array whose length is upto 31 bytes
  392|   577k|                sink_.push_back(jsoncons::msgpack::msgpack_type::fixstr_base_type | static_cast<uint8_t>(length));
  393|   577k|            }
  394|  2.75k|            else if (length <= (std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (394:22): [True: 1.58k, False: 1.16k]
  ------------------
  395|  1.58k|            {
  396|       |                // str 8 stores a byte array whose length is upto (2^8)-1 bytes
  397|  1.58k|                sink_.push_back(jsoncons::msgpack::msgpack_type::str8_type);
  398|  1.58k|                sink_.push_back(static_cast<uint8_t>(length));
  399|  1.58k|            }
  400|  1.16k|            else if (length <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (400:22): [True: 772, False: 397]
  ------------------
  401|    772|            {
  402|       |                // str 16 stores a byte array whose length is upto (2^16)-1 bytes
  403|    772|                sink_.push_back(jsoncons::msgpack::msgpack_type::str16_type);
  404|    772|                binary::native_to_big(static_cast<uint16_t>(length), std::back_inserter(sink_));
  405|    772|            }
  406|    397|            else if (length <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (406:22): [True: 397, False: 0]
  ------------------
  407|    397|            {
  408|       |                // str 32 stores a byte array whose length is upto (2^32)-1 bytes
  409|    397|                sink_.push_back(jsoncons::msgpack::msgpack_type::str32_type);
  410|    397|                binary::native_to_big(static_cast<uint32_t>(length),std::back_inserter(sink_));
  411|    397|            }
  412|       |
  413|   579k|            for (auto c : sv)
  ------------------
  |  Branch (413:25): [True: 96.2M, False: 579k]
  ------------------
  414|  96.2M|            {
  415|  96.2M|                sink_.push_back(c);
  416|  96.2M|            }
  417|   579k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  423|  3.10k|        {
  424|       |
  425|  3.10k|            const std::size_t length = b.size();
  426|  3.10k|            if (length <= (std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (426:17): [True: 2.42k, False: 678]
  ------------------
  427|  2.42k|            {
  428|       |                // bin 8 stores a byte array whose length is upto (2^8)-1 bytes
  429|  2.42k|                sink_.push_back(jsoncons::msgpack::msgpack_type::bin8_type);
  430|  2.42k|                sink_.push_back(static_cast<uint8_t>(length));
  431|  2.42k|            }
  432|    678|            else if (length <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (432:22): [True: 616, False: 62]
  ------------------
  433|    616|            {
  434|       |                // bin 16 stores a byte array whose length is upto (2^16)-1 bytes
  435|    616|                sink_.push_back(jsoncons::msgpack::msgpack_type::bin16_type);
  436|    616|                binary::native_to_big(static_cast<uint16_t>(length), std::back_inserter(sink_));
  437|    616|            }
  438|     62|            else if (length <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (438:22): [True: 62, False: 0]
  ------------------
  439|     62|            {
  440|       |                // bin 32 stores a byte array whose length is upto (2^32)-1 bytes
  441|     62|                sink_.push_back(jsoncons::msgpack::msgpack_type::bin32_type);
  442|     62|                binary::native_to_big(static_cast<uint32_t>(length),std::back_inserter(sink_));
  443|     62|            }
  444|       |
  445|  3.10k|            for (auto c : b)
  ------------------
  |  Branch (445:25): [True: 6.38M, False: 3.10k]
  ------------------
  446|  6.38M|            {
  447|  6.38M|                sink_.push_back(c);
  448|  6.38M|            }
  449|       |
  450|  3.10k|            end_value();
  451|  3.10k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.10k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  452|  3.10k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS3_10error_codeE:
  458|   338k|        {
  459|   338k|            const std::size_t length = b.size();
  460|   338k|            switch (length)
  461|   338k|            {
  462|  2.12k|                case 1:
  ------------------
  |  Branch (462:17): [True: 2.12k, False: 336k]
  ------------------
  463|  2.12k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext1_type);
  464|  2.12k|                    sink_.push_back(static_cast<uint8_t>(raw_tag));
  465|  2.12k|                    break;
  466|   323k|                case 2:
  ------------------
  |  Branch (466:17): [True: 323k, False: 15.7k]
  ------------------
  467|   323k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext2_type);
  468|   323k|                    sink_.push_back(static_cast<uint8_t>(raw_tag));
  469|   323k|                    break;
  470|    738|                case 4:
  ------------------
  |  Branch (470:17): [True: 738, False: 338k]
  ------------------
  471|    738|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext4_type);
  472|    738|                    sink_.push_back(static_cast<uint8_t>(raw_tag));
  473|    738|                    break;
  474|  3.27k|                case 8:
  ------------------
  |  Branch (474:17): [True: 3.27k, False: 335k]
  ------------------
  475|  3.27k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext8_type);
  476|  3.27k|                    sink_.push_back(static_cast<uint8_t>(raw_tag));
  477|  3.27k|                    break;
  478|  6.07k|                case 16:
  ------------------
  |  Branch (478:17): [True: 6.07k, False: 332k]
  ------------------
  479|  6.07k|                    sink_.push_back(jsoncons::msgpack::msgpack_type::fixext16_type);
  480|  6.07k|                    sink_.push_back(static_cast<uint8_t>(raw_tag));
  481|  6.07k|                    break;
  482|  3.52k|                default:
  ------------------
  |  Branch (482:17): [True: 3.52k, False: 335k]
  ------------------
  483|  3.52k|                    if (length <= (std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (483:25): [True: 2.54k, False: 981]
  ------------------
  484|  2.54k|                    {
  485|  2.54k|                        sink_.push_back(jsoncons::msgpack::msgpack_type::ext8_type);
  486|  2.54k|                        sink_.push_back(static_cast<uint8_t>(length));
  487|  2.54k|                        sink_.push_back(static_cast<uint8_t>(raw_tag));
  488|  2.54k|                    }
  489|    981|                    else if (length <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (489:30): [True: 900, False: 81]
  ------------------
  490|    900|                    {
  491|    900|                        sink_.push_back(jsoncons::msgpack::msgpack_type::ext16_type);
  492|    900|                        binary::native_to_big(static_cast<uint16_t>(length), std::back_inserter(sink_));
  493|    900|                        sink_.push_back(static_cast<uint8_t>(raw_tag));
  494|    900|                    }
  495|     81|                    else if (length <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (495:30): [True: 81, False: 0]
  ------------------
  496|     81|                    {
  497|     81|                        sink_.push_back(jsoncons::msgpack::msgpack_type::ext32_type);
  498|     81|                        binary::native_to_big(static_cast<uint32_t>(length),std::back_inserter(sink_));
  499|     81|                        sink_.push_back(static_cast<uint8_t>(raw_tag));
  500|     81|                    }
  501|  3.52k|                    break;
  502|   338k|            }
  503|       |
  504|   338k|            for (auto c : b)
  ------------------
  |  Branch (504:25): [True: 9.54M, False: 338k]
  ------------------
  505|  9.54M|            {
  506|  9.54M|                sink_.push_back(c);
  507|  9.54M|            }
  508|       |
  509|   338k|            end_value();
  510|   338k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   338k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  511|   338k|        }
_ZN8jsoncons7msgpack21basic_msgpack_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEED2Ev:
  111|  6.23k|        {
  112|  6.23k|            sink_.flush();
  113|  6.23k|        }

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

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

_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RKNS0_22msgpack_decode_optionsERKS7_:
   86|  6.23k|       : source_(std::forward<Sourceable>(source)),
   87|  6.23k|         max_nesting_depth_(options.max_nesting_depth()),
   88|  6.23k|         text_buffer_(alloc),
   89|  6.23k|         bytes_buffer_(alloc),
   90|  6.23k|         state_stack_(alloc)
   91|  6.23k|    {
   92|  6.23k|        state_stack_.emplace_back(parse_mode::root,0);
   93|  6.23k|    }
_ZN8jsoncons7msgpack11parse_stateC2ENS0_10parse_modeEm:
   46|   697k|        : mode(mode), length(length)
   47|   697k|    {
   48|   697k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5resetEv:
  101|  6.23k|    {
  102|  6.23k|        more_ = true;
  103|  6.23k|        done_ = false;
  104|  6.23k|        text_buffer_.clear();
  105|  6.23k|        bytes_buffer_.clear();
  106|  6.23k|        state_stack_.clear();
  107|  6.23k|        state_stack_.emplace_back(parse_mode::root,0);
  108|  6.23k|        nesting_depth_ = 0;
  109|  6.23k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  159|  6.23k|    {
  160|  46.3M|        while (!done_ && more_)
  ------------------
  |  Branch (160:16): [True: 46.3M, False: 1.51k]
  |  Branch (160:26): [True: 46.3M, False: 0]
  ------------------
  161|  46.3M|        {
  162|  46.3M|            switch (state_stack_.back().mode)
  ------------------
  |  Branch (162:21): [True: 46.3M, False: 0]
  ------------------
  163|  46.3M|            {
  164|  27.8M|                case parse_mode::array:
  ------------------
  |  Branch (164:17): [True: 27.8M, False: 18.4M]
  ------------------
  165|  27.8M|                {
  166|  27.8M|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (166:25): [True: 27.4M, False: 419k]
  ------------------
  167|  27.4M|                    {
  168|  27.4M|                        ++state_stack_.back().index;
  169|  27.4M|                        read_item(visitor, ec);
  170|  27.4M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  27.4M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.61k, False: 27.4M]
  |  |  ------------------
  ------------------
  171|  1.61k|                        {
  172|  1.61k|                            return;
  173|  1.61k|                        }
  174|  27.4M|                    }
  175|   419k|                    else
  176|   419k|                    {
  177|   419k|                        end_array(visitor, ec);
  178|   419k|                    }
  179|  27.8M|                    break;
  180|  27.8M|                }
  181|  27.8M|                case parse_mode::map_key:
  ------------------
  |  Branch (181:17): [True: 9.34M, False: 36.9M]
  ------------------
  182|  9.34M|                {
  183|  9.34M|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (183:25): [True: 9.13M, False: 206k]
  ------------------
  184|  9.13M|                    {
  185|  9.13M|                        ++state_stack_.back().index;
  186|  9.13M|                        state_stack_.back().mode = parse_mode::map_value;
  187|  9.13M|                        read_item(visitor, ec);
  188|  9.13M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  9.13M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 828, False: 9.13M]
  |  |  ------------------
  ------------------
  189|    828|                        {
  190|    828|                            return;
  191|    828|                        }
  192|  9.13M|                    }
  193|   206k|                    else
  194|   206k|                    {
  195|   206k|                        end_object(visitor, ec);
  196|   206k|                    }
  197|  9.34M|                    break;
  198|  9.34M|                }
  199|  9.34M|                case parse_mode::map_value:
  ------------------
  |  Branch (199:17): [True: 9.12M, False: 37.1M]
  ------------------
  200|  9.12M|                {
  201|  9.12M|                    state_stack_.back().mode = parse_mode::map_key;
  202|  9.12M|                    read_item(visitor, ec);
  203|  9.12M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  9.12M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.88k, False: 9.12M]
  |  |  ------------------
  ------------------
  204|  1.88k|                    {
  205|  1.88k|                        return;
  206|  1.88k|                    }
  207|  9.12M|                    break;
  208|  9.12M|                }
  209|  9.12M|                case parse_mode::root:
  ------------------
  |  Branch (209:17): [True: 6.23k, False: 46.3M]
  ------------------
  210|  6.23k|                {
  211|  6.23k|                    state_stack_.back().mode = parse_mode::accept;
  212|  6.23k|                    read_item(visitor, ec);
  213|  6.23k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  6.23k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 399, False: 5.83k]
  |  |  ------------------
  ------------------
  214|    399|                    {
  215|    399|                        return;
  216|    399|                    }
  217|  5.83k|                    break;
  218|  6.23k|                }
  219|  5.83k|                case parse_mode::accept:
  ------------------
  |  Branch (219:17): [True: 1.51k, False: 46.3M]
  ------------------
  220|  1.51k|                {
  221|  1.51k|                    JSONCONS_ASSERT(state_stack_.size() == 1);
  ------------------
  |  |   49|  1.51k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 1.51k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  222|  1.51k|                    state_stack_.clear();
  223|  1.51k|                    more_ = false;
  224|  1.51k|                    done_ = true;
  225|  1.51k|                    visitor.flush();
  226|  1.51k|                    break;
  227|  1.51k|                }
  228|  46.3M|            }
  229|  46.3M|        }
  230|  6.23k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_itemERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  234|  45.6M|    {
  235|  45.6M|        if (source_.is_error())
  ------------------
  |  Branch (235:13): [True: 0, False: 45.6M]
  ------------------
  236|      0|        {
  237|      0|            ec = msgpack_errc::source_error;
  238|      0|            more_ = false;
  239|      0|            return;
  240|      0|        }   
  241|       |
  242|  45.6M|        uint8_t type;
  243|  45.6M|        if (source_.read(&type, 1) == 0)
  ------------------
  |  Branch (243:13): [True: 3.75k, False: 45.6M]
  ------------------
  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|  45.6M|        if (type <= 0xbf)
  ------------------
  |  Branch (250:13): [True: 15.8M, False: 29.8M]
  ------------------
  251|  15.8M|        {
  252|  15.8M|            if (type <= 0x7f) 
  ------------------
  |  Branch (252:17): [True: 14.7M, False: 1.01M]
  ------------------
  253|  14.7M|            {
  254|       |                // positive fixint
  255|  14.7M|                visitor.uint64_value(type, semantic_tag::none, *this, ec);
  256|  14.7M|                more_ = !cursor_mode_;
  257|  14.7M|            }
  258|  1.01M|            else if (type <= 0x8f) 
  ------------------
  |  Branch (258:22): [True: 226k, False: 788k]
  ------------------
  259|   226k|            {
  260|   226k|                begin_object(visitor,type,ec); // fixmap
  261|   226k|            }
  262|   788k|            else if (type <= 0x9f) 
  ------------------
  |  Branch (262:22): [True: 442k, False: 345k]
  ------------------
  263|   442k|            {
  264|   442k|                begin_array(visitor,type,ec); // fixarray
  265|   442k|            }
  266|   345k|            else 
  267|   345k|            {
  268|       |                // fixstr
  269|   345k|                const size_t len = type & 0x1f;
  270|       |
  271|   345k|                auto data = source_.read_span(len, bytes_buffer_);
  272|   345k|                if (data.size() != static_cast<std::size_t>(len))
  ------------------
  |  Branch (272:21): [True: 41, False: 345k]
  ------------------
  273|     41|                {
  274|     41|                    ec = msgpack_errc::unexpected_eof;
  275|     41|                    more_ = false;
  276|     41|                    return;
  277|     41|                }
  278|       |
  279|   345k|                auto result = unicode_traits::validate(data.data(), data.size());
  280|   345k|                if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (280:21): [True: 150, False: 345k]
  ------------------
  281|    150|                {
  282|    150|                    ec = msgpack_errc::invalid_utf8_text_string;
  283|    150|                    more_ = false;
  284|    150|                    return;
  285|    150|                }
  286|   345k|                visitor.string_value(jsoncons::string_view(reinterpret_cast<const char*>(data.data()),data.size()), 
  287|   345k|                    semantic_tag::none, *this, ec);
  288|   345k|                more_ = !cursor_mode_;
  289|   345k|            }
  290|  15.8M|        }
  291|  29.8M|        else if (type >= 0xe0) 
  ------------------
  |  Branch (291:18): [True: 2.08M, False: 27.7M]
  ------------------
  292|  2.08M|        {
  293|       |            // negative fixint
  294|  2.08M|            visitor.int64_value(static_cast<int8_t>(type), semantic_tag::none, *this, ec);
  295|  2.08M|            more_ = !cursor_mode_;
  296|  2.08M|        }
  297|  27.7M|        else
  298|  27.7M|        {
  299|  27.7M|            switch (type)
  300|  27.7M|            {
  301|   563k|                case jsoncons::msgpack::msgpack_type::nil_type: 
  ------------------
  |  Branch (301:17): [True: 563k, False: 27.2M]
  ------------------
  302|   563k|                {
  303|   563k|                    visitor.null_value(semantic_tag::none, *this, ec);
  304|   563k|                    more_ = !cursor_mode_;
  305|   563k|                    break;
  306|      0|                }
  307|  75.6k|                case jsoncons::msgpack::msgpack_type::true_type:
  ------------------
  |  Branch (307:17): [True: 75.6k, False: 27.7M]
  ------------------
  308|  75.6k|                {
  309|  75.6k|                    visitor.bool_value(true, semantic_tag::none, *this, ec);
  310|  75.6k|                    more_ = !cursor_mode_;
  311|  75.6k|                    break;
  312|      0|                }
  313|  25.6M|                case jsoncons::msgpack::msgpack_type::false_type:
  ------------------
  |  Branch (313:17): [True: 25.6M, False: 2.11M]
  ------------------
  314|  25.6M|                {
  315|  25.6M|                    visitor.bool_value(false, semantic_tag::none, *this, ec);
  316|  25.6M|                    more_ = !cursor_mode_;
  317|  25.6M|                    break;
  318|      0|                }
  319|  69.2k|                case jsoncons::msgpack::msgpack_type::float32_type: 
  ------------------
  |  Branch (319:17): [True: 69.2k, False: 27.7M]
  ------------------
  320|  69.2k|                {
  321|  69.2k|                    uint8_t buf[sizeof(float)];
  322|  69.2k|                    if (source_.read(buf, sizeof(float)) != sizeof(float))
  ------------------
  |  Branch (322:25): [True: 22, False: 69.2k]
  ------------------
  323|     22|                    {
  324|     22|                        ec = msgpack_errc::unexpected_eof;
  325|     22|                        more_ = false;
  326|     22|                        return;
  327|     22|                    }
  328|  69.2k|                    float val = binary::big_to_native<float>(buf, sizeof(buf));
  329|  69.2k|                    visitor.double_value(val, semantic_tag::none, *this, ec);
  330|  69.2k|                    more_ = !cursor_mode_;
  331|  69.2k|                    break;
  332|  69.2k|                }
  333|       |
  334|  60.5k|                case jsoncons::msgpack::msgpack_type::float64_type: 
  ------------------
  |  Branch (334:17): [True: 60.5k, False: 27.7M]
  ------------------
  335|  60.5k|                {
  336|  60.5k|                    uint8_t buf[sizeof(double)];
  337|  60.5k|                    if (source_.read(buf, sizeof(double)) != sizeof(double))
  ------------------
  |  Branch (337:25): [True: 15, False: 60.5k]
  ------------------
  338|     15|                    {
  339|     15|                        ec = msgpack_errc::unexpected_eof;
  340|     15|                        more_ = false;
  341|     15|                        return;
  342|     15|                    }
  343|  60.5k|                    double val = binary::big_to_native<double>(buf, sizeof(buf));
  344|  60.5k|                    visitor.double_value(val, semantic_tag::none, *this, ec);
  345|  60.5k|                    more_ = !cursor_mode_;
  346|  60.5k|                    break;
  347|  60.5k|                }
  348|       |
  349|  17.2k|                case jsoncons::msgpack::msgpack_type::uint8_type: 
  ------------------
  |  Branch (349:17): [True: 17.2k, False: 27.7M]
  ------------------
  350|  17.2k|                {
  351|  17.2k|                    uint8_t b;
  352|  17.2k|                    if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (352:25): [True: 1, False: 17.2k]
  ------------------
  353|      1|                    {
  354|      1|                        ec = msgpack_errc::unexpected_eof;
  355|      1|                        more_ = false;
  356|      1|                        return;
  357|      1|                    }
  358|  17.2k|                    visitor.uint64_value(b, semantic_tag::none, *this, ec);
  359|  17.2k|                    more_ = !cursor_mode_;
  360|  17.2k|                    break;
  361|  17.2k|                }
  362|       |
  363|  1.79k|                case jsoncons::msgpack::msgpack_type::uint16_type: 
  ------------------
  |  Branch (363:17): [True: 1.79k, False: 27.7M]
  ------------------
  364|  1.79k|                {
  365|  1.79k|                    uint8_t buf[sizeof(uint16_t)];
  366|  1.79k|                    if (source_.read(buf, sizeof(uint16_t)) !=sizeof(uint16_t)) 
  ------------------
  |  Branch (366:25): [True: 2, False: 1.79k]
  ------------------
  367|      2|                    {
  368|      2|                        ec = msgpack_errc::unexpected_eof;
  369|      2|                        more_ = false;
  370|      2|                        return;
  371|      2|                    }
  372|  1.79k|                    uint16_t val = binary::big_to_native<uint16_t>(buf, sizeof(buf));
  373|  1.79k|                    visitor.uint64_value(val, semantic_tag::none, *this, ec);
  374|  1.79k|                    more_ = !cursor_mode_;
  375|  1.79k|                    break;
  376|  1.79k|                }
  377|       |
  378|  6.69k|                case jsoncons::msgpack::msgpack_type::uint32_type: 
  ------------------
  |  Branch (378:17): [True: 6.69k, False: 27.7M]
  ------------------
  379|  6.69k|                {
  380|  6.69k|                    uint8_t buf[sizeof(uint32_t)];
  381|  6.69k|                    if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (381:25): [True: 4, False: 6.69k]
  ------------------
  382|      4|                    {
  383|      4|                        ec = msgpack_errc::unexpected_eof;
  384|      4|                        more_ = false;
  385|      4|                        return;
  386|      4|                    }
  387|  6.69k|                    uint32_t val = binary::big_to_native<uint32_t>(buf, sizeof(buf));
  388|  6.69k|                    visitor.uint64_value(val, semantic_tag::none, *this, ec);
  389|  6.69k|                    more_ = !cursor_mode_;
  390|  6.69k|                    break;
  391|  6.69k|                }
  392|       |
  393|  6.80k|                case jsoncons::msgpack::msgpack_type::uint64_type: 
  ------------------
  |  Branch (393:17): [True: 6.80k, False: 27.7M]
  ------------------
  394|  6.80k|                {
  395|  6.80k|                    uint8_t buf[sizeof(uint64_t)];
  396|  6.80k|                    if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (396:25): [True: 5, False: 6.79k]
  ------------------
  397|      5|                    {
  398|      5|                        ec = msgpack_errc::unexpected_eof;
  399|      5|                        more_ = false;
  400|      5|                        return;
  401|      5|                    }
  402|  6.79k|                    uint64_t val = binary::big_to_native<uint64_t>(buf, sizeof(buf));
  403|  6.79k|                    visitor.uint64_value(val, semantic_tag::none, *this, ec);
  404|  6.79k|                    more_ = !cursor_mode_;
  405|  6.79k|                    break;
  406|  6.80k|                }
  407|       |
  408|   164k|                case jsoncons::msgpack::msgpack_type::int8_type: 
  ------------------
  |  Branch (408:17): [True: 164k, False: 27.6M]
  ------------------
  409|   164k|                {
  410|   164k|                    uint8_t buf[sizeof(int8_t)];
  411|   164k|                    if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (411:25): [True: 3, False: 164k]
  ------------------
  412|      3|                    {
  413|      3|                        ec = msgpack_errc::unexpected_eof;
  414|      3|                        more_ = false;
  415|      3|                        return;
  416|      3|                    }
  417|   164k|                    int8_t val = binary::big_to_native<int8_t>(buf, sizeof(buf));
  418|   164k|                    visitor.int64_value(val, semantic_tag::none, *this, ec);
  419|   164k|                    more_ = !cursor_mode_;
  420|   164k|                    break;
  421|   164k|                }
  422|       |
  423|  28.2k|                case jsoncons::msgpack::msgpack_type::int16_type: 
  ------------------
  |  Branch (423:17): [True: 28.2k, False: 27.7M]
  ------------------
  424|  28.2k|                {
  425|  28.2k|                    uint8_t buf[sizeof(int16_t)];
  426|  28.2k|                    if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t))
  ------------------
  |  Branch (426:25): [True: 7, False: 28.2k]
  ------------------
  427|      7|                    {
  428|      7|                        ec = msgpack_errc::unexpected_eof;
  429|      7|                        more_ = false;
  430|      7|                        return;
  431|      7|                    }
  432|  28.2k|                    int16_t val = binary::big_to_native<int16_t>(buf, sizeof(buf));
  433|  28.2k|                    visitor.int64_value(val, semantic_tag::none, *this, ec);
  434|  28.2k|                    more_ = !cursor_mode_;
  435|  28.2k|                    break;
  436|  28.2k|                }
  437|       |
  438|  14.9k|                case jsoncons::msgpack::msgpack_type::int32_type: 
  ------------------
  |  Branch (438:17): [True: 14.9k, False: 27.7M]
  ------------------
  439|  14.9k|                {
  440|  14.9k|                    uint8_t buf[sizeof(int32_t)];
  441|  14.9k|                    if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t))
  ------------------
  |  Branch (441:25): [True: 4, False: 14.9k]
  ------------------
  442|      4|                    {
  443|      4|                        ec = msgpack_errc::unexpected_eof;
  444|      4|                        more_ = false;
  445|      4|                        return;
  446|      4|                    }
  447|  14.9k|                    int32_t val = binary::big_to_native<int32_t>(buf, sizeof(buf));
  448|  14.9k|                    visitor.int64_value(val, semantic_tag::none, *this, ec);
  449|  14.9k|                    more_ = !cursor_mode_;
  450|  14.9k|                    break;
  451|  14.9k|                }
  452|       |
  453|  27.5k|                case jsoncons::msgpack::msgpack_type::int64_type: 
  ------------------
  |  Branch (453:17): [True: 27.5k, False: 27.7M]
  ------------------
  454|  27.5k|                {
  455|  27.5k|                    uint8_t buf[sizeof(int64_t)];
  456|  27.5k|                    if (source_.read(buf, sizeof(int64_t)) != sizeof(int64_t))
  ------------------
  |  Branch (456:25): [True: 24, False: 27.5k]
  ------------------
  457|     24|                    {
  458|     24|                        ec = msgpack_errc::unexpected_eof;
  459|     24|                        more_ = false;
  460|     24|                        return;
  461|     24|                    }
  462|  27.5k|                    int64_t val = binary::big_to_native<int64_t>(buf, sizeof(buf));
  463|  27.5k|                    visitor.int64_value(val, semantic_tag::none, *this, ec);
  464|  27.5k|                    more_ = !cursor_mode_;
  465|  27.5k|                    break;
  466|  27.5k|                }
  467|       |
  468|    916|                case jsoncons::msgpack::msgpack_type::str8_type: 
  ------------------
  |  Branch (468:17): [True: 916, False: 27.7M]
  ------------------
  469|  1.31k|                case jsoncons::msgpack::msgpack_type::str16_type: 
  ------------------
  |  Branch (469:17): [True: 396, False: 27.7M]
  ------------------
  470|  2.17k|                case jsoncons::msgpack::msgpack_type::str32_type: 
  ------------------
  |  Branch (470:17): [True: 867, False: 27.7M]
  ------------------
  471|  2.17k|                {
  472|  2.17k|                    std::size_t len = get_size(type, ec);
  473|  2.17k|                    if (!more_)
  ------------------
  |  Branch (473:25): [True: 25, False: 2.15k]
  ------------------
  474|     25|                    {
  475|     25|                        return;
  476|     25|                    }
  477|       |
  478|  2.15k|                    auto data = source_.read_span(len, bytes_buffer_);
  479|  2.15k|                    if (data.size() != static_cast<std::size_t>(len))
  ------------------
  |  Branch (479:25): [True: 123, False: 2.03k]
  ------------------
  480|    123|                    {
  481|    123|                        ec = msgpack_errc::unexpected_eof;
  482|    123|                        more_ = false;
  483|    123|                        return;
  484|    123|                    }
  485|       |
  486|  2.03k|                    auto result = unicode_traits::validate(data.data(), data.size());
  487|  2.03k|                    if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (487:25): [True: 41, False: 1.99k]
  ------------------
  488|     41|                    {
  489|     41|                        ec = msgpack_errc::invalid_utf8_text_string;
  490|     41|                        more_ = false;
  491|     41|                        return;
  492|     41|                    }
  493|  1.99k|                    visitor.string_value(jsoncons::string_view(reinterpret_cast<const char*>(data.data()),data.size()), 
  494|  1.99k|                        semantic_tag::none, *this, ec);
  495|  1.99k|                    more_ = !cursor_mode_;
  496|  1.99k|                    break;
  497|  2.03k|                }
  498|       |
  499|  31.0k|                case jsoncons::msgpack::msgpack_type::bin8_type: 
  ------------------
  |  Branch (499:17): [True: 31.0k, False: 27.7M]
  ------------------
  500|  32.2k|                case jsoncons::msgpack::msgpack_type::bin16_type: 
  ------------------
  |  Branch (500:17): [True: 1.29k, False: 27.7M]
  ------------------
  501|  32.6k|                case jsoncons::msgpack::msgpack_type::bin32_type: 
  ------------------
  |  Branch (501:17): [True: 355, False: 27.7M]
  ------------------
  502|  32.6k|                {
  503|  32.6k|                    std::size_t len = get_size(type,ec);
  504|  32.6k|                    if (!more_)
  ------------------
  |  Branch (504:25): [True: 27, False: 32.6k]
  ------------------
  505|     27|                    {
  506|     27|                        return;
  507|     27|                    }
  508|  32.6k|                    auto data = source_.read_span(len, bytes_buffer_);
  509|  32.6k|                    if (JSONCONS_UNLIKELY(data.size() != static_cast<std::size_t>(len)))
  ------------------
  |  |   78|  32.6k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 119, False: 32.5k]
  |  |  ------------------
  ------------------
  510|    119|                    {
  511|    119|                        ec = msgpack_errc::unexpected_eof;
  512|    119|                        more_ = false;
  513|    119|                        return;
  514|    119|                    }
  515|       |
  516|  32.5k|                    visitor.byte_string_value(byte_string_view(data.data(),data.size()), 
  517|  32.5k|                        semantic_tag::none, 
  518|  32.5k|                        *this,
  519|  32.5k|                        ec);
  520|  32.5k|                    more_ = !cursor_mode_;
  521|  32.5k|                    break;
  522|  32.6k|                }
  523|  10.9k|                case jsoncons::msgpack::msgpack_type::fixext1_type: 
  ------------------
  |  Branch (523:17): [True: 10.9k, False: 27.7M]
  ------------------
  524|   864k|                case jsoncons::msgpack::msgpack_type::fixext2_type: 
  ------------------
  |  Branch (524:17): [True: 853k, False: 26.9M]
  ------------------
  525|   876k|                case jsoncons::msgpack::msgpack_type::fixext4_type: 
  ------------------
  |  Branch (525:17): [True: 11.7k, False: 27.7M]
  ------------------
  526|   993k|                case jsoncons::msgpack::msgpack_type::fixext8_type: 
  ------------------
  |  Branch (526:17): [True: 117k, False: 27.6M]
  ------------------
  527|  1.00M|                case jsoncons::msgpack::msgpack_type::fixext16_type: 
  ------------------
  |  Branch (527:17): [True: 13.7k, False: 27.7M]
  ------------------
  528|  1.02M|                case jsoncons::msgpack::msgpack_type::ext8_type: 
  ------------------
  |  Branch (528:17): [True: 18.6k, False: 27.7M]
  ------------------
  529|  1.02M|                case jsoncons::msgpack::msgpack_type::ext16_type: 
  ------------------
  |  Branch (529:17): [True: 562, False: 27.7M]
  ------------------
  530|  1.02M|                case jsoncons::msgpack::msgpack_type::ext32_type: 
  ------------------
  |  Branch (530:17): [True: 2.08k, False: 27.7M]
  ------------------
  531|  1.02M|                {
  532|  1.02M|                    std::size_t len = get_size(type,ec);
  533|  1.02M|                    if (!more_)
  ------------------
  |  Branch (533:25): [True: 28, False: 1.02M]
  ------------------
  534|     28|                    {
  535|     28|                        return;
  536|     28|                    }
  537|       |
  538|       |                    // type
  539|  1.02M|                    uint8_t buf[sizeof(int8_t)];
  540|  1.02M|                    if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (540:25): [True: 41, False: 1.02M]
  ------------------
  541|     41|                    {
  542|     41|                        ec = msgpack_errc::unexpected_eof;
  543|     41|                        more_ = false;
  544|     41|                        return;
  545|     41|                    }
  546|       |
  547|  1.02M|                    int8_t ext_type = binary::big_to_native<int8_t>(buf, sizeof(buf));
  548|       |
  549|  1.02M|                    bool is_timestamp = false; 
  550|  1.02M|                    if (ext_type == -1)
  ------------------
  |  Branch (550:25): [True: 126k, False: 902k]
  ------------------
  551|   126k|                    {
  552|   126k|                        is_timestamp = true;;
  553|   126k|                    }
  554|       |
  555|       |                    // payload
  556|  1.02M|                    if (is_timestamp && len == 4)
  ------------------
  |  Branch (556:25): [True: 126k, False: 902k]
  |  Branch (556:41): [True: 2.41k, False: 123k]
  ------------------
  557|  2.41k|                    {
  558|  2.41k|                        uint8_t buf32[sizeof(uint32_t)];
  559|  2.41k|                        if (source_.read(buf32, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (559:29): [True: 3, False: 2.41k]
  ------------------
  560|      3|                        {
  561|      3|                            ec = msgpack_errc::unexpected_eof;
  562|      3|                            more_ = false;
  563|      3|                            return;
  564|      3|                        }
  565|  2.41k|                        uint32_t val = binary::big_to_native<uint32_t>(buf32, sizeof(buf32));
  566|  2.41k|                        visitor.uint64_value(val, semantic_tag::epoch_second, *this, ec);
  567|  2.41k|                        more_ = !cursor_mode_;
  568|  2.41k|                    }
  569|  1.02M|                    else if (is_timestamp && len == 8)
  ------------------
  |  Branch (569:30): [True: 123k, False: 902k]
  |  Branch (569:46): [True: 108k, False: 15.0k]
  ------------------
  570|   108k|                    {
  571|   108k|                        uint8_t buf64[sizeof(uint64_t)];
  572|   108k|                        if (source_.read(buf64, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (572:29): [True: 10, False: 108k]
  ------------------
  573|     10|                        {
  574|     10|                            ec = msgpack_errc::unexpected_eof;
  575|     10|                            more_ = false;
  576|     10|                            return;
  577|     10|                        }
  578|   108k|                        uint64_t data64 = binary::big_to_native<uint64_t>(buf64, sizeof(buf64));
  579|   108k|                        uint64_t sec = data64 & 0x00000003ffffffffL;
  580|   108k|                        uint64_t nsec = data64 >> 34;
  581|       |
  582|   108k|                        bigint nano(sec);
  583|   108k|                        nano *= uint64_t(nanos_in_second);
  584|   108k|                        nano += nsec;
  585|   108k|                        text_buffer_.clear();
  586|   108k|                        nano.write_string(text_buffer_);
  587|   108k|                        visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);
  588|   108k|                        more_ = !cursor_mode_;
  589|   108k|                        if (!more_) return;
  ------------------
  |  Branch (589:29): [True: 0, False: 108k]
  ------------------
  590|   108k|                    }
  591|   917k|                    else if (is_timestamp && len == 12)
  ------------------
  |  Branch (591:30): [True: 15.0k, False: 902k]
  |  Branch (591:46): [True: 13.6k, False: 1.38k]
  ------------------
  592|  13.6k|                    {
  593|  13.6k|                        uint8_t buf1[sizeof(uint32_t)];
  594|  13.6k|                        if (source_.read(buf1, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (594:29): [True: 3, False: 13.6k]
  ------------------
  595|      3|                        {
  596|      3|                            ec = msgpack_errc::unexpected_eof;
  597|      3|                            more_ = false;
  598|      3|                            return;
  599|      3|                        }
  600|  13.6k|                        uint32_t nsec = binary::big_to_native<uint32_t>(buf1, sizeof(buf1));
  601|       |
  602|  13.6k|                        uint8_t buf2[sizeof(int64_t)];
  603|  13.6k|                        if (source_.read(buf2, sizeof(int64_t)) != sizeof(int64_t))
  ------------------
  |  Branch (603:29): [True: 12, False: 13.6k]
  ------------------
  604|     12|                        {
  605|     12|                            ec = msgpack_errc::unexpected_eof;
  606|     12|                            more_ = false;
  607|     12|                            return;
  608|     12|                        }
  609|  13.6k|                        int64_t sec = binary::big_to_native<int64_t>(buf2, sizeof(buf2));
  610|       |
  611|  13.6k|                        bigint nano(sec);
  612|       |
  613|  13.6k|                        nano *= uint64_t(nanos_in_second);
  614|       |
  615|  13.6k|                        if (nano < 0)
  ------------------
  |  Branch (615:29): [True: 7.43k, False: 6.21k]
  ------------------
  616|  7.43k|                        {
  617|  7.43k|                            nano -= nsec;
  618|  7.43k|                        }
  619|  6.21k|                        else
  620|  6.21k|                        {
  621|  6.21k|                            nano += nsec;
  622|  6.21k|                        }
  623|       |
  624|  13.6k|                        text_buffer_.clear();
  625|  13.6k|                        nano.write_string(text_buffer_);
  626|  13.6k|                        visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);
  627|  13.6k|                        more_ = !cursor_mode_;
  628|  13.6k|                        if (!more_) return;
  ------------------
  |  Branch (628:29): [True: 0, False: 13.6k]
  ------------------
  629|  13.6k|                    }
  630|   903k|                    else
  631|   903k|                    {
  632|   903k|                        auto data = source_.read_span(len, bytes_buffer_);
  633|   903k|                        if (JSONCONS_UNLIKELY(data.size() != static_cast<std::size_t>(len)))
  ------------------
  |  |   78|   903k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 199, False: 903k]
  |  |  ------------------
  ------------------
  634|    199|                        {
  635|    199|                            ec = msgpack_errc::unexpected_eof;
  636|    199|                            more_ = false;
  637|    199|                            return;
  638|    199|                        }
  639|       |
  640|   903k|                        visitor.byte_string_value(byte_string_view(data.data(),data.size()), 
  641|   903k|                                                          static_cast<uint8_t>(ext_type), 
  642|   903k|                                                          *this,
  643|   903k|                                                          ec);
  644|   903k|                        more_ = !cursor_mode_;
  645|   903k|                    }
  646|  1.02M|                    break;
  647|  1.02M|                }
  648|       |
  649|  1.02M|                case jsoncons::msgpack::msgpack_type::array16_type: 
  ------------------
  |  Branch (649:17): [True: 5.30k, False: 27.7M]
  ------------------
  650|  12.4k|                case jsoncons::msgpack::msgpack_type::array32_type: 
  ------------------
  |  Branch (650:17): [True: 7.14k, False: 27.7M]
  ------------------
  651|  12.4k|                {
  652|  12.4k|                    begin_array(visitor,type,ec);
  653|  12.4k|                    break;
  654|  5.30k|                }
  655|       |
  656|  1.37k|                case jsoncons::msgpack::msgpack_type::map16_type : 
  ------------------
  |  Branch (656:17): [True: 1.37k, False: 27.7M]
  ------------------
  657|  3.25k|                case jsoncons::msgpack::msgpack_type::map32_type : 
  ------------------
  |  Branch (657:17): [True: 1.87k, False: 27.7M]
  ------------------
  658|  3.25k|                {
  659|  3.25k|                    begin_object(visitor, type, ec);
  660|  3.25k|                    break;
  661|  1.37k|                }
  662|       |
  663|     12|                default:
  ------------------
  |  Branch (663:17): [True: 12, False: 27.7M]
  ------------------
  664|     12|                {
  665|     12|                    ec = msgpack_errc::unknown_type;
  666|     12|                    more_ = false;
  667|     12|                    return;
  668|  1.37k|                }
  669|  27.7M|            }
  670|  27.7M|        }
  671|  45.6M|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12begin_objectERNS_21basic_generic_visitorIcEEhRNS3_10error_codeE:
  701|   229k|    {
  702|   229k|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|   229k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 229k]
  |  |  ------------------
  ------------------
  703|      1|        {
  704|      1|            ec = msgpack_errc::max_nesting_depth_exceeded;
  705|      1|            more_ = false;
  706|      1|            return;
  707|      1|        } 
  708|   229k|        std::size_t length = get_size(type, ec);
  709|   229k|        if (!more_)
  ------------------
  |  Branch (709:13): [True: 18, False: 229k]
  ------------------
  710|     18|        {
  711|     18|            return;
  712|     18|        }
  713|   229k|        state_stack_.emplace_back(parse_mode::map_key,length);
  714|   229k|        visitor.begin_object(length, semantic_tag::none, *this, ec);
  715|   229k|        more_ = !cursor_mode_;
  716|   229k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayERNS_21basic_generic_visitorIcEEhRNS3_10error_codeE:
  674|   455k|    {
  675|   455k|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|   455k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 455k]
  |  |  ------------------
  ------------------
  676|      4|        {
  677|      4|            ec = msgpack_errc::max_nesting_depth_exceeded;
  678|      4|            more_ = false;
  679|      4|            return;
  680|      4|        } 
  681|   455k|        std::size_t length = get_size(type, ec);
  682|   455k|        if (!more_)
  ------------------
  |  Branch (682:13): [True: 14, False: 455k]
  ------------------
  683|     14|        {
  684|     14|            return;
  685|     14|        }
  686|   455k|        state_stack_.emplace_back(parse_mode::array,length);
  687|   455k|        visitor.begin_array(length, semantic_tag::none, *this, ec);
  688|   455k|        more_ = !cursor_mode_;
  689|   455k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE8get_sizeEhRNS3_10error_codeE:
  727|  1.74M|    {
  728|  1.74M|        switch (type)
  729|  1.74M|        {
  730|    916|            case jsoncons::msgpack::msgpack_type::str8_type: 
  ------------------
  |  Branch (730:13): [True: 916, False: 1.74M]
  ------------------
  731|  31.9k|            case jsoncons::msgpack::msgpack_type::bin8_type: 
  ------------------
  |  Branch (731:13): [True: 31.0k, False: 1.71M]
  ------------------
  732|  50.5k|            case jsoncons::msgpack::msgpack_type::ext8_type: 
  ------------------
  |  Branch (732:13): [True: 18.6k, False: 1.72M]
  ------------------
  733|  50.5k|            {
  734|  50.5k|                uint8_t buf[sizeof(int8_t)];
  735|  50.5k|                if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (735:21): [True: 27, False: 50.5k]
  ------------------
  736|     27|                {
  737|     27|                    ec = msgpack_errc::unexpected_eof;
  738|     27|                    more_ = false;
  739|     27|                    return 0;
  740|     27|                }
  741|  50.5k|                uint8_t len = binary::big_to_native<uint8_t>(buf, sizeof(buf));
  742|  50.5k|                return static_cast<std::size_t>(len);
  743|  50.5k|            }
  744|       |
  745|    396|            case jsoncons::msgpack::msgpack_type::str16_type: 
  ------------------
  |  Branch (745:13): [True: 396, False: 1.74M]
  ------------------
  746|  1.68k|            case jsoncons::msgpack::msgpack_type::bin16_type: 
  ------------------
  |  Branch (746:13): [True: 1.29k, False: 1.74M]
  ------------------
  747|  2.24k|            case jsoncons::msgpack::msgpack_type::ext16_type: 
  ------------------
  |  Branch (747:13): [True: 562, False: 1.74M]
  ------------------
  748|  7.55k|            case jsoncons::msgpack::msgpack_type::array16_type: 
  ------------------
  |  Branch (748:13): [True: 5.30k, False: 1.74M]
  ------------------
  749|  8.93k|            case jsoncons::msgpack::msgpack_type::map16_type:
  ------------------
  |  Branch (749:13): [True: 1.37k, False: 1.74M]
  ------------------
  750|  8.93k|            {
  751|  8.93k|                uint8_t buf[sizeof(int16_t)];
  752|  8.93k|                if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t))
  ------------------
  |  Branch (752:21): [True: 40, False: 8.89k]
  ------------------
  753|     40|                {
  754|     40|                    ec = msgpack_errc::unexpected_eof;
  755|     40|                    more_ = false;
  756|     40|                    return 0;
  757|     40|                }
  758|  8.89k|                uint16_t len = binary::big_to_native<uint16_t>(buf, sizeof(buf));
  759|  8.89k|                return static_cast<std::size_t>(len);
  760|  8.93k|            }
  761|       |
  762|    867|            case jsoncons::msgpack::msgpack_type::str32_type: 
  ------------------
  |  Branch (762:13): [True: 867, False: 1.74M]
  ------------------
  763|  1.22k|            case jsoncons::msgpack::msgpack_type::bin32_type: 
  ------------------
  |  Branch (763:13): [True: 355, False: 1.74M]
  ------------------
  764|  3.30k|            case jsoncons::msgpack::msgpack_type::ext32_type: 
  ------------------
  |  Branch (764:13): [True: 2.08k, False: 1.74M]
  ------------------
  765|  10.4k|            case jsoncons::msgpack::msgpack_type::array32_type: 
  ------------------
  |  Branch (765:13): [True: 7.14k, False: 1.74M]
  ------------------
  766|  12.3k|            case jsoncons::msgpack::msgpack_type::map32_type : 
  ------------------
  |  Branch (766:13): [True: 1.87k, False: 1.74M]
  ------------------
  767|  12.3k|            {
  768|  12.3k|                uint8_t buf[sizeof(int32_t)];
  769|  12.3k|                if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t))
  ------------------
  |  Branch (769:21): [True: 45, False: 12.2k]
  ------------------
  770|     45|                {
  771|     45|                    ec = msgpack_errc::unexpected_eof;
  772|     45|                    more_ = false;
  773|     45|                    return 0;
  774|     45|                }
  775|  12.2k|                uint32_t len = binary::big_to_native<uint32_t>(buf, sizeof(buf));
  776|  12.2k|                return static_cast<std::size_t>(len);
  777|  12.3k|            }
  778|  10.9k|            case jsoncons::msgpack::msgpack_type::fixext1_type: 
  ------------------
  |  Branch (778:13): [True: 10.9k, False: 1.73M]
  ------------------
  779|  10.9k|                return 1;
  780|   853k|            case jsoncons::msgpack::msgpack_type::fixext2_type: 
  ------------------
  |  Branch (780:13): [True: 853k, False: 894k]
  ------------------
  781|   853k|                return 2;
  782|  11.7k|            case jsoncons::msgpack::msgpack_type::fixext4_type: 
  ------------------
  |  Branch (782:13): [True: 11.7k, False: 1.73M]
  ------------------
  783|  11.7k|                return 4;
  784|   117k|            case jsoncons::msgpack::msgpack_type::fixext8_type: 
  ------------------
  |  Branch (784:13): [True: 117k, False: 1.63M]
  ------------------
  785|   117k|                return 8;
  786|  13.7k|            case jsoncons::msgpack::msgpack_type::fixext16_type: 
  ------------------
  |  Branch (786:13): [True: 13.7k, False: 1.73M]
  ------------------
  787|  13.7k|                return 16;
  788|   668k|            default:
  ------------------
  |  Branch (788:13): [True: 668k, False: 1.07M]
  ------------------
  789|   668k|                if ((type > 0x8f && type <= 0x9f) // fixarray
  ------------------
  |  Branch (789:22): [True: 442k, False: 226k]
  |  Branch (789:37): [True: 442k, False: 0]
  ------------------
  790|   226k|                    || (type > 0x7f && type <= 0x8f) // fixmap
  ------------------
  |  Branch (790:25): [True: 226k, False: 0]
  |  Branch (790:40): [True: 226k, False: 0]
  ------------------
  791|   668k|        )
  792|   668k|                {
  793|   668k|                    return type & 0x0f;
  794|   668k|                }
  795|      0|                else
  796|      0|                {
  797|      0|                    ec = msgpack_errc::unknown_type;
  798|      0|                    more_ = false;
  799|      0|                    return 0;
  800|      0|                }
  801|      0|                break;
  802|  1.74M|        }
  803|  1.74M|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9end_arrayERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  692|   419k|    {
  693|   419k|        --nesting_depth_;
  694|       |
  695|   419k|        visitor.end_array(*this, ec);
  696|   419k|        more_ = !cursor_mode_;
  697|   419k|        state_stack_.pop_back();
  698|   419k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10end_objectERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  719|   206k|    {
  720|   206k|        --nesting_depth_;
  721|   206k|        visitor.end_object(*this, ec);
  722|   206k|        more_ = !cursor_mode_;
  723|   206k|        state_stack_.pop_back();
  724|   206k|    }

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