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

_ZN8jsoncons6binary11decode_halfEt:
  536|      3|    {
  537|       |    #if defined(__F16C__) && !defined(APPLE_MISSING_INTRINSICS)
  538|       |        return _cvtsh_ss(half);
  539|       |    #else
  540|      3|        int64_t exp = (half >> 10) & 0x1f;
  541|      3|        int64_t mant = half & 0x3ff;
  542|      3|        double val;
  543|      3|        if (exp == 0) 
  ------------------
  |  Branch (543:13): [True: 0, False: 3]
  ------------------
  544|      0|        {
  545|      0|            val = ldexp(static_cast<double>(mant), -24);
  546|      0|        }
  547|      3|        else if (exp != 31) 
  ------------------
  |  Branch (547:18): [True: 3, False: 0]
  ------------------
  548|      3|        {
  549|      3|            val = ldexp(static_cast<double>(mant) + 1024.0, static_cast<int>(exp - 25));
  550|      3|        } 
  551|      0|        else
  552|      0|        {
  553|      0|            val = mant == 0 ? std::numeric_limits<double>::infinity() : std::nan("");
  ------------------
  |  Branch (553:19): [True: 0, False: 0]
  ------------------
  554|      0|        }
  555|      3|        return half & 0x8000 ? -val : val;
  ------------------
  |  Branch (555:16): [True: 0, False: 3]
  ------------------
  556|      3|    #endif
  557|      3|    }

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

_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4sizeEv:
  116|     38|        {
  117|     38|            return size_;
  118|     38|        }
_ZNK8jsoncons6detail4spanIhLm18446744073709551615EE4dataEv:
  111|    793|        {
  112|    793|            return data_;
  113|    793|        }
_ZNK8jsoncons6detail4spanIhLm18446744073709551615EE4sizeEv:
  116|    793|        {
  117|    793|            return size_;
  118|    793|        }
_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2EPS2_m:
   61|      4|            : data_(data), size_(size)
   62|      4|        {
   63|      4|        }
_ZN8jsoncons6detail4spanIhLm18446744073709551615EEC2INSt3__16vectorIhNS4_9allocatorIhEEEEEERT_PNS4_9enable_ifIXaaaaaantsr7is_spanIS9_EE5valuentsr10ext_traits12is_std_arrayIS9_EE5valuesr10ext_traits21is_compatible_elementIS9_hEE5valuesr10ext_traits17has_data_and_sizeIS9_EE5valueEvE4typeE:
   68|    793|            : data_(c.data()), size_(c.size())
   69|    793|        {
   70|    793|        }
_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EEixEm:
  126|     26|         {
  127|     26|             return data_[index];
  128|     26|         }
_ZN8jsoncons6detail4spanItLm18446744073709551615EEC2EPtm:
   61|      1|            : data_(data), size_(size)
   62|      1|        {
   63|      1|        }
_ZNK8jsoncons6detail4spanItLm18446744073709551615EE4sizeEv:
  116|      4|        {
  117|      4|            return size_;
  118|      4|        }
_ZN8jsoncons6detail4spanImLm18446744073709551615EEC2EPmm:
   61|     91|            : data_(data), size_(size)
   62|     91|        {
   63|     91|        }
_ZNK8jsoncons6detail4spanImLm18446744073709551615EE4sizeEv:
  116|    290|        {
  117|    290|            return size_;
  118|    290|        }
_ZNK8jsoncons6detail4spanImLm18446744073709551615EEixEm:
  126|      1|         {
  127|      1|             return data_[index];
  128|      1|         }
_ZN8jsoncons6detail4spanIsLm18446744073709551615EEC2EPsm:
   61|    692|            : data_(data), size_(size)
   62|    692|        {
   63|    692|        }
_ZNK8jsoncons6detail4spanIsLm18446744073709551615EE4sizeEv:
  116|  2.11k|        {
  117|  2.11k|            return size_;
  118|  2.11k|        }
_ZNK8jsoncons6detail4spanIsLm18446744073709551615EEixEm:
  126|     41|         {
  127|     41|             return data_[index];
  128|     41|         }
_ZN8jsoncons6detail4spanIlLm18446744073709551615EEC2EPlm:
   61|      1|            : data_(data), size_(size)
   62|      1|        {
   63|      1|        }
_ZNK8jsoncons6detail4spanIlLm18446744073709551615EE4sizeEv:
  116|      3|        {
  117|      3|            return size_;
  118|      3|        }
_ZN8jsoncons6detail4spanIfLm18446744073709551615EEC2EPfm:
   61|      2|            : data_(data), size_(size)
   62|      2|        {
   63|      2|        }
_ZNK8jsoncons6detail4spanIfLm18446744073709551615EE4sizeEv:
  116|     10|        {
  117|     10|            return size_;
  118|     10|        }
_ZNK8jsoncons6detail4spanIfLm18446744073709551615EEixEm:
  126|      4|         {
  127|      4|             return data_[index];
  128|      4|         }
_ZN8jsoncons6detail4spanIdLm18446744073709551615EEC2EPdm:
   61|      2|            : data_(data), size_(size)
   62|      2|        {
   63|      2|        }
_ZNK8jsoncons6detail4spanIdLm18446744073709551615EE4sizeEv:
  116|      8|        {
  117|      8|            return size_;
  118|      8|        }
_ZNK8jsoncons6detail4spanIdLm18446744073709551615EEixEm:
  126|      2|         {
  127|      2|             return data_[index];
  128|      2|         }

_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1011|    990|        {
 1012|    990|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1012:17): [True: 195, False: 795]
  ------------------
 1013|    195|            {
 1014|    195|                if (level_stack_.back().target() == target_t::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1014:21): [True: 106, False: 89]
  |  Branch (1014:73): [True: 106, False: 0]
  ------------------
 1015|    106|                {
 1016|    106|                    key_buffer_.push_back(',');
 1017|    106|                }
 1018|    195|                level_stack_.emplace_back(target_t::buffer, container_t::array);
 1019|    195|                key_buffer_.push_back('[');
 1020|    195|            }
 1021|    795|            else
 1022|    795|            {
 1023|    795|                switch (level_stack_.back().target())
 1024|    795|                {
 1025|    626|                    case target_t::buffer:
  ------------------
  |  Branch (1025:21): [True: 626, False: 169]
  ------------------
 1026|    626|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1026:29): [True: 519, False: 107]
  |  Branch (1026:65): [True: 518, False: 1]
  ------------------
 1027|    518|                        {
 1028|    518|                            key_buffer_.push_back(',');
 1029|    518|                        }
 1030|    626|                        level_stack_.emplace_back(target_t::buffer, container_t::array);
 1031|    626|                        key_buffer_.push_back('[');
 1032|    626|                        break;
 1033|    169|                    default:
  ------------------
  |  Branch (1033:21): [True: 169, False: 626]
  ------------------
 1034|    169|                        level_stack_.emplace_back(target_t::destination, container_t::array);
 1035|    169|                        destination_->begin_array(length, tag, context, ec);
 1036|    169|                        break;
 1037|    795|                }
 1038|    795|            }
 1039|    990|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    990|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1040|    990|        }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level6is_keyEv:
  814|  12.5M|            {
  815|  12.5M|                return even_odd_ == 0;
  816|  12.5M|            }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level6targetEv:
  824|  6.96M|            {
  825|  6.96M|                return state_;
  826|  6.96M|            }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level5countEv:
  829|   762k|            {
  830|   762k|                return count_;
  831|   762k|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5levelC2ENS4_8target_tENS4_11container_tE:
  797|  1.05k|                : state_(state), type_(type), even_odd_(type == container_t::object ? 0 : 1)
  ------------------
  |  Branch (797:57): [True: 36, False: 1.01k]
  ------------------
  798|  1.05k|            {
  799|  1.05k|            }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level9is_objectEv:
  819|  4.95M|            {
  820|  4.95M|                return type_ == container_t::object;
  821|  4.95M|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE15visit_end_arrayERKNS_11ser_contextERNS1_10error_codeE:
 1043|    984|        {
 1044|    984|            switch (level_stack_.back().target())
 1045|    984|            {
 1046|    818|                case target_t::buffer:
  ------------------
  |  Branch (1046:17): [True: 818, False: 166]
  ------------------
 1047|    818|                    key_buffer_.push_back(']');
 1048|    818|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   45|    818|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 818]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1049|    818|                    level_stack_.pop_back();
 1050|    818|                    if (level_stack_.back().target() == target_t::destination)
  ------------------
  |  Branch (1050:25): [True: 86, False: 732]
  ------------------
 1051|     86|                    {
 1052|     86|                        destination_->key(key_buffer_, context, ec);
 1053|     86|                        key_buffer_.clear();
 1054|     86|                    }
 1055|    732|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (1055:30): [True: 106, False: 626]
  ------------------
 1056|    106|                    {
 1057|    106|                        key_buffer_.push_back(':');
 1058|    106|                    }
 1059|    818|                    level_stack_.back().advance();
 1060|    818|                    break;
 1061|    166|                default:
  ------------------
  |  Branch (1061:17): [True: 166, False: 818]
  ------------------
 1062|    166|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   45|    166|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 166]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1063|    166|                    level_stack_.pop_back();
 1064|    166|                    level_stack_.back().advance();
 1065|    166|                    destination_->end_array(context, ec);
 1066|    166|                    break;
 1067|    984|            }
 1068|    984|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    984|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1069|    984|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level7advanceEv:
  802|  4.19M|            {
  803|  4.19M|                if (!is_key())
  ------------------
  |  Branch (803:21): [True: 2.77M, False: 1.41M]
  ------------------
  804|  2.77M|                {
  805|  2.77M|                    ++count_;
  806|  2.77M|                }
  807|  4.19M|                if (is_object())
  ------------------
  |  Branch (807:21): [True: 2.83M, False: 1.35M]
  ------------------
  808|  2.83M|                {
  809|  2.83M|                    even_odd_ = !even_odd_;
  810|  2.83M|                }
  811|  4.19M|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1236|  4.19M|        {
 1237|  4.19M|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1237:17): [True: 1.41M, False: 2.77M]
  |  Branch (1237:49): [True: 761k, False: 2.01M]
  ------------------
 1238|  2.17M|            {
 1239|  2.17M|                key_.clear();
 1240|  2.17M|                jsoncons::from_integer(value,key_);
 1241|  2.17M|            }
 1242|       |
 1243|  4.19M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1243:17): [True: 1.41M, False: 2.77M]
  ------------------
 1244|  1.41M|            {
 1245|  1.41M|                switch (level_stack_.back().target())
 1246|  1.41M|                {
 1247|   284k|                    case target_t::buffer:
  ------------------
  |  Branch (1247:21): [True: 284k, False: 1.13M]
  ------------------
 1248|   284k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1248:29): [True: 284k, False: 2]
  ------------------
 1249|   284k|                        {
 1250|   284k|                            key_buffer_.push_back(',');
 1251|   284k|                        }
 1252|   284k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1253|   284k|                        key_buffer_.push_back(':');
 1254|   284k|                        break;
 1255|  1.13M|                    default:
  ------------------
  |  Branch (1255:21): [True: 1.13M, False: 284k]
  ------------------
 1256|  1.13M|                        destination_->key(key_, context, ec);
 1257|  1.13M|                        break;
 1258|  1.41M|                }
 1259|  1.41M|            }
 1260|  2.77M|            else
 1261|  2.77M|            {
 1262|  2.77M|                switch (level_stack_.back().target())
 1263|  2.77M|                {
 1264|   761k|                    case target_t::buffer:
  ------------------
  |  Branch (1264:21): [True: 761k, False: 2.01M]
  ------------------
 1265|   761k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1265:29): [True: 476k, False: 284k]
  |  Branch (1265:65): [True: 476k, False: 3]
  ------------------
 1266|   476k|                        {
 1267|   476k|                            key_buffer_.push_back(',');
 1268|   476k|                        }
 1269|   761k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1270|   761k|                        break;
 1271|  2.01M|                    default:
  ------------------
  |  Branch (1271:21): [True: 2.01M, False: 761k]
  ------------------
 1272|  2.01M|                        destination_->uint64_value(value, tag, context, ec);
 1273|  2.01M|                        break;
 1274|  2.77M|                }
 1275|  2.77M|            }
 1276|       |
 1277|  4.19M|            level_stack_.back().advance();
 1278|  4.19M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  4.19M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1279|  4.19M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1282|    279|        {
 1283|    279|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1283:17): [True: 119, False: 160]
  |  Branch (1283:49): [True: 149, False: 11]
  ------------------
 1284|    268|            {
 1285|    268|                key_.clear();
 1286|    268|                jsoncons::from_integer(value,key_);
 1287|    268|            }
 1288|       |
 1289|    279|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1289:17): [True: 119, False: 160]
  ------------------
 1290|    119|            {
 1291|    119|                switch (level_stack_.back().target())
 1292|    119|                {
 1293|    104|                    case target_t::buffer:
  ------------------
  |  Branch (1293:21): [True: 104, False: 15]
  ------------------
 1294|    104|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1294:29): [True: 103, False: 1]
  ------------------
 1295|    103|                        {
 1296|    103|                            key_buffer_.push_back(',');
 1297|    103|                        }
 1298|    104|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1299|    104|                        key_buffer_.push_back(':');
 1300|    104|                        break;
 1301|     15|                    default:
  ------------------
  |  Branch (1301:21): [True: 15, False: 104]
  ------------------
 1302|     15|                        destination_->key(key_, context, ec);
 1303|     15|                        break;
 1304|    119|                }
 1305|    119|            }
 1306|    160|            else
 1307|    160|            {
 1308|    160|                switch (level_stack_.back().target())
 1309|    160|                {
 1310|    149|                    case target_t::buffer:
  ------------------
  |  Branch (1310:21): [True: 149, False: 11]
  ------------------
 1311|    149|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1311:29): [True: 49, False: 100]
  |  Branch (1311:65): [True: 39, False: 10]
  ------------------
 1312|     39|                        {
 1313|     39|                            key_buffer_.push_back(',');
 1314|     39|                        }
 1315|    149|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1316|    149|                        break;
 1317|     11|                    default:
  ------------------
  |  Branch (1317:21): [True: 11, False: 149]
  ------------------
 1318|     11|                        destination_->int64_value(value, tag, context, ec);
 1319|     11|                        break;
 1320|    160|                }
 1321|    160|            }
 1322|       |
 1323|    279|            level_stack_.back().advance();
 1324|    279|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    279|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1325|    279|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1377|      6|        {
 1378|      6|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1378:17): [True: 0, False: 6]
  |  Branch (1378:49): [True: 2, False: 4]
  ------------------
 1379|      2|            {
 1380|      2|                key_.clear();
 1381|      2|                string_sink<string_type> sink(key_);
 1382|      2|                jsoncons::write_double f{float_chars_format::general,0};
 1383|      2|                f(value, sink);
 1384|      2|            }
 1385|       |
 1386|      6|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1386:17): [True: 0, False: 6]
  ------------------
 1387|      0|            {
 1388|      0|                switch (level_stack_.back().target())
 1389|      0|                {
 1390|      0|                    case target_t::buffer:
  ------------------
  |  Branch (1390:21): [True: 0, False: 0]
  ------------------
 1391|      0|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1391:29): [True: 0, False: 0]
  ------------------
 1392|      0|                        {
 1393|      0|                            key_buffer_.push_back(',');
 1394|      0|                        }
 1395|      0|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1396|      0|                        key_buffer_.push_back(':');
 1397|      0|                        break;
 1398|      0|                    default:
  ------------------
  |  Branch (1398:21): [True: 0, False: 0]
  ------------------
 1399|      0|                        destination_->key(key_, context, ec);
 1400|      0|                        break;
 1401|      0|                }
 1402|      0|            }
 1403|      6|            else
 1404|      6|            {
 1405|      6|                switch (level_stack_.back().target())
 1406|      6|                {
 1407|      2|                    case target_t::buffer:
  ------------------
  |  Branch (1407:21): [True: 2, False: 4]
  ------------------
 1408|      2|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1408:29): [True: 2, False: 0]
  |  Branch (1408:65): [True: 1, False: 1]
  ------------------
 1409|      1|                        {
 1410|      1|                            key_buffer_.push_back(',');
 1411|      1|                        }
 1412|      2|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1413|      2|                        break;
 1414|      4|                    default:
  ------------------
  |  Branch (1414:21): [True: 4, False: 2]
  ------------------
 1415|      4|                        destination_->double_value(value, tag, context, ec);
 1416|      4|                        break;
 1417|      6|                }
 1418|      6|            }
 1419|       |
 1420|      6|            level_stack_.back().advance();
 1421|      6|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1422|      6|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE11visit_flushEv:
  884|     10|        {
  885|     10|            destination_->flush();
  886|     10|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  889|      6|        {
  890|      6|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (890:17): [True: 0, False: 6]
  ------------------
  891|      0|            {
  892|      0|                if (level_stack_.back().target() == target_t::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (892:21): [True: 0, False: 0]
  |  Branch (892:73): [True: 0, False: 0]
  ------------------
  893|      0|                {
  894|      0|                    key_buffer_.push_back(',');
  895|      0|                }
  896|      0|                level_stack_.emplace_back(target_t::buffer, container_t::object);
  897|      0|                key_buffer_.push_back('{');
  898|      0|            }
  899|      6|            else
  900|      6|            {
  901|      6|                switch (level_stack_.back().target())
  902|      6|                {
  903|      1|                    case target_t::buffer:
  ------------------
  |  Branch (903:21): [True: 1, False: 5]
  ------------------
  904|      1|                        level_stack_.emplace_back(target_t::buffer, container_t::object);
  905|      1|                        key_buffer_.push_back('{');
  906|      1|                        break;
  907|      5|                    default:
  ------------------
  |  Branch (907:21): [True: 5, False: 1]
  ------------------
  908|      5|                        level_stack_.emplace_back(target_t::destination, container_t::object);
  909|      5|                        destination_->begin_object(tag, context, ec);
  910|      5|                        break;
  911|      6|                }
  912|      6|            }
  913|      6|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  914|      6|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  917|     30|        {
  918|     30|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (918:17): [True: 18, False: 12]
  ------------------
  919|     18|            {
  920|     18|                if (level_stack_.back().target() == target_t::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (920:21): [True: 13, False: 5]
  |  Branch (920:73): [True: 2, False: 11]
  ------------------
  921|      2|                {
  922|      2|                    key_buffer_.push_back(',');
  923|      2|                }
  924|     18|                level_stack_.emplace_back(target_t::buffer, container_t::object);
  925|     18|                key_buffer_.push_back('{');
  926|     18|            }
  927|     12|            else
  928|     12|            {
  929|     12|                switch (level_stack_.back().target())
  930|     12|                {
  931|      6|                    case target_t::buffer:
  ------------------
  |  Branch (931:21): [True: 6, False: 6]
  ------------------
  932|      6|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (932:29): [True: 4, False: 2]
  |  Branch (932:65): [True: 4, False: 0]
  ------------------
  933|      4|                        {
  934|      4|                            key_buffer_.push_back(',');
  935|      4|                        }
  936|      6|                        level_stack_.emplace_back(target_t::buffer, container_t::object);
  937|      6|                        key_buffer_.push_back('{');
  938|      6|                        break;
  939|      6|                    default:
  ------------------
  |  Branch (939:21): [True: 6, False: 6]
  ------------------
  940|      6|                        level_stack_.emplace_back(target_t::destination, container_t::object);
  941|      6|                        destination_->begin_object(length, tag, context, ec);
  942|      6|                        break;
  943|     12|                }
  944|     12|            }
  945|     30|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     30|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  946|     30|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE16visit_end_objectERKNS_11ser_contextERNS1_10error_codeE:
  949|     28|        {
  950|     28|            switch (level_stack_.back().target())
  951|     28|            {
  952|     25|                case target_t::buffer:
  ------------------
  |  Branch (952:17): [True: 25, False: 3]
  ------------------
  953|     25|                    key_buffer_.push_back('}');
  954|     25|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   45|     25|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 25]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  955|     25|                    level_stack_.pop_back();
  956|       |                    
  957|     25|                    if (level_stack_.back().target() == target_t::destination)
  ------------------
  |  Branch (957:25): [True: 5, False: 20]
  ------------------
  958|      5|                    {
  959|      5|                        destination_->key(key_buffer_,context, ec);
  960|      5|                        key_buffer_.clear();
  961|      5|                    }
  962|     20|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (962:30): [True: 13, False: 7]
  ------------------
  963|     13|                    {
  964|     13|                        key_buffer_.push_back(':');
  965|     13|                    }
  966|     25|                    level_stack_.back().advance();
  967|     25|                    break;
  968|      3|                default:
  ------------------
  |  Branch (968:17): [True: 3, False: 25]
  ------------------
  969|      3|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   45|      3|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 3]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  970|      3|                    level_stack_.pop_back();
  971|      3|                    level_stack_.back().advance();
  972|      3|                    destination_->end_object(context, ec);
  973|      3|                    break;
  974|     28|            }
  975|     28|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     28|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  976|     28|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  979|      6|        {
  980|      6|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (980:17): [True: 0, False: 6]
  ------------------
  981|      0|            {
  982|      0|                if (level_stack_.back().target() == target_t::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (982:21): [True: 0, False: 0]
  |  Branch (982:73): [True: 0, False: 0]
  ------------------
  983|      0|                {
  984|      0|                    key_buffer_.push_back(',');
  985|      0|                }
  986|      0|                level_stack_.emplace_back(target_t::buffer, container_t::array);
  987|      0|                key_buffer_.push_back('[');
  988|      0|            }
  989|      6|            else
  990|      6|            {
  991|      6|                switch (level_stack_.back().target())
  992|      6|                {
  993|      0|                    case target_t::buffer:
  ------------------
  |  Branch (993:21): [True: 0, False: 6]
  ------------------
  994|      0|                        if (level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (994:29): [True: 0, False: 0]
  |  Branch (994:64): [True: 0, False: 0]
  ------------------
  995|      0|                        {
  996|      0|                            key_buffer_.push_back(',');
  997|      0|                        }
  998|      0|                        level_stack_.emplace_back(target_t::buffer, container_t::array);
  999|      0|                        key_buffer_.push_back('[');
 1000|      0|                        break;
 1001|      6|                    default:
  ------------------
  |  Branch (1001:21): [True: 6, False: 0]
  ------------------
 1002|      6|                        level_stack_.emplace_back(target_t::destination, container_t::array);
 1003|      6|                        destination_->begin_array(tag, context, ec);
 1004|      6|                        break;
 1005|      6|                }
 1006|      6|            }
 1007|      6|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1008|      6|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1478|     33|        {
 1479|     33|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1479:17): [True: 14, False: 19]
  |  Branch (1479:49): [True: 4, False: 15]
  ------------------
 1480|     18|            {
 1481|     18|                key_.clear(); 
 1482|     18|                key_.insert(key_.begin(), null_constant.begin(), null_constant.end());
 1483|     18|            }
 1484|       |
 1485|     33|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1485:17): [True: 14, False: 19]
  ------------------
 1486|     14|            {
 1487|     14|                switch (level_stack_.back().target())
 1488|     14|                {
 1489|      0|                    case target_t::buffer:
  ------------------
  |  Branch (1489:21): [True: 0, False: 14]
  ------------------
 1490|      0|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1490:29): [True: 0, False: 0]
  ------------------
 1491|      0|                        {
 1492|      0|                            key_buffer_.push_back(',');
 1493|      0|                        }
 1494|      0|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1495|      0|                        key_buffer_.push_back(':');
 1496|      0|                        break;
 1497|     14|                    default:
  ------------------
  |  Branch (1497:21): [True: 14, False: 0]
  ------------------
 1498|     14|                        destination_->key(key_, context, ec);
 1499|     14|                        break;
 1500|     14|                }
 1501|     14|            }
 1502|     19|            else
 1503|     19|            {
 1504|     19|                switch (level_stack_.back().target())
 1505|     19|                {
 1506|      4|                    case target_t::buffer:
  ------------------
  |  Branch (1506:21): [True: 4, False: 15]
  ------------------
 1507|      4|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1507:29): [True: 4, False: 0]
  |  Branch (1507:65): [True: 4, False: 0]
  ------------------
 1508|      4|                        {
 1509|      4|                            key_buffer_.push_back(',');
 1510|      4|                        }
 1511|      4|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1512|      4|                        break;
 1513|     15|                    default:
  ------------------
  |  Branch (1513:21): [True: 15, False: 4]
  ------------------
 1514|     15|                        destination_->null_value(tag, context, ec);
 1515|     15|                        break;
 1516|     19|                }
 1517|     19|            }
 1518|       |
 1519|     33|            level_stack_.back().advance();
 1520|     33|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     33|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1521|     33|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1425|     14|        {
 1426|     14|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1426:17): [True: 7, False: 7]
  |  Branch (1426:49): [True: 0, False: 7]
  ------------------
 1427|      7|            {
 1428|      7|                key_.clear(); 
 1429|      7|                if (value)
  ------------------
  |  Branch (1429:21): [True: 7, False: 0]
  ------------------
 1430|      7|                {
 1431|      7|                    key_.insert(key_.begin(), true_constant.begin(), true_constant.end());
 1432|      7|                }
 1433|      0|                else
 1434|      0|                {
 1435|      0|                    key_.insert(key_.begin(), false_constant.begin(), false_constant.end());
 1436|      0|                }
 1437|      7|            }
 1438|       |
 1439|     14|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1439:17): [True: 7, False: 7]
  ------------------
 1440|      7|            {
 1441|      7|                switch (level_stack_.back().target())
 1442|      7|                {
 1443|      0|                    case target_t::buffer:
  ------------------
  |  Branch (1443:21): [True: 0, False: 7]
  ------------------
 1444|      0|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1444:29): [True: 0, False: 0]
  ------------------
 1445|      0|                        {
 1446|      0|                            key_buffer_.push_back(',');
 1447|      0|                        }
 1448|      0|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1449|      0|                        key_buffer_.push_back(':');
 1450|      0|                        break;
 1451|      7|                    default:
  ------------------
  |  Branch (1451:21): [True: 7, False: 0]
  ------------------
 1452|      7|                        destination_->key(key_, context, ec);
 1453|      7|                        break;
 1454|      7|                }
 1455|      7|            }
 1456|      7|            else
 1457|      7|            {
 1458|      7|                switch (level_stack_.back().target())
 1459|      7|                {
 1460|      0|                    case target_t::buffer:
  ------------------
  |  Branch (1460:21): [True: 0, False: 7]
  ------------------
 1461|      0|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1461:29): [True: 0, False: 0]
  |  Branch (1461:65): [True: 0, False: 0]
  ------------------
 1462|      0|                        {
 1463|      0|                            key_buffer_.push_back(',');
 1464|      0|                        }
 1465|      0|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1466|      0|                        break;
 1467|      7|                    default:
  ------------------
  |  Branch (1467:21): [True: 7, False: 0]
  ------------------
 1468|      7|                        destination_->bool_value(value, tag, context, ec);
 1469|      7|                        break;
 1470|      7|                }
 1471|      7|            }
 1472|       |
 1473|     14|            level_stack_.back().advance();
 1474|     14|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     14|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1475|     14|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE12visit_stringERKNS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1075|     20|        {
 1076|     20|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1076:17): [True: 6, False: 14]
  ------------------
 1077|      6|            {
 1078|      6|                switch (level_stack_.back().target())
 1079|      6|                {
 1080|      2|                    case target_t::buffer:
  ------------------
  |  Branch (1080:21): [True: 2, False: 4]
  ------------------
 1081|      2|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1081:29): [True: 2, False: 0]
  ------------------
 1082|      2|                        {
 1083|      2|                            key_buffer_.push_back(',');
 1084|      2|                        }
 1085|      2|                        key_buffer_.push_back('\"');
 1086|      2|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1087|      2|                        key_buffer_.push_back('\"');
 1088|      2|                        key_buffer_.push_back(':');
 1089|      2|                        break;
 1090|      4|                    default:
  ------------------
  |  Branch (1090:21): [True: 4, False: 2]
  ------------------
 1091|      4|                        destination_->key(value, context, ec);
 1092|      4|                        break;
 1093|      6|                }
 1094|      6|            }
 1095|     14|            else
 1096|     14|            {
 1097|     14|                switch (level_stack_.back().target())
 1098|     14|                {
 1099|      8|                    case target_t::buffer:
  ------------------
  |  Branch (1099:21): [True: 8, False: 6]
  ------------------
 1100|      8|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1100:29): [True: 6, False: 2]
  |  Branch (1100:65): [True: 4, False: 2]
  ------------------
 1101|      4|                        {
 1102|      4|                            key_buffer_.push_back(',');
 1103|      4|                        }
 1104|      8|                        key_buffer_.push_back('\"');
 1105|      8|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1106|      8|                        key_buffer_.push_back('\"');
 1107|      8|                        break;
 1108|      6|                    default:
  ------------------
  |  Branch (1108:21): [True: 6, False: 8]
  ------------------
 1109|      6|                        destination_->string_value(value, tag, context, ec);
 1110|      6|                        break;
 1111|     14|                }
 1112|     14|            }
 1113|       |
 1114|     20|            level_stack_.back().advance();
 1115|     20|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     20|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1116|     20|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1122|    410|        {
 1123|    410|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1123:17): [True: 166, False: 244]
  |  Branch (1123:49): [True: 65, False: 179]
  ------------------
 1124|    231|            {
 1125|    231|                key_.clear();
 1126|    231|                switch (tag)
 1127|    231|                {
 1128|      0|                    case semantic_tag::base64:
  ------------------
  |  Branch (1128:21): [True: 0, False: 231]
  ------------------
 1129|      0|                        bytes_to_base64(value.begin(), value.end(), key_);
 1130|      0|                        break;
 1131|      0|                    case semantic_tag::base16:
  ------------------
  |  Branch (1131:21): [True: 0, False: 231]
  ------------------
 1132|      0|                        bytes_to_base16(value.begin(), value.end(),key_);
 1133|      0|                        break;
 1134|    231|                    default:
  ------------------
  |  Branch (1134:21): [True: 231, False: 0]
  ------------------
 1135|    231|                        bytes_to_base64url(value.begin(), value.end(),key_);
 1136|    231|                        break;
 1137|    231|                }
 1138|    231|            }
 1139|       |
 1140|    410|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1140:17): [True: 166, False: 244]
  ------------------
 1141|    166|            {
 1142|    166|                switch (level_stack_.back().target())
 1143|    166|                {
 1144|      8|                    case target_t::buffer:
  ------------------
  |  Branch (1144:21): [True: 8, False: 158]
  ------------------
 1145|      8|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1145:29): [True: 4, False: 4]
  ------------------
 1146|      4|                        {
 1147|      4|                            key_buffer_.push_back(',');
 1148|      4|                        }
 1149|      8|                        key_buffer_.push_back('\"');
 1150|      8|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1151|      8|                        key_buffer_.push_back('\"');
 1152|      8|                        key_buffer_.push_back(':');
 1153|      8|                        break;
 1154|    158|                    default:
  ------------------
  |  Branch (1154:21): [True: 158, False: 8]
  ------------------
 1155|    158|                        destination_->key(key_, context, ec);
 1156|    158|                        break;
 1157|    166|                }
 1158|    166|            }
 1159|    244|            else
 1160|    244|            {
 1161|    244|                switch (level_stack_.back().target())
 1162|    244|                {
 1163|     65|                    case target_t::buffer:
  ------------------
  |  Branch (1163:21): [True: 65, False: 179]
  ------------------
 1164|     65|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1164:29): [True: 49, False: 16]
  |  Branch (1164:65): [True: 48, False: 1]
  ------------------
 1165|     48|                        {
 1166|     48|                            key_buffer_.push_back(',');
 1167|     48|                        }
 1168|     65|                        key_buffer_.push_back('\"');
 1169|     65|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1170|     65|                        key_buffer_.push_back('\"');
 1171|     65|                        break;
 1172|    179|                    default:
  ------------------
  |  Branch (1172:21): [True: 179, False: 65]
  ------------------
 1173|    179|                        destination_->byte_string_value(value, tag, context, ec);
 1174|    179|                        break;
 1175|    244|                }
 1176|    244|            }
 1177|       |
 1178|    410|            level_stack_.back().advance();
 1179|    410|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    410|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1180|    410|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS1_10error_codeE:
 1186|     24|        {
 1187|     24|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1187:17): [True: 3, False: 21]
  |  Branch (1187:49): [True: 18, False: 3]
  ------------------
 1188|     21|            {
 1189|     21|                key_.clear();
 1190|     21|                bytes_to_base64url(value.begin(), value.end(),key_);
 1191|     21|            }
 1192|       |
 1193|     24|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1193:17): [True: 3, False: 21]
  ------------------
 1194|      3|            {
 1195|      3|                switch (level_stack_.back().target())
 1196|      3|                {
 1197|      3|                    case target_t::buffer:
  ------------------
  |  Branch (1197:21): [True: 3, False: 0]
  ------------------
 1198|      3|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1198:29): [True: 3, False: 0]
  ------------------
 1199|      3|                        {
 1200|      3|                            key_buffer_.push_back(',');
 1201|      3|                        }
 1202|      3|                        key_buffer_.push_back('\"');
 1203|      3|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1204|      3|                        key_buffer_.push_back('\"');
 1205|      3|                        key_buffer_.push_back(':');
 1206|      3|                        break;
 1207|      0|                    default:
  ------------------
  |  Branch (1207:21): [True: 0, False: 3]
  ------------------
 1208|      0|                        destination_->key(key_, context, ec);
 1209|      0|                        break;
 1210|      3|                }
 1211|      3|            }
 1212|     21|            else
 1213|     21|            {
 1214|     21|                switch (level_stack_.back().target())
 1215|     21|                {
 1216|     18|                    case target_t::buffer:
  ------------------
  |  Branch (1216:21): [True: 18, False: 3]
  ------------------
 1217|     18|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1217:29): [True: 15, False: 3]
  |  Branch (1217:65): [True: 15, False: 0]
  ------------------
 1218|     15|                        {
 1219|     15|                            key_buffer_.push_back(',');
 1220|     15|                        }
 1221|     18|                        key_buffer_.push_back('\"');
 1222|     18|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1223|     18|                        key_buffer_.push_back('\"');
 1224|     18|                        break;
 1225|      3|                    default:
  ------------------
  |  Branch (1225:21): [True: 3, False: 18]
  ------------------
 1226|      3|                        destination_->byte_string_value(value, ext_tag, context, ec);
 1227|      3|                        break;
 1228|     21|                }
 1229|     21|            }
 1230|       |
 1231|     24|            level_stack_.back().advance();
 1232|     24|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     24|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1233|     24|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE10visit_halfEtNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1328|      3|        {
 1329|      3|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1329:17): [True: 0, False: 3]
  |  Branch (1329:49): [True: 3, False: 0]
  ------------------
 1330|      3|            {
 1331|      3|                key_.clear();
 1332|      3|                jsoncons::string_sink<string_type> sink(key_);
 1333|      3|                jsoncons::write_double f{float_chars_format::general,0};
 1334|      3|                double x = binary::decode_half(value);
 1335|      3|                f(x, sink);
 1336|      3|            }
 1337|       |
 1338|      3|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1338:17): [True: 0, False: 3]
  ------------------
 1339|      0|            {
 1340|      0|                switch (level_stack_.back().target())
 1341|      0|                {
 1342|      0|                    case target_t::buffer:
  ------------------
  |  Branch (1342:21): [True: 0, False: 0]
  ------------------
 1343|      0|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1343:29): [True: 0, False: 0]
  ------------------
 1344|      0|                        {
 1345|      0|                            key_buffer_.push_back(',');
 1346|      0|                        }
 1347|      0|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1348|      0|                        key_buffer_.push_back(':');
 1349|      0|                        break;
 1350|      0|                    default:
  ------------------
  |  Branch (1350:21): [True: 0, False: 0]
  ------------------
 1351|      0|                        destination_->key(key_, context, ec);
 1352|      0|                        break;
 1353|      0|                }
 1354|      0|            }
 1355|      3|            else
 1356|      3|            {
 1357|      3|                switch (level_stack_.back().target())
 1358|      3|                {
 1359|      3|                    case target_t::buffer:
  ------------------
  |  Branch (1359:21): [True: 3, False: 0]
  ------------------
 1360|      3|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1360:29): [True: 2, False: 1]
  |  Branch (1360:65): [True: 2, False: 0]
  ------------------
 1361|      2|                        {
 1362|      2|                            key_buffer_.push_back(',');
 1363|      2|                        }
 1364|      3|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1365|      3|                        break;
 1366|      0|                    default:
  ------------------
  |  Branch (1366:21): [True: 0, False: 3]
  ------------------
 1367|      0|                        destination_->half_value(value, tag, context, ec);
 1368|      0|                        break;
 1369|      3|                }
 1370|      3|            }
 1371|       |
 1372|      3|            level_stack_.back().advance();
 1373|      3|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1374|      3|        }
_ZN8jsoncons24basic_item_event_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  293|    197|        {
  294|    197|            visit_begin_array(length, tag, context, ec);
  295|    197|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    197|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  296|    197|        }
_ZN8jsoncons24basic_item_event_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  362|  4.19M|        {
  363|  4.19M|            visit_uint64(value, tag, context, ec);
  364|  4.19M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  4.19M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  365|  4.19M|        }
_ZN8jsoncons24basic_item_event_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  299|    191|        {
  300|    191|            visit_end_array(context, ec);
  301|    191|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    191|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  302|    191|        }
_ZN8jsoncons24basic_item_event_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  371|    238|        {
  372|    238|            visit_int64(value, tag, context, ec);
  373|    238|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    238|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  374|    238|        }
_ZN8jsoncons24basic_item_event_visitorIcE10half_valueEtNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  380|      3|        {
  381|      3|            visit_half(value, tag, context, ec);
  382|      3|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  383|      3|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEEC2ERNS_18basic_json_visitorIcEERKS3_:
  858|     18|            : destination_(std::addressof(visitor)), 
  859|     18|              key_(alloc), key_buffer_(alloc), level_stack_(alloc)
  860|     18|        {
  861|     18|            level_stack_.emplace_back(target_t::destination,container_t::root); // root
  862|     18|        }
_ZN8jsoncons24basic_item_event_visitorIcEC2Ev:
   51|     18|        basic_item_event_visitor() = default;
_ZN8jsoncons24basic_item_event_visitorIcE17byte_string_valueINSt3__16vectorIhNS3_9allocatorIhEEEEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeENS3_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS8_EE5valueEiE4typeE:
  342|    410|        {
  343|    410|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  344|    410|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    410|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  345|    410|        }
_ZN8jsoncons24basic_item_event_visitorIcE17byte_string_valueINSt3__16vectorIhNS3_9allocatorIhEEEEEEbRKT_mRKNS_11ser_contextERNS3_10error_codeENS3_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS8_EE5valueEiE4typeE:
  353|     24|        {
  354|     24|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), ext_tag, context, ec);
  355|     24|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     24|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  356|     24|        }
_ZN8jsoncons24basic_item_event_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  322|     14|        {
  323|     14|            visit_bool(value, tag, context, ec);
  324|     14|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     14|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  325|     14|        }
_ZN8jsoncons24basic_item_event_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  313|     33|        {
  314|     33|            visit_null(tag, context, ec);
  315|     33|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     33|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  316|     33|        }
_ZN8jsoncons24basic_item_event_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  331|     20|        {
  332|     20|            visit_string(value, tag, context, ec);
  333|     20|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     20|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  334|     20|        }
_ZN8jsoncons24basic_item_event_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  287|      6|        {
  288|      6|            visit_begin_array(tag, context, ec);
  289|      6|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  290|      6|        }
_ZN8jsoncons24basic_item_event_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  266|      6|        {
  267|      6|            visit_begin_object(tag, context, ec);
  268|      6|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  269|      6|        }
_ZN8jsoncons24basic_item_event_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  275|     30|        {
  276|     30|            visit_begin_object(length, tag, context, ec);
  277|     30|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     30|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  278|     30|        }
_ZN8jsoncons24basic_item_event_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  281|     28|        {
  282|     28|            visit_end_object(context, ec);
  283|     28|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     28|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  284|     28|        }
_ZN8jsoncons24basic_item_event_visitorIcE5flushEv:
   56|     10|        {
   57|     10|            visit_flush();
   58|     10|        }

_ZN8jsoncons19typed_array_visitorD2Ev:
   33|     54|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  345|    169|        {
  346|    169|            visit_begin_array(length, tag, context, ec);
  347|    169|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    169|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  348|    169|        }
_ZN8jsoncons18basic_json_visitorIcE3keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  357|  1.13M|        {
  358|  1.13M|            visit_key(name, context, ec);
  359|  1.13M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  1.13M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  360|  1.13M|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  351|    166|        {
  352|    166|            visit_end_array(context, ec);
  353|    166|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    166|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  354|    166|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|  2.01M|        {
  415|  2.01M|            visit_uint64(value, tag, context, ec);
  416|  2.01M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  2.01M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  417|  2.01M|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|     11|        {
  424|     11|            visit_int64(value, tag, context, ec);
  425|     11|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     11|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  426|     11|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|      4|        {
  442|      4|            visit_double(value, tag, context, ec);
  443|      4|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      4|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  444|      4|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|     10|        {
  109|     10|            visit_flush();
  110|     10|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  318|      5|        {
  319|      5|            visit_begin_object(tag, context, ec);
  320|      5|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      5|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  321|      5|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  327|      6|        {
  328|      6|            visit_begin_object(length, tag, context, ec);
  329|      6|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  330|      6|        }
_ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  333|      3|        {
  334|      3|            visit_end_object(context, ec);
  335|      3|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  336|      3|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  339|      6|        {
  340|      6|            visit_begin_array(tag, context, ec);
  341|      6|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  342|      6|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  365|     15|        {
  366|     15|            visit_null(tag, context, ec);
  367|     15|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     15|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  368|     15|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  374|      7|        {
  375|      7|            visit_bool(value, tag, context, ec);
  376|      7|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      7|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  377|      7|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  383|      6|        {
  384|      6|            visit_string(value, tag, context, ec);
  385|      6|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  386|      6|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  394|    179|        {
  395|    179|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  396|    179|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    179|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  397|    179|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  405|      3|        {
  406|      3|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), ext_tag, context, ec);
  407|      3|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  408|      3|        }
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|     36|        basic_json_visitor() = default;
_ZN8jsoncons26basic_default_json_visitorIcEC2Ev:
  811|     18|        basic_default_json_visitor() = default;
_ZN8jsoncons19typed_array_visitor11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
   36|    793|        {
   37|    793|            visit_begin_array(length, tag, context, ec);
   38|    793|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    793|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
   39|    793|        }
_ZN8jsoncons19typed_array_visitor9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
   42|    793|        {
   43|    793|            visit_end_array(context, ec);
   44|    793|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    793|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
   45|    793|        }
_ZN8jsoncons19typed_array_visitor12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
   51|     27|        {
   52|     27|            visit_uint64(value, tag, context, ec);
   53|     27|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     27|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
   54|     27|        }
_ZN8jsoncons19typed_array_visitor11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
   60|     41|        {
   61|     41|            visit_int64(value, tag, context, ec);
   62|     41|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     41|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
   63|     41|        }
_ZN8jsoncons19typed_array_visitor12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
   69|      6|        {
   70|      6|            visit_double(value, tag, context, ec);
   71|      6|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
   72|      6|        }

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

_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERS7_:
  256|      5|            : buf_ptr(std::addressof(buf))
  257|      5|        {
  258|      5|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9push_backEc:
  287|     69|        {
  288|     69|            buf_ptr->push_back(ch);
  289|     69|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvEC2ERS5_:
  315|     18|            : buf_ptr(std::addressof(buf))
  316|     18|        {
  317|     18|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE9push_backEh:
  329|  4.27M|        {
  330|  4.27M|            buf_ptr->push_back(static_cast<value_type>(ch));
  331|  4.27M|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE5flushEv:
  325|     28|        {
  326|     28|        }

_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev:
  188|     18|        {
  189|     18|            if (buffer_)
  ------------------
  |  Branch (189:17): [True: 18, False: 0]
  ------------------
  190|     18|            {
  191|     18|                std::allocator_traits<char_allocator_type>::deallocate(alloc_, buffer_, buffer_size_);
  192|     18|            }
  193|     18|        }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  171|     18|            : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  172|     18|              buffer_size_(default_max_buffer_size)
  173|     18|        {
  174|     18|            buffer_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, buffer_size_);
  175|     18|            data_ = buffer_;
  176|     18|        }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   54|     18|          : std::basic_istream<CharT>(&nb_)
   55|     18|        {
   56|     18|        }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   40|     18|            null_buffer() = default;
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm:
  343|  8.38M|        {
  344|  8.38M|            std::size_t len = 0;
  345|  8.38M|            if (length_ > 0)
  ------------------
  |  Branch (345:17): [True: 8.38M, False: 128]
  ------------------
  346|  8.38M|            {
  347|  8.38M|                len = (std::min)(length_, length);
  348|  8.38M|                std::memcpy(p, data_, len*sizeof(value_type));
  349|  8.38M|                data_ += len;
  350|  8.38M|                length_ -= len;
  351|  8.38M|                position_ += len;
  352|  8.38M|            }
  353|  8.38M|            if (length - len == 0)
  ------------------
  |  Branch (353:17): [True: 8.38M, False: 320]
  ------------------
  354|  8.38M|            {
  355|  8.38M|                return len;
  356|  8.38M|            }
  357|    320|            else if (length - len < buffer_size_)
  ------------------
  |  Branch (357:22): [True: 320, False: 0]
  ------------------
  358|    320|            {
  359|    320|                fill_buffer();
  360|    320|                if (length_ > 0)
  ------------------
  |  Branch (360:21): [True: 315, False: 5]
  ------------------
  361|    315|                {
  362|    315|                    std::size_t len2 = (std::min)(length_, length-len);
  363|    315|                    std::memcpy(p+len, data_, len2*sizeof(value_type));
  364|    315|                    data_ += len2;
  365|    315|                    length_ -= len2;
  366|    315|                    position_ += len2;
  367|    315|                    len += len2;
  368|    315|                }
  369|    320|                return len;
  370|    320|            }
  371|      0|            else
  372|      0|            {
  373|      0|                if (stream_ptr_->eof())
  ------------------
  |  Branch (373:21): [True: 0, False: 0]
  ------------------
  374|      0|                {
  375|      0|                    length_ = 0;
  376|      0|                    return 0;
  377|      0|                }
  378|      0|                JSONCONS_TRY
  ------------------
  |  |   37|      0|    #define JSONCONS_TRY try
  ------------------
  379|      0|                {
  380|      0|                    std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(p+len), length-len);
  381|      0|                    std::size_t len2 = static_cast<std::size_t>(count);
  382|      0|                    if (len2 < length-len)
  ------------------
  |  Branch (382:25): [True: 0, False: 0]
  ------------------
  383|      0|                    {
  384|      0|                        stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  385|      0|                    }
  386|      0|                    len += len2;
  387|      0|                    position_ += len2;
  388|      0|                    return len;
  389|      0|                }
  390|      0|                JSONCONS_CATCH(const std::exception&)     
  391|      0|                {
  392|      0|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  393|      0|                    return 0;
  394|      0|                }
  395|      0|            }
  396|  8.38M|        }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEv:
  399|    722|        {
  400|    722|            if (stream_ptr_->eof())
  ------------------
  |  Branch (400:17): [True: 0, False: 722]
  ------------------
  401|      0|            {
  402|      0|                length_ = 0;
  403|      0|                return;
  404|      0|            }
  405|       |
  406|    722|            data_ = buffer_;
  407|    722|            JSONCONS_TRY
  ------------------
  |  |   37|    722|    #define JSONCONS_TRY try
  ------------------
  408|    722|            {
  409|    722|                std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(buffer_), buffer_size_);
  410|    722|                length_ = static_cast<std::size_t>(count);
  411|       |
  412|    722|                if (length_ < buffer_size_)
  ------------------
  |  Branch (412:21): [True: 11, False: 711]
  ------------------
  413|     11|                {
  414|     11|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  415|     11|                }
  416|    722|            }
  417|    722|            JSONCONS_CATCH(const std::exception&)     
  418|    722|            {
  419|      0|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  420|      0|                length_ = 0;
  421|      0|            }
  422|    722|        }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_6vectorIhS4_EEEENS2_9enable_ifIXaaaasr3std14is_convertibleIhNT_10value_typeEEE5valuesr10ext_traits11has_reserveISB_EE5valuesr10ext_traits14has_data_exactIPhSB_EE5valueEmE4typeERS5_RSB_m:
  859|  1.22k|        {
  860|  1.22k|            std::size_t unread = length;
  861|       |
  862|  1.22k|            std::size_t n = (std::min)(max_buffer_length, unread);
  863|  1.47k|            while (n > 0 && !source.eof())
  ------------------
  |  Branch (863:20): [True: 246, False: 1.22k]
  |  Branch (863:29): [True: 243, False: 3]
  ------------------
  864|    243|            {
  865|    243|                std::size_t offset = v.size();
  866|    243|                v.resize(v.size()+n);
  867|    243|                std::size_t actual = source.read(v.data()+offset, n);
  868|    243|                unread -= actual;
  869|    243|                n = (std::min)(max_buffer_length, unread);
  870|    243|            }
  871|       |
  872|  1.22k|            return length - unread;
  873|  1.22k|        }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv:
  271|    382|        {
  272|    382|            return length_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:20): [True: 5, False: 377]
  |  Branch (272:36): [True: 5, False: 0]
  ------------------
  273|    382|        }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_12basic_stringIcNS2_11char_traitsIcEENS3_IcEEEEEENS2_9enable_ifIXaaaasr3std14is_convertibleIhNT_10value_typeEEE5valuesr10ext_traits11has_reserveISE_EE5valuentsr10ext_traits14has_data_exactIPhSE_EE5valueEmE4typeERS5_RSE_m:
  882|      8|        {
  883|      8|            std::size_t unread = length;
  884|       |
  885|      8|            std::size_t n = (std::min)(max_buffer_length, unread);
  886|    142|            while (n > 0 && !source.eof())
  ------------------
  |  Branch (886:20): [True: 136, False: 6]
  |  Branch (886:29): [True: 134, False: 2]
  ------------------
  887|    134|            {
  888|    134|                v.reserve(v.size()+n);
  889|    134|                std::size_t actual = 0;
  890|  2.09M|                while (actual < n)
  ------------------
  |  Branch (890:24): [True: 2.09M, False: 132]
  ------------------
  891|  2.09M|                {
  892|  2.09M|                    typename Source::value_type c{};
  893|  2.09M|                    if (source.read(&c,1) != 1)
  ------------------
  |  Branch (893:25): [True: 2, False: 2.09M]
  ------------------
  894|      2|                    {
  895|      2|                        break;
  896|      2|                    }
  897|  2.09M|                    v.push_back(c);
  898|  2.09M|                    ++actual;
  899|  2.09M|                }
  900|    134|                unread -= actual;
  901|    134|                n = (std::min)(max_buffer_length, unread);
  902|    134|            }
  903|       |
  904|      8|            return length - unread;
  905|      8|        }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4peekEv:
  311|  12.7M|        {
  312|  12.7M|            if (length_ == 0)
  ------------------
  |  Branch (312:17): [True: 402, False: 12.7M]
  ------------------
  313|    402|            {
  314|    402|                fill_buffer();
  315|    402|            }
  316|  12.7M|            if (length_ > 0)
  ------------------
  |  Branch (316:17): [True: 12.7M, False: 6]
  ------------------
  317|  12.7M|            {
  318|  12.7M|                value_type c = *data_;
  319|  12.7M|                return char_result<value_type>{c, false};
  320|  12.7M|            }
  321|      6|            else
  322|      6|            {
  323|      6|                return char_result<value_type>{0, true};
  324|      6|            }
  325|  12.7M|        }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE6ignoreEm:
  286|  1.29k|        {
  287|  1.29k|            std::size_t len = 0;
  288|  1.29k|            if (length_ > 0)
  ------------------
  |  Branch (288:17): [True: 1.29k, False: 0]
  ------------------
  289|  1.29k|            {
  290|  1.29k|                len = (std::min)(length_, length);
  291|  1.29k|                position_ += len;
  292|  1.29k|                data_ += len;
  293|  1.29k|                length_ -= len;
  294|  1.29k|            }
  295|  1.29k|            while (len < length)
  ------------------
  |  Branch (295:20): [True: 0, False: 1.29k]
  ------------------
  296|      0|            {
  297|      0|                fill_buffer();
  298|      0|                if (length_ == 0)
  ------------------
  |  Branch (298:21): [True: 0, False: 0]
  ------------------
  299|      0|                {
  300|      0|                    break;
  301|      0|                }
  302|      0|                std::size_t len2 = (std::min)(length_, length-len);
  303|      0|                position_ += len2;
  304|      0|                data_ += len2;
  305|      0|                length_ -= len2;
  306|      0|                len += len2;
  307|      0|            }
  308|  1.29k|        }

_ZN8jsoncons16typed_array_castIKhEENS_6detail4spanIT_Lm18446744073709551615EEENS3_IhLm18446744073709551615EEE:
  108|      4|{
  109|      4|    return jsoncons::span<const uint8_t>{reinterpret_cast<const uint8_t*>(bytes.data()), bytes.size()};
  110|      4|}
_ZN8jsoncons20typed_array_iteratorD2Ev:
  215|    793|    virtual ~typed_array_iterator() = default;
_ZN8jsoncons20typed_array_iterator11write_valueIhEENSt3__19enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueEvE4typeES4_NS_12semantic_tagERNS_19typed_array_visitorERKNS_11ser_contextERNS2_10error_codeE:
  234|     26|    {
  235|     26|        visitor.uint64_value(val, tag, context, ec);
  236|     26|    }
_ZN8jsoncons31sequential_typed_array_iteratorIKhNS_8identityEEC2ENS_6detail4spanIS1_Lm18446744073709551615EEENS_12semantic_tagES2_:
  259|      4|        : data_(data), tag_(tag), func_(func)
  260|      4|    {
  261|      4|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIKhNS_8identityEE4doneEv:
  263|     34|    {
  264|     34|        return done_;
  265|     34|    }
_ZN8jsoncons31sequential_typed_array_iteratorIKhNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  269|     34|    {
  270|     34|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|     34|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 30]
  |  |  ------------------
  ------------------
  271|      4|        {
  272|      4|            visitor.begin_array(data_.size(), tag_, context, ec);
  273|      4|            first_ = false;
  274|      4|        }
  275|     30|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|     30|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 26, False: 4]
  |  |  ------------------
  ------------------
  276|     26|        {
  277|     26|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  278|     26|            ++index_;
  279|     26|        }
  280|      4|        else if (!done_)
  ------------------
  |  Branch (280:18): [True: 4, False: 0]
  ------------------
  281|      4|        {
  282|      4|            visitor.end_array(context, ec);
  283|      4|            done_ = true;
  284|      4|        }
  285|     34|    }
_ZN8jsoncons16typed_array_castItEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   54|      1|{
   55|      1|    return jsoncons::span<uint16_t>{reinterpret_cast<uint16_t*>(bytes.data()), bytes.size()/sizeof(uint16_t)};
   56|      1|}
_ZN8jsoncons31sequential_typed_array_iteratorItNS_8identityEEC2ENS_6detail4spanItLm18446744073709551615EEENS_12semantic_tagES1_:
  259|      1|        : data_(data), tag_(tag), func_(func)
  260|      1|    {
  261|      1|    }
_ZNK8jsoncons31sequential_typed_array_iteratorItNS_8identityEE4doneEv:
  263|      2|    {
  264|      2|        return done_;
  265|      2|    }
_ZN8jsoncons31sequential_typed_array_iteratorItNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  269|      2|    {
  270|      2|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 1]
  |  |  ------------------
  ------------------
  271|      1|        {
  272|      1|            visitor.begin_array(data_.size(), tag_, context, ec);
  273|      1|            first_ = false;
  274|      1|        }
  275|      1|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|      1|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  276|      0|        {
  277|      0|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  278|      0|            ++index_;
  279|      0|        }
  280|      1|        else if (!done_)
  ------------------
  |  Branch (280:18): [True: 1, False: 0]
  ------------------
  281|      1|        {
  282|      1|            visitor.end_array(context, ec);
  283|      1|            done_ = true;
  284|      1|        }
  285|      2|    }
_ZN8jsoncons16typed_array_castImEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   66|     91|{
   67|     91|    return jsoncons::span<uint64_t>{reinterpret_cast<uint64_t*>(bytes.data()), bytes.size()/sizeof(uint64_t)};
   68|     91|}
_ZN8jsoncons20typed_array_iterator11write_valueImEENSt3__19enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueEvE4typeES4_NS_12semantic_tagERNS_19typed_array_visitorERKNS_11ser_contextERNS2_10error_codeE:
  234|      1|    {
  235|      1|        visitor.uint64_value(val, tag, context, ec);
  236|      1|    }
_ZN8jsoncons31sequential_typed_array_iteratorImNS_8identityEEC2ENS_6detail4spanImLm18446744073709551615EEENS_12semantic_tagES1_:
  259|     91|        : data_(data), tag_(tag), func_(func)
  260|     91|    {
  261|     91|    }
_ZNK8jsoncons31sequential_typed_array_iteratorImNS_8identityEE4doneEv:
  263|    183|    {
  264|    183|        return done_;
  265|    183|    }
_ZN8jsoncons31sequential_typed_array_iteratorImNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  269|    183|    {
  270|    183|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|    183|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 91, False: 92]
  |  |  ------------------
  ------------------
  271|     91|        {
  272|     91|            visitor.begin_array(data_.size(), tag_, context, ec);
  273|     91|            first_ = false;
  274|     91|        }
  275|     92|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|     92|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 1, False: 91]
  |  |  ------------------
  ------------------
  276|      1|        {
  277|      1|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  278|      1|            ++index_;
  279|      1|        }
  280|     91|        else if (!done_)
  ------------------
  |  Branch (280:18): [True: 91, False: 0]
  ------------------
  281|     91|        {
  282|     91|            visitor.end_array(context, ec);
  283|     91|            done_ = true;
  284|     91|        }
  285|    183|    }
_ZN8jsoncons16typed_array_castIsEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   78|    692|{
   79|    692|    return jsoncons::span<int16_t>{reinterpret_cast<int16_t*>(bytes.data()), bytes.size()/sizeof(int16_t)};
   80|    692|}
_ZN8jsoncons20typed_array_iterator11write_valueIsEENSt3__19enable_ifIXsr10ext_traits17is_signed_integerIT_EE5valueEvE4typeES4_NS_12semantic_tagERNS_19typed_array_visitorERKNS_11ser_contextERNS2_10error_codeE:
  226|     41|    {
  227|     41|        visitor.int64_value(val, tag, context, ec);
  228|     41|    }
_ZN8jsoncons31sequential_typed_array_iteratorIsNS_8identityEEC2ENS_6detail4spanIsLm18446744073709551615EEENS_12semantic_tagES1_:
  259|    692|        : data_(data), tag_(tag), func_(func)
  260|    692|    {
  261|    692|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIsNS_8identityEE4doneEv:
  263|  1.42k|    {
  264|  1.42k|        return done_;
  265|  1.42k|    }
_ZN8jsoncons31sequential_typed_array_iteratorIsNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  269|  1.42k|    {
  270|  1.42k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|  1.42k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 692, False: 733]
  |  |  ------------------
  ------------------
  271|    692|        {
  272|    692|            visitor.begin_array(data_.size(), tag_, context, ec);
  273|    692|            first_ = false;
  274|    692|        }
  275|    733|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|    733|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 41, False: 692]
  |  |  ------------------
  ------------------
  276|     41|        {
  277|     41|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  278|     41|            ++index_;
  279|     41|        }
  280|    692|        else if (!done_)
  ------------------
  |  Branch (280:18): [True: 692, False: 0]
  ------------------
  281|    692|        {
  282|    692|            visitor.end_array(context, ec);
  283|    692|            done_ = true;
  284|    692|        }
  285|  1.42k|    }
_ZN8jsoncons16typed_array_castIlEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   90|      1|{
   91|      1|    return jsoncons::span<int64_t>{reinterpret_cast<int64_t*>(bytes.data()), bytes.size()/sizeof(int64_t)};
   92|      1|}
_ZN8jsoncons31sequential_typed_array_iteratorIlNS_8identityEEC2ENS_6detail4spanIlLm18446744073709551615EEENS_12semantic_tagES1_:
  259|      1|        : data_(data), tag_(tag), func_(func)
  260|      1|    {
  261|      1|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIlNS_8identityEE4doneEv:
  263|      2|    {
  264|      2|        return done_;
  265|      2|    }
_ZN8jsoncons31sequential_typed_array_iteratorIlNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  269|      2|    {
  270|      2|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 1]
  |  |  ------------------
  ------------------
  271|      1|        {
  272|      1|            visitor.begin_array(data_.size(), tag_, context, ec);
  273|      1|            first_ = false;
  274|      1|        }
  275|      1|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|      1|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  276|      0|        {
  277|      0|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  278|      0|            ++index_;
  279|      0|        }
  280|      1|        else if (!done_)
  ------------------
  |  Branch (280:18): [True: 1, False: 0]
  ------------------
  281|      1|        {
  282|      1|            visitor.end_array(context, ec);
  283|      1|            done_ = true;
  284|      1|        }
  285|      2|    }
_ZN8jsoncons20typed_array_iterator11write_valueIdEENSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEvE4typeES4_NS_12semantic_tagERNS_19typed_array_visitorERKNS_11ser_contextERNS2_10error_codeE:
  242|      2|    {
  243|      2|        visitor.double_value(val, tag, context, ec);
  244|      2|    }
_ZN8jsoncons16typed_array_castIfEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   96|      2|{
   97|      2|    return jsoncons::span<float>{reinterpret_cast<float*>(bytes.data()), bytes.size()/sizeof(float)};
   98|      2|}
_ZN8jsoncons20typed_array_iterator11write_valueIfEENSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEvE4typeES4_NS_12semantic_tagERNS_19typed_array_visitorERKNS_11ser_contextERNS2_10error_codeE:
  242|      4|    {
  243|      4|        visitor.double_value(val, tag, context, ec);
  244|      4|    }
_ZN8jsoncons31sequential_typed_array_iteratorIfNS_8identityEEC2ENS_6detail4spanIfLm18446744073709551615EEENS_12semantic_tagES1_:
  259|      2|        : data_(data), tag_(tag), func_(func)
  260|      2|    {
  261|      2|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIfNS_8identityEE4doneEv:
  263|      8|    {
  264|      8|        return done_;
  265|      8|    }
_ZN8jsoncons31sequential_typed_array_iteratorIfNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  269|      8|    {
  270|      8|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 6]
  |  |  ------------------
  ------------------
  271|      2|        {
  272|      2|            visitor.begin_array(data_.size(), tag_, context, ec);
  273|      2|            first_ = false;
  274|      2|        }
  275|      6|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|      6|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 4, False: 2]
  |  |  ------------------
  ------------------
  276|      4|        {
  277|      4|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  278|      4|            ++index_;
  279|      4|        }
  280|      2|        else if (!done_)
  ------------------
  |  Branch (280:18): [True: 2, False: 0]
  ------------------
  281|      2|        {
  282|      2|            visitor.end_array(context, ec);
  283|      2|            done_ = true;
  284|      2|        }
  285|      8|    }
_ZN8jsoncons16typed_array_castIdEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  102|      2|{
  103|      2|    return jsoncons::span<double>{reinterpret_cast<double*>(bytes.data()), bytes.size()/sizeof(double)};
  104|      2|}
_ZN8jsoncons31sequential_typed_array_iteratorIdNS_8identityEEC2ENS_6detail4spanIdLm18446744073709551615EEENS_12semantic_tagES1_:
  259|      2|        : data_(data), tag_(tag), func_(func)
  260|      2|    {
  261|      2|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIdNS_8identityEE4doneEv:
  263|      6|    {
  264|      6|        return done_;
  265|      6|    }
_ZN8jsoncons31sequential_typed_array_iteratorIdNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  269|      6|    {
  270|      6|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|      6|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 4]
  |  |  ------------------
  ------------------
  271|      2|        {
  272|      2|            visitor.begin_array(data_.size(), tag_, context, ec);
  273|      2|            first_ = false;
  274|      2|        }
  275|      4|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|      4|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 2, False: 2]
  |  |  ------------------
  ------------------
  276|      2|        {
  277|      2|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  278|      2|            ++index_;
  279|      2|        }
  280|      2|        else if (!done_)
  ------------------
  |  Branch (280:18): [True: 2, False: 0]
  ------------------
  281|      2|        {
  282|      2|            visitor.end_array(context, ec);
  283|      2|            done_ = true;
  284|      2|        }
  285|      6|    }

_ZN8jsoncons6binary13native_to_bigItNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|      4|    {
  128|      4|        T val2 = byte_swap(val);
  129|      4|        uint8_t buf[sizeof(T)];
  130|      4|        std::memcpy(buf, &val2, sizeof(T));
  131|      4|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 8, False: 4]
  ------------------
  132|      8|        {
  133|      8|            *d_first++ = item;
  134|      8|        }
  135|      4|    }
_ZN8jsoncons6binary9byte_swapItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|     23|    {
   29|     23|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|     23|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  466|     23|#      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|     23|    }
_ZN8jsoncons6binary13native_to_bigIjNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|      3|    {
  128|      3|        T val2 = byte_swap(val);
  129|      3|        uint8_t buf[sizeof(T)];
  130|      3|        std::memcpy(buf, &val2, sizeof(T));
  131|      3|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 12, False: 3]
  ------------------
  132|     12|        {
  133|     12|            *d_first++ = item;
  134|     12|        }
  135|      3|    }
_ZN8jsoncons6binary9byte_swapIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|     10|    {
   40|     10|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|     10|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  462|     10|#  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|     10|    }
_ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|     11|    {
   52|     11|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|     11|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|     11|#  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|     11|    }
_ZN8jsoncons6binary13native_to_bigIhNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  1.13M|    {
  128|  1.13M|        T val2 = byte_swap(val);
  129|  1.13M|        uint8_t buf[sizeof(T)];
  130|  1.13M|        std::memcpy(buf, &val2, sizeof(T));
  131|  1.13M|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 1.13M, False: 1.13M]
  ------------------
  132|  1.13M|        {
  133|  1.13M|            *d_first++ = item;
  134|  1.13M|        }
  135|  1.13M|    }
_ZN8jsoncons6binary9byte_swapIhEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_:
   21|  1.13M|    {
   22|  1.13M|        return val;
   23|  1.13M|    }
_ZN8jsoncons6binary13native_to_bigIlNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|      5|    {
  128|      5|        T val2 = byte_swap(val);
  129|      5|        uint8_t buf[sizeof(T)];
  130|      5|        std::memcpy(buf, &val2, sizeof(T));
  131|      5|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 40, False: 5]
  ------------------
  132|     40|        {
  133|     40|            *d_first++ = item;
  134|     40|        }
  135|      5|    }
_ZN8jsoncons6binary9byte_swapIlEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|      5|    {
   52|      5|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|      5|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|      5|#  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|      5|    }
_ZN8jsoncons6binary13native_to_bigIfNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|      2|    {
  128|      2|        T val2 = byte_swap(val);
  129|      2|        uint8_t buf[sizeof(T)];
  130|      2|        std::memcpy(buf, &val2, sizeof(T));
  131|      2|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 8, False: 2]
  ------------------
  132|      8|        {
  133|      8|            *d_first++ = item;
  134|      8|        }
  135|      2|    }
_ZN8jsoncons6binary9byte_swapIfEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   64|      2|    {
   65|      2|        uint32_t x;
   66|      2|        std::memcpy(&x,&val,sizeof(uint32_t));
   67|      2|        uint32_t y = byte_swap(x);
   68|      2|        T val2;
   69|      2|        std::memcpy(&val2,&y,sizeof(uint32_t));
   70|      2|        return val2;
   71|      2|    }
_ZN8jsoncons6binary13native_to_bigIdNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|      2|    {
  128|      2|        T val2 = byte_swap(val);
  129|      2|        uint8_t buf[sizeof(T)];
  130|      2|        std::memcpy(buf, &val2, sizeof(T));
  131|      2|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 16, False: 2]
  ------------------
  132|     16|        {
  133|     16|            *d_first++ = item;
  134|     16|        }
  135|      2|    }
_ZN8jsoncons6binary9byte_swapIdEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   76|      2|    {
   77|      2|        uint64_t x;
   78|      2|        std::memcpy(&x,&val,sizeof(uint64_t));
   79|      2|        uint64_t y = byte_swap(x);
   80|      2|        T val2;
   81|      2|        std::memcpy(&val2,&y,sizeof(uint64_t));
   82|      2|        return val2;
   83|      2|    }
_ZN8jsoncons6binary13big_to_nativeItNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|     19|    {
  183|     19|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 19]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     19|        T val;
  188|     19|        std::memcpy(&val,first,sizeof(T));
  189|     19|        return byte_swap(val);
  190|     19|    }
_ZN8jsoncons6binary13big_to_nativeIjNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|      5|    {
  183|      5|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 5]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|      5|        T val;
  188|      5|        std::memcpy(&val,first,sizeof(T));
  189|      5|        return byte_swap(val);
  190|      5|    }
_ZN8jsoncons6binary13big_to_nativeImNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|      9|    {
  183|      9|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 9]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|      9|        T val;
  188|      9|        std::memcpy(&val,first,sizeof(T));
  189|      9|        return byte_swap(val);
  190|      9|    }

_ZN8jsoncons6detail23bytes_to_base64_genericIPKhNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS4_9enable_ifIXsr3std7is_sameINS4_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESD_SD_PKcRT0_:
   44|    252|    {
   45|    252|        std::size_t count = 0;
   46|    252|        unsigned char a3[3];
   47|    252|        unsigned char a4[4];
   48|    252|        unsigned char fill = alphabet[64];
   49|    252|        int i = 0;
   50|    252|        int j = 0;
   51|       |
   52|    554|        while (first != last)
  ------------------
  |  Branch (52:16): [True: 302, False: 252]
  ------------------
   53|    302|        {
   54|    302|            a3[i++] = *first++;
   55|    302|            if (i == 3)
  ------------------
  |  Branch (55:17): [True: 93, False: 209]
  ------------------
   56|     93|            {
   57|     93|                a4[0] = (a3[0] & 0xfc) >> 2;
   58|     93|                a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   59|     93|                a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   60|     93|                a4[3] = a3[2] & 0x3f;
   61|       |
   62|    465|                for (i = 0; i < 4; i++) 
  ------------------
  |  Branch (62:29): [True: 372, False: 93]
  ------------------
   63|    372|                {
   64|    372|                    result.push_back(alphabet[a4[i]]);
   65|    372|                    ++count;
   66|    372|                }
   67|     93|                i = 0;
   68|     93|            }
   69|    302|        }
   70|       |
   71|    252|        if (i > 0)
  ------------------
  |  Branch (71:13): [True: 23, False: 229]
  ------------------
   72|     23|        {
   73|     69|            for (j = i; j < 3; ++j) 
  ------------------
  |  Branch (73:25): [True: 46, False: 23]
  ------------------
   74|     46|            {
   75|     46|                a3[j] = 0;
   76|     46|            }
   77|       |
   78|     23|            a4[0] = (a3[0] & 0xfc) >> 2;
   79|     23|            a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   80|     23|            a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   81|       |
   82|     69|            for (j = 0; j < i + 1; ++j) 
  ------------------
  |  Branch (82:25): [True: 46, False: 23]
  ------------------
   83|     46|            {
   84|     46|                result.push_back(alphabet[a4[j]]);
   85|     46|                ++count;
   86|     46|            }
   87|       |
   88|     23|            if (fill != 0)
  ------------------
  |  Branch (88:17): [True: 0, False: 23]
  ------------------
   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|     23|        }
   97|       |
   98|    252|        return count;
   99|    252|    }
_ZNK8jsoncons16byte_string_view5beginEv:
  409|    436|        {
  410|    436|            return data_;
  411|    436|        }
_ZNK8jsoncons16byte_string_view3endEv:
  413|    436|        {
  414|    436|            return data_ + size_;
  415|    436|        }
_ZN8jsoncons18bytes_to_base64urlIPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  177|    252|    {
  178|    252|        static constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  179|    252|                                                      "abcdefghijklmnopqrstuvwxyz"
  180|    252|                                                      "0123456789-_"
  181|    252|                                                      "\0";
  182|    252|        return detail::bytes_to_base64_generic(first, last, alphabet, result);
  183|    252|    }
_ZNK8jsoncons16byte_string_view4dataEv:
  399|    182|        {
  400|    182|            return data_;
  401|    182|        }
_ZNK8jsoncons16byte_string_view4sizeEv:
  403|    548|        {
  404|    548|            return size_;
  405|    548|        }
_ZN8jsoncons16byte_string_viewC2EPKhm:
  362|    616|            : data_(data), size_(length)
  363|    616|        {
  364|    616|        }
_ZN8jsoncons16byte_string_viewC2INSt3__16vectorIhNS2_9allocatorIhEEEEEERKT_NS2_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS7_EE5valueEiE4typeE:
  369|      2|            : data_(reinterpret_cast<const uint8_t*>(cont.data())), size_(cont.size())
  370|      2|        {
  371|      2|        }

_ZNK8jsoncons8identityclIRKhEEOT_S5_:
   19|     26|    {
   20|     26|        return std::forward<T>(val);
   21|     26|    }
_ZNK8jsoncons8identityclIRmEEOT_S4_:
   19|      1|    {
   20|      1|        return std::forward<T>(val);
   21|      1|    }
_ZNK8jsoncons8identityclIRsEEOT_S4_:
   19|     41|    {
   20|     41|        return std::forward<T>(val);
   21|     41|    }
_ZNK8jsoncons8identityclIRfEEOT_S4_:
   19|      4|    {
   20|      4|        return std::forward<T>(val);
   21|      4|    }
_ZNK8jsoncons8identityclIRdEEOT_S4_:
   19|      2|    {
   20|      2|        return std::forward<T>(val);
   21|      2|    }

_ZN8jsoncons10ext_traits14integer_limitsIlvE6lowestEv:
  110|      5|        {
  111|      5|            return std::numeric_limits<T>::lowest();
  112|      5|        }
_ZN8jsoncons10ext_traits14integer_limitsIlvE3maxEv:
  102|      1|        {
  103|      1|            return (std::numeric_limits<T>::max)();
  104|      1|        }

_ZN8jsoncons16to_number_resultIcEC2EPKcNSt3__14errcE:
  141|     14|        : ptr(ptr_), ec(ec_)
  142|     14|    {
  143|     14|    }
_ZN8jsoncons10to_integerIlcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  557|      6|{
  558|      6|    n = 0;
  559|       |
  560|      6|    if (length == 0)
  ------------------
  |  Branch (560:9): [True: 0, False: 6]
  ------------------
  561|      0|    {
  562|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  563|      0|    }
  564|       |
  565|      6|    bool is_negative = *s == '-' ? true : false;
  ------------------
  |  Branch (565:24): [True: 5, False: 1]
  ------------------
  566|      6|    if (is_negative)
  ------------------
  |  Branch (566:9): [True: 5, False: 1]
  ------------------
  567|      5|    {
  568|      5|        ++s;
  569|      5|        --length;
  570|      5|    }
  571|       |
  572|      6|    using U = typename ext_traits::make_unsigned<T>::type;
  573|       |
  574|      6|    U u;
  575|      6|    auto ru = to_integer(s, length, u);
  576|      6|    if (ru.ec != std::errc{})
  ------------------
  |  Branch (576:9): [True: 0, False: 6]
  ------------------
  577|      0|    {
  578|      0|        return to_number_result<CharT>(ru.ptr, ru.ec);
  579|      0|    }
  580|      6|    if (is_negative)
  ------------------
  |  Branch (580:9): [True: 5, False: 1]
  ------------------
  581|      5|    {
  582|      5|        if (u > static_cast<U>(-((ext_traits::integer_limits<T>::lowest)()+T(1))) + U(1))
  ------------------
  |  Branch (582:13): [True: 0, False: 5]
  ------------------
  583|      0|        {
  584|      0|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  585|      0|        }
  586|      5|        else
  587|      5|        {
  588|      5|            n = static_cast<T>(U(0) - u);
  589|      5|            return to_number_result<CharT>(ru.ptr, std::errc{});
  590|      5|        }
  591|      5|    }
  592|      1|    else
  593|      1|    {
  594|      1|        if (u > static_cast<U>((ext_traits::integer_limits<T>::max)()))
  ------------------
  |  Branch (594:13): [True: 0, False: 1]
  ------------------
  595|      0|        {
  596|      0|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  597|      0|        }
  598|      1|        else
  599|      1|        {
  600|      1|            n = static_cast<T>(u);
  601|      1|            return to_number_result<CharT>(ru.ptr, std::errc{});
  602|      1|        }
  603|      1|    }
  604|      6|}
_ZN8jsoncons10to_integerImcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedntsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  374|      6|{
  375|      6|    n = 0;
  376|       |
  377|      6|    integer_chars_state state = integer_chars_state::initial;
  378|       |
  379|      6|    const CharT* end = s + length; 
  380|     17|    while (s < end)
  ------------------
  |  Branch (380:12): [True: 11, False: 6]
  ------------------
  381|     11|    {
  382|     11|        switch(state)
  383|     11|        {
  384|      6|            case integer_chars_state::initial:
  ------------------
  |  Branch (384:13): [True: 6, False: 5]
  ------------------
  385|      6|            {
  386|      6|                switch(*s)
  387|      6|                {
  388|      1|                    case '0':
  ------------------
  |  Branch (388:21): [True: 1, False: 5]
  ------------------
  389|      1|                        state = integer_chars_state::integer; // Could be binary, octal, hex 
  390|      1|                        ++s;
  391|      1|                        break;
  392|      5|                    case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9': // Must be decimal
  ------------------
  |  Branch (392:21): [True: 0, False: 6]
  |  Branch (392:30): [True: 1, False: 5]
  |  Branch (392:39): [True: 4, False: 2]
  |  Branch (392:48): [True: 0, False: 6]
  |  Branch (392:57): [True: 0, False: 6]
  |  Branch (392:66): [True: 0, False: 6]
  |  Branch (392:75): [True: 0, False: 6]
  |  Branch (392:84): [True: 0, False: 6]
  |  Branch (392:94): [True: 0, False: 6]
  ------------------
  393|      5|                        state = integer_chars_state::decimal;
  394|      5|                        break;
  395|      0|                    default:
  ------------------
  |  Branch (395:21): [True: 0, False: 6]
  ------------------
  396|      0|                        return to_number_result<CharT>(s, std::errc::invalid_argument);
  397|      6|                }
  398|      6|                break;
  399|      6|            }
  400|      6|            case integer_chars_state::integer:
  ------------------
  |  Branch (400:13): [True: 0, False: 11]
  ------------------
  401|      0|            {
  402|      0|                switch(*s)
  403|      0|                {
  404|      0|                    case 'b':case 'B':
  ------------------
  |  Branch (404:21): [True: 0, False: 0]
  |  Branch (404:30): [True: 0, False: 0]
  ------------------
  405|      0|                    {
  406|      0|                        state = integer_chars_state::binary;
  407|      0|                        ++s;
  408|      0|                        break;
  409|      0|                    }
  410|      0|                    case 'x':case 'X':
  ------------------
  |  Branch (410:21): [True: 0, False: 0]
  |  Branch (410:30): [True: 0, False: 0]
  ------------------
  411|      0|                    {
  412|      0|                        state = integer_chars_state::base16;
  413|      0|                        ++s;
  414|      0|                        break;
  415|      0|                    }
  416|      0|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (416:21): [True: 0, False: 0]
  |  Branch (416:30): [True: 0, False: 0]
  |  Branch (416:39): [True: 0, False: 0]
  |  Branch (416:48): [True: 0, False: 0]
  |  Branch (416:57): [True: 0, False: 0]
  |  Branch (416:66): [True: 0, False: 0]
  |  Branch (416:75): [True: 0, False: 0]
  |  Branch (416:84): [True: 0, False: 0]
  |  Branch (416:93): [True: 0, False: 0]
  |  Branch (416:103): [True: 0, False: 0]
  ------------------
  417|      0|                    {
  418|      0|                        state = integer_chars_state::octal;
  419|      0|                        break;
  420|      0|                    }
  421|      0|                    default:
  ------------------
  |  Branch (421:21): [True: 0, False: 0]
  ------------------
  422|      0|                        return to_number_result<CharT>(s, std::errc::invalid_argument);
  423|      0|                }
  424|      0|                break;
  425|      0|            }
  426|      0|            case integer_chars_state::binary:
  ------------------
  |  Branch (426:13): [True: 0, False: 11]
  ------------------
  427|      0|            {
  428|      0|                static constexpr T max_value = (ext_traits::integer_limits<T>::max)();
  429|      0|                static constexpr T max_value_div_2 = max_value / 2;
  430|      0|                for (; s < end; ++s)
  ------------------
  |  Branch (430:24): [True: 0, False: 0]
  ------------------
  431|      0|                {
  432|      0|                    T x = 0;
  433|      0|                    switch(*s)
  434|      0|                    {
  435|      0|                        case '0':case '1':
  ------------------
  |  Branch (435:25): [True: 0, False: 0]
  |  Branch (435:34): [True: 0, False: 0]
  ------------------
  436|      0|                            x = static_cast<T>(*s) - static_cast<T>('0');
  437|      0|                            break;
  438|      0|                        default:
  ------------------
  |  Branch (438:25): [True: 0, False: 0]
  ------------------
  439|      0|                            return to_number_result<CharT>(s, std::errc::invalid_argument);
  440|      0|                    }
  441|      0|                    if (n > max_value_div_2)
  ------------------
  |  Branch (441:25): [True: 0, False: 0]
  ------------------
  442|      0|                    {
  443|      0|                        return to_number_result<CharT>(s, std::errc::result_out_of_range);
  444|      0|                    }
  445|      0|                    n = n * 2;
  446|      0|                    if (n > max_value - x)
  ------------------
  |  Branch (446:25): [True: 0, False: 0]
  ------------------
  447|      0|                    {
  448|      0|                        return to_number_result<CharT>(s, std::errc::result_out_of_range);
  449|      0|                    }
  450|      0|                    n += x;
  451|      0|                }
  452|      0|                break;
  453|      0|            }
  454|      0|            case integer_chars_state::octal:
  ------------------
  |  Branch (454:13): [True: 0, False: 11]
  ------------------
  455|      0|            {
  456|      0|                static constexpr T max_value = (ext_traits::integer_limits<T>::max)();
  457|      0|                static constexpr T max_value_div_8 = max_value / 8;
  458|      0|                for (; s < end; ++s)
  ------------------
  |  Branch (458:24): [True: 0, False: 0]
  ------------------
  459|      0|                {
  460|      0|                    T x = 0;
  461|      0|                    switch(*s)
  462|      0|                    {
  463|      0|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':
  ------------------
  |  Branch (463:25): [True: 0, False: 0]
  |  Branch (463:34): [True: 0, False: 0]
  |  Branch (463:43): [True: 0, False: 0]
  |  Branch (463:52): [True: 0, False: 0]
  |  Branch (463:61): [True: 0, False: 0]
  |  Branch (463:70): [True: 0, False: 0]
  |  Branch (463:79): [True: 0, False: 0]
  |  Branch (463:88): [True: 0, False: 0]
  ------------------
  464|      0|                            x = static_cast<T>(*s) - static_cast<T>('0');
  465|      0|                            break;
  466|      0|                        default:
  ------------------
  |  Branch (466:25): [True: 0, False: 0]
  ------------------
  467|      0|                            return to_number_result<CharT>(s, std::errc::invalid_argument);
  468|      0|                    }
  469|      0|                    if (n > max_value_div_8)
  ------------------
  |  Branch (469:25): [True: 0, False: 0]
  ------------------
  470|      0|                    {
  471|      0|                        return to_number_result<CharT>(s, std::errc::result_out_of_range);
  472|      0|                    }
  473|      0|                    n = n * 8;
  474|      0|                    if (n > max_value - x)
  ------------------
  |  Branch (474:25): [True: 0, False: 0]
  ------------------
  475|      0|                    {
  476|      0|                        return to_number_result<CharT>(s, std::errc::result_out_of_range);
  477|      0|                    }
  478|      0|                    n += x;
  479|      0|                }
  480|      0|                break;
  481|      0|            }
  482|      5|            case integer_chars_state::decimal:
  ------------------
  |  Branch (482:13): [True: 5, False: 6]
  ------------------
  483|      5|            {
  484|      5|                static constexpr T max_value = (ext_traits::integer_limits<T>::max)();
  485|      5|                static constexpr T max_value_div_10 = max_value / 10;
  486|     79|                for (; s < end; ++s)
  ------------------
  |  Branch (486:24): [True: 74, False: 5]
  ------------------
  487|     74|                {
  488|     74|                    T x = 0;
  489|     74|                    switch(*s)
  490|     74|                    {
  491|     74|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (491:25): [True: 68, False: 6]
  |  Branch (491:34): [True: 0, False: 74]
  |  Branch (491:43): [True: 2, False: 72]
  |  Branch (491:52): [True: 4, False: 70]
  |  Branch (491:61): [True: 0, False: 74]
  |  Branch (491:70): [True: 0, False: 74]
  |  Branch (491:79): [True: 0, False: 74]
  |  Branch (491:88): [True: 0, False: 74]
  |  Branch (491:97): [True: 0, False: 74]
  |  Branch (491:107): [True: 0, False: 74]
  ------------------
  492|     74|                            x = static_cast<T>(*s) - static_cast<T>('0');
  493|     74|                            break;
  494|      0|                        default:
  ------------------
  |  Branch (494:25): [True: 0, False: 74]
  ------------------
  495|      0|                            return to_number_result<CharT>(s, std::errc::invalid_argument);
  496|     74|                    }
  497|     74|                    if (n > max_value_div_10)
  ------------------
  |  Branch (497:25): [True: 0, False: 74]
  ------------------
  498|      0|                    {
  499|      0|                        return to_number_result<CharT>(s, std::errc::result_out_of_range);
  500|      0|                    }
  501|     74|                    n = n * 10;
  502|     74|                    if (n > max_value - x)
  ------------------
  |  Branch (502:25): [True: 0, False: 74]
  ------------------
  503|      0|                    {
  504|      0|                        return to_number_result<CharT>(s, std::errc::result_out_of_range);
  505|      0|                    }
  506|     74|                    n += x;
  507|     74|                }
  508|      5|                break;
  509|      5|            }
  510|      5|            case integer_chars_state::base16:
  ------------------
  |  Branch (510:13): [True: 0, False: 11]
  ------------------
  511|      0|            {
  512|      0|                static constexpr T max_value = (ext_traits::integer_limits<T>::max)();
  513|      0|                static constexpr T max_value_div_16 = max_value / 16;
  514|      0|                for (; s < end; ++s)
  ------------------
  |  Branch (514:24): [True: 0, False: 0]
  ------------------
  515|      0|                {
  516|      0|                    CharT c = *s;
  517|      0|                    T x = 0;
  518|      0|                    switch (c)
  519|      0|                    {
  520|      0|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (520:25): [True: 0, False: 0]
  |  Branch (520:34): [True: 0, False: 0]
  |  Branch (520:43): [True: 0, False: 0]
  |  Branch (520:52): [True: 0, False: 0]
  |  Branch (520:61): [True: 0, False: 0]
  |  Branch (520:70): [True: 0, False: 0]
  |  Branch (520:79): [True: 0, False: 0]
  |  Branch (520:88): [True: 0, False: 0]
  |  Branch (520:97): [True: 0, False: 0]
  |  Branch (520:107): [True: 0, False: 0]
  ------------------
  521|      0|                            x = static_cast<T>(c - '0');
  522|      0|                            break;
  523|      0|                        case 'a':case 'b':case 'c':case 'd':case 'e':case 'f':
  ------------------
  |  Branch (523:25): [True: 0, False: 0]
  |  Branch (523:34): [True: 0, False: 0]
  |  Branch (523:43): [True: 0, False: 0]
  |  Branch (523:52): [True: 0, False: 0]
  |  Branch (523:61): [True: 0, False: 0]
  |  Branch (523:70): [True: 0, False: 0]
  ------------------
  524|      0|                            x = static_cast<T>(c - ('a' - 10));
  525|      0|                            break;
  526|      0|                        case 'A':case 'B':case 'C':case 'D':case 'E':case 'F':
  ------------------
  |  Branch (526:25): [True: 0, False: 0]
  |  Branch (526:34): [True: 0, False: 0]
  |  Branch (526:43): [True: 0, False: 0]
  |  Branch (526:52): [True: 0, False: 0]
  |  Branch (526:61): [True: 0, False: 0]
  |  Branch (526:70): [True: 0, False: 0]
  ------------------
  527|      0|                            x = static_cast<T>(c - ('A' - 10));
  528|      0|                            break;
  529|      0|                        default:
  ------------------
  |  Branch (529:25): [True: 0, False: 0]
  ------------------
  530|      0|                            return to_number_result<CharT>(s, std::errc::invalid_argument);
  531|      0|                    }
  532|      0|                    if (n > max_value_div_16)
  ------------------
  |  Branch (532:25): [True: 0, False: 0]
  ------------------
  533|      0|                    {
  534|      0|                        return to_number_result<CharT>(s, std::errc::result_out_of_range);
  535|      0|                    }
  536|      0|                    n = n * 16;
  537|      0|                    if (n > max_value - x)
  ------------------
  |  Branch (537:25): [True: 0, False: 0]
  ------------------
  538|      0|                    {
  539|      0|                        return to_number_result<CharT>(s, std::errc::result_out_of_range);
  540|      0|                    }
  541|       |
  542|      0|                    n += x;
  543|      0|                }
  544|      0|                break;
  545|      0|            }
  546|      0|            default:
  ------------------
  |  Branch (546:13): [True: 0, False: 11]
  ------------------
  547|      0|                JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
  548|      0|                break;
  549|     11|        }
  550|     11|    }
  551|      6|    return (state == integer_chars_state::initial) ? to_number_result<CharT>(s, std::errc::invalid_argument) : to_number_result<CharT>(s, std::errc{});
  ------------------
  |  Branch (551:12): [True: 0, False: 6]
  ------------------
  552|      6|}
_ZNK8jsoncons16to_number_resultIcEcvbEv:
  150|      8|    {
  151|      8|        return ec == std::errc{};
  152|      8|    }
_ZN8jsoncons14hex_to_integerIlcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  618|      2|{
  619|      2|    static_assert(ext_traits::integer_limits<T>::is_specialized, "Integer type not specialized");
  620|      2|    JSONCONS_ASSERT(length > 0);
  ------------------
  |  |   45|      2|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 2]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  621|       |
  622|      2|    n = 0;
  623|       |
  624|      2|    const CharT* end = s + length; 
  625|      2|    if (*s == '-')
  ------------------
  |  Branch (625:9): [True: 2, False: 0]
  ------------------
  626|      2|    {
  627|      2|        static constexpr T min_value = (ext_traits::integer_limits<T>::lowest)();
  628|      2|        static constexpr T min_value_div_16 = min_value / 16;
  629|      2|        ++s;
  630|     19|        for (; s < end; ++s)
  ------------------
  |  Branch (630:16): [True: 17, False: 2]
  ------------------
  631|     17|        {
  632|     17|            CharT c = *s;
  633|     17|            T x = 0;
  634|     17|            switch (c)
  635|     17|            {
  636|     16|                case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (636:17): [True: 12, False: 5]
  |  Branch (636:26): [True: 1, False: 16]
  |  Branch (636:35): [True: 1, False: 16]
  |  Branch (636:44): [True: 0, False: 17]
  |  Branch (636:53): [True: 0, False: 17]
  |  Branch (636:62): [True: 0, False: 17]
  |  Branch (636:71): [True: 0, False: 17]
  |  Branch (636:80): [True: 2, False: 15]
  |  Branch (636:89): [True: 0, False: 17]
  |  Branch (636:99): [True: 0, False: 17]
  ------------------
  637|     16|                    x = c - '0';
  638|     16|                    break;
  639|      0|                case 'a':case 'b':case 'c':case 'd':case 'e':case 'f':
  ------------------
  |  Branch (639:17): [True: 0, False: 17]
  |  Branch (639:26): [True: 0, False: 17]
  |  Branch (639:35): [True: 0, False: 17]
  |  Branch (639:44): [True: 0, False: 17]
  |  Branch (639:53): [True: 0, False: 17]
  |  Branch (639:62): [True: 0, False: 17]
  ------------------
  640|      0|                    x = c - ('a' - 10);
  641|      0|                    break;
  642|      1|                case 'A':case 'B':case 'C':case 'D':case 'E':case 'F':
  ------------------
  |  Branch (642:17): [True: 0, False: 17]
  |  Branch (642:26): [True: 0, False: 17]
  |  Branch (642:35): [True: 0, False: 17]
  |  Branch (642:44): [True: 0, False: 17]
  |  Branch (642:53): [True: 0, False: 17]
  |  Branch (642:62): [True: 1, False: 16]
  ------------------
  643|      1|                    x = c - ('A' - 10);
  644|      1|                    break;
  645|      0|                default:
  ------------------
  |  Branch (645:17): [True: 0, False: 17]
  ------------------
  646|      0|                    return to_number_result<CharT>(s, std::errc::invalid_argument);
  647|     17|            }
  648|     17|            if (n < min_value_div_16)
  ------------------
  |  Branch (648:17): [True: 0, False: 17]
  ------------------
  649|      0|            {
  650|      0|                return to_number_result<CharT>(s, std::errc::result_out_of_range);
  651|      0|            }
  652|     17|            n = n * 16;
  653|     17|            if (n < min_value + x)
  ------------------
  |  Branch (653:17): [True: 0, False: 17]
  ------------------
  654|      0|            {
  655|      0|                return to_number_result<CharT>(s, std::errc::result_out_of_range);
  656|      0|            }
  657|     17|            n -= x;
  658|     17|        }
  659|      2|    }
  660|      0|    else
  661|      0|    {
  662|      0|        static constexpr T max_value = (ext_traits::integer_limits<T>::max)();
  663|      0|        static constexpr T max_value_div_16 = max_value / 16;
  664|      0|        for (; s < end; ++s)
  ------------------
  |  Branch (664:16): [True: 0, False: 0]
  ------------------
  665|      0|        {
  666|      0|            CharT c = *s;
  667|      0|            T x = 0;
  668|      0|            switch (c)
  669|      0|            {
  670|      0|                case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (670:17): [True: 0, False: 0]
  |  Branch (670:26): [True: 0, False: 0]
  |  Branch (670:35): [True: 0, False: 0]
  |  Branch (670:44): [True: 0, False: 0]
  |  Branch (670:53): [True: 0, False: 0]
  |  Branch (670:62): [True: 0, False: 0]
  |  Branch (670:71): [True: 0, False: 0]
  |  Branch (670:80): [True: 0, False: 0]
  |  Branch (670:89): [True: 0, False: 0]
  |  Branch (670:99): [True: 0, False: 0]
  ------------------
  671|      0|                    x = c - '0';
  672|      0|                    break;
  673|      0|                case 'a':case 'b':case 'c':case 'd':case 'e':case 'f':
  ------------------
  |  Branch (673:17): [True: 0, False: 0]
  |  Branch (673:26): [True: 0, False: 0]
  |  Branch (673:35): [True: 0, False: 0]
  |  Branch (673:44): [True: 0, False: 0]
  |  Branch (673:53): [True: 0, False: 0]
  |  Branch (673:62): [True: 0, False: 0]
  ------------------
  674|      0|                    x = c - ('a' - 10);
  675|      0|                    break;
  676|      0|                case 'A':case 'B':case 'C':case 'D':case 'E':case 'F':
  ------------------
  |  Branch (676:17): [True: 0, False: 0]
  |  Branch (676:26): [True: 0, False: 0]
  |  Branch (676:35): [True: 0, False: 0]
  |  Branch (676:44): [True: 0, False: 0]
  |  Branch (676:53): [True: 0, False: 0]
  |  Branch (676:62): [True: 0, False: 0]
  ------------------
  677|      0|                    x = c - ('A' - 10);
  678|      0|                    break;
  679|      0|                default:
  ------------------
  |  Branch (679:17): [True: 0, False: 0]
  ------------------
  680|      0|                    return to_number_result<CharT>(s, std::errc::invalid_argument);
  681|      0|            }
  682|      0|            if (n > max_value_div_16)
  ------------------
  |  Branch (682:17): [True: 0, False: 0]
  ------------------
  683|      0|            {
  684|      0|                return to_number_result<CharT>(s, std::errc::result_out_of_range);
  685|      0|            }
  686|      0|            n = n * 16;
  687|      0|            if (n > max_value - x)
  ------------------
  |  Branch (687:17): [True: 0, False: 0]
  ------------------
  688|      0|            {
  689|      0|                return to_number_result<CharT>(s, std::errc::result_out_of_range);
  690|      0|            }
  691|       |
  692|      0|            n += x;
  693|      0|        }
  694|      0|    }
  695|       |
  696|      2|    return to_number_result<CharT>(s, std::errc{});
  697|      2|}

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

_ZN8jsoncons12from_integerImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  2.17M|{
   43|  2.17M|    using char_type = typename Result::value_type;
   44|       |
   45|  2.17M|    char_type buf[255];
   46|  2.17M|    char_type *p = buf;
   47|  2.17M|    const char_type* last = buf+255;
   48|       |
   49|  2.17M|    bool is_negative = value < 0;
   50|       |
   51|  2.17M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 2.17M]
  ------------------
   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|  2.17M|    else
   60|  2.17M|    {
   61|       |
   62|  2.17M|        do
   63|  2.17M|        {
   64|  2.17M|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  2.17M|        }
   66|  2.17M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 71, False: 2.17M]
  |  Branch (66:33): [True: 71, False: 0]
  ------------------
   67|  2.17M|    }
   68|  2.17M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   45|  2.17M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 2.17M]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|  2.17M|    std::size_t count = (p - buf);
   71|  2.17M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 2.17M]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  4.35M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 2.17M, False: 2.17M]
  ------------------
   77|  2.17M|    {
   78|  2.17M|        result.push_back(*p);
   79|  2.17M|    }
   80|       |
   81|  2.17M|    return count;
   82|  2.17M|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|    276|{
   43|    276|    using char_type = typename Result::value_type;
   44|       |
   45|    276|    char_type buf[255];
   46|    276|    char_type *p = buf;
   47|    276|    const char_type* last = buf+255;
   48|       |
   49|    276|    bool is_negative = value < 0;
   50|       |
   51|    276|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 232, False: 44]
  ------------------
   52|    232|    {
   53|    232|        do
   54|    470|        {
   55|    470|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|    470|        }
   57|    470|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 238, False: 232]
  |  Branch (57:33): [True: 238, False: 0]
  ------------------
   58|    232|    }
   59|     44|    else
   60|     44|    {
   61|       |
   62|     44|        do
   63|    198|        {
   64|    198|            *p++ = static_cast<char_type>(48 + value % 10);
   65|    198|        }
   66|    198|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 154, False: 44]
  |  Branch (66:33): [True: 154, False: 0]
  ------------------
   67|     44|    }
   68|    276|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   45|    276|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 276]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|    276|    std::size_t count = (p - buf);
   71|    276|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 232, False: 44]
  ------------------
   72|    232|    {
   73|    232|        result.push_back('-');
   74|    232|        ++count;
   75|    232|    }
   76|    944|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 668, False: 276]
  ------------------
   77|    668|    {
   78|    668|        result.push_back(*p);
   79|    668|    }
   80|       |
   81|    276|    return count;
   82|    276|}
_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|      5|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|      5|    {
  489|      5|#if !defined(JSONCONS_NO_LOCALECONV)
  490|      5|        struct lconv *lc = localeconv();
  491|      5|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 5, False: 0]
  |  Branch (491:30): [True: 5, False: 0]
  ------------------
  492|      5|        {
  493|      5|            decimal_point_ = lc->decimal_point[0];
  494|      5|        }
  495|      5|#endif
  496|      5|    }
_ZN8jsoncons12write_doubleclINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEmdRT_:
  503|      5|    {
  504|      5|        std::size_t count = 0;
  505|       |
  506|      5|        char number_buffer[200];
  507|      5|        int length = 0;
  508|       |
  509|      5|        switch (float_format_)
  510|      5|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 5]
  ------------------
  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: 5]
  ------------------
  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|      5|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 5, False: 0]
  ------------------
  552|      5|            {
  553|      5|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 5]
  ------------------
  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|      5|                else
  563|      5|                {
  564|      5|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 5]
  ------------------
  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|      5|                }             
  569|      5|                break;
  570|      5|            }
  571|      5|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 5]
  ------------------
  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|      5|        }
  575|      5|        return count;
  576|      5|    }
_ZN8jsoncons15prettify_stringINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKcmiiiRT_:
  171|      5|{
  172|      5|    int nb_digits = (int)length;
  173|      5|    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|      5|    int kk = nb_digits + k;
  179|       |
  180|      5|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 2, False: 3]
  |  Branch (180:28): [True: 0, False: 2]
  ------------------
  181|      0|    {
  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|      0|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 0, False: 0]
  ------------------
  186|      0|        {
  187|      0|            result.push_back(buffer[i]);
  188|      0|        }
  189|      0|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 0, False: 0]
  ------------------
  190|      0|        {
  191|      0|            result.push_back('0');
  192|      0|        }
  193|      0|        result.push_back('.');
  194|      0|        result.push_back('0');
  195|      0|    } 
  196|      5|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 5, False: 0]
  |  Branch (196:24): [True: 3, False: 2]
  ------------------
  197|      3|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|      6|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 3, False: 3]
  ------------------
  200|      3|        {
  201|      3|            result.push_back(buffer[i]);
  202|      3|        }
  203|      3|        result.push_back('.');
  204|     21|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 18, False: 3]
  ------------------
  205|     18|        {
  206|     18|            result.push_back(buffer[i]);
  207|     18|        }
  208|      3|    } 
  209|      2|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 2, False: 0]
  |  Branch (209:30): [True: 0, False: 2]
  ------------------
  210|      0|    {
  211|      0|        offset = 2 - kk;
  212|       |
  213|      0|        result.push_back('0');
  214|      0|        result.push_back('.');
  215|      0|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 0, False: 0]
  ------------------
  216|      0|            result.push_back('0');
  217|      0|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 0, False: 0]
  ------------------
  218|      0|        {
  219|      0|            result.push_back(buffer[i]);
  220|      0|        }
  221|      0|    } 
  222|      2|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 0, False: 2]
  ------------------
  223|      0|    {
  224|      0|        result.push_back(buffer[0]);
  225|      0|        result.push_back('e');
  226|      0|        fill_exponent(kk - 1, result);
  227|      0|    } 
  228|      2|    else
  229|      2|    {
  230|      2|        result.push_back(buffer[0]);
  231|      2|        result.push_back('.');
  232|     33|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 31, False: 2]
  ------------------
  233|     31|        {
  234|     31|            result.push_back(buffer[i]);
  235|     31|        }
  236|      2|        result.push_back('e');
  237|      2|        fill_exponent(kk - 1, result);
  238|      2|    }
  239|      5|}
_ZN8jsoncons13fill_exponentINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEviRT_:
  136|      2|{
  137|      2|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 0, False: 2]
  ------------------
  138|      0|    {
  139|      0|        result.push_back('-');
  140|      0|        K = -K;
  141|      0|    }
  142|      2|    else
  143|      2|    {
  144|      2|        result.push_back('+'); // compatibility with sprintf
  145|      2|    }
  146|       |
  147|      2|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 0, False: 2]
  ------------------
  148|      0|    {
  149|      0|        result.push_back('0'); // compatibility with sprintf
  150|      0|        result.push_back((char)('0' + K));
  151|      0|    }
  152|      2|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 2, False: 0]
  ------------------
  153|      2|    {
  154|      2|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|      2|        result.push_back((char)('0' + K));
  156|      2|    }
  157|      0|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 0, False: 0]
  ------------------
  158|      0|    {
  159|      0|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|      0|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|      0|        result.push_back((char)('0' + K));
  162|      0|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|      2|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_:
  475|      5|{
  476|      5|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|      5|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb1EEE:
  366|      5|{
  367|      5|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 0, False: 5]
  ------------------
  368|      0|    {
  369|      0|        result.push_back('0');
  370|      0|        result.push_back('.');
  371|      0|        result.push_back('0');
  372|      0|        return true;
  373|      0|    }
  374|       |
  375|      5|    int length = 0;
  376|      5|    int k;
  377|       |
  378|      5|    char buffer[100];
  379|       |
  380|      5|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 2, False: 3]
  ------------------
  381|      5|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 5, False: 0]
  ------------------
  382|      5|    {
  383|      5|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 2, False: 3]
  ------------------
  384|      2|        {
  385|      2|            result.push_back('-');
  386|      2|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|      5|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|      5|        return true;
  391|      5|    }
  392|      0|    else
  393|      0|    {
  394|      0|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|      0|    }
  396|      5|}
_ZN8jsoncons15prettify_stringINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKcmiiiRT_:
  171|     13|{
  172|     13|    int nb_digits = (int)length;
  173|     13|    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|     13|    int kk = nb_digits + k;
  179|       |
  180|     13|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 8, False: 5]
  |  Branch (180:28): [True: 8, False: 0]
  ------------------
  181|      8|    {
  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|     16|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 8, False: 8]
  ------------------
  186|      8|        {
  187|      8|            result.push_back(buffer[i]);
  188|      8|        }
  189|    136|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 128, False: 8]
  ------------------
  190|    128|        {
  191|    128|            result.push_back('0');
  192|    128|        }
  193|      8|        result.push_back('.');
  194|      8|        result.push_back('0');
  195|      8|    } 
  196|      5|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 0, False: 5]
  |  Branch (196:24): [True: 0, False: 0]
  ------------------
  197|      0|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|      0|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 0, False: 0]
  ------------------
  200|      0|        {
  201|      0|            result.push_back(buffer[i]);
  202|      0|        }
  203|      0|        result.push_back('.');
  204|      0|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 0, False: 0]
  ------------------
  205|      0|        {
  206|      0|            result.push_back(buffer[i]);
  207|      0|        }
  208|      0|    } 
  209|      5|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 0, False: 5]
  |  Branch (209:30): [True: 0, False: 0]
  ------------------
  210|      0|    {
  211|      0|        offset = 2 - kk;
  212|       |
  213|      0|        result.push_back('0');
  214|      0|        result.push_back('.');
  215|      0|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 0, False: 0]
  ------------------
  216|      0|            result.push_back('0');
  217|      0|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 0, False: 0]
  ------------------
  218|      0|        {
  219|      0|            result.push_back(buffer[i]);
  220|      0|        }
  221|      0|    } 
  222|      5|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 5, False: 0]
  ------------------
  223|      5|    {
  224|      5|        result.push_back(buffer[0]);
  225|      5|        result.push_back('e');
  226|      5|        fill_exponent(kk - 1, result);
  227|      5|    } 
  228|      0|    else
  229|      0|    {
  230|      0|        result.push_back(buffer[0]);
  231|      0|        result.push_back('.');
  232|      0|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 0, False: 0]
  ------------------
  233|      0|        {
  234|      0|            result.push_back(buffer[i]);
  235|      0|        }
  236|      0|        result.push_back('e');
  237|      0|        fill_exponent(kk - 1, result);
  238|      0|    }
  239|     13|}
_ZN8jsoncons13fill_exponentINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEviRT_:
  136|      5|{
  137|      5|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 5, False: 0]
  ------------------
  138|      5|    {
  139|      5|        result.push_back('-');
  140|      5|        K = -K;
  141|      5|    }
  142|      0|    else
  143|      0|    {
  144|      0|        result.push_back('+'); // compatibility with sprintf
  145|      0|    }
  146|       |
  147|      5|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 4, False: 1]
  ------------------
  148|      4|    {
  149|      4|        result.push_back('0'); // compatibility with sprintf
  150|      4|        result.push_back((char)('0' + K));
  151|      4|    }
  152|      1|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 1, False: 0]
  ------------------
  153|      1|    {
  154|      1|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|      1|        result.push_back((char)('0' + K));
  156|      1|    }
  157|      0|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 0, False: 0]
  ------------------
  158|      0|    {
  159|      0|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|      0|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|      0|        result.push_back((char)('0' + K));
  162|      0|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|      5|}
_ZN8jsoncons14integer_to_hexImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   89|      2|{
   90|      2|    using char_type = typename Result::value_type;
   91|       |
   92|      2|    char_type buf[255];
   93|      2|    char_type *p = buf;
   94|      2|    const char_type* last = buf+255;
   95|       |
   96|      2|    bool is_negative = value < 0;
   97|       |
   98|      2|    if (value < 0)
  ------------------
  |  Branch (98:9): [True: 0, False: 2]
  ------------------
   99|      0|    {
  100|      0|        do
  101|      0|        {
  102|      0|            *p++ = to_hex_character(0-(value % 16));
  103|      0|        }
  104|      0|        while ((value /= 16) && (p < last));
  ------------------
  |  Branch (104:16): [True: 0, False: 0]
  |  Branch (104:33): [True: 0, False: 0]
  ------------------
  105|      0|    }
  106|      2|    else
  107|      2|    {
  108|       |
  109|      2|        do
  110|     17|        {
  111|     17|            *p++ = to_hex_character(value % 16);
  112|     17|        }
  113|     17|        while ((value /= 16) && (p < last));
  ------------------
  |  Branch (113:16): [True: 15, False: 2]
  |  Branch (113:33): [True: 15, False: 0]
  ------------------
  114|      2|    }
  115|      2|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   45|      2|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 2]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  116|       |
  117|      2|    std::size_t count = (p - buf);
  118|      2|    if (is_negative)
  ------------------
  |  Branch (118:9): [True: 0, False: 2]
  ------------------
  119|      0|    {
  120|      0|        result.push_back('-');
  121|      0|        ++count;
  122|      0|    }
  123|     19|    while (--p >= buf)
  ------------------
  |  Branch (123:12): [True: 17, False: 2]
  ------------------
  124|     17|    {
  125|     17|        result.push_back(*p);
  126|     17|    }
  127|       |
  128|      2|    return count;
  129|      2|}
_ZN8jsoncons16to_hex_characterEh:
   33|     17|{
   34|     17|    return (char)((c < 10) ? ('0' + c) : ('A' - 10 + c));
  ------------------
  |  Branch (34:19): [True: 16, False: 1]
  ------------------
   35|     17|}

_ZN8jsoncons4cbor6detail24min_length_for_stringrefEm:
   58|     88|{
   59|     88|    std::size_t n;
   60|     88|    if (index <= 23)
  ------------------
  |  Branch (60:9): [True: 88, False: 0]
  ------------------
   61|     88|    {
   62|     88|        n = 3;
   63|     88|    }
   64|      0|    else if (index <= 255)
  ------------------
  |  Branch (64:14): [True: 0, False: 0]
  ------------------
   65|      0|    {
   66|      0|        n = 4;
   67|      0|    }
   68|      0|    else if (index <= 65535)
  ------------------
  |  Branch (68:14): [True: 0, False: 0]
  ------------------
   69|      0|    {
   70|      0|        n = 5;
   71|      0|    }
   72|      0|    else if (index <= 4294967295)
  ------------------
  |  Branch (72:14): [True: 0, False: 0]
  ------------------
   73|      0|    {
   74|      0|        n = 7;
   75|      0|    }
   76|      0|    else 
   77|      0|    {
   78|      0|        n = 11;
   79|      0|    }
   80|     88|    return n;
   81|     88|}

_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEEC2EOS8_RKS9_:
  125|     18|       : basic_cbor_encoder(std::forward<Sink>(sink), cbor_encode_options(), alloc)
  126|     18|    {
  127|     18|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEEC2EOS8_RKNS0_19cbor_encode_optionsERKS9_:
  131|     18|       : sink_(std::forward<Sink>(sink)), 
  132|     18|         max_nesting_depth_(options.max_nesting_depth()), 
  133|     18|         pack_strings_(options.pack_strings()),
  134|     18|         use_typed_arrays_(options.use_typed_arrays()),
  135|     18|         alloc_(alloc),
  136|     18|         stack_(alloc),
  137|     18|         stringref_map_(alloc),
  138|     18|         bytestringref_map_(alloc)
  139|     18|    {
  140|     18|        if (options.pack_strings())
  ------------------
  |  Branch (140:13): [True: 0, False: 18]
  ------------------
  141|      0|        {
  142|      0|            write_tag(256);
  143|      0|        }
  144|     18|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9write_tagEm:
 1196|      9|    {
 1197|      9|        if (value <= 0x17)
  ------------------
  |  Branch (1197:13): [True: 6, False: 3]
  ------------------
 1198|      6|        {
 1199|      6|            sink_.push_back(0xc0 | static_cast<uint8_t>(value)); 
 1200|      6|        } 
 1201|      3|        else if (value <=(std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (1201:18): [True: 3, False: 0]
  ------------------
 1202|      3|        {
 1203|      3|            sink_.push_back(0xd8);
 1204|      3|            sink_.push_back(static_cast<uint8_t>(value));
 1205|      3|        } 
 1206|      0|        else if (value <=(std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (1206:18): [True: 0, False: 0]
  ------------------
 1207|      0|        {
 1208|      0|            sink_.push_back(0xd9);
 1209|      0|            binary::native_to_big(static_cast<uint16_t>(value), 
 1210|      0|                                            std::back_inserter(sink_));
 1211|      0|        }
 1212|      0|        else if (value <=(std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (1212:18): [True: 0, False: 0]
  ------------------
 1213|      0|        {
 1214|      0|            sink_.push_back(0xda);
 1215|      0|            binary::native_to_big(static_cast<uint32_t>(value), 
 1216|      0|                                            std::back_inserter(sink_));
 1217|      0|        }
 1218|      0|        else 
 1219|      0|        {
 1220|      0|            sink_.push_back(0xdb);
 1221|      0|            binary::native_to_big(static_cast<uint64_t>(value), 
 1222|      0|                                            std::back_inserter(sink_));
 1223|      0|        }
 1224|      9|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  366|    175|    {
  367|    175|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|    175|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 175]
  |  |  ------------------
  ------------------
  368|      0|        {
  369|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  370|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  371|      0|        } 
  372|    175|        stack_.emplace_back(cbor_container_type::array, length);
  373|    175|        if (length <= 0x17)
  ------------------
  |  Branch (373:13): [True: 168, False: 7]
  ------------------
  374|    168|        {
  375|    168|            binary::native_to_big(static_cast<uint8_t>(0x80 + length), 
  376|    168|                                  std::back_inserter(sink_));
  377|    168|        } 
  378|      7|        else if (length <= 0xff)
  ------------------
  |  Branch (378:18): [True: 0, False: 7]
  ------------------
  379|      0|        {
  380|      0|            binary::native_to_big(static_cast<uint8_t>(0x98), 
  381|      0|                                  std::back_inserter(sink_));
  382|      0|            binary::native_to_big(static_cast<uint8_t>(length), 
  383|      0|                                  std::back_inserter(sink_));
  384|      0|        } 
  385|      7|        else if (length <= 0xffff)
  ------------------
  |  Branch (385:18): [True: 4, False: 3]
  ------------------
  386|      4|        {
  387|      4|            binary::native_to_big(static_cast<uint8_t>(0x99), 
  388|      4|                                  std::back_inserter(sink_));
  389|      4|            binary::native_to_big(static_cast<uint16_t>(length), 
  390|      4|                                  std::back_inserter(sink_));
  391|      4|        } 
  392|      3|        else if (length <= 0xffffffff)
  ------------------
  |  Branch (392:18): [True: 3, False: 0]
  ------------------
  393|      3|        {
  394|      3|            binary::native_to_big(static_cast<uint8_t>(0x9a), 
  395|      3|                                  std::back_inserter(sink_));
  396|      3|            binary::native_to_big(static_cast<uint32_t>(length), 
  397|      3|                                  std::back_inserter(sink_));
  398|      3|        } 
  399|      0|        else if (uint64_t(length) <= (std::numeric_limits<std::uint64_t>::max)())
  ------------------
  |  Branch (399:18): [True: 0, False: 0]
  ------------------
  400|      0|        {
  401|      0|            binary::native_to_big(static_cast<uint8_t>(0x9b), 
  402|      0|                                  std::back_inserter(sink_));
  403|      0|            binary::native_to_big(static_cast<uint64_t>(length), 
  404|      0|                                  std::back_inserter(sink_));
  405|      0|        }
  406|    175|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    175|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  407|    175|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_itemC2ENS0_19cbor_container_typeEm:
   74|    192|           : type_(type), length_(length)
   75|    192|        {
   76|    192|        }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE15visit_end_arrayERKNS_11ser_contextERNS3_10error_codeE:
  410|    172|    {
  411|    172|        JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   45|    172|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 172]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  412|    172|        --nesting_depth_;
  413|       |
  414|    172|        if (stack_.back().is_indefinite_length())
  ------------------
  |  Branch (414:13): [True: 0, False: 172]
  ------------------
  415|      0|        {
  416|      0|            sink_.push_back(0xff);
  417|      0|        }
  418|    172|        else
  419|    172|        {
  420|    172|            if (stack_.back().count() < stack_.back().length())
  ------------------
  |  Branch (420:17): [True: 0, False: 172]
  ------------------
  421|      0|            {
  422|      0|                ec = cbor_errc::too_few_items;
  423|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  424|      0|            }
  425|    172|            if (stack_.back().count() > stack_.back().length())
  ------------------
  |  Branch (425:17): [True: 0, False: 172]
  ------------------
  426|      0|            {
  427|      0|                ec = cbor_errc::too_many_items;
  428|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  429|      0|            }
  430|    172|        }
  431|       |
  432|    172|        stack_.pop_back();
  433|    172|        end_value();
  434|       |
  435|    172|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    172|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  436|    172|    }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item20is_indefinite_lengthEv:
   96|    175|        {
   97|    175|            return type_ == cbor_container_type::indefinite_length_array || type_ == cbor_container_type::indefinite_length_object;
  ------------------
  |  Branch (97:20): [True: 0, False: 175]
  |  Branch (97:77): [True: 0, False: 175]
  ------------------
   98|    175|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item5countEv:
   86|    350|        {
   87|    350|            return is_object() ? index_/2 : index_;
  ------------------
  |  Branch (87:20): [True: 6, False: 344]
  ------------------
   88|    350|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item9is_objectEv:
   91|    350|        {
   92|    350|            return type_ == cbor_container_type::object || type_ == cbor_container_type::indefinite_length_object;
  ------------------
  |  Branch (92:20): [True: 6, False: 344]
  |  Branch (92:60): [True: 0, False: 344]
  ------------------
   93|    350|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item6lengthEv:
   81|    350|        {
   82|    350|            return length_;
   83|    350|        }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9end_valueEv:
 1828|  3.14M|    {
 1829|  3.14M|        if (!stack_.empty())
  ------------------
  |  Branch (1829:13): [True: 3.14M, False: 7]
  ------------------
 1830|  3.14M|        {
 1831|  3.14M|            ++stack_.back().index_;
 1832|  3.14M|        }
 1833|  3.14M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1177|  2.01M|    {
 1178|  2.01M|        switch (tag)
 1179|  2.01M|        {
 1180|      0|            case semantic_tag::epoch_milli:
  ------------------
  |  Branch (1180:13): [True: 0, False: 2.01M]
  ------------------
 1181|      0|            case semantic_tag::epoch_nano:
  ------------------
  |  Branch (1181:13): [True: 0, False: 2.01M]
  ------------------
 1182|      0|                return visit_double(static_cast<double>(value), tag, context, ec);
 1183|      0|            case semantic_tag::epoch_second:
  ------------------
  |  Branch (1183:13): [True: 0, False: 2.01M]
  ------------------
 1184|      0|                write_tag(1);
 1185|      0|                break;
 1186|  2.01M|            default:
  ------------------
  |  Branch (1186:13): [True: 2.01M, False: 0]
  ------------------
 1187|  2.01M|                break;
 1188|  2.01M|        }
 1189|       |
 1190|  2.01M|        write_uint64_value(value);
 1191|  2.01M|        end_value();
 1192|  2.01M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  2.01M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1193|  2.01M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18write_uint64_valueEm:
 1227|  2.01M|    {
 1228|  2.01M|        if (value <= 0x17)
  ------------------
  |  Branch (1228:13): [True: 2.01M, False: 0]
  ------------------
 1229|  2.01M|        {
 1230|  2.01M|            sink_.push_back(static_cast<uint8_t>(value));
 1231|  2.01M|        } 
 1232|      0|        else if (value <=(std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (1232:18): [True: 0, False: 0]
  ------------------
 1233|      0|        {
 1234|      0|            sink_.push_back(static_cast<uint8_t>(0x18));
 1235|      0|            sink_.push_back(static_cast<uint8_t>(value));
 1236|      0|        } 
 1237|      0|        else if (value <=(std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (1237:18): [True: 0, False: 0]
  ------------------
 1238|      0|        {
 1239|      0|            sink_.push_back(static_cast<uint8_t>(0x19));
 1240|      0|            binary::native_to_big(static_cast<uint16_t>(value), 
 1241|      0|                                            std::back_inserter(sink_));
 1242|      0|        } 
 1243|      0|        else if (value <=(std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (1243:18): [True: 0, False: 0]
  ------------------
 1244|      0|        {
 1245|      0|            sink_.push_back(static_cast<uint8_t>(0x1a));
 1246|      0|            binary::native_to_big(static_cast<uint32_t>(value), 
 1247|      0|                                            std::back_inserter(sink_));
 1248|      0|        } 
 1249|      0|        else if (value <=(std::numeric_limits<uint64_t>::max)())
  ------------------
  |  Branch (1249:18): [True: 0, False: 0]
  ------------------
 1250|      0|        {
 1251|      0|            sink_.push_back(static_cast<uint8_t>(0x1b));
 1252|      0|            binary::native_to_big(static_cast<uint64_t>(value), 
 1253|      0|                                            std::back_inserter(sink_));
 1254|      0|        }
 1255|  2.01M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1156|     23|    {
 1157|     23|        switch (tag)
 1158|     23|        {
 1159|      0|            case semantic_tag::epoch_milli:
  ------------------
  |  Branch (1159:13): [True: 0, False: 23]
  ------------------
 1160|      0|            case semantic_tag::epoch_nano:
  ------------------
  |  Branch (1160:13): [True: 0, False: 23]
  ------------------
 1161|      0|                return visit_double(static_cast<double>(value), tag, context, ec);
 1162|      0|            case semantic_tag::epoch_second:
  ------------------
  |  Branch (1162:13): [True: 0, False: 23]
  ------------------
 1163|      0|                write_tag(1);
 1164|      0|                break;
 1165|     23|            default:
  ------------------
  |  Branch (1165:13): [True: 23, False: 0]
  ------------------
 1166|     23|                break;
 1167|     23|        }
 1168|     23|        write_int64_value(value);
 1169|     23|        end_value();
 1170|     23|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     23|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1171|     23|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17write_int64_valueEl:
 1258|     23|    {
 1259|     23|        if (value >= 0)
  ------------------
  |  Branch (1259:13): [True: 5, False: 18]
  ------------------
 1260|      5|        {
 1261|      5|            if (value <= 0x17)
  ------------------
  |  Branch (1261:17): [True: 5, False: 0]
  ------------------
 1262|      5|            {
 1263|      5|                binary::native_to_big(static_cast<uint8_t>(value), 
 1264|      5|                                  std::back_inserter(sink_));
 1265|      5|            } 
 1266|      0|            else if (value <= (std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (1266:22): [True: 0, False: 0]
  ------------------
 1267|      0|            {
 1268|      0|                binary::native_to_big(static_cast<uint8_t>(0x18), 
 1269|      0|                                  std::back_inserter(sink_));
 1270|      0|                binary::native_to_big(static_cast<uint8_t>(value), 
 1271|      0|                                  std::back_inserter(sink_));
 1272|      0|            } 
 1273|      0|            else if (value <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (1273:22): [True: 0, False: 0]
  ------------------
 1274|      0|            {
 1275|      0|                binary::native_to_big(static_cast<uint8_t>(0x19), 
 1276|      0|                                  std::back_inserter(sink_));
 1277|      0|                binary::native_to_big(static_cast<uint16_t>(value), 
 1278|      0|                                  std::back_inserter(sink_));
 1279|      0|            } 
 1280|      0|            else if (value <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (1280:22): [True: 0, False: 0]
  ------------------
 1281|      0|            {
 1282|      0|                binary::native_to_big(static_cast<uint8_t>(0x1a), 
 1283|      0|                                  std::back_inserter(sink_));
 1284|      0|                binary::native_to_big(static_cast<uint32_t>(value), 
 1285|      0|                                  std::back_inserter(sink_));
 1286|      0|            } 
 1287|      0|            else if (value <= (std::numeric_limits<int64_t>::max)())
  ------------------
  |  Branch (1287:22): [True: 0, False: 0]
  ------------------
 1288|      0|            {
 1289|      0|                binary::native_to_big(static_cast<uint8_t>(0x1b), 
 1290|      0|                                  std::back_inserter(sink_));
 1291|      0|                binary::native_to_big(static_cast<int64_t>(value), 
 1292|      0|                                  std::back_inserter(sink_));
 1293|      0|            }
 1294|      5|        } else
 1295|     18|        {
 1296|     18|            const auto posnum = -1 - value;
 1297|     18|            if (value >= -24)
  ------------------
  |  Branch (1297:17): [True: 13, False: 5]
  ------------------
 1298|     13|            {
 1299|     13|                binary::native_to_big(static_cast<uint8_t>(0x20 + posnum), 
 1300|     13|                                  std::back_inserter(sink_));
 1301|     13|            } 
 1302|      5|            else if (posnum <= (std::numeric_limits<uint8_t>::max)())
  ------------------
  |  Branch (1302:22): [True: 0, False: 5]
  ------------------
 1303|      0|            {
 1304|      0|                binary::native_to_big(static_cast<uint8_t>(0x38), 
 1305|      0|                                  std::back_inserter(sink_));
 1306|      0|                binary::native_to_big(static_cast<uint8_t>(posnum), 
 1307|      0|                                  std::back_inserter(sink_));
 1308|      0|            } 
 1309|      5|            else if (posnum <= (std::numeric_limits<uint16_t>::max)())
  ------------------
  |  Branch (1309:22): [True: 0, False: 5]
  ------------------
 1310|      0|            {
 1311|      0|                binary::native_to_big(static_cast<uint8_t>(0x39), 
 1312|      0|                                  std::back_inserter(sink_));
 1313|      0|                binary::native_to_big(static_cast<uint16_t>(posnum), 
 1314|      0|                                  std::back_inserter(sink_));
 1315|      0|            } 
 1316|      5|            else if (posnum <= (std::numeric_limits<uint32_t>::max)())
  ------------------
  |  Branch (1316:22): [True: 0, False: 5]
  ------------------
 1317|      0|            {
 1318|      0|                binary::native_to_big(static_cast<uint8_t>(0x3a), 
 1319|      0|                                  std::back_inserter(sink_));
 1320|      0|                binary::native_to_big(static_cast<uint32_t>(posnum), 
 1321|      0|                                  std::back_inserter(sink_));
 1322|      0|            } 
 1323|      5|            else if (posnum <= (std::numeric_limits<int64_t>::max)())
  ------------------
  |  Branch (1323:22): [True: 5, False: 0]
  ------------------
 1324|      5|            {
 1325|      5|                binary::native_to_big(static_cast<uint8_t>(0x3b), 
 1326|      5|                                  std::back_inserter(sink_));
 1327|      5|                binary::native_to_big(static_cast<int64_t>(posnum), 
 1328|      5|                                  std::back_inserter(sink_));
 1329|      5|            }
 1330|     18|        }
 1331|     23|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1108|      4|    {
 1109|      4|        switch (tag)
 1110|      4|        {
 1111|      0|            case semantic_tag::epoch_second:
  ------------------
  |  Branch (1111:13): [True: 0, False: 4]
  ------------------
 1112|      0|                write_tag(1);
 1113|      0|                break;
 1114|      0|            case semantic_tag::epoch_milli:
  ------------------
  |  Branch (1114:13): [True: 0, False: 4]
  ------------------
 1115|      0|                write_tag(1);
 1116|      0|                if (val != 0)
  ------------------
  |  Branch (1116:21): [True: 0, False: 0]
  ------------------
 1117|      0|                {
 1118|      0|                    val /= millis_in_second;
 1119|      0|                }
 1120|      0|                break;
 1121|      0|            case semantic_tag::epoch_nano:
  ------------------
  |  Branch (1121:13): [True: 0, False: 4]
  ------------------
 1122|      0|                write_tag(1);
 1123|      0|                if (val != 0)
  ------------------
  |  Branch (1123:21): [True: 0, False: 0]
  ------------------
 1124|      0|                {
 1125|      0|                    val /= nanos_in_second;
 1126|      0|                }
 1127|      0|                break;
 1128|      4|            default:
  ------------------
  |  Branch (1128:13): [True: 4, False: 0]
  ------------------
 1129|      4|                break;
 1130|      4|        }
 1131|       |
 1132|      4|        float valf = (float)val;
 1133|      4|        if ((double)valf == val)
  ------------------
  |  Branch (1133:13): [True: 2, False: 2]
  ------------------
 1134|      2|        {
 1135|      2|            binary::native_to_big(static_cast<uint8_t>(0xfa), 
 1136|      2|                                  std::back_inserter(sink_));
 1137|      2|            binary::native_to_big(valf, std::back_inserter(sink_));
 1138|      2|        }
 1139|      2|        else
 1140|      2|        {
 1141|      2|            binary::native_to_big(static_cast<uint8_t>(0xfb), 
 1142|      2|                                  std::back_inserter(sink_));
 1143|      2|            binary::native_to_big(val, std::back_inserter(sink_));
 1144|      2|        }
 1145|       |
 1146|       |        // write double
 1147|       |
 1148|      4|        end_value();
 1149|      4|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      4|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1150|      4|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE11visit_flushEv:
  261|     10|    {
  262|     10|        sink_.flush();
  263|     10|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  266|      5|    {
  267|      5|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
  268|      0|        {
  269|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  270|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  271|      0|        } 
  272|      5|        stack_.emplace_back(cbor_container_type::indefinite_length_object);
  273|       |        
  274|      5|        sink_.push_back(0xbf);
  275|      5|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      5|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  276|      5|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  279|      6|    {
  280|      6|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|      6|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 6]
  |  |  ------------------
  ------------------
  281|      0|        {
  282|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  283|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  284|      0|        } 
  285|      6|        stack_.emplace_back(cbor_container_type::object, length);
  286|       |
  287|      6|        if (length <= 0x17)
  ------------------
  |  Branch (287:13): [True: 6, False: 0]
  ------------------
  288|      6|        {
  289|      6|            binary::native_to_big(static_cast<uint8_t>(0xa0 + length), 
  290|      6|                                  std::back_inserter(sink_));
  291|      6|        } 
  292|      0|        else if (length <= 0xff)
  ------------------
  |  Branch (292:18): [True: 0, False: 0]
  ------------------
  293|      0|        {
  294|      0|            binary::native_to_big(static_cast<uint8_t>(0xb8), 
  295|      0|                                  std::back_inserter(sink_));
  296|      0|            binary::native_to_big(static_cast<uint8_t>(length), 
  297|      0|                                  std::back_inserter(sink_));
  298|      0|        } 
  299|      0|        else if (length <= 0xffff)
  ------------------
  |  Branch (299:18): [True: 0, False: 0]
  ------------------
  300|      0|        {
  301|      0|            binary::native_to_big(static_cast<uint8_t>(0xb9), 
  302|      0|                                  std::back_inserter(sink_));
  303|      0|            binary::native_to_big(static_cast<uint16_t>(length), 
  304|      0|                                  std::back_inserter(sink_));
  305|      0|        } 
  306|      0|        else if (length <= 0xffffffff)
  ------------------
  |  Branch (306:18): [True: 0, False: 0]
  ------------------
  307|      0|        {
  308|      0|            binary::native_to_big(static_cast<uint8_t>(0xba), 
  309|      0|                                  std::back_inserter(sink_));
  310|      0|            binary::native_to_big(static_cast<uint32_t>(length), 
  311|      0|                                  std::back_inserter(sink_));
  312|      0|        } 
  313|      0|        else if (uint64_t(length) <= (std::numeric_limits<std::uint64_t>::max)())
  ------------------
  |  Branch (313:18): [True: 0, False: 0]
  ------------------
  314|      0|        {
  315|      0|            binary::native_to_big(static_cast<uint8_t>(0xbb), 
  316|      0|                                  std::back_inserter(sink_));
  317|      0|            binary::native_to_big(static_cast<uint64_t>(length), 
  318|      0|                                  std::back_inserter(sink_));
  319|      0|        }
  320|       |
  321|      6|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  322|      6|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE16visit_end_objectERKNS_11ser_contextERNS3_10error_codeE:
  325|      3|    {
  326|      3|        JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   45|      3|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 3]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  327|      3|        --nesting_depth_;
  328|       |
  329|      3|        if (stack_.back().is_indefinite_length())
  ------------------
  |  Branch (329:13): [True: 0, False: 3]
  ------------------
  330|      0|        {
  331|      0|            sink_.push_back(0xff);
  332|      0|        }
  333|      3|        else
  334|      3|        {
  335|      3|            if (stack_.back().count() < stack_.back().length())
  ------------------
  |  Branch (335:17): [True: 0, False: 3]
  ------------------
  336|      0|            {
  337|      0|                ec = cbor_errc::too_few_items;
  338|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  339|      0|            }
  340|      3|            if (stack_.back().count() > stack_.back().length())
  ------------------
  |  Branch (340:17): [True: 0, False: 3]
  ------------------
  341|      0|            {
  342|      0|                ec = cbor_errc::too_many_items;
  343|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  344|      0|            }
  345|      3|        }
  346|       |
  347|      3|        stack_.pop_back();
  348|      3|        end_value();
  349|       |
  350|      3|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  351|      3|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  354|      6|    {
  355|      6|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|      6|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 6]
  |  |  ------------------
  ------------------
  356|      0|        {
  357|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  358|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  359|      0|        } 
  360|      6|        stack_.emplace_back(cbor_container_type::indefinite_length_array);
  361|      6|        sink_.push_back(0x9f);
  362|      6|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  363|      6|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9visit_keyERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKNS_11ser_contextERNS3_10error_codeE:
  439|  1.13M|    {
  440|  1.13M|        visit_string(name, semantic_tag::none, context, ec);
  441|  1.13M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  1.13M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  442|  1.13M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  445|     15|    {
  446|     15|        if (tag == semantic_tag::undefined)
  ------------------
  |  Branch (446:13): [True: 12, False: 3]
  ------------------
  447|     12|        {
  448|     12|            sink_.push_back(0xf7);
  449|     12|        }
  450|      3|        else
  451|      3|        {
  452|      3|            sink_.push_back(0xf6);
  453|      3|        }
  454|       |
  455|     15|        end_value();
  456|     15|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|     15|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  457|     15|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1334|      7|    {
 1335|      7|        if (value)
  ------------------
  |  Branch (1335:13): [True: 7, False: 0]
  ------------------
 1336|      7|        {
 1337|      7|            sink_.push_back(0xf5);
 1338|      7|        }
 1339|      0|        else
 1340|      0|        {
 1341|      0|            sink_.push_back(0xf4);
 1342|      0|        }
 1343|       |
 1344|      7|        end_value();
 1345|      7|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      7|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1346|      7|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  912|  1.13M|    {
  913|  1.13M|        switch (tag)
  914|  1.13M|        {
  915|      0|            case semantic_tag::bigint:
  ------------------
  |  Branch (915:13): [True: 0, False: 1.13M]
  ------------------
  916|      0|            {
  917|      0|                bigint n(sv.data(), sv.length());
  918|      0|                write_bignum(n);
  919|      0|                end_value();
  920|      0|                break;
  921|      0|            }
  922|      5|            case semantic_tag::bigdec:
  ------------------
  |  Branch (922:13): [True: 5, False: 1.13M]
  ------------------
  923|      5|            {
  924|      5|                write_decimal_value(sv, context, ec);
  925|      5|                break;
  926|      0|            }
  927|      1|            case semantic_tag::bigfloat:
  ------------------
  |  Branch (927:13): [True: 1, False: 1.13M]
  ------------------
  928|      1|            {
  929|      1|                write_hexfloat_value(sv, context, ec);
  930|      1|                break;
  931|      0|            }
  932|      0|            case semantic_tag::datetime:
  ------------------
  |  Branch (932:13): [True: 0, False: 1.13M]
  ------------------
  933|      0|            {
  934|      0|                write_tag(0);
  935|       |
  936|      0|                write_string(sv);
  937|      0|                end_value();
  938|      0|                break;
  939|      0|            }
  940|      0|            case semantic_tag::uri:
  ------------------
  |  Branch (940:13): [True: 0, False: 1.13M]
  ------------------
  941|      0|            {
  942|      0|                write_tag(32);
  943|      0|                write_string(sv);
  944|      0|                end_value();
  945|      0|                break;
  946|      0|            }
  947|      0|            case semantic_tag::base64url:
  ------------------
  |  Branch (947:13): [True: 0, False: 1.13M]
  ------------------
  948|      0|            {
  949|      0|                write_tag(33);
  950|      0|                write_string(sv);
  951|      0|                end_value();
  952|      0|                break;
  953|      0|            }
  954|      0|            case semantic_tag::base64:
  ------------------
  |  Branch (954:13): [True: 0, False: 1.13M]
  ------------------
  955|      0|            {
  956|      0|                write_tag(34);
  957|      0|                write_string(sv);
  958|      0|                end_value();
  959|      0|                break;
  960|      0|            }
  961|  1.13M|            default:
  ------------------
  |  Branch (961:13): [True: 1.13M, False: 6]
  ------------------
  962|  1.13M|            {
  963|  1.13M|                write_string(sv);
  964|  1.13M|                end_value();
  965|  1.13M|                break;
  966|      0|            }
  967|  1.13M|        }
  968|  1.13M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|  1.13M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  969|  1.13M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE19write_decimal_valueERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKNS_11ser_contextERNS3_10error_codeE:
  597|      5|    {
  598|      5|        decimal_parse_state state = decimal_parse_state::start;
  599|      5|        std::basic_string<char> s;
  600|      5|        std::basic_string<char> exponent;
  601|      5|        int64_t scale = 0;
  602|      5|        for (auto c : sv)
  ------------------
  |  Branch (602:21): [True: 85, False: 5]
  ------------------
  603|     85|        {
  604|     85|            switch (state)
  ------------------
  |  Branch (604:21): [True: 85, False: 0]
  ------------------
  605|     85|            {
  606|      5|                case decimal_parse_state::start:
  ------------------
  |  Branch (606:17): [True: 5, False: 80]
  ------------------
  607|      5|                {
  608|      5|                    switch (c)
  609|      5|                    {
  610|      4|                        case '-':
  ------------------
  |  Branch (610:25): [True: 4, False: 1]
  ------------------
  611|      5|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (611:25): [True: 1, False: 4]
  |  Branch (611:34): [True: 0, False: 5]
  |  Branch (611:43): [True: 0, False: 5]
  |  Branch (611:52): [True: 0, False: 5]
  |  Branch (611:61): [True: 0, False: 5]
  |  Branch (611:70): [True: 0, False: 5]
  |  Branch (611:79): [True: 0, False: 5]
  |  Branch (611:88): [True: 0, False: 5]
  |  Branch (611:97): [True: 0, False: 5]
  |  Branch (611:107): [True: 0, False: 5]
  ------------------
  612|      5|                            s.push_back(c);
  613|      5|                            state = decimal_parse_state::integer;
  614|      5|                            break;
  615|      0|                        default:
  ------------------
  |  Branch (615:25): [True: 0, False: 5]
  ------------------
  616|      0|                        {
  617|      0|                            ec = cbor_errc::invalid_decimal_fraction;
  618|      0|                            return;
  619|      5|                        }
  620|      5|                    }
  621|      5|                    break;
  622|      5|                }
  623|     73|                case decimal_parse_state::integer:
  ------------------
  |  Branch (623:17): [True: 73, False: 12]
  ------------------
  624|     73|                {
  625|     73|                    switch (c)
  626|     73|                    {
  627|     68|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (627:25): [True: 64, False: 9]
  |  Branch (627:34): [True: 0, False: 73]
  |  Branch (627:43): [True: 0, False: 73]
  |  Branch (627:52): [True: 4, False: 69]
  |  Branch (627:61): [True: 0, False: 73]
  |  Branch (627:70): [True: 0, False: 73]
  |  Branch (627:79): [True: 0, False: 73]
  |  Branch (627:88): [True: 0, False: 73]
  |  Branch (627:97): [True: 0, False: 73]
  |  Branch (627:107): [True: 0, False: 73]
  ------------------
  628|     68|                            s.push_back(c);
  629|     68|                            break;
  630|      1|                        case 'e': case 'E':
  ------------------
  |  Branch (630:25): [True: 1, False: 72]
  |  Branch (630:35): [True: 0, False: 73]
  ------------------
  631|      1|                            state = decimal_parse_state::exp1;
  632|      1|                            break;
  633|      4|                        case '.':
  ------------------
  |  Branch (633:25): [True: 4, False: 69]
  ------------------
  634|      4|                            state = decimal_parse_state::fraction1;
  635|      4|                            break;
  636|      0|                        default:
  ------------------
  |  Branch (636:25): [True: 0, False: 73]
  ------------------
  637|      0|                        {
  638|      0|                            ec = cbor_errc::invalid_decimal_fraction;
  639|      0|                            return;
  640|      1|                        }
  641|     73|                    }
  642|     73|                    break;
  643|     73|                }
  644|     73|                case decimal_parse_state::exp1:
  ------------------
  |  Branch (644:17): [True: 1, False: 84]
  ------------------
  645|      1|                {
  646|      1|                    switch (c)
  647|      1|                    {
  648|      0|                        case '+':
  ------------------
  |  Branch (648:25): [True: 0, False: 1]
  ------------------
  649|      0|                            state = decimal_parse_state::exp2;
  650|      0|                            break;
  651|      1|                        case '-':
  ------------------
  |  Branch (651:25): [True: 1, False: 0]
  ------------------
  652|      1|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (652:25): [True: 0, False: 1]
  |  Branch (652:34): [True: 0, False: 1]
  |  Branch (652:43): [True: 0, False: 1]
  |  Branch (652:52): [True: 0, False: 1]
  |  Branch (652:61): [True: 0, False: 1]
  |  Branch (652:70): [True: 0, False: 1]
  |  Branch (652:79): [True: 0, False: 1]
  |  Branch (652:88): [True: 0, False: 1]
  |  Branch (652:97): [True: 0, False: 1]
  |  Branch (652:107): [True: 0, False: 1]
  ------------------
  653|      1|                            exponent.push_back(c);
  654|      1|                            state = decimal_parse_state::exp2;
  655|      1|                            break;
  656|      0|                        default:
  ------------------
  |  Branch (656:25): [True: 0, False: 1]
  ------------------
  657|      0|                        {
  658|      0|                            ec = cbor_errc::invalid_decimal_fraction;
  659|      0|                            return;
  660|      1|                        }
  661|      1|                    }
  662|      1|                    break;
  663|      1|                }
  664|      2|                case decimal_parse_state::exp2:
  ------------------
  |  Branch (664:17): [True: 2, False: 83]
  ------------------
  665|      2|                {
  666|      2|                    switch (c)
  667|      2|                    {
  668|      2|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (668:25): [True: 0, False: 2]
  |  Branch (668:34): [True: 0, False: 2]
  |  Branch (668:43): [True: 2, False: 0]
  |  Branch (668:52): [True: 0, False: 2]
  |  Branch (668:61): [True: 0, False: 2]
  |  Branch (668:70): [True: 0, False: 2]
  |  Branch (668:79): [True: 0, False: 2]
  |  Branch (668:88): [True: 0, False: 2]
  |  Branch (668:97): [True: 0, False: 2]
  |  Branch (668:107): [True: 0, False: 2]
  ------------------
  669|      2|                            exponent.push_back(c);
  670|      2|                            break;
  671|      0|                        default:
  ------------------
  |  Branch (671:25): [True: 0, False: 2]
  ------------------
  672|      0|                        {
  673|      0|                            ec = cbor_errc::invalid_decimal_fraction;
  674|      0|                            return;
  675|      2|                        }
  676|      2|                    }
  677|      2|                    break;
  678|      2|                }
  679|      4|                case decimal_parse_state::fraction1:
  ------------------
  |  Branch (679:17): [True: 4, False: 81]
  ------------------
  680|      4|                {
  681|      4|                    switch (c)
  682|      4|                    {
  683|      4|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (683:25): [True: 4, False: 0]
  |  Branch (683:34): [True: 0, False: 4]
  |  Branch (683:43): [True: 0, False: 4]
  |  Branch (683:52): [True: 0, False: 4]
  |  Branch (683:61): [True: 0, False: 4]
  |  Branch (683:70): [True: 0, False: 4]
  |  Branch (683:79): [True: 0, False: 4]
  |  Branch (683:88): [True: 0, False: 4]
  |  Branch (683:97): [True: 0, False: 4]
  |  Branch (683:107): [True: 0, False: 4]
  ------------------
  684|      4|                            s.push_back(c);
  685|      4|                            --scale;
  686|      4|                            break;
  687|      0|                        default:
  ------------------
  |  Branch (687:25): [True: 0, False: 4]
  ------------------
  688|      0|                        {
  689|      0|                            ec = cbor_errc::invalid_decimal_fraction;
  690|      0|                            return;
  691|      4|                        }
  692|      4|                    }
  693|      4|                    break;
  694|      4|                }
  695|     85|            }
  696|     85|        }
  697|       |
  698|      5|        write_tag(4);
  699|      5|        visit_begin_array((std::size_t)2, semantic_tag::none, context, ec);
  700|      5|        if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
  701|      5|        if (exponent.length() > 0)
  ------------------
  |  Branch (701:13): [True: 1, False: 4]
  ------------------
  702|      1|        {
  703|      1|            int64_t val{};
  704|      1|            auto r = jsoncons::to_integer(exponent.data(), exponent.length(), val);
  705|      1|            if (!r)
  ------------------
  |  Branch (705:17): [True: 0, False: 1]
  ------------------
  706|      0|            {
  707|      0|                ec = r.error_code();
  708|      0|                return;
  709|      0|            }
  710|      1|            scale += val;
  711|      1|        }
  712|      5|        visit_int64(scale, semantic_tag::none, context, ec);
  713|      5|        if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
  714|       |
  715|      5|        int64_t val{ 0 };
  716|      5|        auto r = jsoncons::to_integer(s.data(),s.length(), val);
  717|      5|        if (r)
  ------------------
  |  Branch (717:13): [True: 5, False: 0]
  ------------------
  718|      5|        {
  719|      5|            visit_int64(val, semantic_tag::none, context, ec);
  720|      5|            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
  721|      5|        }
  722|      0|        else if (r.error_code() == std::errc::result_out_of_range)
  ------------------
  |  Branch (722:18): [True: 0, False: 0]
  ------------------
  723|      0|        {
  724|      0|            bigint n(s.data(), s.length());
  725|      0|            write_bignum(n);
  726|      0|            end_value();
  727|      0|        }
  728|      0|        else
  729|      0|        {
  730|      0|            ec = r.error_code();
  731|      0|            return;
  732|      0|        }
  733|      5|        visit_end_array(context, ec);
  734|      5|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE20write_hexfloat_valueERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKNS_11ser_contextERNS3_10error_codeE:
  737|      1|    {
  738|      1|        hexfloat_parse_state state = hexfloat_parse_state::start;
  739|      1|        std::basic_string<char> s;
  740|      1|        std::basic_string<char> exponent;
  741|      1|        int64_t scale = 0;
  742|       |
  743|      1|        for (auto c : sv)
  ------------------
  |  Branch (743:21): [True: 22, False: 1]
  ------------------
  744|     22|        {
  745|     22|            switch (state)
  ------------------
  |  Branch (745:21): [True: 22, False: 0]
  ------------------
  746|     22|            {
  747|      1|                case hexfloat_parse_state::start:
  ------------------
  |  Branch (747:17): [True: 1, False: 21]
  ------------------
  748|      1|                {
  749|      1|                    switch (c)
  750|      1|                    {
  751|      1|                        case '-':
  ------------------
  |  Branch (751:25): [True: 1, False: 0]
  ------------------
  752|      1|                            s.push_back(c);
  753|      1|                            state = hexfloat_parse_state::expect_0;
  754|      1|                            break;
  755|      0|                        case '0':
  ------------------
  |  Branch (755:25): [True: 0, False: 1]
  ------------------
  756|      0|                            state = hexfloat_parse_state::expect_x;
  757|      0|                            break;
  758|      0|                        default:
  ------------------
  |  Branch (758:25): [True: 0, False: 1]
  ------------------
  759|      0|                        {
  760|      0|                            ec = cbor_errc::invalid_bigfloat;
  761|      0|                            return;
  762|      0|                        }
  763|      1|                    }
  764|      1|                    break;
  765|      1|                }
  766|      1|                case hexfloat_parse_state::expect_0:
  ------------------
  |  Branch (766:17): [True: 1, False: 21]
  ------------------
  767|      1|                {
  768|      1|                    switch (c)
  769|      1|                    {
  770|      1|                        case '0':
  ------------------
  |  Branch (770:25): [True: 1, False: 0]
  ------------------
  771|      1|                            state = hexfloat_parse_state::expect_x;
  772|      1|                            break;
  773|      0|                        default:
  ------------------
  |  Branch (773:25): [True: 0, False: 1]
  ------------------
  774|      0|                        {
  775|      0|                            ec = cbor_errc::invalid_bigfloat;
  776|      0|                            return;
  777|      0|                        }
  778|      1|                    }
  779|      1|                    break;
  780|      1|                }
  781|      1|                case hexfloat_parse_state::expect_x:
  ------------------
  |  Branch (781:17): [True: 1, False: 21]
  ------------------
  782|      1|                {
  783|      1|                    switch (c)
  784|      1|                    {
  785|      1|                        case 'x':
  ------------------
  |  Branch (785:25): [True: 1, False: 0]
  ------------------
  786|      1|                        case 'X':
  ------------------
  |  Branch (786:25): [True: 0, False: 1]
  ------------------
  787|      1|                            state = hexfloat_parse_state::integer;
  788|      1|                            break;
  789|      0|                        default:
  ------------------
  |  Branch (789:25): [True: 0, False: 1]
  ------------------
  790|      0|                        {
  791|      0|                            ec = cbor_errc::invalid_bigfloat;
  792|      0|                            return;
  793|      1|                        }
  794|      1|                    }
  795|      1|                    break;
  796|      1|                }
  797|     17|                case hexfloat_parse_state::integer:
  ------------------
  |  Branch (797:17): [True: 17, False: 5]
  ------------------
  798|     17|                {
  799|     17|                    switch (c)
  800|     17|                    {
  801|     16|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':case 'a':case 'b':case 'c':case 'd':case 'e':case 'f':case 'A':case 'B':case 'C':case 'D':case 'E':case 'F':
  ------------------
  |  Branch (801:25): [True: 12, False: 5]
  |  Branch (801:34): [True: 1, False: 16]
  |  Branch (801:43): [True: 1, False: 16]
  |  Branch (801:52): [True: 0, False: 17]
  |  Branch (801:61): [True: 0, False: 17]
  |  Branch (801:70): [True: 0, False: 17]
  |  Branch (801:79): [True: 0, False: 17]
  |  Branch (801:88): [True: 2, False: 15]
  |  Branch (801:97): [True: 0, False: 17]
  |  Branch (801:107): [True: 0, False: 17]
  |  Branch (801:116): [True: 0, False: 17]
  |  Branch (801:125): [True: 0, False: 17]
  |  Branch (801:134): [True: 0, False: 17]
  |  Branch (801:143): [True: 0, False: 17]
  |  Branch (801:152): [True: 0, False: 17]
  |  Branch (801:161): [True: 0, False: 17]
  |  Branch (801:170): [True: 0, False: 17]
  |  Branch (801:179): [True: 0, False: 17]
  |  Branch (801:188): [True: 0, False: 17]
  |  Branch (801:197): [True: 0, False: 17]
  |  Branch (801:206): [True: 0, False: 17]
  |  Branch (801:215): [True: 0, False: 17]
  ------------------
  802|     16|                            s.push_back(c);
  803|     16|                            break;
  804|      1|                        case 'p': case 'P':
  ------------------
  |  Branch (804:25): [True: 1, False: 16]
  |  Branch (804:35): [True: 0, False: 17]
  ------------------
  805|      1|                            state = hexfloat_parse_state::exp1;
  806|      1|                            break;
  807|      0|                        case '.':
  ------------------
  |  Branch (807:25): [True: 0, False: 17]
  ------------------
  808|      0|                            state = hexfloat_parse_state::fraction1;
  809|      0|                            break;
  810|      0|                        default:
  ------------------
  |  Branch (810:25): [True: 0, False: 17]
  ------------------
  811|      0|                        {
  812|      0|                            ec = cbor_errc::invalid_bigfloat;
  813|      0|                            return;
  814|      1|                        }
  815|     17|                    }
  816|     17|                    break;
  817|     17|                }
  818|     17|                case hexfloat_parse_state::exp1:
  ------------------
  |  Branch (818:17): [True: 1, False: 21]
  ------------------
  819|      1|                {
  820|      1|                    switch (c)
  821|      1|                    {
  822|      0|                        case '+':
  ------------------
  |  Branch (822:25): [True: 0, False: 1]
  ------------------
  823|      0|                            state = hexfloat_parse_state::exp2;
  824|      0|                            break;
  825|      1|                        case '-':
  ------------------
  |  Branch (825:25): [True: 1, False: 0]
  ------------------
  826|      1|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':case 'a':case 'b':case 'c':case 'd':case 'e':case 'f':case 'A':case 'B':case 'C':case 'D':case 'E':case 'F':
  ------------------
  |  Branch (826:25): [True: 0, False: 1]
  |  Branch (826:34): [True: 0, False: 1]
  |  Branch (826:43): [True: 0, False: 1]
  |  Branch (826:52): [True: 0, False: 1]
  |  Branch (826:61): [True: 0, False: 1]
  |  Branch (826:70): [True: 0, False: 1]
  |  Branch (826:79): [True: 0, False: 1]
  |  Branch (826:88): [True: 0, False: 1]
  |  Branch (826:97): [True: 0, False: 1]
  |  Branch (826:107): [True: 0, False: 1]
  |  Branch (826:116): [True: 0, False: 1]
  |  Branch (826:125): [True: 0, False: 1]
  |  Branch (826:134): [True: 0, False: 1]
  |  Branch (826:143): [True: 0, False: 1]
  |  Branch (826:152): [True: 0, False: 1]
  |  Branch (826:161): [True: 0, False: 1]
  |  Branch (826:170): [True: 0, False: 1]
  |  Branch (826:179): [True: 0, False: 1]
  |  Branch (826:188): [True: 0, False: 1]
  |  Branch (826:197): [True: 0, False: 1]
  |  Branch (826:206): [True: 0, False: 1]
  |  Branch (826:215): [True: 0, False: 1]
  ------------------
  827|      1|                            exponent.push_back(c);
  828|      1|                            state = hexfloat_parse_state::exp2;
  829|      1|                            break;
  830|      0|                        default:
  ------------------
  |  Branch (830:25): [True: 0, False: 1]
  ------------------
  831|      0|                        {
  832|      0|                            ec = cbor_errc::invalid_bigfloat;
  833|      0|                            return;
  834|      1|                        }
  835|      1|                    }
  836|      1|                    break;
  837|      1|                }
  838|      1|                case hexfloat_parse_state::exp2:
  ------------------
  |  Branch (838:17): [True: 1, False: 21]
  ------------------
  839|      1|                {
  840|      1|                    switch (c)
  841|      1|                    {
  842|      1|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':case 'a':case 'b':case 'c':case 'd':case 'e':case 'f':case 'A':case 'B':case 'C':case 'D':case 'E':case 'F':
  ------------------
  |  Branch (842:25): [True: 0, False: 1]
  |  Branch (842:34): [True: 0, False: 1]
  |  Branch (842:43): [True: 0, False: 1]
  |  Branch (842:52): [True: 0, False: 1]
  |  Branch (842:61): [True: 0, False: 1]
  |  Branch (842:70): [True: 0, False: 1]
  |  Branch (842:79): [True: 0, False: 1]
  |  Branch (842:88): [True: 0, False: 1]
  |  Branch (842:97): [True: 0, False: 1]
  |  Branch (842:107): [True: 0, False: 1]
  |  Branch (842:116): [True: 0, False: 1]
  |  Branch (842:125): [True: 0, False: 1]
  |  Branch (842:134): [True: 0, False: 1]
  |  Branch (842:143): [True: 0, False: 1]
  |  Branch (842:152): [True: 0, False: 1]
  |  Branch (842:161): [True: 0, False: 1]
  |  Branch (842:170): [True: 0, False: 1]
  |  Branch (842:179): [True: 0, False: 1]
  |  Branch (842:188): [True: 0, False: 1]
  |  Branch (842:197): [True: 0, False: 1]
  |  Branch (842:206): [True: 0, False: 1]
  |  Branch (842:215): [True: 1, False: 0]
  ------------------
  843|      1|                            exponent.push_back(c);
  844|      1|                            break;
  845|      0|                        default:
  ------------------
  |  Branch (845:25): [True: 0, False: 1]
  ------------------
  846|      0|                        {
  847|      0|                            ec = cbor_errc::invalid_bigfloat;
  848|      0|                            return;
  849|      0|                        }
  850|      1|                    }
  851|      1|                    break;
  852|      1|                }
  853|      1|                case hexfloat_parse_state::fraction1:
  ------------------
  |  Branch (853:17): [True: 0, False: 22]
  ------------------
  854|      0|                {
  855|      0|                    switch (c)
  856|      0|                    {
  857|      0|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':case 'a':case 'b':case 'c':case 'd':case 'e':case 'f':case 'A':case 'B':case 'C':case 'D':case 'E':case 'F':
  ------------------
  |  Branch (857:25): [True: 0, False: 0]
  |  Branch (857:34): [True: 0, False: 0]
  |  Branch (857:43): [True: 0, False: 0]
  |  Branch (857:52): [True: 0, False: 0]
  |  Branch (857:61): [True: 0, False: 0]
  |  Branch (857:70): [True: 0, False: 0]
  |  Branch (857:79): [True: 0, False: 0]
  |  Branch (857:88): [True: 0, False: 0]
  |  Branch (857:97): [True: 0, False: 0]
  |  Branch (857:107): [True: 0, False: 0]
  |  Branch (857:116): [True: 0, False: 0]
  |  Branch (857:125): [True: 0, False: 0]
  |  Branch (857:134): [True: 0, False: 0]
  |  Branch (857:143): [True: 0, False: 0]
  |  Branch (857:152): [True: 0, False: 0]
  |  Branch (857:161): [True: 0, False: 0]
  |  Branch (857:170): [True: 0, False: 0]
  |  Branch (857:179): [True: 0, False: 0]
  |  Branch (857:188): [True: 0, False: 0]
  |  Branch (857:197): [True: 0, False: 0]
  |  Branch (857:206): [True: 0, False: 0]
  |  Branch (857:215): [True: 0, False: 0]
  ------------------
  858|      0|                            s.push_back(c);
  859|      0|                            scale -= 4;
  860|      0|                            break;
  861|      0|                        default:
  ------------------
  |  Branch (861:25): [True: 0, False: 0]
  ------------------
  862|      0|                        {
  863|      0|                            ec = cbor_errc::invalid_bigfloat;
  864|      0|                            return;
  865|      0|                        }
  866|      0|                    }
  867|      0|                    break;
  868|      0|                }
  869|     22|            }
  870|     22|        }
  871|       |
  872|      1|        write_tag(5);
  873|      1|        visit_begin_array((std::size_t)2, semantic_tag::none, context, ec);
  874|      1|        if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  875|       |
  876|      1|        if (exponent.length() > 0)
  ------------------
  |  Branch (876:13): [True: 1, False: 0]
  ------------------
  877|      1|        {
  878|      1|            int64_t val{ 0 };
  879|      1|            auto r = jsoncons::hex_to_integer(exponent.data(), exponent.length(), val);
  880|      1|            if (!r)
  ------------------
  |  Branch (880:17): [True: 0, False: 1]
  ------------------
  881|      0|            {
  882|      0|                ec = r.error_code();
  883|      0|                return;
  884|      0|            }
  885|      1|            scale += val;
  886|      1|        }
  887|      1|        visit_int64(scale, semantic_tag::none, context, ec);
  888|      1|        if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  889|       |
  890|      1|        int64_t val{ 0 };
  891|      1|        auto r = jsoncons::hex_to_integer(s.data(),s.length(), val);
  892|      1|        if (r)
  ------------------
  |  Branch (892:13): [True: 1, False: 0]
  ------------------
  893|      1|        {
  894|      1|            visit_int64(val, semantic_tag::none, context, ec);
  895|      1|            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  896|      1|        }
  897|      0|        else if (r.error_code() == std::errc::result_out_of_range)
  ------------------
  |  Branch (897:18): [True: 0, False: 0]
  ------------------
  898|      0|        {
  899|      0|            bigint n = bigint::parse_radix(s.data(), s.length(), 16);
  900|      0|            write_bignum(n);
  901|      0|            end_value();
  902|      0|        }
  903|      0|        else
  904|      0|        {
  905|      0|            ec = r.error_code();
  906|      0|            return;
  907|      0|        }
  908|      1|        visit_end_array(context, ec);
  909|      1|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12write_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEE:
  460|  1.13M|    {
  461|  1.13M|        auto sink = unicode_traits::validate(sv.data(), sv.size());
  462|  1.13M|        if (sink.ec != unicode_traits::conv_errc())
  ------------------
  |  Branch (462:13): [True: 0, False: 1.13M]
  ------------------
  463|      0|        {
  464|      0|            JSONCONS_THROW(ser_error(cbor_errc::invalid_utf8_text_string));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  465|      0|        }
  466|       |
  467|  1.13M|        if (pack_strings_ && sv.size() >= jsoncons::cbor::detail::min_length_for_stringref(next_stringref_))
  ------------------
  |  Branch (467:13): [True: 0, False: 1.13M]
  |  Branch (467:30): [True: 0, False: 0]
  ------------------
  468|      0|        {
  469|      0|            string_type s(sv.data(), sv.size(), alloc_);
  470|      0|            auto it = stringref_map_.find(s);
  471|      0|            if (it == stringref_map_.end())
  ------------------
  |  Branch (471:17): [True: 0, False: 0]
  ------------------
  472|      0|            {
  473|      0|                stringref_map_.emplace(std::make_pair(std::move(s), next_stringref_++));
  474|      0|                write_utf8_string(sv);
  475|      0|            }
  476|      0|            else
  477|      0|            {
  478|      0|                write_tag(25);
  479|      0|                write_uint64_value((*it).second);
  480|      0|            }
  481|      0|        }
  482|  1.13M|        else
  483|  1.13M|        {
  484|  1.13M|            write_utf8_string(sv);
  485|  1.13M|        }
  486|  1.13M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17write_utf8_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEE:
  489|  1.13M|    {
  490|  1.13M|        const size_t length = sv.size();
  491|       |
  492|  1.13M|        if (length <= 0x17)
  ------------------
  |  Branch (492:13): [True: 1.13M, False: 3]
  ------------------
  493|  1.13M|        {
  494|       |            // fixstr stores a byte array whose length is upto 31 bytes
  495|  1.13M|            binary::native_to_big(static_cast<uint8_t>(0x60 + length), 
  496|  1.13M|                                            std::back_inserter(sink_));
  497|  1.13M|        }
  498|      3|        else if (length <= 0xff)
  ------------------
  |  Branch (498:18): [True: 3, False: 0]
  ------------------
  499|      3|        {
  500|      3|            binary::native_to_big(static_cast<uint8_t>(0x78), 
  501|      3|                                            std::back_inserter(sink_));
  502|      3|            binary::native_to_big(static_cast<uint8_t>(length), 
  503|      3|                                            std::back_inserter(sink_));
  504|      3|        }
  505|      0|        else if (length <= 0xffff)
  ------------------
  |  Branch (505:18): [True: 0, False: 0]
  ------------------
  506|      0|        {
  507|      0|            binary::native_to_big(static_cast<uint8_t>(0x79), 
  508|      0|                                            std::back_inserter(sink_));
  509|      0|            binary::native_to_big(static_cast<uint16_t>(length), 
  510|      0|                                            std::back_inserter(sink_));
  511|      0|        }
  512|      0|        else if (length <= 0xffffffff)
  ------------------
  |  Branch (512:18): [True: 0, False: 0]
  ------------------
  513|      0|        {
  514|      0|            binary::native_to_big(static_cast<uint8_t>(0x7a), 
  515|      0|                                            std::back_inserter(sink_));
  516|      0|            binary::native_to_big(static_cast<uint32_t>(length), 
  517|      0|                                            std::back_inserter(sink_));
  518|      0|        }
  519|      0|        else if (uint64_t(length) <= (std::numeric_limits<std::uint64_t>::max)())
  ------------------
  |  Branch (519:18): [True: 0, False: 0]
  ------------------
  520|      0|        {
  521|      0|            binary::native_to_big(static_cast<uint8_t>(0x7b), 
  522|      0|                                            std::back_inserter(sink_));
  523|      0|            binary::native_to_big(static_cast<uint64_t>(length), 
  524|      0|                                            std::back_inserter(sink_));
  525|      0|        }
  526|       |
  527|  1.13M|        for (auto c : sv)
  ------------------
  |  Branch (527:21): [True: 1.13M, False: 1.13M]
  ------------------
  528|  1.13M|        {
  529|  1.13M|            sink_.push_back(c);
  530|  1.13M|        }
  531|  1.13M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  975|    179|    {
  976|    179|        byte_string_chars_format encoding_hint;
  977|    179|        switch (tag)
  978|    179|        {
  979|      0|            case semantic_tag::base16:
  ------------------
  |  Branch (979:13): [True: 0, False: 179]
  ------------------
  980|      0|                encoding_hint = byte_string_chars_format::base16;
  981|      0|                break;
  982|      0|            case semantic_tag::base64:
  ------------------
  |  Branch (982:13): [True: 0, False: 179]
  ------------------
  983|      0|                encoding_hint = byte_string_chars_format::base64;
  984|      0|                break;
  985|      0|            case semantic_tag::base64url:
  ------------------
  |  Branch (985:13): [True: 0, False: 179]
  ------------------
  986|      0|                encoding_hint = byte_string_chars_format::base64url;
  987|      0|                break;
  988|    179|            default:
  ------------------
  |  Branch (988:13): [True: 179, False: 0]
  ------------------
  989|    179|                encoding_hint = byte_string_chars_format::none;
  990|    179|                break;
  991|    179|        }
  992|    179|        switch (encoding_hint)
  993|    179|        {
  994|      0|            case byte_string_chars_format::base64url:
  ------------------
  |  Branch (994:13): [True: 0, False: 179]
  ------------------
  995|      0|                write_tag(21);
  996|      0|                break;
  997|      0|            case byte_string_chars_format::base64:
  ------------------
  |  Branch (997:13): [True: 0, False: 179]
  ------------------
  998|      0|                write_tag(22);
  999|      0|                break;
 1000|      0|            case byte_string_chars_format::base16:
  ------------------
  |  Branch (1000:13): [True: 0, False: 179]
  ------------------
 1001|      0|                write_tag(23);
 1002|      0|                break;
 1003|    179|            default:
  ------------------
  |  Branch (1003:13): [True: 179, False: 0]
  ------------------
 1004|    179|                break;
 1005|    179|        }
 1006|    179|        if (pack_strings_ && b.size() >= jsoncons::cbor::detail::min_length_for_stringref(next_stringref_))
  ------------------
  |  Branch (1006:13): [True: 0, False: 179]
  |  Branch (1006:30): [True: 0, False: 0]
  ------------------
 1007|      0|        {
 1008|      0|            byte_string_type bs(b.data(), b.size(), alloc_);
 1009|      0|            auto it = bytestringref_map_.find(bs);
 1010|      0|            if (it == bytestringref_map_.end())
  ------------------
  |  Branch (1010:17): [True: 0, False: 0]
  ------------------
 1011|      0|            {
 1012|      0|                bytestringref_map_.emplace(std::make_pair(bs, next_stringref_++));
 1013|      0|                write_byte_string(bs);
 1014|      0|            }
 1015|      0|            else
 1016|      0|            {
 1017|      0|                write_tag(25);
 1018|      0|                write_uint64_value((*it).second);
 1019|      0|            }
 1020|      0|        }
 1021|    179|        else
 1022|    179|        {
 1023|    179|            write_byte_string(b);
 1024|    179|        }
 1025|       |
 1026|    179|        end_value();
 1027|    179|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|    179|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1028|    179|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17write_byte_stringERKNS_16byte_string_viewE:
 1062|    182|    {
 1063|    182|        if (b.size() <= 0x17)
  ------------------
  |  Branch (1063:13): [True: 182, False: 0]
  ------------------
 1064|    182|        {
 1065|       |            // fixstr stores a byte array whose length is upto 31 bytes
 1066|    182|            binary::native_to_big(static_cast<uint8_t>(0x40 + b.size()), 
 1067|    182|                                            std::back_inserter(sink_));
 1068|    182|        }
 1069|      0|        else if (b.size() <= 0xff)
  ------------------
  |  Branch (1069:18): [True: 0, False: 0]
  ------------------
 1070|      0|        {
 1071|      0|            binary::native_to_big(static_cast<uint8_t>(0x58), 
 1072|      0|                                            std::back_inserter(sink_));
 1073|      0|            binary::native_to_big(static_cast<uint8_t>(b.size()), 
 1074|      0|                                            std::back_inserter(sink_));
 1075|      0|        }
 1076|      0|        else if (b.size() <= 0xffff)
  ------------------
  |  Branch (1076:18): [True: 0, False: 0]
  ------------------
 1077|      0|        {
 1078|      0|            binary::native_to_big(static_cast<uint8_t>(0x59), 
 1079|      0|                                            std::back_inserter(sink_));
 1080|      0|            binary::native_to_big(static_cast<uint16_t>(b.size()), 
 1081|      0|                                            std::back_inserter(sink_));
 1082|      0|        }
 1083|      0|        else if (b.size() <= 0xffffffff)
  ------------------
  |  Branch (1083:18): [True: 0, False: 0]
  ------------------
 1084|      0|        {
 1085|      0|            binary::native_to_big(static_cast<uint8_t>(0x5a), 
 1086|      0|                                            std::back_inserter(sink_));
 1087|      0|            binary::native_to_big(static_cast<uint32_t>(b.size()), 
 1088|      0|                                            std::back_inserter(sink_));
 1089|      0|        }
 1090|      0|        else // if (b.size() <= 0xffffffffffffffff)
 1091|      0|        {
 1092|      0|            binary::native_to_big(static_cast<uint8_t>(0x5b), 
 1093|      0|                                            std::back_inserter(sink_));
 1094|      0|            binary::native_to_big(static_cast<uint64_t>(b.size()), 
 1095|      0|                                            std::back_inserter(sink_));
 1096|      0|        }
 1097|       |
 1098|    182|        for (auto c : b)
  ------------------
  |  Branch (1098:21): [True: 170, False: 182]
  ------------------
 1099|    170|        {
 1100|    170|            sink_.push_back(c);
 1101|    170|        }
 1102|    182|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS3_10error_codeE:
 1034|      3|    {
 1035|      3|        if (pack_strings_ && b.size() >= jsoncons::cbor::detail::min_length_for_stringref(next_stringref_))
  ------------------
  |  Branch (1035:13): [True: 0, False: 3]
  |  Branch (1035:30): [True: 0, False: 0]
  ------------------
 1036|      0|        {
 1037|      0|            byte_string_type bs(b.data(), b.size(), alloc_);
 1038|      0|            auto it = bytestringref_map_.find(bs);
 1039|      0|            if (it == bytestringref_map_.end())
  ------------------
  |  Branch (1039:17): [True: 0, False: 0]
  ------------------
 1040|      0|            {
 1041|      0|                bytestringref_map_.emplace(std::make_pair(bs, next_stringref_++));
 1042|      0|                write_tag(ext_tag);
 1043|      0|                write_byte_string(bs);
 1044|      0|            }
 1045|      0|            else
 1046|      0|            {
 1047|      0|                write_tag(25);
 1048|      0|                write_uint64_value((*it).second);
 1049|      0|            }
 1050|      0|        }
 1051|      3|        else
 1052|      3|        {
 1053|      3|            write_tag(ext_tag);
 1054|      3|            write_byte_string(b);
 1055|      3|        }
 1056|       |
 1057|      3|        end_value();
 1058|      3|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  272|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1059|      3|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEED2Ev:
  147|     18|    {
  148|     18|        JSONCONS_TRY
  ------------------
  |  |   37|     18|    #define JSONCONS_TRY try
  ------------------
  149|     18|        {
  150|     18|            sink_.flush();
  151|     18|        }
  152|     18|        JSONCONS_CATCH(...)
  153|     18|        {
  154|      0|        }
  155|     18|    }

_ZN8jsoncons4cbor15make_error_codeENS0_9cbor_errcE:
   87|     11|{
   88|     11|    return std::error_code(static_cast<int>(e),cbor_error_category());
   89|     11|}
_ZN8jsoncons4cbor19cbor_error_categoryEv:
   80|     11|{
   81|     11|  static cbor_error_category_impl instance;
   82|     11|  return instance;
   83|     11|}

_ZN8jsoncons4cbor19cbor_decode_optionsC1Ev:
   42|     18|    cbor_decode_options() = default;
_ZN8jsoncons4cbor19cbor_options_commonC2Ev:
   25|     36|    cbor_options_common() = default;
_ZN8jsoncons4cbor19cbor_options_commonD2Ev:
   27|     36|    virtual ~cbor_options_common() = default;
_ZN8jsoncons4cbor19cbor_encode_optionsC1Ev:
   55|     18|    cbor_encode_options() = default;
_ZNK8jsoncons4cbor19cbor_options_common17max_nesting_depthEv:
   33|     36|    {
   34|     36|        return max_nesting_depth_;
   35|     36|    }
_ZNK8jsoncons4cbor19cbor_encode_options12pack_stringsEv:
   61|     36|    {
   62|     36|        return use_stringref_;
   63|     36|    }
_ZNK8jsoncons4cbor19cbor_encode_options16use_typed_arraysEv:
   66|     18|    {
   67|     18|        return use_typed_arrays_;
   68|     18|    }

_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEED2Ev:
  211|     18|    ~basic_cbor_parser() = default;
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringD2Ev:
  118|     23|        ~mapped_string() = default;
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RKNS0_19cbor_decode_optionsERKS7_:
  194|     18|       : alloc_(alloc),
  195|     18|         source_(std::forward<Sourceable>(source)),
  196|     18|         max_nesting_depth_(options.max_nesting_depth()),
  197|     18|         text_buffer_(alloc),
  198|     18|         bytes_buffer_(alloc),
  199|     18|         state_stack_(alloc),
  200|     18|         array_buffer_(alloc),
  201|     18|         stringref_map_stack_(alloc)
  202|     18|    {
  203|     18|        state_stack_.emplace_back(parse_mode::root,0);
  204|     18|    }
_ZN8jsoncons4cbor11parse_stateC2ENS0_10parse_modeEmb:
   47|  1.06k|        : mode(mode), length(length), pop_stringref_map_stack(pop_stringref_map_stack)
   48|  1.06k|    {
   49|  1.06k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5resetEv:
  219|     18|    {
  220|     18|        more_ = true;
  221|     18|        done_ = false;
  222|     18|        text_buffer_.clear();
  223|     18|        bytes_buffer_.clear();
  224|     18|        raw_tag_ = 0;
  225|     18|        state_stack_.clear();
  226|     18|        state_stack_.emplace_back(parse_mode::root,0);
  227|     18|        array_buffer_.clear();
  228|     18|        stringref_map_stack_.clear();
  229|     18|        nesting_depth_ = 0;
  230|     18|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
  323|     18|    {
  324|  4.19M|        while (!done_ && more_)
  ------------------
  |  Branch (324:16): [True: 4.19M, False: 10]
  |  Branch (324:26): [True: 4.19M, False: 5]
  ------------------
  325|  4.19M|        {
  326|  4.19M|            switch (state_stack_.back().mode)
  ------------------
  |  Branch (326:21): [True: 4.19M, False: 0]
  ------------------
  327|  4.19M|            {
  328|      0|                case parse_mode::multi_dim:
  ------------------
  |  Branch (328:17): [True: 0, False: 4.19M]
  ------------------
  329|      0|                {
  330|      0|                    if (state_stack_.back().index == 0)
  ------------------
  |  Branch (330:25): [True: 0, False: 0]
  ------------------
  331|      0|                    {
  332|      0|                        ++state_stack_.back().index;
  333|      0|                        read_item(visitor, ec);
  334|      0|                    }
  335|      0|                    else
  336|      0|                    {
  337|      0|                        state_stack_.pop_back();
  338|      0|                    }
  339|      0|                    break;
  340|      0|                }
  341|   492k|                case parse_mode::array:
  ------------------
  |  Branch (341:17): [True: 492k, False: 3.70M]
  ------------------
  342|   492k|                {
  343|   492k|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (343:25): [True: 492k, False: 191]
  ------------------
  344|   492k|                    {
  345|   492k|                        ++state_stack_.back().index;
  346|   492k|                        read_item(visitor, ec);
  347|   492k|                    }
  348|    191|                    else
  349|    191|                    {
  350|    191|                        end_array(visitor, ec);
  351|    191|                    }
  352|   492k|                    break;
  353|      0|                }
  354|  1.66k|                case parse_mode::typed_array:
  ------------------
  |  Branch (354:17): [True: 1.66k, False: 4.19M]
  ------------------
  355|  1.66k|                {
  356|  1.66k|                    read_item(visitor, ec);
  357|  1.66k|                    break;
  358|      0|                }
  359|   866k|                case parse_mode::indefinite_array:
  ------------------
  |  Branch (359:17): [True: 866k, False: 3.32M]
  ------------------
  360|   866k|                {
  361|   866k|                    auto c = source_.peek();
  362|   866k|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   866k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 866k]
  |  |  ------------------
  ------------------
  363|      2|                    {
  364|      2|                        ec = cbor_errc::unexpected_eof;
  365|      2|                        more_ = false;
  366|      2|                        return;
  367|      2|                    }
  368|   866k|                    if (c.value == 0xff)
  ------------------
  |  Branch (368:25): [True: 0, False: 866k]
  ------------------
  369|      0|                    {
  370|      0|                        source_.ignore(1);
  371|      0|                        end_array(visitor, ec);
  372|      0|                    }
  373|   866k|                    else
  374|   866k|                    {
  375|   866k|                        read_item(visitor, ec);
  376|   866k|                    }
  377|   866k|                    break;
  378|   866k|                }
  379|     73|                case parse_mode::map_key:
  ------------------
  |  Branch (379:17): [True: 73, False: 4.19M]
  ------------------
  380|     73|                {
  381|     73|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (381:25): [True: 46, False: 27]
  ------------------
  382|     46|                    {
  383|     46|                        ++state_stack_.back().index;
  384|     46|                        state_stack_.back().mode = parse_mode::map_value;
  385|     46|                        read_item(visitor, ec);
  386|     46|                    }
  387|     27|                    else
  388|     27|                    {
  389|     27|                        end_object(visitor, ec);
  390|     27|                    }
  391|     73|                    break;
  392|   866k|                }
  393|     45|                case parse_mode::map_value:
  ------------------
  |  Branch (393:17): [True: 45, False: 4.19M]
  ------------------
  394|     45|                {
  395|     45|                    state_stack_.back().mode = parse_mode::map_key;
  396|     45|                    read_item(visitor, ec);
  397|     45|                    break;
  398|   866k|                }
  399|  1.41M|                case parse_mode::indefinite_map_key:
  ------------------
  |  Branch (399:17): [True: 1.41M, False: 2.77M]
  ------------------
  400|  1.41M|                {
  401|  1.41M|                    auto c = source_.peek();
  402|  1.41M|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.41M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 1.41M]
  |  |  ------------------
  ------------------
  403|      1|                    {
  404|      1|                        ec = cbor_errc::unexpected_eof;
  405|      1|                        more_ = false;
  406|      1|                        return;
  407|      1|                    }
  408|  1.41M|                    if (c.value == 0xff)
  ------------------
  |  Branch (408:25): [True: 1, False: 1.41M]
  ------------------
  409|      1|                    {
  410|      1|                        source_.ignore(1);
  411|      1|                        end_object(visitor, ec);
  412|      1|                    }
  413|  1.41M|                    else
  414|  1.41M|                    {
  415|  1.41M|                        state_stack_.back().mode = parse_mode::indefinite_map_value;
  416|  1.41M|                        read_item(visitor, ec);
  417|  1.41M|                    }
  418|  1.41M|                    break;
  419|  1.41M|                }
  420|  1.41M|                case parse_mode::indefinite_map_value:
  ------------------
  |  Branch (420:17): [True: 1.41M, False: 2.77M]
  ------------------
  421|  1.41M|                {
  422|  1.41M|                    state_stack_.back().mode = parse_mode::indefinite_map_key;
  423|  1.41M|                    read_item(visitor, ec);
  424|  1.41M|                    break;
  425|  1.41M|                }
  426|     18|                case parse_mode::root:
  ------------------
  |  Branch (426:17): [True: 18, False: 4.19M]
  ------------------
  427|     18|                {
  428|     18|                    state_stack_.back().mode = parse_mode::accept;
  429|     18|                    read_item(visitor, ec);
  430|     18|                    break;
  431|  1.41M|                }
  432|     10|                case parse_mode::accept:
  ------------------
  |  Branch (432:17): [True: 10, False: 4.19M]
  ------------------
  433|     10|                {
  434|     10|                    JSONCONS_ASSERT(state_stack_.size() == 1);
  ------------------
  |  |   45|     10|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 10]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  435|     10|                    state_stack_.clear();
  436|     10|                    more_ = false;
  437|     10|                    done_ = true;
  438|     10|                    visitor.flush();
  439|     10|                    break;
  440|     10|                }
  441|  4.19M|            }
  442|  4.19M|        }
  443|     18|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_itemERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
  446|  4.19M|    {
  447|  4.19M|        if (is_typed_array_)
  ------------------
  |  Branch (447:13): [True: 1.66k, False: 4.19M]
  ------------------
  448|  1.66k|        {
  449|  1.66k|            if (!typed_array_iter_->done())
  ------------------
  |  Branch (449:17): [True: 867, False: 793]
  ------------------
  450|    867|            {
  451|    867|                typed_array_iter_->next(visitor, *this, ec);
  452|    867|                more_ = !cursor_mode_;
  453|    867|            }
  454|    793|            else
  455|    793|            {
  456|    793|                is_typed_array_ = false;
  457|    793|                state_stack_.pop_back();
  458|    793|            }
  459|  1.66k|            return;
  460|  1.66k|        }
  461|  4.19M|        read_tags(ec);
  462|  4.19M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.19M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 4.19M]
  |  |  ------------------
  ------------------
  463|      1|        {
  464|      1|            return;
  465|      1|        }
  466|  4.19M|        auto c = source_.peek();
  467|  4.19M|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  4.19M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4.19M]
  |  |  ------------------
  ------------------
  468|      0|        {
  469|      0|            ec = cbor_errc::unexpected_eof;
  470|      0|            more_ = false;
  471|      0|            return;
  472|      0|        }
  473|  4.19M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
  474|  4.19M|        uint8_t info = get_additional_information_value(c.value);
  475|       |
  476|  4.19M|        switch (major_type)
  477|  4.19M|        {
  478|  4.19M|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (478:13): [True: 4.19M, False: 1.77k]
  ------------------
  479|  4.19M|            {
  480|  4.19M|                uint64_t val = read_uint64(ec);
  481|  4.19M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.19M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4.19M]
  |  |  ------------------
  ------------------
  482|      0|                {
  483|      0|                    return;
  484|      0|                }
  485|  4.19M|                if (!stringref_map_stack_.empty() && other_tags_[stringref_tag])
  ------------------
  |  Branch (485:21): [True: 881k, False: 3.30M]
  |  Branch (485:21): [True: 2, False: 4.19M]
  |  Branch (485:54): [True: 2, False: 881k]
  ------------------
  486|      2|                {
  487|      2|                    other_tags_[stringref_tag] = false;
  488|      2|                    if (val >= stringref_map_stack_.back().size())
  ------------------
  |  Branch (488:25): [True: 0, False: 2]
  ------------------
  489|      0|                    {
  490|      0|                        ec = cbor_errc::stringref_too_large;
  491|      0|                        more_ = false;
  492|      0|                        return;
  493|      0|                    }
  494|      2|                    auto index = static_cast<typename stringref_map::size_type>(val);
  495|      2|                    if (index != val)
  ------------------
  |  Branch (495:25): [True: 0, False: 2]
  ------------------
  496|      0|                    {
  497|      0|                        ec = cbor_errc::number_too_large;
  498|      0|                        more_ = false;
  499|      0|                        return;
  500|      0|                    }
  501|      2|                    auto& str = stringref_map_stack_.back().at(index);
  502|      2|                    switch (str.type)
  503|      2|                    {
  504|      0|                        case jsoncons::cbor::detail::cbor_major_type::text_string:
  ------------------
  |  Branch (504:25): [True: 0, False: 2]
  ------------------
  505|      0|                        {
  506|      0|                            handle_string(visitor, jsoncons::basic_string_view<char>(str.str.data(),str.str.length()),ec);
  507|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  508|      0|                            {
  509|      0|                                return;
  510|      0|                            }
  511|      0|                            break;
  512|      0|                        }
  513|      2|                        case jsoncons::cbor::detail::cbor_major_type::byte_string:
  ------------------
  |  Branch (513:25): [True: 2, False: 0]
  ------------------
  514|      2|                        {
  515|      2|                            read_byte_string_from_buffer read(byte_string_view(str.bytes));
  516|      2|                            read_byte_string(read, visitor, ec);
  517|      2|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  518|      0|                            {
  519|      0|                                return;
  520|      0|                            }
  521|      2|                            break;
  522|      2|                        }
  523|      2|                        default:
  ------------------
  |  Branch (523:25): [True: 0, False: 2]
  ------------------
  524|      0|                            JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
  525|      0|                            break;
  526|      2|                    }
  527|      2|                }
  528|  4.19M|                else
  529|  4.19M|                {
  530|  4.19M|                    semantic_tag tag = semantic_tag::none;
  531|  4.19M|                    if (other_tags_[item_tag])
  ------------------
  |  Branch (531:25): [True: 14, False: 4.19M]
  ------------------
  532|     14|                    {
  533|     14|                        if (raw_tag_ == 1)
  ------------------
  |  Branch (533:29): [True: 0, False: 14]
  ------------------
  534|      0|                        {
  535|      0|                            tag = semantic_tag::epoch_second;
  536|      0|                        }
  537|     14|                        other_tags_[item_tag] = false;
  538|     14|                    }
  539|  4.19M|                    visitor.uint64_value(val, tag, *this, ec);
  540|  4.19M|                    more_ = !cursor_mode_;
  541|  4.19M|                }
  542|  4.19M|                break;
  543|  4.19M|            }
  544|  4.19M|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (544:13): [True: 238, False: 4.19M]
  ------------------
  545|    238|            {
  546|    238|                int64_t val = read_int64(ec);
  547|    238|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    238|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 238]
  |  |  ------------------
  ------------------
  548|      0|                {
  549|      0|                    return;
  550|      0|                }
  551|    238|                semantic_tag tag = semantic_tag::none;
  552|    238|                if (other_tags_[item_tag])
  ------------------
  |  Branch (552:21): [True: 3, False: 235]
  ------------------
  553|      3|                {
  554|      3|                    if (raw_tag_ == 1)
  ------------------
  |  Branch (554:25): [True: 0, False: 3]
  ------------------
  555|      0|                    {
  556|      0|                        tag = semantic_tag::epoch_second;
  557|      0|                    }
  558|      3|                    other_tags_[item_tag] = false;
  559|      3|                }
  560|    238|                visitor.int64_value(val, tag, *this, ec);
  561|    238|                more_ = !cursor_mode_;
  562|    238|                break;
  563|    238|            }
  564|  1.22k|            case jsoncons::cbor::detail::cbor_major_type::byte_string:
  ------------------
  |  Branch (564:13): [True: 1.22k, False: 4.19M]
  ------------------
  565|  1.22k|            {
  566|  1.22k|                read_byte_string_from_source read(this);
  567|  1.22k|                read_byte_string(read, visitor, ec);
  568|  1.22k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.22k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 1.22k]
  |  |  ------------------
  ------------------
  569|      3|                {
  570|      3|                    return;
  571|      3|                }
  572|  1.22k|                break;
  573|  1.22k|            }
  574|  1.22k|            case jsoncons::cbor::detail::cbor_major_type::text_string:
  ------------------
  |  Branch (574:13): [True: 8, False: 4.19M]
  ------------------
  575|      8|            {
  576|      8|                text_buffer_.clear();
  577|       |
  578|      8|                read_text_string(text_buffer_, ec);
  579|      8|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 6]
  |  |  ------------------
  ------------------
  580|      2|                {
  581|      2|                    return;
  582|      2|                }
  583|      6|                auto result = unicode_traits::validate(text_buffer_.data(),text_buffer_.size());
  584|      6|                if (result.ec != unicode_traits::conv_errc())
  ------------------
  |  Branch (584:21): [True: 0, False: 6]
  ------------------
  585|      0|                {
  586|      0|                    ec = cbor_errc::invalid_utf8_text_string;
  587|      0|                    more_ = false;
  588|      0|                    return;
  589|      0|                }
  590|      6|                handle_string(visitor, jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()),ec);
  591|      6|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      6|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 6]
  |  |  ------------------
  ------------------
  592|      0|                {
  593|      0|                    return;
  594|      0|                }
  595|      6|                break;
  596|      6|            }
  597|      6|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (597:13): [True: 0, False: 4.19M]
  ------------------
  598|      0|            {
  599|      0|                JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
  600|      0|                break;
  601|      6|            }
  602|     50|            case jsoncons::cbor::detail::cbor_major_type::simple:
  ------------------
  |  Branch (602:13): [True: 50, False: 4.19M]
  ------------------
  603|     50|            {
  604|     50|                switch (info)
  605|     50|                {
  606|      0|                    case 0x14:
  ------------------
  |  Branch (606:21): [True: 0, False: 50]
  ------------------
  607|      0|                        visitor.bool_value(false, semantic_tag::none, *this, ec);
  608|      0|                        more_ = !cursor_mode_;
  609|      0|                        source_.ignore(1);
  610|      0|                        break;
  611|     14|                    case 0x15:
  ------------------
  |  Branch (611:21): [True: 14, False: 36]
  ------------------
  612|     14|                        visitor.bool_value(true, semantic_tag::none, *this, ec);
  613|     14|                        more_ = !cursor_mode_;
  614|     14|                        source_.ignore(1);
  615|     14|                        break;
  616|      9|                    case 0x16:
  ------------------
  |  Branch (616:21): [True: 9, False: 41]
  ------------------
  617|      9|                        visitor.null_value(semantic_tag::none, *this, ec);
  618|      9|                        more_ = !cursor_mode_;
  619|      9|                        source_.ignore(1);
  620|      9|                        break;
  621|     24|                    case 0x17:
  ------------------
  |  Branch (621:21): [True: 24, False: 26]
  ------------------
  622|     24|                        visitor.null_value(semantic_tag::undefined, *this, ec);
  623|     24|                        more_ = !cursor_mode_;
  624|     24|                        source_.ignore(1);
  625|     24|                        break;
  626|      3|                    case 0x19: // Half-Precision Float (two-byte IEEE 754)
  ------------------
  |  Branch (626:21): [True: 3, False: 47]
  ------------------
  627|      3|                    {
  628|      3|                        uint64_t val = read_uint64(ec);
  629|      3|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
  630|      0|                        {
  631|      0|                            return;
  632|      0|                        }
  633|      3|                        visitor.half_value(static_cast<uint16_t>(val), semantic_tag::none, *this, ec);
  634|      3|                        more_ = !cursor_mode_;
  635|      3|                        break;
  636|      3|                    }
  637|      0|                    case 0x1a: // Single-Precision Float (four-byte IEEE 754)
  ------------------
  |  Branch (637:21): [True: 0, False: 50]
  ------------------
  638|      0|                    case 0x1b: // Double-Precision Float (eight-byte IEEE 754)
  ------------------
  |  Branch (638:21): [True: 0, False: 50]
  ------------------
  639|      0|                    {
  640|      0|                        double val = read_double(ec);
  641|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  642|      0|                        {
  643|      0|                            return;
  644|      0|                        }
  645|      0|                        semantic_tag tag = semantic_tag::none;
  646|      0|                        if (other_tags_[item_tag])
  ------------------
  |  Branch (646:29): [True: 0, False: 0]
  ------------------
  647|      0|                        {
  648|      0|                            if (raw_tag_ == 1)
  ------------------
  |  Branch (648:33): [True: 0, False: 0]
  ------------------
  649|      0|                            {
  650|      0|                                tag = semantic_tag::epoch_second;
  651|      0|                            }
  652|      0|                            other_tags_[item_tag] = false;
  653|      0|                        }
  654|      0|                        visitor.double_value(val, tag, *this, ec);
  655|      0|                        more_ = !cursor_mode_;
  656|      0|                        break;
  657|      0|                    }
  658|      0|                    default:
  ------------------
  |  Branch (658:21): [True: 0, False: 50]
  ------------------
  659|      0|                    {
  660|      0|                        ec = cbor_errc::unknown_type;
  661|      0|                        more_ = false;
  662|      0|                        return;
  663|      0|                    }
  664|     50|                }
  665|     50|                break;
  666|     50|            }
  667|    219|            case jsoncons::cbor::detail::cbor_major_type::array:
  ------------------
  |  Branch (667:13): [True: 219, False: 4.19M]
  ------------------
  668|    219|            {
  669|    219|                if (other_tags_[item_tag])
  ------------------
  |  Branch (669:21): [True: 19, False: 200]
  ------------------
  670|     19|                {
  671|     19|                    switch (raw_tag_)
  672|     19|                    {
  673|     13|                        case 0x04:
  ------------------
  |  Branch (673:25): [True: 13, False: 6]
  ------------------
  674|     13|                            text_buffer_.clear();
  675|     13|                            read_decimal_fraction(text_buffer_, ec);
  676|     13|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     13|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 13]
  |  |  ------------------
  ------------------
  677|      0|                            {
  678|      0|                                return;
  679|      0|                            }
  680|     13|                            visitor.string_value(text_buffer_, semantic_tag::bigdec, *this, ec);
  681|     13|                            more_ = !cursor_mode_;
  682|     13|                            break;
  683|      1|                        case 0x05:
  ------------------
  |  Branch (683:25): [True: 1, False: 18]
  ------------------
  684|      1|                            text_buffer_.clear();
  685|      1|                            read_bigfloat(text_buffer_, ec);
  686|      1|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  687|      0|                            {
  688|      0|                                return;
  689|      0|                            }
  690|      1|                            visitor.string_value(text_buffer_, semantic_tag::bigfloat, *this, ec);
  691|      1|                            more_ = !cursor_mode_;
  692|      1|                            break;
  693|      2|                        case 40: // row major storage
  ------------------
  |  Branch (693:25): [True: 2, False: 17]
  ------------------
  694|      2|                            is_multi_dim_ = true;
  695|      2|                            order_ = mdarray_order::row_major;
  696|      2|                            produce_begin_multi_dim(ec);
  697|      2|                            break;
  698|      0|                        case 1040: // column major storage
  ------------------
  |  Branch (698:25): [True: 0, False: 19]
  ------------------
  699|      0|                            is_multi_dim_ = true;
  700|      0|                            order_ = mdarray_order::column_major;
  701|      0|                            produce_begin_multi_dim(ec);
  702|      0|                            break;
  703|      3|                        default:
  ------------------
  |  Branch (703:25): [True: 3, False: 16]
  ------------------
  704|      3|                            begin_array(visitor, info, ec);
  705|      3|                            break;
  706|     19|                    }
  707|     19|                    other_tags_[item_tag] = false;
  708|     19|                }
  709|    200|                else
  710|    200|                {
  711|    200|                    begin_array(visitor, info, ec);
  712|    200|                }
  713|    219|                break;
  714|    219|            }
  715|    219|            case jsoncons::cbor::detail::cbor_major_type::map:
  ------------------
  |  Branch (715:13): [True: 36, False: 4.19M]
  ------------------
  716|     36|            {
  717|     36|                begin_object(visitor, info, ec);
  718|     36|                break;
  719|    219|            }
  720|      0|            default:
  ------------------
  |  Branch (720:13): [True: 0, False: 4.19M]
  ------------------
  721|      0|                break;
  722|  4.19M|        }
  723|  4.19M|        other_tags_[item_tag] = false;
  724|  4.19M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_tagsERNS3_10error_codeE:
 1548|  4.19M|    {
 1549|  4.19M|        auto c = source_.peek();
 1550|  4.19M|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  4.19M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 4.19M]
  |  |  ------------------
  ------------------
 1551|      1|        {
 1552|      1|            ec = cbor_errc::unexpected_eof;
 1553|      1|            more_ = false;
 1554|      1|            return;
 1555|      1|        }
 1556|  4.19M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1557|       |
 1558|  4.19M|        while (major_type == jsoncons::cbor::detail::cbor_major_type::semantic_tag)
  ------------------
  |  Branch (1558:16): [True: 908, False: 4.19M]
  ------------------
 1559|    908|        {
 1560|    908|            uint64_t val = read_uint64(ec);
 1561|    908|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    908|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 908]
  |  |  ------------------
  ------------------
 1562|      0|            {
 1563|      0|                return;
 1564|      0|            }
 1565|    908|            switch(val)
 1566|    908|            {
 1567|      8|                case 25: // stringref
  ------------------
  |  Branch (1567:17): [True: 8, False: 900]
  ------------------
 1568|      8|                    other_tags_[stringref_tag] = true;
 1569|      8|                    break;
 1570|      3|                case 256: // stringref-namespace
  ------------------
  |  Branch (1570:17): [True: 3, False: 905]
  ------------------
 1571|      3|                    other_tags_[stringref_namespace_tag] = true;
 1572|      3|                    break;
 1573|    897|                default:
  ------------------
  |  Branch (1573:17): [True: 897, False: 11]
  ------------------
 1574|    897|                    other_tags_[item_tag] = true;
 1575|    897|                    raw_tag_ = val;
 1576|    897|                    break;
 1577|    908|            }
 1578|    908|            c = source_.peek();
 1579|    908|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|    908|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 908]
  |  |  ------------------
  ------------------
 1580|      0|            {
 1581|      0|                ec = cbor_errc::unexpected_eof;
 1582|      0|                more_ = false;
 1583|      0|                return;
 1584|      0|            }
 1585|    908|            major_type = get_major_type(c.value);
 1586|    908|        }
 1587|  4.19M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE14get_major_typeEh:
 1534|  8.38M|    {
 1535|  8.38M|        static constexpr uint8_t major_type_shift = 0x05;
 1536|  8.38M|        uint8_t value = type >> major_type_shift;
 1537|  8.38M|        return static_cast<jsoncons::cbor::detail::cbor_major_type>(value);
 1538|  8.38M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE32get_additional_information_valueEh:
 1541|  10.4M|    {
 1542|  10.4M|        static constexpr uint8_t additional_information_mask = (1U << 5) - 1;
 1543|  10.4M|        uint8_t value = type & additional_information_mask;
 1544|  10.4M|        return value;
 1545|  10.4M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11read_uint64ERNS3_10error_codeE:
 1008|  6.28M|    {
 1009|  6.28M|        uint64_t val = 0;
 1010|       |
 1011|  6.28M|        uint8_t initial_b;
 1012|  6.28M|        if (source_.read(&initial_b, 1) == 0)
  ------------------
  |  Branch (1012:13): [True: 0, False: 6.28M]
  ------------------
 1013|      0|        {
 1014|      0|            ec = cbor_errc::unexpected_eof;
 1015|      0|            more_ = false;
 1016|      0|            return 0;
 1017|      0|        }
 1018|  6.28M|        uint8_t info = get_additional_information_value(initial_b);
 1019|  6.28M|        switch (info)
 1020|  6.28M|        {
 1021|  6.28M|            case JSONCONS_EXT_CBOR_0x00_0x17: // Integer 0x00..0x17 (0..23)
  ------------------
  |  |   18|  6.28M|    0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x09:case 0x0a:case 0x0b:case 0x0c:case 0x0d:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16:case 0x17
  |  |  ------------------
  |  |  |  Branch (18:10): [True: 50, False: 6.28M]
  |  |  |  Branch (18:20): [True: 20, False: 6.28M]
  |  |  |  Branch (18:30): [True: 13, False: 6.28M]
  |  |  |  Branch (18:40): [True: 31, False: 6.28M]
  |  |  |  Branch (18:50): [True: 15, False: 6.28M]
  |  |  |  Branch (18:60): [True: 1, False: 6.28M]
  |  |  |  Branch (18:70): [True: 3, False: 6.28M]
  |  |  |  Branch (18:80): [True: 8, False: 6.28M]
  |  |  |  Branch (18:90): [True: 3, False: 6.28M]
  |  |  |  Branch (18:100): [True: 3, False: 6.28M]
  |  |  |  Branch (18:110): [True: 898, False: 6.28M]
  |  |  |  Branch (18:120): [True: 0, False: 6.28M]
  |  |  |  Branch (18:130): [True: 33, False: 6.28M]
  |  |  |  Branch (18:140): [True: 2, False: 6.28M]
  |  |  |  Branch (18:150): [True: 8, False: 6.28M]
  |  |  |  Branch (18:160): [True: 12, False: 6.28M]
  |  |  |  Branch (18:170): [True: 4, False: 6.28M]
  |  |  |  Branch (18:180): [True: 3, False: 6.28M]
  |  |  |  Branch (18:190): [True: 6, False: 6.28M]
  |  |  |  Branch (18:200): [True: 2, False: 6.28M]
  |  |  |  Branch (18:210): [True: 0, False: 6.28M]
  |  |  |  Branch (18:220): [True: 5, False: 6.28M]
  |  |  ------------------
  ------------------
  |  Branch (1021:13): [True: 6.28M, False: 2.39k]
  ------------------
 1022|  6.28M|            {
 1023|  6.28M|                val = info;
 1024|  6.28M|                break;
 1025|   138M|            }
 1026|       |
 1027|    836|            case 0x18: // Unsigned integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1027:13): [True: 836, False: 6.28M]
  ------------------
 1028|    836|            {
 1029|    836|                uint8_t b;
 1030|    836|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1030:21): [True: 0, False: 836]
  ------------------
 1031|      0|                {
 1032|      0|                    ec = cbor_errc::unexpected_eof;
 1033|      0|                    more_ = false;
 1034|      0|                    return val;
 1035|      0|                }
 1036|    836|                val = b;
 1037|    836|                break;
 1038|    836|            }
 1039|       |
 1040|     16|            case 0x19: // Unsigned integer (two-byte uint16_t follows)
  ------------------
  |  Branch (1040:13): [True: 16, False: 6.28M]
  ------------------
 1041|     16|            {
 1042|     16|                uint8_t buf[sizeof(uint16_t)];
 1043|     16|                source_.read(buf, sizeof(uint16_t));
 1044|     16|                val = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1045|     16|                break;
 1046|    836|            }
 1047|       |
 1048|      5|            case 0x1a: // Unsigned integer (four-byte uint32_t follows)
  ------------------
  |  Branch (1048:13): [True: 5, False: 6.28M]
  ------------------
 1049|      5|            {
 1050|      5|                uint8_t buf[sizeof(uint32_t)];
 1051|      5|                source_.read(buf, sizeof(uint32_t));
 1052|      5|                val = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1053|      5|                break;
 1054|    836|            }
 1055|       |
 1056|      6|            case 0x1b: // Unsigned integer (eight-byte uint64_t follows)
  ------------------
  |  Branch (1056:13): [True: 6, False: 6.28M]
  ------------------
 1057|      6|            {
 1058|      6|                uint8_t buf[sizeof(uint64_t)];
 1059|      6|                source_.read(buf, sizeof(uint64_t));
 1060|      6|                val = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1061|      6|                break;
 1062|    836|            }
 1063|    382|            default:
  ------------------
  |  Branch (1063:13): [True: 382, False: 6.28M]
  ------------------
 1064|    382|                break;
 1065|  6.28M|        }
 1066|  6.28M|        return val;
 1067|  6.28M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13handle_stringERNS_24basic_item_event_visitorIcEERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERNS3_10error_codeE:
 1590|      6|    {
 1591|      6|        semantic_tag tag = semantic_tag::none;
 1592|      6|        if (other_tags_[item_tag])
  ------------------
  |  Branch (1592:13): [True: 0, False: 6]
  ------------------
 1593|      0|        {
 1594|      0|            switch (raw_tag_)
 1595|      0|            {
 1596|      0|                case 0:
  ------------------
  |  Branch (1596:17): [True: 0, False: 0]
  ------------------
 1597|      0|                    tag = semantic_tag::datetime;
 1598|      0|                    break;
 1599|      0|                case 32:
  ------------------
  |  Branch (1599:17): [True: 0, False: 0]
  ------------------
 1600|      0|                    tag = semantic_tag::uri;
 1601|      0|                    break;
 1602|      0|                case 33:
  ------------------
  |  Branch (1602:17): [True: 0, False: 0]
  ------------------
 1603|      0|                    tag = semantic_tag::base64url;
 1604|      0|                    break;
 1605|      0|                case 34:
  ------------------
  |  Branch (1605:17): [True: 0, False: 0]
  ------------------
 1606|      0|                    tag = semantic_tag::base64;
 1607|      0|                    break;
 1608|      0|                default:
  ------------------
  |  Branch (1608:17): [True: 0, False: 0]
  ------------------
 1609|      0|                    break;
 1610|      0|            }
 1611|      0|            other_tags_[item_tag] = false;
 1612|      0|        }
 1613|      6|        visitor.string_value(v, tag, *this, ec);
 1614|      6|        more_ = !cursor_mode_;
 1615|      6|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_bufferC2ERKNS_16byte_string_viewE:
  159|      2|            : bytes(b)
  160|      2|        {
  161|      2|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringINS8_28read_byte_string_from_bufferEEEvT_RNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
 1632|      2|    {
 1633|      2|        if (other_tags_[item_tag])
  ------------------
  |  Branch (1633:13): [True: 2, False: 0]
  ------------------
 1634|      2|        {
 1635|      2|            switch (raw_tag_)
 1636|      2|            {
 1637|      0|                case 0x2:
  ------------------
  |  Branch (1637:17): [True: 0, False: 2]
  ------------------
 1638|      0|                {
 1639|      0|                    bytes_buffer_.clear();
 1640|      0|                    read(bytes_buffer_,ec);
 1641|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1642|      0|                    {
 1643|      0|                        more_ = false;
 1644|      0|                        return;
 1645|      0|                    }
 1646|      0|                    bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1647|      0|                    text_buffer_.clear();
 1648|      0|                    n.write_string(text_buffer_);
 1649|      0|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 1650|      0|                    more_ = !cursor_mode_;
 1651|      0|                    break;
 1652|      0|                }
 1653|      0|                case 0x3:
  ------------------
  |  Branch (1653:17): [True: 0, False: 2]
  ------------------
 1654|      0|                {
 1655|      0|                    bytes_buffer_.clear();
 1656|      0|                    read(bytes_buffer_,ec);
 1657|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1658|      0|                    {
 1659|      0|                        more_ = false;
 1660|      0|                        return;
 1661|      0|                    }
 1662|      0|                    bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1663|      0|                    n = -1 - n;
 1664|      0|                    text_buffer_.clear();
 1665|      0|                    n.write_string(text_buffer_);
 1666|      0|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 1667|      0|                    more_ = !cursor_mode_;
 1668|      0|                    break;
 1669|      0|                }
 1670|      0|                case 0x15:
  ------------------
  |  Branch (1670:17): [True: 0, False: 2]
  ------------------
 1671|      0|                {
 1672|      0|                    read(bytes_buffer_,ec);
 1673|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1674|      0|                    {
 1675|      0|                        more_ = false;
 1676|      0|                        return;
 1677|      0|                    }
 1678|      0|                    visitor.byte_string_value(bytes_buffer_, semantic_tag::base64url, *this, ec);
 1679|      0|                    more_ = !cursor_mode_;
 1680|      0|                    break;
 1681|      0|                }
 1682|      0|                case 0x16:
  ------------------
  |  Branch (1682:17): [True: 0, False: 2]
  ------------------
 1683|      0|                {
 1684|      0|                    read(bytes_buffer_,ec);
 1685|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1686|      0|                    {
 1687|      0|                        more_ = false;
 1688|      0|                        return;
 1689|      0|                    }
 1690|      0|                    visitor.byte_string_value(bytes_buffer_, semantic_tag::base64, *this, ec);
 1691|      0|                    more_ = !cursor_mode_;
 1692|      0|                    break;
 1693|      0|                }
 1694|      0|                case 0x17:
  ------------------
  |  Branch (1694:17): [True: 0, False: 2]
  ------------------
 1695|      0|                {
 1696|      0|                    read(bytes_buffer_,ec);
 1697|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1698|      0|                    {
 1699|      0|                        more_ = false;
 1700|      0|                        return;
 1701|      0|                    }
 1702|      0|                    visitor.byte_string_value(bytes_buffer_, semantic_tag::base16, *this, ec);
 1703|      0|                    more_ = !cursor_mode_;
 1704|      0|                    break;
 1705|      0|                }
 1706|      0|                case 0x40:
  ------------------
  |  Branch (1706:17): [True: 0, False: 2]
  ------------------
 1707|      0|                {
 1708|      0|                    is_typed_array_ = true;
 1709|      0|                    element_type_ = typed_array_element_types::uint8;
 1710|      0|                    array_buffer_.clear();
 1711|      0|                    read(array_buffer_,ec);
 1712|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1713|      0|                    {
 1714|      0|                        more_ = false;
 1715|      0|                        return;
 1716|      0|                    }
 1717|      0|                    auto ta = typed_array_cast<const uint8_t>(array_buffer_);
 1718|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1718:25): [True: 0, False: 0]
  ------------------
 1719|      0|                    {
 1720|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<const uint8_t>>(ta, extents_, order_);
 1721|      0|                    }
 1722|      0|                    else
 1723|      0|                    {
 1724|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<const uint8_t>>(ta);
 1725|      0|                    }
 1726|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1727|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1728|      0|                    more_ = !cursor_mode_;
 1729|      0|                    break;
 1730|      0|                }
 1731|      0|                case 0x44:
  ------------------
  |  Branch (1731:17): [True: 0, False: 2]
  ------------------
 1732|      0|                {
 1733|      0|                    is_typed_array_ = true;
 1734|      0|                    element_type_ = typed_array_element_types::uint8;
 1735|      0|                    typed_array_tag_ = semantic_tag::clamped;
 1736|      0|                    array_buffer_.clear();
 1737|      0|                    read(array_buffer_,ec);
 1738|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1739|      0|                    {
 1740|      0|                        more_ = false;
 1741|      0|                        return;
 1742|      0|                    }
 1743|      0|                    auto ta = typed_array_cast<const uint8_t>(array_buffer_);
 1744|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1744:25): [True: 0, False: 0]
  ------------------
 1745|      0|                    {
 1746|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<const uint8_t>>(ta, extents_, order_);
 1747|      0|                    }
 1748|      0|                    else
 1749|      0|                    {
 1750|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<const uint8_t>>(ta, semantic_tag::clamped);
 1751|      0|                    }
 1752|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1753|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1754|      0|                    more_ = !cursor_mode_;
 1755|      0|                    break;
 1756|      0|                }
 1757|      0|                case 0x41:
  ------------------
  |  Branch (1757:17): [True: 0, False: 2]
  ------------------
 1758|      0|                case 0x45:
  ------------------
  |  Branch (1758:17): [True: 0, False: 2]
  ------------------
 1759|      0|                {
 1760|      0|                    is_typed_array_ = true;
 1761|      0|                    element_type_ = typed_array_element_types::uint16;
 1762|      0|                    array_buffer_.clear();
 1763|      0|                    read(array_buffer_,ec);
 1764|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1765|      0|                    {
 1766|      0|                        more_ = false;
 1767|      0|                        return;
 1768|      0|                    }
 1769|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 1770|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 1771|      0|                    auto ta = typed_array_cast<uint16_t>(array_buffer_);
 1772|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (1772:25): [True: 0, False: 0]
  ------------------
 1773|      0|                    {
 1774|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (1774:49): [True: 0, False: 0]
  ------------------
 1775|      0|                        {
 1776|      0|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 1777|      0|                        }
 1778|      0|                    }
 1779|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1779:25): [True: 0, False: 0]
  ------------------
 1780|      0|                    {
 1781|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint16_t>>(ta, extents_, order_);
 1782|      0|                    }
 1783|      0|                    else
 1784|      0|                    {
 1785|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint16_t>>(ta);
 1786|      0|                    }
 1787|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1788|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1789|      0|                    more_ = !cursor_mode_;
 1790|      0|                    break;
 1791|      0|                }
 1792|      0|                case 0x42:
  ------------------
  |  Branch (1792:17): [True: 0, False: 2]
  ------------------
 1793|      0|                case 0x46:
  ------------------
  |  Branch (1793:17): [True: 0, False: 2]
  ------------------
 1794|      0|                {
 1795|      0|                    is_typed_array_ = true;
 1796|      0|                    element_type_ = typed_array_element_types::uint32;
 1797|      0|                    array_buffer_.clear();
 1798|      0|                    read(array_buffer_,ec);
 1799|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1800|      0|                    {
 1801|      0|                        more_ = false;
 1802|      0|                        return;
 1803|      0|                    }
 1804|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 1805|      0|                    jsoncons::endian e = get_typed_array_endianness(tag);
 1806|      0|                    auto ta = typed_array_cast<uint32_t>(array_buffer_);
 1807|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (1807:25): [True: 0, False: 0]
  ------------------
 1808|      0|                    {
 1809|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (1809:49): [True: 0, False: 0]
  ------------------
 1810|      0|                        {
 1811|      0|                            ta[i] = binary::byte_swap<uint32_t>(ta[i]);
 1812|      0|                        }
 1813|      0|                    }
 1814|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1814:25): [True: 0, False: 0]
  ------------------
 1815|      0|                    {
 1816|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint32_t>>(ta, extents_, order_);
 1817|      0|                    }
 1818|      0|                    else
 1819|      0|                    {
 1820|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint32_t>>(ta);
 1821|      0|                    }
 1822|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1823|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1824|      0|                    more_ = !cursor_mode_;
 1825|      0|                    break;
 1826|      0|                }
 1827|      0|                case 0x43:
  ------------------
  |  Branch (1827:17): [True: 0, False: 2]
  ------------------
 1828|      0|                case 0x47:
  ------------------
  |  Branch (1828:17): [True: 0, False: 2]
  ------------------
 1829|      0|                {
 1830|      0|                    is_typed_array_ = true;
 1831|      0|                    element_type_ = typed_array_element_types::uint64;
 1832|      0|                    array_buffer_.clear();
 1833|      0|                    read(array_buffer_,ec);
 1834|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1835|      0|                    {
 1836|      0|                        more_ = false;
 1837|      0|                        return;
 1838|      0|                    }
 1839|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 1840|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 1841|      0|                    auto ta = typed_array_cast<uint64_t>(array_buffer_);
 1842|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (1842:25): [True: 0, False: 0]
  ------------------
 1843|      0|                    {
 1844|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (1844:49): [True: 0, False: 0]
  ------------------
 1845|      0|                        {
 1846|      0|                            ta[i] = binary::byte_swap<uint64_t>(ta[i]);
 1847|      0|                        }
 1848|      0|                    }
 1849|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1849:25): [True: 0, False: 0]
  ------------------
 1850|      0|                    {
 1851|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint64_t>>(ta, extents_, order_);
 1852|      0|                    }
 1853|      0|                    else
 1854|      0|                    {
 1855|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint64_t>>(ta);
 1856|      0|                    }
 1857|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1858|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1859|      0|                    more_ = !cursor_mode_;
 1860|      0|                    break;
 1861|      0|                }
 1862|      0|                case 0x48:
  ------------------
  |  Branch (1862:17): [True: 0, False: 2]
  ------------------
 1863|      0|                {
 1864|      0|                    is_typed_array_ = true;
 1865|      0|                    element_type_ = typed_array_element_types::int8;
 1866|      0|                    array_buffer_.clear();
 1867|      0|                    read(array_buffer_,ec);
 1868|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1869|      0|                    {
 1870|      0|                        more_ = false;
 1871|      0|                        return;
 1872|      0|                    }
 1873|      0|                    auto ta = typed_array_cast<int8_t>(array_buffer_);
 1874|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1874:25): [True: 0, False: 0]
  ------------------
 1875|      0|                    {
 1876|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int8_t>>(ta, extents_, order_);
 1877|      0|                    }
 1878|      0|                    else
 1879|      0|                    {
 1880|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int8_t>>(ta);
 1881|      0|                    }
 1882|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1883|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1884|      0|                    more_ = !cursor_mode_;
 1885|      0|                    break;
 1886|      0|                }
 1887|      0|                case 0x49:
  ------------------
  |  Branch (1887:17): [True: 0, False: 2]
  ------------------
 1888|      0|                case 0x4d:
  ------------------
  |  Branch (1888:17): [True: 0, False: 2]
  ------------------
 1889|      0|                {
 1890|      0|                    is_typed_array_ = true;
 1891|      0|                    element_type_ = typed_array_element_types::int16;
 1892|      0|                    array_buffer_.clear();
 1893|      0|                    read(array_buffer_,ec);
 1894|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1895|      0|                    {
 1896|      0|                        more_ = false;
 1897|      0|                        return;
 1898|      0|                    }
 1899|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 1900|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 1901|      0|                    auto ta = typed_array_cast<int16_t>(array_buffer_);
 1902|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (1902:25): [True: 0, False: 0]
  ------------------
 1903|      0|                    {
 1904|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (1904:49): [True: 0, False: 0]
  ------------------
 1905|      0|                        {
 1906|      0|                            ta[i] = binary::byte_swap<int16_t>(ta[i]);
 1907|      0|                        }
 1908|      0|                    }
 1909|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1909:25): [True: 0, False: 0]
  ------------------
 1910|      0|                    {
 1911|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int16_t>>(ta, extents_, order_);
 1912|      0|                    }
 1913|      0|                    else
 1914|      0|                    {
 1915|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int16_t>>(ta);
 1916|      0|                    }
 1917|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1918|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1919|      0|                    more_ = !cursor_mode_;
 1920|      0|                    break;
 1921|      0|                }
 1922|      0|                case 0x4a:
  ------------------
  |  Branch (1922:17): [True: 0, False: 2]
  ------------------
 1923|      0|                case 0x4e:
  ------------------
  |  Branch (1923:17): [True: 0, False: 2]
  ------------------
 1924|      0|                {
 1925|      0|                    is_typed_array_ = true;
 1926|      0|                    element_type_ = typed_array_element_types::int32;
 1927|      0|                    array_buffer_.clear();
 1928|      0|                    read(array_buffer_,ec);
 1929|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1930|      0|                    {
 1931|      0|                        more_ = false;
 1932|      0|                        return;
 1933|      0|                    }
 1934|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 1935|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 1936|      0|                    auto ta = typed_array_cast<int32_t>(array_buffer_);
 1937|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (1937:25): [True: 0, False: 0]
  ------------------
 1938|      0|                    {
 1939|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (1939:49): [True: 0, False: 0]
  ------------------
 1940|      0|                        {
 1941|      0|                            ta[i] = binary::byte_swap<int32_t>(ta[i]);
 1942|      0|                        }
 1943|      0|                    }
 1944|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1944:25): [True: 0, False: 0]
  ------------------
 1945|      0|                    {
 1946|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int32_t>>(ta, extents_, order_);
 1947|      0|                    }
 1948|      0|                    else
 1949|      0|                    {
 1950|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int32_t>>(ta);
 1951|      0|                    }
 1952|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1953|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1954|      0|                    more_ = !cursor_mode_;
 1955|      0|                    break;
 1956|      0|                }
 1957|      0|                case 0x4b:
  ------------------
  |  Branch (1957:17): [True: 0, False: 2]
  ------------------
 1958|      0|                case 0x4f:
  ------------------
  |  Branch (1958:17): [True: 0, False: 2]
  ------------------
 1959|      0|                {
 1960|      0|                    is_typed_array_ = true;
 1961|      0|                    element_type_ = typed_array_element_types::int64;
 1962|      0|                    array_buffer_.clear();
 1963|      0|                    read(array_buffer_,ec);
 1964|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1965|      0|                    {
 1966|      0|                        more_ = false;
 1967|      0|                        return;
 1968|      0|                    }
 1969|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 1970|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 1971|      0|                    auto ta = typed_array_cast<int64_t>(array_buffer_);
 1972|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (1972:25): [True: 0, False: 0]
  ------------------
 1973|      0|                    {
 1974|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (1974:49): [True: 0, False: 0]
  ------------------
 1975|      0|                        {
 1976|      0|                            ta[i] = binary::byte_swap<int64_t>(ta[i]);
 1977|      0|                        }
 1978|      0|                    }
 1979|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1979:25): [True: 0, False: 0]
  ------------------
 1980|      0|                    {
 1981|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int64_t>>(ta, extents_, order_);
 1982|      0|                    }
 1983|      0|                    else
 1984|      0|                    {
 1985|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int64_t>>(ta);
 1986|      0|                    }
 1987|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1988|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1989|      0|                    more_ = !cursor_mode_;
 1990|      0|                    break;
 1991|      0|                }
 1992|      0|                case 0x50:
  ------------------
  |  Branch (1992:17): [True: 0, False: 2]
  ------------------
 1993|      0|                case 0x54:
  ------------------
  |  Branch (1993:17): [True: 0, False: 2]
  ------------------
 1994|      0|                {
 1995|      0|                    is_typed_array_ = true;
 1996|      0|                    element_type_ = typed_array_element_types::half_float;
 1997|      0|                    array_buffer_.clear();
 1998|      0|                    read(array_buffer_,ec);
 1999|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2000|      0|                    {
 2001|      0|                        more_ = false;
 2002|      0|                        return;
 2003|      0|                    }
 2004|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2005|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2006|      0|                    auto ta = typed_array_cast<uint16_t>(array_buffer_);
 2007|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2007:25): [True: 0, False: 0]
  ------------------
 2008|      0|                    {
 2009|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2009:49): [True: 0, False: 0]
  ------------------
 2010|      0|                        {
 2011|      0|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2012|      0|                        }
 2013|      0|                    }
 2014|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (2014:25): [True: 0, False: 0]
  ------------------
 2015|      0|                    {
 2016|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint16_t>>(ta, extents_, order_);
 2017|      0|                    }
 2018|      0|                    else
 2019|      0|                    {
 2020|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint16_t,decode_half>>(ta);
 2021|      0|                    }
 2022|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2023|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2024|      0|                    more_ = !cursor_mode_;
 2025|      0|                    break;
 2026|      0|                }
 2027|      0|                case 0x51:
  ------------------
  |  Branch (2027:17): [True: 0, False: 2]
  ------------------
 2028|      0|                case 0x55:
  ------------------
  |  Branch (2028:17): [True: 0, False: 2]
  ------------------
 2029|      0|                {
 2030|      0|                    is_typed_array_ = true;
 2031|      0|                    element_type_ = typed_array_element_types::float32;
 2032|      0|                    array_buffer_.clear();
 2033|      0|                    read(array_buffer_,ec);
 2034|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2035|      0|                    {
 2036|      0|                        more_ = false;
 2037|      0|                        return;
 2038|      0|                    }
 2039|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2040|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2041|      0|                    auto ta = typed_array_cast<float>(array_buffer_);
 2042|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2042:25): [True: 0, False: 0]
  ------------------
 2043|      0|                    {
 2044|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2044:49): [True: 0, False: 0]
  ------------------
 2045|      0|                        {
 2046|      0|                            ta[i] = binary::byte_swap<float>(ta[i]);
 2047|      0|                        }
 2048|      0|                    }
 2049|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (2049:25): [True: 0, False: 0]
  ------------------
 2050|      0|                    {
 2051|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<float>>(ta, extents_, order_);
 2052|      0|                    }
 2053|      0|                    else
 2054|      0|                    {
 2055|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<float>>(ta);
 2056|      0|                    }
 2057|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2058|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2059|      0|                    more_ = !cursor_mode_;
 2060|      0|                    break;
 2061|      0|                }
 2062|      0|                case 0x52:
  ------------------
  |  Branch (2062:17): [True: 0, False: 2]
  ------------------
 2063|      2|                case 0x56:
  ------------------
  |  Branch (2063:17): [True: 2, False: 0]
  ------------------
 2064|      2|                {
 2065|      2|                    is_typed_array_ = true;
 2066|      2|                    element_type_ = typed_array_element_types::float64 ;
 2067|      2|                    array_buffer_.clear();
 2068|      2|                    read(array_buffer_,ec);
 2069|      2|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 2070|      0|                    {
 2071|      0|                        more_ = false;
 2072|      0|                        return;
 2073|      0|                    }
 2074|      2|                    const uint8_t tag = (uint8_t)raw_tag_;
 2075|      2|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2076|      2|                    auto ta = typed_array_cast<double>(array_buffer_);
 2077|      2|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2077:25): [True: 0, False: 2]
  ------------------
 2078|      0|                    {
 2079|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2079:49): [True: 0, False: 0]
  ------------------
 2080|      0|                        {
 2081|      0|                            ta[i] = binary::byte_swap<double>(ta[i]);
 2082|      0|                        }
 2083|      0|                    }
 2084|      2|                    if (is_multi_dim_)
  ------------------
  |  Branch (2084:25): [True: 0, False: 2]
  ------------------
 2085|      0|                    {
 2086|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<double>>(ta, extents_, order_);
 2087|      0|                    }
 2088|      2|                    else
 2089|      2|                    {
 2090|      2|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<double>>(ta);
 2091|      2|                    }
 2092|      2|                    typed_array_iter_->next(visitor, *this, ec);
 2093|      2|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2094|      2|                    more_ = !cursor_mode_;
 2095|      2|                    break;
 2096|      2|                }
 2097|      0|                default:
  ------------------
  |  Branch (2097:17): [True: 0, False: 2]
  ------------------
 2098|      0|                {
 2099|      0|                    read(bytes_buffer_,ec);
 2100|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2101|      0|                    {
 2102|      0|                        more_ = false;
 2103|      0|                        return;
 2104|      0|                    }
 2105|      0|                    visitor.byte_string_value(bytes_buffer_, raw_tag_, *this, ec);
 2106|      0|                    more_ = !cursor_mode_;
 2107|      0|                    break;
 2108|      0|                }
 2109|      2|            }
 2110|      2|            other_tags_[item_tag] = false;
 2111|      2|        }
 2112|      0|        else
 2113|      0|        {
 2114|      0|            read(bytes_buffer_,ec);
 2115|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2116|      0|            {
 2117|      0|                return;
 2118|      0|            }
 2119|      0|            visitor.byte_string_value(bytes_buffer_, semantic_tag::none, *this, ec);
 2120|      0|            more_ = !cursor_mode_;
 2121|      0|        }
 2122|      2|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_bufferclINS3_6vectorIhS5_EEEEvRT_RNS3_10error_codeE:
  164|      2|        {
  165|      2|            c.clear();
  166|      2|            c.reserve(bytes.size());
  167|      2|            for (auto b : bytes)
  ------------------
  |  Branch (167:25): [True: 22, False: 2]
  ------------------
  168|     22|            {
  169|     22|                c.push_back(b);
  170|     22|            }
  171|      2|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE26get_typed_array_endiannessEh:
 1618|    789|    {
 1619|    789|        return ((tag & detail::cbor_array_tags_e_mask) >> detail::cbor_array_tags_e_shift) == 0 ? jsoncons::endian::big : jsoncons::endian::little; 
  ------------------
  |  Branch (1619:16): [True: 17, False: 772]
  ------------------
 1620|    789|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10read_int64ERNS3_10error_codeE:
 1070|    253|    {
 1071|    253|        int64_t val = 0;
 1072|       |
 1073|    253|        auto ch = source_.peek();
 1074|    253|        if (ch.eof)
  ------------------
  |  Branch (1074:13): [True: 0, False: 253]
  ------------------
 1075|      0|        {
 1076|      0|            ec = cbor_errc::unexpected_eof;
 1077|      0|            more_ = false;
 1078|      0|            return val;
 1079|      0|        }
 1080|       |
 1081|    253|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(ch.value);
 1082|    253|        uint8_t info = get_additional_information_value(ch.value);
 1083|    253|        switch (major_type)
 1084|    253|        {
 1085|    253|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1085:13): [True: 253, False: 0]
  ------------------
 1086|    253|                source_.ignore(1);
 1087|    253|                switch (info)
  ------------------
  |  Branch (1087:25): [True: 239, False: 14]
  ------------------
 1088|    253|                {
 1089|    233|                    case JSONCONS_EXT_CBOR_0x00_0x17: // 0x00..0x17 (0..23)
  ------------------
  |  |   18|    233|    0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x09:case 0x0a:case 0x0b:case 0x0c:case 0x0d:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16:case 0x17
  |  |  ------------------
  |  |  |  Branch (18:10): [True: 0, False: 253]
  |  |  |  Branch (18:20): [True: 22, False: 231]
  |  |  |  Branch (18:30): [True: 0, False: 253]
  |  |  |  Branch (18:40): [True: 0, False: 253]
  |  |  |  Branch (18:50): [True: 8, False: 245]
  |  |  |  Branch (18:60): [True: 0, False: 253]
  |  |  |  Branch (18:70): [True: 1, False: 252]
  |  |  |  Branch (18:80): [True: 1, False: 252]
  |  |  |  Branch (18:90): [True: 1, False: 252]
  |  |  |  Branch (18:100): [True: 0, False: 253]
  |  |  |  Branch (18:110): [True: 0, False: 253]
  |  |  |  Branch (18:120): [True: 1, False: 252]
  |  |  |  Branch (18:130): [True: 1, False: 252]
  |  |  |  Branch (18:140): [True: 3, False: 250]
  |  |  |  Branch (18:150): [True: 0, False: 253]
  |  |  |  Branch (18:160): [True: 4, False: 249]
  |  |  |  Branch (18:170): [True: 1, False: 252]
  |  |  |  Branch (18:180): [True: 172, False: 81]
  |  |  |  Branch (18:190): [True: 1, False: 252]
  |  |  |  Branch (18:200): [True: 2, False: 251]
  |  |  |  Branch (18:210): [True: 5, False: 248]
  |  |  |  Branch (18:220): [True: 1, False: 252]
  |  |  ------------------
  ------------------
  |  Branch (1089:21): [True: 9, False: 244]
  ------------------
 1090|    233|                    {
 1091|    233|                        val = static_cast<int8_t>(- 1 - info);
 1092|    233|                        break;
 1093|  1.81k|                    }
 1094|      0|                    case 0x18: // Negative integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1094:21): [True: 0, False: 253]
  ------------------
 1095|      0|                        {
 1096|      0|                            uint8_t b;
 1097|      0|                            if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1097:33): [True: 0, False: 0]
  ------------------
 1098|      0|                            {
 1099|      0|                                ec = cbor_errc::unexpected_eof;
 1100|      0|                                more_ = false;
 1101|      0|                                return val;
 1102|      0|                            }
 1103|      0|                            val = static_cast<int64_t>(-1) - static_cast<int64_t>(b);
 1104|      0|                            break;
 1105|      0|                        }
 1106|       |
 1107|      3|                    case 0x19: // Negative integer -1-n (two-byte uint16_t follows)
  ------------------
  |  Branch (1107:21): [True: 3, False: 250]
  ------------------
 1108|      3|                        {
 1109|      3|                            uint8_t buf[sizeof(uint16_t)];
 1110|      3|                            if (source_.read(buf, sizeof(uint16_t)) != sizeof(uint16_t))
  ------------------
  |  Branch (1110:33): [True: 0, False: 3]
  ------------------
 1111|      0|                            {
 1112|      0|                                ec = cbor_errc::unexpected_eof;
 1113|      0|                                more_ = false;
 1114|      0|                                return val;
 1115|      0|                            }
 1116|      3|                            auto x = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1117|      3|                            val = static_cast<int64_t>(-1)- x;
 1118|      3|                            break;
 1119|      3|                        }
 1120|       |
 1121|      0|                    case 0x1a: // Negative integer -1-n (four-byte uint32_t follows)
  ------------------
  |  Branch (1121:21): [True: 0, False: 253]
  ------------------
 1122|      0|                        {
 1123|      0|                            uint8_t buf[sizeof(uint32_t)];
 1124|      0|                            if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (1124:33): [True: 0, False: 0]
  ------------------
 1125|      0|                            {
 1126|      0|                                ec = cbor_errc::unexpected_eof;
 1127|      0|                                more_ = false;
 1128|      0|                                return val;
 1129|      0|                            }
 1130|      0|                            auto x = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1131|      0|                            val = static_cast<int64_t>(-1)- x;
 1132|      0|                            break;
 1133|      0|                        }
 1134|       |
 1135|      3|                    case 0x1b: // Negative integer -1-n (eight-byte uint64_t follows)
  ------------------
  |  Branch (1135:21): [True: 3, False: 250]
  ------------------
 1136|      3|                        {
 1137|      3|                            uint8_t buf[sizeof(uint64_t)];
 1138|      3|                            if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (1138:33): [True: 0, False: 3]
  ------------------
 1139|      0|                            {
 1140|      0|                                ec = cbor_errc::unexpected_eof;
 1141|      0|                                more_ = false;
 1142|      0|                                return val;
 1143|      0|                            }
 1144|      3|                            auto x = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1145|      3|                            val = static_cast<int64_t>(-1)- static_cast<int64_t>(x);
 1146|      3|                            break;
 1147|      3|                        }
 1148|    253|                }
 1149|    253|                break;
 1150|       |
 1151|    253|                case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1151:17): [True: 0, False: 253]
  ------------------
 1152|      0|                {
 1153|      0|                    uint64_t x = read_uint64(ec);
 1154|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1155|      0|                    {
 1156|      0|                        return 0;
 1157|      0|                    }
 1158|      0|                    if (x <= static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1158:25): [True: 0, False: 0]
  ------------------
 1159|      0|                    {
 1160|      0|                        val = x;
 1161|      0|                    }
 1162|      0|                    else
 1163|      0|                    {
 1164|       |                        // error;
 1165|      0|                    }
 1166|       |                    
 1167|      0|                    break;
 1168|      0|                }
 1169|      0|                break;
 1170|      0|            default:
  ------------------
  |  Branch (1170:13): [True: 0, False: 253]
  ------------------
 1171|      0|                break;
 1172|    253|        }
 1173|       |
 1174|    253|        return val;
 1175|    253|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_sourceC2EPS8_:
  179|  1.22k|            : source(source)
  180|  1.22k|        {
  181|  1.22k|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringINS8_28read_byte_string_from_sourceEEEvT_RNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
 1632|  1.22k|    {
 1633|  1.22k|        if (other_tags_[item_tag])
  ------------------
  |  Branch (1633:13): [True: 815, False: 413]
  ------------------
 1634|    815|        {
 1635|    815|            switch (raw_tag_)
 1636|    815|            {
 1637|      0|                case 0x2:
  ------------------
  |  Branch (1637:17): [True: 0, False: 815]
  ------------------
 1638|      0|                {
 1639|      0|                    bytes_buffer_.clear();
 1640|      0|                    read(bytes_buffer_,ec);
 1641|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1642|      0|                    {
 1643|      0|                        more_ = false;
 1644|      0|                        return;
 1645|      0|                    }
 1646|      0|                    bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1647|      0|                    text_buffer_.clear();
 1648|      0|                    n.write_string(text_buffer_);
 1649|      0|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 1650|      0|                    more_ = !cursor_mode_;
 1651|      0|                    break;
 1652|      0|                }
 1653|      0|                case 0x3:
  ------------------
  |  Branch (1653:17): [True: 0, False: 815]
  ------------------
 1654|      0|                {
 1655|      0|                    bytes_buffer_.clear();
 1656|      0|                    read(bytes_buffer_,ec);
 1657|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1658|      0|                    {
 1659|      0|                        more_ = false;
 1660|      0|                        return;
 1661|      0|                    }
 1662|      0|                    bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1663|      0|                    n = -1 - n;
 1664|      0|                    text_buffer_.clear();
 1665|      0|                    n.write_string(text_buffer_);
 1666|      0|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 1667|      0|                    more_ = !cursor_mode_;
 1668|      0|                    break;
 1669|      0|                }
 1670|      0|                case 0x15:
  ------------------
  |  Branch (1670:17): [True: 0, False: 815]
  ------------------
 1671|      0|                {
 1672|      0|                    read(bytes_buffer_,ec);
 1673|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1674|      0|                    {
 1675|      0|                        more_ = false;
 1676|      0|                        return;
 1677|      0|                    }
 1678|      0|                    visitor.byte_string_value(bytes_buffer_, semantic_tag::base64url, *this, ec);
 1679|      0|                    more_ = !cursor_mode_;
 1680|      0|                    break;
 1681|      0|                }
 1682|      0|                case 0x16:
  ------------------
  |  Branch (1682:17): [True: 0, False: 815]
  ------------------
 1683|      0|                {
 1684|      0|                    read(bytes_buffer_,ec);
 1685|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1686|      0|                    {
 1687|      0|                        more_ = false;
 1688|      0|                        return;
 1689|      0|                    }
 1690|      0|                    visitor.byte_string_value(bytes_buffer_, semantic_tag::base64, *this, ec);
 1691|      0|                    more_ = !cursor_mode_;
 1692|      0|                    break;
 1693|      0|                }
 1694|      0|                case 0x17:
  ------------------
  |  Branch (1694:17): [True: 0, False: 815]
  ------------------
 1695|      0|                {
 1696|      0|                    read(bytes_buffer_,ec);
 1697|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1698|      0|                    {
 1699|      0|                        more_ = false;
 1700|      0|                        return;
 1701|      0|                    }
 1702|      0|                    visitor.byte_string_value(bytes_buffer_, semantic_tag::base16, *this, ec);
 1703|      0|                    more_ = !cursor_mode_;
 1704|      0|                    break;
 1705|      0|                }
 1706|      4|                case 0x40:
  ------------------
  |  Branch (1706:17): [True: 4, False: 811]
  ------------------
 1707|      4|                {
 1708|      4|                    is_typed_array_ = true;
 1709|      4|                    element_type_ = typed_array_element_types::uint8;
 1710|      4|                    array_buffer_.clear();
 1711|      4|                    read(array_buffer_,ec);
 1712|      4|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 1713|      0|                    {
 1714|      0|                        more_ = false;
 1715|      0|                        return;
 1716|      0|                    }
 1717|      4|                    auto ta = typed_array_cast<const uint8_t>(array_buffer_);
 1718|      4|                    if (is_multi_dim_)
  ------------------
  |  Branch (1718:25): [True: 0, False: 4]
  ------------------
 1719|      0|                    {
 1720|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<const uint8_t>>(ta, extents_, order_);
 1721|      0|                    }
 1722|      4|                    else
 1723|      4|                    {
 1724|      4|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<const uint8_t>>(ta);
 1725|      4|                    }
 1726|      4|                    typed_array_iter_->next(visitor, *this, ec);
 1727|      4|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1728|      4|                    more_ = !cursor_mode_;
 1729|      4|                    break;
 1730|      4|                }
 1731|      0|                case 0x44:
  ------------------
  |  Branch (1731:17): [True: 0, False: 815]
  ------------------
 1732|      0|                {
 1733|      0|                    is_typed_array_ = true;
 1734|      0|                    element_type_ = typed_array_element_types::uint8;
 1735|      0|                    typed_array_tag_ = semantic_tag::clamped;
 1736|      0|                    array_buffer_.clear();
 1737|      0|                    read(array_buffer_,ec);
 1738|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1739|      0|                    {
 1740|      0|                        more_ = false;
 1741|      0|                        return;
 1742|      0|                    }
 1743|      0|                    auto ta = typed_array_cast<const uint8_t>(array_buffer_);
 1744|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1744:25): [True: 0, False: 0]
  ------------------
 1745|      0|                    {
 1746|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<const uint8_t>>(ta, extents_, order_);
 1747|      0|                    }
 1748|      0|                    else
 1749|      0|                    {
 1750|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<const uint8_t>>(ta, semantic_tag::clamped);
 1751|      0|                    }
 1752|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1753|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1754|      0|                    more_ = !cursor_mode_;
 1755|      0|                    break;
 1756|      0|                }
 1757|      1|                case 0x41:
  ------------------
  |  Branch (1757:17): [True: 1, False: 814]
  ------------------
 1758|      1|                case 0x45:
  ------------------
  |  Branch (1758:17): [True: 0, False: 815]
  ------------------
 1759|      1|                {
 1760|      1|                    is_typed_array_ = true;
 1761|      1|                    element_type_ = typed_array_element_types::uint16;
 1762|      1|                    array_buffer_.clear();
 1763|      1|                    read(array_buffer_,ec);
 1764|      1|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1765|      0|                    {
 1766|      0|                        more_ = false;
 1767|      0|                        return;
 1768|      0|                    }
 1769|      1|                    const uint8_t tag = (uint8_t)raw_tag_;
 1770|      1|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 1771|      1|                    auto ta = typed_array_cast<uint16_t>(array_buffer_);
 1772|      1|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (1772:25): [True: 1, False: 0]
  ------------------
 1773|      1|                    {
 1774|      1|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (1774:49): [True: 0, False: 1]
  ------------------
 1775|      0|                        {
 1776|      0|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 1777|      0|                        }
 1778|      1|                    }
 1779|      1|                    if (is_multi_dim_)
  ------------------
  |  Branch (1779:25): [True: 0, False: 1]
  ------------------
 1780|      0|                    {
 1781|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint16_t>>(ta, extents_, order_);
 1782|      0|                    }
 1783|      1|                    else
 1784|      1|                    {
 1785|      1|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint16_t>>(ta);
 1786|      1|                    }
 1787|      1|                    typed_array_iter_->next(visitor, *this, ec);
 1788|      1|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1789|      1|                    more_ = !cursor_mode_;
 1790|      1|                    break;
 1791|      1|                }
 1792|      0|                case 0x42:
  ------------------
  |  Branch (1792:17): [True: 0, False: 815]
  ------------------
 1793|      0|                case 0x46:
  ------------------
  |  Branch (1793:17): [True: 0, False: 815]
  ------------------
 1794|      0|                {
 1795|      0|                    is_typed_array_ = true;
 1796|      0|                    element_type_ = typed_array_element_types::uint32;
 1797|      0|                    array_buffer_.clear();
 1798|      0|                    read(array_buffer_,ec);
 1799|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1800|      0|                    {
 1801|      0|                        more_ = false;
 1802|      0|                        return;
 1803|      0|                    }
 1804|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 1805|      0|                    jsoncons::endian e = get_typed_array_endianness(tag);
 1806|      0|                    auto ta = typed_array_cast<uint32_t>(array_buffer_);
 1807|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (1807:25): [True: 0, False: 0]
  ------------------
 1808|      0|                    {
 1809|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (1809:49): [True: 0, False: 0]
  ------------------
 1810|      0|                        {
 1811|      0|                            ta[i] = binary::byte_swap<uint32_t>(ta[i]);
 1812|      0|                        }
 1813|      0|                    }
 1814|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1814:25): [True: 0, False: 0]
  ------------------
 1815|      0|                    {
 1816|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint32_t>>(ta, extents_, order_);
 1817|      0|                    }
 1818|      0|                    else
 1819|      0|                    {
 1820|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint32_t>>(ta);
 1821|      0|                    }
 1822|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1823|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1824|      0|                    more_ = !cursor_mode_;
 1825|      0|                    break;
 1826|      0|                }
 1827|     16|                case 0x43:
  ------------------
  |  Branch (1827:17): [True: 16, False: 799]
  ------------------
 1828|     91|                case 0x47:
  ------------------
  |  Branch (1828:17): [True: 75, False: 740]
  ------------------
 1829|     91|                {
 1830|     91|                    is_typed_array_ = true;
 1831|     91|                    element_type_ = typed_array_element_types::uint64;
 1832|     91|                    array_buffer_.clear();
 1833|     91|                    read(array_buffer_,ec);
 1834|     91|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     91|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 91]
  |  |  ------------------
  ------------------
 1835|      0|                    {
 1836|      0|                        more_ = false;
 1837|      0|                        return;
 1838|      0|                    }
 1839|     91|                    const uint8_t tag = (uint8_t)raw_tag_;
 1840|     91|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 1841|     91|                    auto ta = typed_array_cast<uint64_t>(array_buffer_);
 1842|     91|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (1842:25): [True: 16, False: 75]
  ------------------
 1843|     16|                    {
 1844|     16|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (1844:49): [True: 0, False: 16]
  ------------------
 1845|      0|                        {
 1846|      0|                            ta[i] = binary::byte_swap<uint64_t>(ta[i]);
 1847|      0|                        }
 1848|     16|                    }
 1849|     91|                    if (is_multi_dim_)
  ------------------
  |  Branch (1849:25): [True: 0, False: 91]
  ------------------
 1850|      0|                    {
 1851|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint64_t>>(ta, extents_, order_);
 1852|      0|                    }
 1853|     91|                    else
 1854|     91|                    {
 1855|     91|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint64_t>>(ta);
 1856|     91|                    }
 1857|     91|                    typed_array_iter_->next(visitor, *this, ec);
 1858|     91|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1859|     91|                    more_ = !cursor_mode_;
 1860|     91|                    break;
 1861|     91|                }
 1862|      0|                case 0x48:
  ------------------
  |  Branch (1862:17): [True: 0, False: 815]
  ------------------
 1863|      0|                {
 1864|      0|                    is_typed_array_ = true;
 1865|      0|                    element_type_ = typed_array_element_types::int8;
 1866|      0|                    array_buffer_.clear();
 1867|      0|                    read(array_buffer_,ec);
 1868|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1869|      0|                    {
 1870|      0|                        more_ = false;
 1871|      0|                        return;
 1872|      0|                    }
 1873|      0|                    auto ta = typed_array_cast<int8_t>(array_buffer_);
 1874|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1874:25): [True: 0, False: 0]
  ------------------
 1875|      0|                    {
 1876|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int8_t>>(ta, extents_, order_);
 1877|      0|                    }
 1878|      0|                    else
 1879|      0|                    {
 1880|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int8_t>>(ta);
 1881|      0|                    }
 1882|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1883|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1884|      0|                    more_ = !cursor_mode_;
 1885|      0|                    break;
 1886|      0|                }
 1887|      0|                case 0x49:
  ------------------
  |  Branch (1887:17): [True: 0, False: 815]
  ------------------
 1888|    692|                case 0x4d:
  ------------------
  |  Branch (1888:17): [True: 692, False: 123]
  ------------------
 1889|    692|                {
 1890|    692|                    is_typed_array_ = true;
 1891|    692|                    element_type_ = typed_array_element_types::int16;
 1892|    692|                    array_buffer_.clear();
 1893|    692|                    read(array_buffer_,ec);
 1894|    692|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    692|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 692]
  |  |  ------------------
  ------------------
 1895|      0|                    {
 1896|      0|                        more_ = false;
 1897|      0|                        return;
 1898|      0|                    }
 1899|    692|                    const uint8_t tag = (uint8_t)raw_tag_;
 1900|    692|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 1901|    692|                    auto ta = typed_array_cast<int16_t>(array_buffer_);
 1902|    692|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (1902:25): [True: 0, False: 692]
  ------------------
 1903|      0|                    {
 1904|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (1904:49): [True: 0, False: 0]
  ------------------
 1905|      0|                        {
 1906|      0|                            ta[i] = binary::byte_swap<int16_t>(ta[i]);
 1907|      0|                        }
 1908|      0|                    }
 1909|    692|                    if (is_multi_dim_)
  ------------------
  |  Branch (1909:25): [True: 0, False: 692]
  ------------------
 1910|      0|                    {
 1911|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int16_t>>(ta, extents_, order_);
 1912|      0|                    }
 1913|    692|                    else
 1914|    692|                    {
 1915|    692|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int16_t>>(ta);
 1916|    692|                    }
 1917|    692|                    typed_array_iter_->next(visitor, *this, ec);
 1918|    692|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1919|    692|                    more_ = !cursor_mode_;
 1920|    692|                    break;
 1921|    692|                }
 1922|      0|                case 0x4a:
  ------------------
  |  Branch (1922:17): [True: 0, False: 815]
  ------------------
 1923|      0|                case 0x4e:
  ------------------
  |  Branch (1923:17): [True: 0, False: 815]
  ------------------
 1924|      0|                {
 1925|      0|                    is_typed_array_ = true;
 1926|      0|                    element_type_ = typed_array_element_types::int32;
 1927|      0|                    array_buffer_.clear();
 1928|      0|                    read(array_buffer_,ec);
 1929|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1930|      0|                    {
 1931|      0|                        more_ = false;
 1932|      0|                        return;
 1933|      0|                    }
 1934|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 1935|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 1936|      0|                    auto ta = typed_array_cast<int32_t>(array_buffer_);
 1937|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (1937:25): [True: 0, False: 0]
  ------------------
 1938|      0|                    {
 1939|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (1939:49): [True: 0, False: 0]
  ------------------
 1940|      0|                        {
 1941|      0|                            ta[i] = binary::byte_swap<int32_t>(ta[i]);
 1942|      0|                        }
 1943|      0|                    }
 1944|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (1944:25): [True: 0, False: 0]
  ------------------
 1945|      0|                    {
 1946|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int32_t>>(ta, extents_, order_);
 1947|      0|                    }
 1948|      0|                    else
 1949|      0|                    {
 1950|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int32_t>>(ta);
 1951|      0|                    }
 1952|      0|                    typed_array_iter_->next(visitor, *this, ec);
 1953|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1954|      0|                    more_ = !cursor_mode_;
 1955|      0|                    break;
 1956|      0|                }
 1957|      0|                case 0x4b:
  ------------------
  |  Branch (1957:17): [True: 0, False: 815]
  ------------------
 1958|      1|                case 0x4f:
  ------------------
  |  Branch (1958:17): [True: 1, False: 814]
  ------------------
 1959|      1|                {
 1960|      1|                    is_typed_array_ = true;
 1961|      1|                    element_type_ = typed_array_element_types::int64;
 1962|      1|                    array_buffer_.clear();
 1963|      1|                    read(array_buffer_,ec);
 1964|      1|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1965|      0|                    {
 1966|      0|                        more_ = false;
 1967|      0|                        return;
 1968|      0|                    }
 1969|      1|                    const uint8_t tag = (uint8_t)raw_tag_;
 1970|      1|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 1971|      1|                    auto ta = typed_array_cast<int64_t>(array_buffer_);
 1972|      1|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (1972:25): [True: 0, False: 1]
  ------------------
 1973|      0|                    {
 1974|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (1974:49): [True: 0, False: 0]
  ------------------
 1975|      0|                        {
 1976|      0|                            ta[i] = binary::byte_swap<int64_t>(ta[i]);
 1977|      0|                        }
 1978|      0|                    }
 1979|      1|                    if (is_multi_dim_)
  ------------------
  |  Branch (1979:25): [True: 0, False: 1]
  ------------------
 1980|      0|                    {
 1981|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int64_t>>(ta, extents_, order_);
 1982|      0|                    }
 1983|      1|                    else
 1984|      1|                    {
 1985|      1|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int64_t>>(ta);
 1986|      1|                    }
 1987|      1|                    typed_array_iter_->next(visitor, *this, ec);
 1988|      1|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 1989|      1|                    more_ = !cursor_mode_;
 1990|      1|                    break;
 1991|      1|                }
 1992|      0|                case 0x50:
  ------------------
  |  Branch (1992:17): [True: 0, False: 815]
  ------------------
 1993|      0|                case 0x54:
  ------------------
  |  Branch (1993:17): [True: 0, False: 815]
  ------------------
 1994|      0|                {
 1995|      0|                    is_typed_array_ = true;
 1996|      0|                    element_type_ = typed_array_element_types::half_float;
 1997|      0|                    array_buffer_.clear();
 1998|      0|                    read(array_buffer_,ec);
 1999|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2000|      0|                    {
 2001|      0|                        more_ = false;
 2002|      0|                        return;
 2003|      0|                    }
 2004|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2005|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2006|      0|                    auto ta = typed_array_cast<uint16_t>(array_buffer_);
 2007|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2007:25): [True: 0, False: 0]
  ------------------
 2008|      0|                    {
 2009|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2009:49): [True: 0, False: 0]
  ------------------
 2010|      0|                        {
 2011|      0|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2012|      0|                        }
 2013|      0|                    }
 2014|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (2014:25): [True: 0, False: 0]
  ------------------
 2015|      0|                    {
 2016|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint16_t>>(ta, extents_, order_);
 2017|      0|                    }
 2018|      0|                    else
 2019|      0|                    {
 2020|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint16_t,decode_half>>(ta);
 2021|      0|                    }
 2022|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2023|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2024|      0|                    more_ = !cursor_mode_;
 2025|      0|                    break;
 2026|      0|                }
 2027|      0|                case 0x51:
  ------------------
  |  Branch (2027:17): [True: 0, False: 815]
  ------------------
 2028|      2|                case 0x55:
  ------------------
  |  Branch (2028:17): [True: 2, False: 813]
  ------------------
 2029|      2|                {
 2030|      2|                    is_typed_array_ = true;
 2031|      2|                    element_type_ = typed_array_element_types::float32;
 2032|      2|                    array_buffer_.clear();
 2033|      2|                    read(array_buffer_,ec);
 2034|      2|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 2035|      0|                    {
 2036|      0|                        more_ = false;
 2037|      0|                        return;
 2038|      0|                    }
 2039|      2|                    const uint8_t tag = (uint8_t)raw_tag_;
 2040|      2|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2041|      2|                    auto ta = typed_array_cast<float>(array_buffer_);
 2042|      2|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2042:25): [True: 0, False: 2]
  ------------------
 2043|      0|                    {
 2044|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2044:49): [True: 0, False: 0]
  ------------------
 2045|      0|                        {
 2046|      0|                            ta[i] = binary::byte_swap<float>(ta[i]);
 2047|      0|                        }
 2048|      0|                    }
 2049|      2|                    if (is_multi_dim_)
  ------------------
  |  Branch (2049:25): [True: 0, False: 2]
  ------------------
 2050|      0|                    {
 2051|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<float>>(ta, extents_, order_);
 2052|      0|                    }
 2053|      2|                    else
 2054|      2|                    {
 2055|      2|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<float>>(ta);
 2056|      2|                    }
 2057|      2|                    typed_array_iter_->next(visitor, *this, ec);
 2058|      2|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2059|      2|                    more_ = !cursor_mode_;
 2060|      2|                    break;
 2061|      2|                }
 2062|      0|                case 0x52:
  ------------------
  |  Branch (2062:17): [True: 0, False: 815]
  ------------------
 2063|      0|                case 0x56:
  ------------------
  |  Branch (2063:17): [True: 0, False: 815]
  ------------------
 2064|      0|                {
 2065|      0|                    is_typed_array_ = true;
 2066|      0|                    element_type_ = typed_array_element_types::float64 ;
 2067|      0|                    array_buffer_.clear();
 2068|      0|                    read(array_buffer_,ec);
 2069|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2070|      0|                    {
 2071|      0|                        more_ = false;
 2072|      0|                        return;
 2073|      0|                    }
 2074|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2075|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2076|      0|                    auto ta = typed_array_cast<double>(array_buffer_);
 2077|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2077:25): [True: 0, False: 0]
  ------------------
 2078|      0|                    {
 2079|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2079:49): [True: 0, False: 0]
  ------------------
 2080|      0|                        {
 2081|      0|                            ta[i] = binary::byte_swap<double>(ta[i]);
 2082|      0|                        }
 2083|      0|                    }
 2084|      0|                    if (is_multi_dim_)
  ------------------
  |  Branch (2084:25): [True: 0, False: 0]
  ------------------
 2085|      0|                    {
 2086|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<double>>(ta, extents_, order_);
 2087|      0|                    }
 2088|      0|                    else
 2089|      0|                    {
 2090|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<double>>(ta);
 2091|      0|                    }
 2092|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2093|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2094|      0|                    more_ = !cursor_mode_;
 2095|      0|                    break;
 2096|      0|                }
 2097|     24|                default:
  ------------------
  |  Branch (2097:17): [True: 24, False: 791]
  ------------------
 2098|     24|                {
 2099|     24|                    read(bytes_buffer_,ec);
 2100|     24|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     24|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 24]
  |  |  ------------------
  ------------------
 2101|      0|                    {
 2102|      0|                        more_ = false;
 2103|      0|                        return;
 2104|      0|                    }
 2105|     24|                    visitor.byte_string_value(bytes_buffer_, raw_tag_, *this, ec);
 2106|     24|                    more_ = !cursor_mode_;
 2107|     24|                    break;
 2108|     24|                }
 2109|    815|            }
 2110|    815|            other_tags_[item_tag] = false;
 2111|    815|        }
 2112|    413|        else
 2113|    413|        {
 2114|    413|            read(bytes_buffer_,ec);
 2115|    413|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    413|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 410]
  |  |  ------------------
  ------------------
 2116|      3|            {
 2117|      3|                return;
 2118|      3|            }
 2119|    410|            visitor.byte_string_value(bytes_buffer_, semantic_tag::none, *this, ec);
 2120|    410|            more_ = !cursor_mode_;
 2121|    410|        }
 2122|  1.22k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_sourceclINS3_6vectorIhS5_EEEEvRT_RNS3_10error_codeE:
  184|  1.22k|        {
  185|  1.22k|            source->read_byte_string(cont,ec);
  186|  1.22k|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringERNS3_6vectorIhS5_EERNS3_10error_codeE:
  890|  1.22k|    {
  891|  1.22k|        v.clear();
  892|  1.22k|        auto c = source_.peek();
  893|  1.22k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.22k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.22k]
  |  |  ------------------
  ------------------
  894|      0|        {
  895|      0|            ec = cbor_errc::unexpected_eof;
  896|      0|            return;
  897|      0|        }
  898|  1.22k|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
  899|  1.22k|        uint8_t info = get_additional_information_value(c.value);
  900|       |
  901|  1.22k|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::byte_string);
  ------------------
  |  |   45|  1.22k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 1.22k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  902|       |
  903|  1.22k|        switch(info)
  904|  1.22k|        {
  905|      0|            case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (905:13): [True: 0, False: 1.22k]
  ------------------
  906|      0|            {
  907|      0|                auto func = [&v](Source& source, std::size_t length, std::error_code& ec) -> bool
  908|      0|                {
  909|      0|                    if (source_reader<Source>::read(source, v, length) != length)
  910|      0|                    {
  911|      0|                        ec = cbor_errc::unexpected_eof;
  912|      0|                        return false;
  913|      0|                    }
  914|      0|                    return true;
  915|      0|                };
  916|      0|                iterate_string_chunks(func, major_type, ec);
  917|      0|                break;
  918|      0|            }
  919|  1.22k|            default:
  ------------------
  |  Branch (919:13): [True: 1.22k, False: 0]
  ------------------
  920|  1.22k|            {
  921|  1.22k|                std::size_t length = read_size(ec);
  922|  1.22k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.22k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.22k]
  |  |  ------------------
  ------------------
  923|      0|                {
  924|      0|                    return;
  925|      0|                }
  926|  1.22k|                if (source_reader<Source>::read(source_, v, length) != length)
  ------------------
  |  Branch (926:21): [True: 3, False: 1.22k]
  ------------------
  927|      3|                {
  928|      3|                    ec = cbor_errc::unexpected_eof;
  929|      3|                    return;
  930|      3|                }
  931|  1.22k|                if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (931:21): [True: 87, False: 1.13k]
  ------------------
  932|     87|                    v.size() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (932:21): [True: 7, False: 80]
  ------------------
  933|      7|                {
  934|      7|                    stringref_map_stack_.back().emplace_back(mapped_string(v, alloc_));
  935|      7|                }
  936|  1.22k|                break;
  937|  1.22k|            }
  938|       |
  939|  1.22k|        }
  940|  1.22k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_sizeERNS3_10error_codeE:
  874|  2.09M|    {
  875|  2.09M|        uint64_t u = read_uint64(ec);
  876|  2.09M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.09M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.09M]
  |  |  ------------------
  ------------------
  877|      0|        {
  878|      0|            return 0;
  879|      0|        }
  880|  2.09M|        std::size_t len = static_cast<std::size_t>(u);
  881|  2.09M|        if (len != u)
  ------------------
  |  Branch (881:13): [True: 0, False: 2.09M]
  ------------------
  882|      0|        {
  883|      0|            ec = cbor_errc::number_too_large;
  884|      0|            more_ = false;
  885|      0|        }
  886|  2.09M|        return len;
  887|  2.09M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringC2EOS9_:
  103|     15|        mapped_string(mapped_string&&) = default;
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringC2ERKNS3_6vectorIhS5_EERKS7_:
   92|      7|            : type(jsoncons::cbor::detail::cbor_major_type::byte_string), str(alloc), bytes(bytes,alloc)
   93|      7|        {
   94|      7|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_text_stringERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
  841|      8|    {
  842|      8|        auto c = source_.peek();
  843|      8|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 8]
  |  |  ------------------
  ------------------
  844|      0|        {
  845|      0|            ec = cbor_errc::unexpected_eof;
  846|      0|            more_ = false;
  847|      0|            return;
  848|      0|        }
  849|      8|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
  850|      8|        uint8_t info = get_additional_information_value(c.value);
  851|       |
  852|      8|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::text_string);
  ------------------
  |  |   45|      8|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 8]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  853|      8|        auto func = [&str](Source& source, std::size_t length, std::error_code& ec) -> bool
  854|      8|        {
  855|      8|            if (source_reader<Source>::read(source, str, length) != length)
  856|      8|            {
  857|      8|                ec = cbor_errc::unexpected_eof;
  858|      8|                return false;
  859|      8|            }
  860|      8|            return true;
  861|      8|        };
  862|      8|        iterate_string_chunks(func, major_type, ec);
  863|       |
  864|      8|        if (!stringref_map_stack_.empty() && 
  ------------------
  |  Branch (864:13): [True: 1, False: 7]
  ------------------
  865|      1|            info != jsoncons::cbor::detail::additional_info::indefinite_length &&
  ------------------
  |  Branch (865:13): [True: 1, False: 0]
  ------------------
  866|      1|            str.length() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (866:13): [True: 1, False: 0]
  ------------------
  867|      1|        {
  868|      1|            stringref_map_stack_.back().emplace_back(mapped_string(str,alloc_));
  869|      1|        }
  870|       |
  871|      8|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21iterate_string_chunksIZNS8_16read_text_stringERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeEEUlRS6_mSG_E_EEvRT_NS0_6detail15cbor_major_typeESG_:
  944|      8|    {
  945|      8|        int nesting_level = 0;
  946|       |
  947|      8|        bool done = false;
  948|     14|        while (!done)
  ------------------
  |  Branch (948:16): [True: 8, False: 6]
  ------------------
  949|      8|        {
  950|      8|            auto c = source_.peek();
  951|      8|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 8]
  |  |  ------------------
  ------------------
  952|      0|            {
  953|      0|                ec = cbor_errc::unexpected_eof;
  954|      0|                more_ = false;
  955|      0|                return;
  956|      0|            }
  957|      8|            if (nesting_level > 0 && c.value == 0xff)
  ------------------
  |  Branch (957:17): [True: 0, False: 8]
  |  Branch (957:38): [True: 0, False: 0]
  ------------------
  958|      0|            {
  959|      0|                --nesting_level;
  960|      0|                if (nesting_level == 0)
  ------------------
  |  Branch (960:21): [True: 0, False: 0]
  ------------------
  961|      0|                {
  962|      0|                    done = true;
  963|      0|                }
  964|      0|                source_.ignore(1);
  965|      0|                continue;
  966|      0|            }
  967|       |
  968|      8|            jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
  969|      8|            if (major_type != type)
  ------------------
  |  Branch (969:17): [True: 0, False: 8]
  ------------------
  970|      0|            {
  971|      0|                ec = cbor_errc::illegal_chunked_string;
  972|      0|                more_ = false;
  973|      0|                return;
  974|      0|            }
  975|      8|            uint8_t info = get_additional_information_value(c.value);
  976|       |
  977|      8|            switch (info)
  978|      8|            {
  979|      0|                case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (979:17): [True: 0, False: 8]
  ------------------
  980|      0|                {
  981|      0|                    ++nesting_level;
  982|      0|                    source_.ignore(1);
  983|      0|                    break;
  984|      0|                }
  985|      8|                default: // definite length
  ------------------
  |  Branch (985:17): [True: 8, False: 0]
  ------------------
  986|      8|                {
  987|      8|                    std::size_t length = read_size(ec);
  988|      8|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 8]
  |  |  ------------------
  ------------------
  989|      0|                    {
  990|      0|                        return;
  991|      0|                    }
  992|      8|                    more_ = func(source_, length, ec);
  993|      8|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 6]
  |  |  ------------------
  ------------------
  994|      2|                    {
  995|      2|                        return;
  996|      2|                    }
  997|      6|                    if (nesting_level == 0)
  ------------------
  |  Branch (997:25): [True: 6, False: 0]
  ------------------
  998|      6|                    {
  999|      6|                        done = true;
 1000|      6|                    }
 1001|      6|                    break;
 1002|      8|                }
 1003|      8|            }
 1004|      8|        } 
 1005|      8|    }
_ZZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_text_stringERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeEENKUlRS6_mSF_E_clESG_mSF_:
  854|      8|        {
  855|      8|            if (source_reader<Source>::read(source, str, length) != length)
  ------------------
  |  Branch (855:17): [True: 2, False: 6]
  ------------------
  856|      2|            {
  857|      2|                ec = cbor_errc::unexpected_eof;
  858|      2|                return false;
  859|      2|            }
  860|      6|            return true;
  861|      8|        };
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringC2ERKNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERKS7_:
   81|      1|            : type(jsoncons::cbor::detail::cbor_major_type::text_string), str(str.c_str(), str.size(), alloc), bytes(alloc)
   82|      1|        {
   83|      1|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_decimal_fractionERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 1224|     13|    {
 1225|     13|        std::size_t size = read_size(ec);
 1226|     13|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     13|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 13]
  |  |  ------------------
  ------------------
 1227|      0|        {
 1228|      0|            return;
 1229|      0|        }
 1230|     13|        if (size != 2)
  ------------------
  |  Branch (1230:13): [True: 0, False: 13]
  ------------------
 1231|      0|        {
 1232|      0|            ec = cbor_errc::invalid_decimal_fraction;
 1233|      0|            more_ = false;
 1234|      0|            return;
 1235|      0|        }
 1236|       |
 1237|     13|        auto c = source_.peek();
 1238|     13|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|     13|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 13]
  |  |  ------------------
  ------------------
 1239|      0|        {
 1240|      0|            ec = cbor_errc::unexpected_eof;
 1241|      0|            more_ = false;
 1242|      0|            return;
 1243|      0|        }
 1244|     13|        int64_t exponent = 0;
 1245|     13|        switch (get_major_type(c.value))
 1246|     13|        {
 1247|      8|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1247:13): [True: 8, False: 5]
  ------------------
 1248|      8|            {
 1249|      8|                exponent = read_uint64(ec);
 1250|      8|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 8]
  |  |  ------------------
  ------------------
 1251|      0|                {
 1252|      0|                    return;
 1253|      0|                }
 1254|      8|                break;
 1255|      8|            }
 1256|      8|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1256:13): [True: 5, False: 8]
  ------------------
 1257|      5|            {
 1258|      5|                exponent = read_int64(ec);
 1259|      5|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
 1260|      0|                {
 1261|      0|                    return;
 1262|      0|                }
 1263|      5|                break;
 1264|      5|            }
 1265|      5|            default:
  ------------------
  |  Branch (1265:13): [True: 0, False: 13]
  ------------------
 1266|      0|            {
 1267|      0|                ec = cbor_errc::invalid_decimal_fraction;
 1268|      0|                more_ = false;
 1269|      0|                return;
 1270|      5|            }
 1271|     13|        }
 1272|       |
 1273|     13|        string_type str(alloc_);
 1274|       |
 1275|     13|        c = source_.peek();
 1276|     13|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|     13|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 13]
  |  |  ------------------
  ------------------
 1277|      0|        {
 1278|      0|            ec = cbor_errc::unexpected_eof;
 1279|      0|            more_ = false;
 1280|      0|            return;
 1281|      0|        }
 1282|       |
 1283|     13|        switch (get_major_type(c.value))
 1284|     13|        {
 1285|      5|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1285:13): [True: 5, False: 8]
  ------------------
 1286|      5|            {
 1287|      5|                uint64_t val = read_uint64(ec);
 1288|      5|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
 1289|      0|                {
 1290|      0|                    return;
 1291|      0|                }
 1292|      5|                jsoncons::from_integer(val, str);
 1293|      5|                break;
 1294|      5|            }
 1295|      8|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1295:13): [True: 8, False: 5]
  ------------------
 1296|      8|            {
 1297|      8|                int64_t val = read_int64(ec);
 1298|      8|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 8]
  |  |  ------------------
  ------------------
 1299|      0|                {
 1300|      0|                    return;
 1301|      0|                }
 1302|      8|                jsoncons::from_integer(val, str);
 1303|      8|                break;
 1304|      8|            }
 1305|      0|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (1305:13): [True: 0, False: 13]
  ------------------
 1306|      0|            {
 1307|      0|                uint8_t b;
 1308|      0|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1308:21): [True: 0, False: 0]
  ------------------
 1309|      0|                {
 1310|      0|                    ec = cbor_errc::unexpected_eof;
 1311|      0|                    more_ = false;
 1312|      0|                    return;
 1313|      0|                }
 1314|      0|                uint8_t tag = get_additional_information_value(b);
 1315|      0|                c = source_.peek();
 1316|      0|                if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1317|      0|                {
 1318|      0|                    ec = cbor_errc::unexpected_eof;
 1319|      0|                    more_ = false;
 1320|      0|                    return;
 1321|      0|                }
 1322|       |
 1323|      0|                if (get_major_type(c.value) == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (1323:21): [True: 0, False: 0]
  ------------------
 1324|      0|                {
 1325|      0|                    bytes_buffer_.clear();
 1326|      0|                    read_byte_string(bytes_buffer_, ec);
 1327|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1328|      0|                    {
 1329|      0|                        more_ = false;
 1330|      0|                        return;
 1331|      0|                    }
 1332|      0|                    if (tag == 2)
  ------------------
  |  Branch (1332:25): [True: 0, False: 0]
  ------------------
 1333|      0|                    {
 1334|      0|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1335|      0|                        n.write_string(str);
 1336|      0|                    }
 1337|      0|                    else if (tag == 3)
  ------------------
  |  Branch (1337:30): [True: 0, False: 0]
  ------------------
 1338|      0|                    {
 1339|      0|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1340|      0|                        n = -1 - n;
 1341|      0|                        n.write_string(str);
 1342|      0|                    }
 1343|      0|                }
 1344|      0|                break;
 1345|      0|            }
 1346|      0|            default:
  ------------------
  |  Branch (1346:13): [True: 0, False: 13]
  ------------------
 1347|      0|            {
 1348|      0|                ec = cbor_errc::invalid_decimal_fraction;
 1349|      0|                more_ = false;
 1350|      0|                return;
 1351|      0|            }
 1352|     13|        }
 1353|       |
 1354|     13|        if (str.size() >= static_cast<std::size_t>((std::numeric_limits<int32_t>::max)()) || 
  ------------------
  |  Branch (1354:13): [True: 0, False: 13]
  ------------------
 1355|     13|            exponent >= (std::numeric_limits<int32_t>::max)() || 
  ------------------
  |  Branch (1355:13): [True: 0, False: 13]
  ------------------
 1356|     13|            exponent <= (std::numeric_limits<int32_t>::min)())
  ------------------
  |  Branch (1356:13): [True: 0, False: 13]
  ------------------
 1357|      0|        {
 1358|      0|            ec = cbor_errc::invalid_decimal_fraction;
 1359|      0|            more_ = false;
 1360|      0|            return;
 1361|      0|        }
 1362|     13|        else if (str.size() > 0)
  ------------------
  |  Branch (1362:18): [True: 13, False: 0]
  ------------------
 1363|     13|        {
 1364|     13|            if (str[0] == '-')
  ------------------
  |  Branch (1364:17): [True: 8, False: 5]
  ------------------
 1365|      8|            {
 1366|      8|                result.push_back('-');
 1367|      8|                jsoncons::prettify_string(str.c_str()+1, str.size()-1, (int)exponent, -4, 17, result);
 1368|      8|            }
 1369|      5|            else
 1370|      5|            {
 1371|      5|                jsoncons::prettify_string(str.c_str(), str.size(), (int)exponent, -4, 17, result);
 1372|      5|            }
 1373|     13|        }
 1374|      0|        else
 1375|      0|        {
 1376|      0|            ec = cbor_errc::invalid_decimal_fraction;
 1377|      0|            more_ = false;
 1378|      0|            return;
 1379|      0|        }
 1380|     13|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13read_bigfloatERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 1383|      1|    {
 1384|      1|        std::size_t size = read_size(ec);
 1385|      1|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1386|      0|        {
 1387|      0|            return;
 1388|      0|        }
 1389|      1|        if (size != 2)
  ------------------
  |  Branch (1389:13): [True: 0, False: 1]
  ------------------
 1390|      0|        {
 1391|      0|            ec = cbor_errc::invalid_bigfloat;
 1392|      0|            more_ = false;
 1393|      0|            return;
 1394|      0|        }
 1395|       |
 1396|      1|        auto c = source_.peek();
 1397|      1|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1398|      0|        {
 1399|      0|            ec = cbor_errc::unexpected_eof;
 1400|      0|            more_ = false;
 1401|      0|            return;
 1402|      0|        }
 1403|      1|        int64_t exponent = 0;
 1404|      1|        switch (get_major_type(c.value))
 1405|      1|        {
 1406|      0|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1406:13): [True: 0, False: 1]
  ------------------
 1407|      0|            {
 1408|      0|                exponent = read_uint64(ec);
 1409|      0|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1410|      0|                {
 1411|      0|                    return;
 1412|      0|                }
 1413|      0|                break;
 1414|      0|            }
 1415|      1|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1415:13): [True: 1, False: 0]
  ------------------
 1416|      1|            {
 1417|      1|                exponent = read_int64(ec);
 1418|      1|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1419|      0|                {
 1420|      0|                    return;
 1421|      0|                }
 1422|      1|                break;
 1423|      1|            }
 1424|      1|            default:
  ------------------
  |  Branch (1424:13): [True: 0, False: 1]
  ------------------
 1425|      0|            {
 1426|      0|                ec = cbor_errc::invalid_bigfloat;
 1427|      0|                more_ = false;
 1428|      0|                return;
 1429|      1|            }
 1430|      1|        }
 1431|       |
 1432|      1|        c = source_.peek();
 1433|      1|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1434|      0|        {
 1435|      0|            ec = cbor_errc::unexpected_eof;
 1436|      0|            more_ = false;
 1437|      0|            return;
 1438|      0|        }
 1439|      1|        switch (get_major_type(c.value))
 1440|      1|        {
 1441|      0|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1441:13): [True: 0, False: 1]
  ------------------
 1442|      0|            {
 1443|      0|                uint64_t val = read_uint64(ec);
 1444|      0|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1445|      0|                {
 1446|      0|                    return;
 1447|      0|                }
 1448|      0|                str.push_back('0');
 1449|      0|                str.push_back('x');
 1450|      0|                jsoncons::integer_to_hex(val, str);
 1451|      0|                break;
 1452|      0|            }
 1453|      1|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1453:13): [True: 1, False: 0]
  ------------------
 1454|      1|            {
 1455|      1|                int64_t val = read_int64(ec);
 1456|      1|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1457|      0|                {
 1458|      0|                    return;
 1459|      0|                }
 1460|      1|                str.push_back('-');
 1461|      1|                str.push_back('0');
 1462|      1|                str.push_back('x');
 1463|      1|                jsoncons::integer_to_hex(static_cast<uint64_t>(-val), str);
 1464|      1|                break;
 1465|      1|            }
 1466|      0|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (1466:13): [True: 0, False: 1]
  ------------------
 1467|      0|            {
 1468|      0|                uint8_t b;
 1469|      0|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1469:21): [True: 0, False: 0]
  ------------------
 1470|      0|                {
 1471|      0|                    ec = cbor_errc::unexpected_eof;
 1472|      0|                    more_ = false;
 1473|      0|                    return;
 1474|      0|                }
 1475|      0|                uint8_t tag = get_additional_information_value(b);
 1476|       |
 1477|      0|                c = source_.peek();
 1478|      0|                if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1479|      0|                {
 1480|      0|                    ec = cbor_errc::unexpected_eof;
 1481|      0|                    more_ = false;
 1482|      0|                    return;
 1483|      0|                }
 1484|       |
 1485|      0|                if (get_major_type(c.value) == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (1485:21): [True: 0, False: 0]
  ------------------
 1486|      0|                {
 1487|      0|                    bytes_buffer_.clear(); 
 1488|      0|                    read_byte_string(bytes_buffer_, ec);
 1489|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1490|      0|                    {
 1491|      0|                        more_ = false;
 1492|      0|                        return;
 1493|      0|                    }
 1494|      0|                    if (tag == 2)
  ------------------
  |  Branch (1494:25): [True: 0, False: 0]
  ------------------
 1495|      0|                    {
 1496|      0|                        str.push_back('0');
 1497|      0|                        str.push_back('x');
 1498|      0|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1499|      0|                        n.write_string_hex(str);
 1500|      0|                    }
 1501|      0|                    else if (tag == 3)
  ------------------
  |  Branch (1501:30): [True: 0, False: 0]
  ------------------
 1502|      0|                    {
 1503|      0|                        str.push_back('-');
 1504|      0|                        str.push_back('0');
 1505|      0|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1506|      0|                        n = -1 - n;
 1507|      0|                        n.write_string_hex(str);
 1508|      0|                        str[2] = 'x'; // overwrite minus
 1509|      0|                    }
 1510|      0|                }
 1511|      0|                break;
 1512|      0|            }
 1513|      0|            default:
  ------------------
  |  Branch (1513:13): [True: 0, False: 1]
  ------------------
 1514|      0|            {
 1515|      0|                ec = cbor_errc::invalid_bigfloat;
 1516|      0|                more_ = false;
 1517|      0|                return;
 1518|      0|            }
 1519|      1|        }
 1520|       |
 1521|      1|        str.push_back('p');
 1522|      1|        if (exponent >=0)
  ------------------
  |  Branch (1522:13): [True: 0, False: 1]
  ------------------
 1523|      0|        {
 1524|      0|            jsoncons::integer_to_hex(static_cast<uint64_t>(exponent), str);
 1525|      0|        }
 1526|      1|        else
 1527|      1|        {
 1528|      1|            str.push_back('-');
 1529|      1|            jsoncons::integer_to_hex(static_cast<uint64_t>(-exponent), str);
 1530|      1|        }
 1531|      1|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE23produce_begin_multi_dimERNS3_10error_codeE:
 2125|      2|    {
 2126|      2|        uint8_t b;
 2127|      2|        if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (2127:13): [True: 0, False: 2]
  ------------------
 2128|      0|        {
 2129|      0|            ec = cbor_errc::unexpected_eof;
 2130|      0|            more_ = false;
 2131|      0|            return;
 2132|      0|        }
 2133|      2|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(b);
 2134|      2|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::array);
  ------------------
  |  |   45|      2|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 2]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 2135|      2|        uint8_t info = get_additional_information_value(b);
 2136|       |       
 2137|      2|        read_extents(info, ec);   
 2138|      2|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 0]
  |  |  ------------------
  ------------------
 2139|      2|        {
 2140|      2|            return;
 2141|      2|        }
 2142|       |
 2143|      0|        state_stack_.emplace_back(parse_mode::multi_dim, 0);
 2144|      0|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12read_extentsEhRNS3_10error_codeE:
 2147|      2|    {
 2148|      2|        extents_.clear();
 2149|      2|        switch (info)
 2150|      2|        {
 2151|      2|            case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (2151:13): [True: 2, False: 0]
  ------------------
 2152|      2|            {
 2153|  2.09M|                while (true)
  ------------------
  |  Branch (2153:24): [True: 2.09M, Folded]
  ------------------
 2154|  2.09M|                {
 2155|  2.09M|                    auto c = source_.peek();
 2156|  2.09M|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  2.09M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 2.09M]
  |  |  ------------------
  ------------------
 2157|      2|                    {
 2158|      2|                        ec = cbor_errc::unexpected_eof;
 2159|      2|                        more_ = false;
 2160|      2|                        return;
 2161|      2|                    }
 2162|  2.09M|                    if (c.value == 0xff)
  ------------------
  |  Branch (2162:25): [True: 978, False: 2.09M]
  ------------------
 2163|    978|                    {
 2164|    978|                        source_.ignore(1);
 2165|    978|                    }
 2166|  2.09M|                    else
 2167|  2.09M|                    {
 2168|  2.09M|                        std::size_t extent_size = read_size(ec);
 2169|  2.09M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.09M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.09M]
  |  |  ------------------
  ------------------
 2170|      0|                        {
 2171|      0|                            return;
 2172|      0|                        }
 2173|  2.09M|                        extents_.push_back(extent_size);
 2174|  2.09M|                    }
 2175|  2.09M|                }
 2176|      0|                break;
 2177|      2|            }
 2178|      0|            default:
  ------------------
  |  Branch (2178:13): [True: 0, False: 2]
  ------------------
 2179|      0|            {
 2180|      0|                std::size_t size = read_size(ec);
 2181|      0|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2182|      0|                {
 2183|      0|                    return;
 2184|      0|                }
 2185|      0|                for (std::size_t i = 0; more_ && i < size; ++i)
  ------------------
  |  Branch (2185:41): [True: 0, False: 0]
  |  Branch (2185:50): [True: 0, False: 0]
  ------------------
 2186|      0|                {
 2187|      0|                    std::size_t extent_size = read_size(ec);
 2188|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2189|      0|                    {
 2190|      0|                        return;
 2191|      0|                    }
 2192|      0|                    extents_.push_back(extent_size);
 2193|      0|                }
 2194|      0|                break;
 2195|      0|            }
 2196|      2|        }
 2197|      2|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayERNS_24basic_item_event_visitorIcEEhRNS3_10error_codeE:
  727|    203|    {
  728|    203|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|    203|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 203]
  |  |  ------------------
  ------------------
  729|      0|        {
  730|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  731|      0|            more_ = false;
  732|      0|            return;
  733|      0|        } 
  734|    203|        semantic_tag tag = semantic_tag::none;
  735|    203|        bool pop_stringref_map_stack = false;
  736|    203|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (736:13): [True: 3, False: 200]
  ------------------
  737|      3|        {
  738|      3|            stringref_map_stack_.emplace_back();
  739|      3|            other_tags_[stringref_namespace_tag] = false;
  740|      3|            pop_stringref_map_stack = true;
  741|      3|        }
  742|    203|        switch (info)
  743|    203|        {
  744|      6|            case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (744:13): [True: 6, False: 197]
  ------------------
  745|      6|            {
  746|      6|                state_stack_.emplace_back(parse_mode::indefinite_array,0,pop_stringref_map_stack);
  747|      6|                visitor.begin_array(tag, *this, ec);
  748|      6|                more_ = !cursor_mode_;
  749|      6|                source_.ignore(1);
  750|      6|                break;
  751|      0|            }
  752|    197|            default: // definite length
  ------------------
  |  Branch (752:13): [True: 197, False: 6]
  ------------------
  753|    197|            {
  754|    197|                std::size_t len = read_size(ec);
  755|    197|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    197|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 197]
  |  |  ------------------
  ------------------
  756|      0|                {
  757|      0|                    return;
  758|      0|                }
  759|    197|                state_stack_.emplace_back(parse_mode::array,len,pop_stringref_map_stack);
  760|    197|                visitor.begin_array(len, tag, *this, ec);
  761|    197|                more_ = !cursor_mode_;
  762|    197|                break;
  763|    197|            }
  764|    203|        }
  765|    203|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12begin_objectERNS_24basic_item_event_visitorIcEEhRNS3_10error_codeE:
  785|     36|    {
  786|     36|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|     36|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 36]
  |  |  ------------------
  ------------------
  787|      0|        {
  788|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  789|      0|            more_ = false;
  790|      0|            return;
  791|      0|        } 
  792|     36|        bool pop_stringref_map_stack = false;
  793|     36|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (793:13): [True: 0, False: 36]
  ------------------
  794|      0|        {
  795|      0|            stringref_map_stack_.emplace_back();
  796|      0|            other_tags_[stringref_namespace_tag] = false;
  797|      0|            pop_stringref_map_stack = true;
  798|      0|        }
  799|     36|        switch (info)
  800|     36|        {
  801|      6|            case jsoncons::cbor::detail::additional_info::indefinite_length: 
  ------------------
  |  Branch (801:13): [True: 6, False: 30]
  ------------------
  802|      6|            {
  803|      6|                state_stack_.emplace_back(parse_mode::indefinite_map_key,0,pop_stringref_map_stack);
  804|      6|                visitor.begin_object(semantic_tag::none, *this, ec);
  805|      6|                more_ = !cursor_mode_;
  806|      6|                source_.ignore(1);
  807|      6|                break;
  808|      0|            }
  809|     30|            default: // definite_length
  ------------------
  |  Branch (809:13): [True: 30, False: 6]
  ------------------
  810|     30|            {
  811|     30|                std::size_t len = read_size(ec);
  812|     30|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     30|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 30]
  |  |  ------------------
  ------------------
  813|      0|                {
  814|      0|                    return;
  815|      0|                }
  816|     30|                state_stack_.emplace_back(parse_mode::map_key,len,pop_stringref_map_stack);
  817|     30|                visitor.begin_object(len, semantic_tag::none, *this, ec);
  818|     30|                more_ = !cursor_mode_;
  819|     30|                break;
  820|     30|            }
  821|     36|        }
  822|     36|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9end_arrayERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
  768|    191|    {
  769|    191|        --nesting_depth_;
  770|       |
  771|    191|        visitor.end_array(*this, ec);
  772|    191|        more_ = !cursor_mode_;
  773|    191|        if (level() == mark_level_)
  ------------------
  |  Branch (773:13): [True: 0, False: 191]
  ------------------
  774|      0|        {
  775|      0|            more_ = false;
  776|      0|        }
  777|    191|        if (state_stack_.back().pop_stringref_map_stack)
  ------------------
  |  Branch (777:13): [True: 0, False: 191]
  ------------------
  778|      0|        {
  779|      0|            stringref_map_stack_.pop_back();
  780|      0|        }
  781|    191|        state_stack_.pop_back();
  782|    191|    }
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5levelEv:
  265|    219|    {
  266|    219|        return static_cast<int>(state_stack_.size());
  267|    219|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10end_objectERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
  825|     28|    {
  826|     28|        --nesting_depth_;
  827|     28|        visitor.end_object(*this, ec);
  828|     28|        if (level() == mark_level_)
  ------------------
  |  Branch (828:13): [True: 0, False: 28]
  ------------------
  829|      0|        {
  830|      0|            more_ = false;
  831|      0|        }
  832|     28|        more_ = !cursor_mode_;
  833|     28|        if (state_stack_.back().pop_stringref_map_stack)
  ------------------
  |  Branch (833:13): [True: 0, False: 28]
  ------------------
  834|      0|        {
  835|      0|            stringref_map_stack_.pop_back();
  836|      0|        }
  837|     28|        state_stack_.pop_back();
  838|     28|    }

_ZN8jsoncons4cbor17basic_cbor_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RNS_18basic_json_visitorIcEERKNS0_19cbor_decode_optionsERKS7_:
   52|     18|       : parser_(std::forward<Sourceable>(source), options, alloc),
   53|     18|         adaptor_(visitor, alloc), visitor_(adaptor_)
   54|     18|    {
   55|     18|    }
_ZN8jsoncons4cbor17basic_cbor_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4readERNS3_10error_codeE:
   88|     18|    {
   89|     18|        parser_.reset();
   90|     18|        parser_.parse(visitor_, ec);
   91|     18|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     18|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 11, False: 7]
  |  |  ------------------
  ------------------
   92|     11|        {
   93|     11|            return;
   94|     11|        }
   95|     18|    }