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

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

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

_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4sizeEv:
  116|  1.11k|        {
  117|  1.11k|            return size_;
  118|  1.11k|        }
_ZNK8jsoncons6detail4spanIKtLm18446744073709551615EE4sizeEv:
  116|     36|        {
  117|     36|            return size_;
  118|     36|        }
_ZNK8jsoncons6detail4spanIKmLm18446744073709551615EE4sizeEv:
  116|     23|        {
  117|     23|            return size_;
  118|     23|        }
_ZNK8jsoncons6detail4spanIKsLm18446744073709551615EE4sizeEv:
  116|  4.23k|        {
  117|  4.23k|            return size_;
  118|  4.23k|        }
_ZNK8jsoncons6detail4spanIKlLm18446744073709551615EE4sizeEv:
  116|      6|        {
  117|      6|            return size_;
  118|      6|        }
_ZNK8jsoncons6detail4spanIKfLm18446744073709551615EE4sizeEv:
  116|     10|        {
  117|     10|            return size_;
  118|     10|        }
_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4dataEv:
  111|    515|        {
  112|    515|            return data_;
  113|    515|        }
_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2EPS2_m:
   61|     82|            : data_(data), size_(size)
   62|     82|        {
   63|     82|        }
_ZNK8jsoncons6detail4spanIhLm18446744073709551615EE4dataEv:
  111|  2.86k|        {
  112|  2.86k|            return data_;
  113|  2.86k|        }
_ZNK8jsoncons6detail4spanIhLm18446744073709551615EE4sizeEv:
  116|  2.86k|        {
  117|  2.86k|            return size_;
  118|  2.86k|        }
_ZN8jsoncons6detail4spanIhLm18446744073709551615EEC2INSt3__16vectorIhNS4_9allocatorIhEEEEEERT_PNS4_9enable_ifIXaaaaaantsr7is_spanIS9_EE5valuentsr10ext_traits12is_std_arrayIS9_EE5valuesr10ext_traits21is_compatible_elementIS9_hEE5valuesr10ext_traits17has_data_and_sizeIS9_EE5valueEvE4typeE:
   68|  2.86k|            : data_(c.data()), size_(c.size())
   69|  2.86k|        {
   70|  2.86k|        }
_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2IhLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|      8|            : data_(s.data()), size_(s.size())
  103|      8|        {
  104|      8|        }
_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EEixEm:
  126|     52|         {
  127|     52|             return data_[index];
  128|     52|         }
_ZN8jsoncons6detail4spanItLm18446744073709551615EEC2EPtm:
   61|     44|            : data_(data), size_(size)
   62|     44|        {
   63|     44|        }
_ZNK8jsoncons6detail4spanItLm18446744073709551615EE4sizeEv:
  116|     56|        {
  117|     56|            return size_;
  118|     56|        }
_ZN8jsoncons6detail4spanIKtLm18446744073709551615EEC2ItLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|     22|            : data_(s.data()), size_(s.size())
  103|     22|        {
  104|     22|        }
_ZNK8jsoncons6detail4spanItLm18446744073709551615EE4dataEv:
  111|     22|        {
  112|     22|            return data_;
  113|     22|        }
_ZN8jsoncons6detail4spanImLm18446744073709551615EEC2EPmm:
   61|     18|            : data_(data), size_(size)
   62|     18|        {
   63|     18|        }
_ZNK8jsoncons6detail4spanImLm18446744073709551615EE4sizeEv:
  116|     25|        {
  117|     25|            return size_;
  118|     25|        }
_ZN8jsoncons6detail4spanIKmLm18446744073709551615EEC2ImLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|      9|            : data_(s.data()), size_(s.size())
  103|      9|        {
  104|      9|        }
_ZNK8jsoncons6detail4spanImLm18446744073709551615EE4dataEv:
  111|      9|        {
  112|      9|            return data_;
  113|      9|        }
_ZNK8jsoncons6detail4spanIKmLm18446744073709551615EEixEm:
  126|      2|         {
  127|      2|             return data_[index];
  128|      2|         }
_ZN8jsoncons6detail4spanIsLm18446744073709551615EEC2EPsm:
   61|  2.77k|            : data_(data), size_(size)
   62|  2.77k|        {
   63|  2.77k|        }
_ZNK8jsoncons6detail4spanIsLm18446744073709551615EE4sizeEv:
  116|  2.78k|        {
  117|  2.78k|            return size_;
  118|  2.78k|        }
_ZN8jsoncons6detail4spanIKsLm18446744073709551615EEC2IsLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|  1.38k|            : data_(s.data()), size_(s.size())
  103|  1.38k|        {
  104|  1.38k|        }
_ZNK8jsoncons6detail4spanIsLm18446744073709551615EE4dataEv:
  111|  1.38k|        {
  112|  1.38k|            return data_;
  113|  1.38k|        }
_ZNK8jsoncons6detail4spanIKsLm18446744073709551615EEixEm:
  126|     82|         {
  127|     82|             return data_[index];
  128|     82|         }
_ZN8jsoncons6detail4spanIlLm18446744073709551615EEC2EPlm:
   61|      4|            : data_(data), size_(size)
   62|      4|        {
   63|      4|        }
_ZNK8jsoncons6detail4spanIlLm18446744073709551615EE4sizeEv:
  116|      4|        {
  117|      4|            return size_;
  118|      4|        }
_ZN8jsoncons6detail4spanIKlLm18446744073709551615EEC2IlLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|      2|            : data_(s.data()), size_(s.size())
  103|      2|        {
  104|      2|        }
_ZNK8jsoncons6detail4spanIlLm18446744073709551615EE4dataEv:
  111|      2|        {
  112|      2|            return data_;
  113|      2|        }
_ZN8jsoncons6detail4spanIfLm18446744073709551615EEC2EPfm:
   61|      4|            : data_(data), size_(size)
   62|      4|        {
   63|      4|        }
_ZNK8jsoncons6detail4spanIfLm18446744073709551615EE4sizeEv:
  116|      4|        {
  117|      4|            return size_;
  118|      4|        }
_ZN8jsoncons6detail4spanIKfLm18446744073709551615EEC2IfLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|      2|            : data_(s.data()), size_(s.size())
  103|      2|        {
  104|      2|        }
_ZNK8jsoncons6detail4spanIfLm18446744073709551615EE4dataEv:
  111|      2|        {
  112|      2|            return data_;
  113|      2|        }
_ZNK8jsoncons6detail4spanIKfLm18446744073709551615EEixEm:
  126|      4|         {
  127|      4|             return data_[index];
  128|      4|         }
_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2Ev:
   58|    445|        {
   59|    445|        }

_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1008|  1.66k|        {
 1009|  1.66k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1009:17): [True: 303, False: 1.35k]
  ------------------
 1010|    303|            {
 1011|    303|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1011:21): [True: 222, False: 81]
  |  Branch (1011:86): [True: 222, False: 0]
  ------------------
 1012|    222|                {
 1013|    222|                    key_buffer_.push_back(',');
 1014|    222|                }
 1015|    303|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
 1016|    303|                key_buffer_.push_back('[');
 1017|    303|            }
 1018|  1.35k|            else
 1019|  1.35k|            {
 1020|  1.35k|                switch (level_stack_.back().target_kind())
 1021|  1.35k|                {
 1022|  1.27k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1022:21): [True: 1.27k, False: 88]
  ------------------
 1023|  1.27k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1023:29): [True: 1.04k, False: 226]
  |  Branch (1023:65): [True: 1.04k, False: 2]
  ------------------
 1024|  1.04k|                        {
 1025|  1.04k|                            key_buffer_.push_back(',');
 1026|  1.04k|                        }
 1027|  1.27k|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
 1028|  1.27k|                        key_buffer_.push_back('[');
 1029|  1.27k|                        break;
 1030|     88|                    default:
  ------------------
  |  Branch (1030:21): [True: 88, False: 1.27k]
  ------------------
 1031|     88|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::array);
 1032|     88|                        destination_->begin_array(length, tag, context, ec);
 1033|     88|                        break;
 1034|  1.35k|                }
 1035|  1.35k|            }
 1036|  1.66k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.66k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1037|  1.66k|        }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure6is_keyEv:
  815|  12.6M|            {
  816|  12.6M|                return even_odd_ == 0;
  817|  12.6M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure11target_kindEv:
  825|  7.31M|            {
  826|  7.31M|                return target_kind_;
  827|  7.31M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure5countEv:
  830|  2.57M|            {
  831|  2.57M|                return count_;
  832|  2.57M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structureC2ENS4_16json_target_kindENS4_19json_structure_kindE:
  798|  1.75k|                : target_kind_(state), structure_kind_(type), even_odd_(type == json_structure_kind::object ? 0 : 1)
  ------------------
  |  Branch (798:73): [True: 75, False: 1.68k]
  ------------------
  799|  1.75k|            {
  800|  1.75k|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure9is_objectEv:
  820|  6.78M|            {
  821|  6.78M|                return structure_kind_ == json_structure_kind::object;
  822|  6.78M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE15visit_end_arrayERKNS_11ser_contextERNS1_10error_codeE:
 1040|  1.65k|        {
 1041|  1.65k|            switch (level_stack_.back().target_kind())
 1042|  1.65k|            {
 1043|  1.56k|                case json_target_kind::buffer:
  ------------------
  |  Branch (1043:17): [True: 1.56k, False: 82]
  ------------------
 1044|  1.56k|                    key_buffer_.push_back(']');
 1045|  1.56k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|  1.56k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 1.56k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1046|  1.56k|                    level_stack_.pop_back();
 1047|  1.56k|                    if (level_stack_.back().target_kind() == json_target_kind::destination)
  ------------------
  |  Branch (1047:25): [True: 78, False: 1.49k]
  ------------------
 1048|     78|                    {
 1049|     78|                        destination_->key(key_buffer_, context, ec);
 1050|     78|                        key_buffer_.clear();
 1051|     78|                    }
 1052|  1.49k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (1052:30): [True: 222, False: 1.26k]
  ------------------
 1053|    222|                    {
 1054|    222|                        key_buffer_.push_back(':');
 1055|    222|                    }
 1056|  1.56k|                    level_stack_.back().advance();
 1057|  1.56k|                    break;
 1058|     82|                default:
  ------------------
  |  Branch (1058:17): [True: 82, False: 1.56k]
  ------------------
 1059|     82|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|     82|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 82]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1060|     82|                    level_stack_.pop_back();
 1061|     82|                    level_stack_.back().advance();
 1062|     82|                    destination_->end_array(context, ec);
 1063|     82|                    break;
 1064|  1.65k|            }
 1065|  1.65k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.65k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1066|  1.65k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure7advanceEv:
  803|  4.20M|            {
  804|  4.20M|                if (!is_key())
  ------------------
  |  Branch (804:21): [True: 3.10M, False: 1.10M]
  ------------------
  805|  3.10M|                {
  806|  3.10M|                    ++count_;
  807|  3.10M|                }
  808|  4.20M|                if (is_object())
  ------------------
  |  Branch (808:21): [True: 2.20M, False: 2.00M]
  ------------------
  809|  2.20M|                {
  810|  2.20M|                    even_odd_ = !even_odd_;
  811|  2.20M|                }
  812|  4.20M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1233|  4.20M|        {
 1234|  4.20M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1234:17): [True: 1.09M, False: 3.10M]
  |  Branch (1234:49): [True: 2.57M, False: 523k]
  ------------------
 1235|  3.67M|            {
 1236|  3.67M|                key_.clear();
 1237|  3.67M|                jsoncons::from_integer(value,key_);
 1238|  3.67M|            }
 1239|       |
 1240|  4.20M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1240:17): [True: 1.09M, False: 3.10M]
  ------------------
 1241|  1.09M|            {
 1242|  1.09M|                switch (level_stack_.back().target_kind())
 1243|  1.09M|                {
 1244|   576k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1244:21): [True: 576k, False: 523k]
  ------------------
 1245|   576k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1245:29): [True: 576k, False: 17]
  ------------------
 1246|   576k|                        {
 1247|   576k|                            key_buffer_.push_back(',');
 1248|   576k|                        }
 1249|   576k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1250|   576k|                        key_buffer_.push_back(':');
 1251|   576k|                        break;
 1252|   523k|                    default:
  ------------------
  |  Branch (1252:21): [True: 523k, False: 576k]
  ------------------
 1253|   523k|                        destination_->key(key_, context, ec);
 1254|   523k|                        break;
 1255|  1.09M|                }
 1256|  1.09M|            }
 1257|  3.10M|            else
 1258|  3.10M|            {
 1259|  3.10M|                switch (level_stack_.back().target_kind())
 1260|  3.10M|                {
 1261|  2.57M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1261:21): [True: 2.57M, False: 523k]
  ------------------
 1262|  2.57M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1262:29): [True: 2.00M, False: 576k]
  |  Branch (1262:65): [True: 2.00M, False: 10]
  ------------------
 1263|  2.00M|                        {
 1264|  2.00M|                            key_buffer_.push_back(',');
 1265|  2.00M|                        }
 1266|  2.57M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1267|  2.57M|                        break;
 1268|   523k|                    default:
  ------------------
  |  Branch (1268:21): [True: 523k, False: 2.57M]
  ------------------
 1269|   523k|                        destination_->uint64_value(value, tag, context, ec);
 1270|   523k|                        break;
 1271|  3.10M|                }
 1272|  3.10M|            }
 1273|       |
 1274|  4.20M|            level_stack_.back().advance();
 1275|  4.20M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  4.20M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1276|  4.20M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1279|    647|        {
 1280|    647|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1280:17): [True: 271, False: 376]
  |  Branch (1280:49): [True: 359, False: 17]
  ------------------
 1281|    630|            {
 1282|    630|                key_.clear();
 1283|    630|                jsoncons::from_integer(value,key_);
 1284|    630|            }
 1285|       |
 1286|    647|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1286:17): [True: 271, False: 376]
  ------------------
 1287|    271|            {
 1288|    271|                switch (level_stack_.back().target_kind())
 1289|    271|                {
 1290|    254|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1290:21): [True: 254, False: 17]
  ------------------
 1291|    254|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1291:29): [True: 253, False: 1]
  ------------------
 1292|    253|                        {
 1293|    253|                            key_buffer_.push_back(',');
 1294|    253|                        }
 1295|    254|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1296|    254|                        key_buffer_.push_back(':');
 1297|    254|                        break;
 1298|     17|                    default:
  ------------------
  |  Branch (1298:21): [True: 17, False: 254]
  ------------------
 1299|     17|                        destination_->key(key_, context, ec);
 1300|     17|                        break;
 1301|    271|                }
 1302|    271|            }
 1303|    376|            else
 1304|    376|            {
 1305|    376|                switch (level_stack_.back().target_kind())
 1306|    376|                {
 1307|    359|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1307:21): [True: 359, False: 17]
  ------------------
 1308|    359|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1308:29): [True: 108, False: 251]
  |  Branch (1308:65): [True: 88, False: 20]
  ------------------
 1309|     88|                        {
 1310|     88|                            key_buffer_.push_back(',');
 1311|     88|                        }
 1312|    359|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1313|    359|                        break;
 1314|     17|                    default:
  ------------------
  |  Branch (1314:21): [True: 17, False: 359]
  ------------------
 1315|     17|                        destination_->int64_value(value, tag, context, ec);
 1316|     17|                        break;
 1317|    376|                }
 1318|    376|            }
 1319|       |
 1320|    647|            level_stack_.back().advance();
 1321|    647|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    647|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1322|    647|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1374|      4|        {
 1375|      4|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1375:17): [True: 0, False: 4]
  |  Branch (1375:49): [True: 2, False: 2]
  ------------------
 1376|      2|            {
 1377|      2|                key_.clear();
 1378|      2|                string_sink<string_type> sink(key_);
 1379|      2|                jsoncons::write_double f{float_chars_format::general,0};
 1380|      2|                f(value, sink);
 1381|      2|            }
 1382|       |
 1383|      4|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1383:17): [True: 0, False: 4]
  ------------------
 1384|      0|            {
 1385|      0|                switch (level_stack_.back().target_kind())
 1386|      0|                {
 1387|      0|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1387:21): [True: 0, False: 0]
  ------------------
 1388|      0|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1388:29): [True: 0, False: 0]
  ------------------
 1389|      0|                        {
 1390|      0|                            key_buffer_.push_back(',');
 1391|      0|                        }
 1392|      0|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1393|      0|                        key_buffer_.push_back(':');
 1394|      0|                        break;
 1395|      0|                    default:
  ------------------
  |  Branch (1395:21): [True: 0, False: 0]
  ------------------
 1396|      0|                        destination_->key(key_, context, ec);
 1397|      0|                        break;
 1398|      0|                }
 1399|      0|            }
 1400|      4|            else
 1401|      4|            {
 1402|      4|                switch (level_stack_.back().target_kind())
 1403|      4|                {
 1404|      2|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1404:21): [True: 2, False: 2]
  ------------------
 1405|      2|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1405:29): [True: 2, False: 0]
  |  Branch (1405:65): [True: 1, False: 1]
  ------------------
 1406|      1|                        {
 1407|      1|                            key_buffer_.push_back(',');
 1408|      1|                        }
 1409|      2|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1410|      2|                        break;
 1411|      2|                    default:
  ------------------
  |  Branch (1411:21): [True: 2, False: 2]
  ------------------
 1412|      2|                        destination_->double_value(value, tag, context, ec);
 1413|      2|                        break;
 1414|      4|                }
 1415|      4|            }
 1416|       |
 1417|      4|            level_stack_.back().advance();
 1418|      4|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      4|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1419|      4|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE11visit_flushEv:
  881|      7|        {
  882|      7|            destination_->flush();
  883|      7|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  886|      4|        {
  887|      4|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (887:17): [True: 0, False: 4]
  ------------------
  888|      0|            {
  889|      0|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (889:21): [True: 0, False: 0]
  |  Branch (889:86): [True: 0, False: 0]
  ------------------
  890|      0|                {
  891|      0|                    key_buffer_.push_back(',');
  892|      0|                }
  893|      0|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  894|      0|                key_buffer_.push_back('{');
  895|      0|            }
  896|      4|            else
  897|      4|            {
  898|      4|                switch (level_stack_.back().target_kind())
  899|      4|                {
  900|      2|                    case json_target_kind::buffer:
  ------------------
  |  Branch (900:21): [True: 2, False: 2]
  ------------------
  901|      2|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  902|      2|                        key_buffer_.push_back('{');
  903|      2|                        break;
  904|      2|                    default:
  ------------------
  |  Branch (904:21): [True: 2, False: 2]
  ------------------
  905|      2|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::object);
  906|      2|                        destination_->begin_object(tag, context, ec);
  907|      2|                        break;
  908|      4|                }
  909|      4|            }
  910|      4|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      4|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  911|      4|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  914|     71|        {
  915|     71|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (915:17): [True: 34, False: 37]
  ------------------
  916|     34|            {
  917|     34|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (917:21): [True: 26, False: 8]
  |  Branch (917:86): [True: 15, False: 11]
  ------------------
  918|     15|                {
  919|     15|                    key_buffer_.push_back(',');
  920|     15|                }
  921|     34|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  922|     34|                key_buffer_.push_back('{');
  923|     34|            }
  924|     37|            else
  925|     37|            {
  926|     37|                switch (level_stack_.back().target_kind())
  927|     37|                {
  928|     30|                    case json_target_kind::buffer:
  ------------------
  |  Branch (928:21): [True: 30, False: 7]
  ------------------
  929|     30|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (929:29): [True: 11, False: 19]
  |  Branch (929:65): [True: 8, False: 3]
  ------------------
  930|      8|                        {
  931|      8|                            key_buffer_.push_back(',');
  932|      8|                        }
  933|     30|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  934|     30|                        key_buffer_.push_back('{');
  935|     30|                        break;
  936|      7|                    default:
  ------------------
  |  Branch (936:21): [True: 7, False: 30]
  ------------------
  937|      7|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::object);
  938|      7|                        destination_->begin_object(length, tag, context, ec);
  939|      7|                        break;
  940|     37|                }
  941|     37|            }
  942|     71|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     71|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  943|     71|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE16visit_end_objectERKNS_11ser_contextERNS1_10error_codeE:
  946|     55|        {
  947|     55|            switch (level_stack_.back().target_kind())
  948|     55|            {
  949|     52|                case json_target_kind::buffer:
  ------------------
  |  Branch (949:17): [True: 52, False: 3]
  ------------------
  950|     52|                    key_buffer_.push_back('}');
  951|     52|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|     52|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 52]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  952|     52|                    level_stack_.pop_back();
  953|       |                    
  954|     52|                    if (level_stack_.back().target_kind() == json_target_kind::destination)
  ------------------
  |  Branch (954:25): [True: 6, False: 46]
  ------------------
  955|      6|                    {
  956|      6|                        destination_->key(key_buffer_,context, ec);
  957|      6|                        key_buffer_.clear();
  958|      6|                    }
  959|     46|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (959:30): [True: 23, False: 23]
  ------------------
  960|     23|                    {
  961|     23|                        key_buffer_.push_back(':');
  962|     23|                    }
  963|     52|                    level_stack_.back().advance();
  964|     52|                    break;
  965|      3|                default:
  ------------------
  |  Branch (965:17): [True: 3, False: 52]
  ------------------
  966|      3|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|      3|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 3]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  967|      3|                    level_stack_.pop_back();
  968|      3|                    level_stack_.back().advance();
  969|      3|                    destination_->end_object(context, ec);
  970|      3|                    break;
  971|     55|            }
  972|     55|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     55|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  973|     55|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  976|      3|        {
  977|      3|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (977:17): [True: 0, False: 3]
  ------------------
  978|      0|            {
  979|      0|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (979:21): [True: 0, False: 0]
  |  Branch (979:86): [True: 0, False: 0]
  ------------------
  980|      0|                {
  981|      0|                    key_buffer_.push_back(',');
  982|      0|                }
  983|      0|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
  984|      0|                key_buffer_.push_back('[');
  985|      0|            }
  986|      3|            else
  987|      3|            {
  988|      3|                switch (level_stack_.back().target_kind())
  989|      3|                {
  990|      3|                    case json_target_kind::buffer:
  ------------------
  |  Branch (990:21): [True: 3, False: 0]
  ------------------
  991|      3|                        if (level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (991:29): [True: 3, False: 0]
  |  Branch (991:64): [True: 0, False: 3]
  ------------------
  992|      0|                        {
  993|      0|                            key_buffer_.push_back(',');
  994|      0|                        }
  995|      3|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
  996|      3|                        key_buffer_.push_back('[');
  997|      3|                        break;
  998|      0|                    default:
  ------------------
  |  Branch (998:21): [True: 0, False: 3]
  ------------------
  999|      0|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::array);
 1000|      0|                        destination_->begin_array(tag, context, ec);
 1001|      0|                        break;
 1002|      3|                }
 1003|      3|            }
 1004|      3|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1005|      3|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1475|     33|        {
 1476|     33|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1476:17): [True: 14, False: 19]
  |  Branch (1476:49): [True: 4, False: 15]
  ------------------
 1477|     18|            {
 1478|     18|                key_.clear(); 
 1479|     18|                key_.insert(key_.begin(), json_literals<char_type>::null_literal.begin(), json_literals<char_type>::null_literal.end());
 1480|     18|            }
 1481|       |
 1482|     33|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1482:17): [True: 14, False: 19]
  ------------------
 1483|     14|            {
 1484|     14|                switch (level_stack_.back().target_kind())
 1485|     14|                {
 1486|      0|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1486:21): [True: 0, False: 14]
  ------------------
 1487|      0|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1487:29): [True: 0, False: 0]
  ------------------
 1488|      0|                        {
 1489|      0|                            key_buffer_.push_back(',');
 1490|      0|                        }
 1491|      0|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1492|      0|                        key_buffer_.push_back(':');
 1493|      0|                        break;
 1494|     14|                    default:
  ------------------
  |  Branch (1494:21): [True: 14, False: 0]
  ------------------
 1495|     14|                        destination_->key(key_, context, ec);
 1496|     14|                        break;
 1497|     14|                }
 1498|     14|            }
 1499|     19|            else
 1500|     19|            {
 1501|     19|                switch (level_stack_.back().target_kind())
 1502|     19|                {
 1503|      4|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1503:21): [True: 4, False: 15]
  ------------------
 1504|      4|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1504:29): [True: 4, False: 0]
  |  Branch (1504:65): [True: 4, False: 0]
  ------------------
 1505|      4|                        {
 1506|      4|                            key_buffer_.push_back(',');
 1507|      4|                        }
 1508|      4|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1509|      4|                        break;
 1510|     15|                    default:
  ------------------
  |  Branch (1510:21): [True: 15, False: 4]
  ------------------
 1511|     15|                        destination_->null_value(tag, context, ec);
 1512|     15|                        break;
 1513|     19|                }
 1514|     19|            }
 1515|       |
 1516|     33|            level_stack_.back().advance();
 1517|     33|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     33|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1518|     33|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1422|     14|        {
 1423|     14|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1423:17): [True: 7, False: 7]
  |  Branch (1423:49): [True: 0, False: 7]
  ------------------
 1424|      7|            {
 1425|      7|                key_.clear(); 
 1426|      7|                if (value)
  ------------------
  |  Branch (1426:21): [True: 7, False: 0]
  ------------------
 1427|      7|                {
 1428|      7|                    key_.insert(key_.begin(), json_literals<char_type>::true_literal.begin(), json_literals<char_type>::true_literal.end());
 1429|      7|                }
 1430|      0|                else
 1431|      0|                {
 1432|      0|                    key_.insert(key_.begin(), json_literals<char_type>::false_literal.begin(), json_literals<char_type>::false_literal.end());
 1433|      0|                }
 1434|      7|            }
 1435|       |
 1436|     14|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1436:17): [True: 7, False: 7]
  ------------------
 1437|      7|            {
 1438|      7|                switch (level_stack_.back().target_kind())
 1439|      7|                {
 1440|      0|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1440:21): [True: 0, False: 7]
  ------------------
 1441|      0|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1441:29): [True: 0, False: 0]
  ------------------
 1442|      0|                        {
 1443|      0|                            key_buffer_.push_back(',');
 1444|      0|                        }
 1445|      0|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1446|      0|                        key_buffer_.push_back(':');
 1447|      0|                        break;
 1448|      7|                    default:
  ------------------
  |  Branch (1448:21): [True: 7, False: 0]
  ------------------
 1449|      7|                        destination_->key(key_, context, ec);
 1450|      7|                        break;
 1451|      7|                }
 1452|      7|            }
 1453|      7|            else
 1454|      7|            {
 1455|      7|                switch (level_stack_.back().target_kind())
 1456|      7|                {
 1457|      0|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1457:21): [True: 0, False: 7]
  ------------------
 1458|      0|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1458:29): [True: 0, False: 0]
  |  Branch (1458:65): [True: 0, False: 0]
  ------------------
 1459|      0|                        {
 1460|      0|                            key_buffer_.push_back(',');
 1461|      0|                        }
 1462|      0|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1463|      0|                        break;
 1464|      7|                    default:
  ------------------
  |  Branch (1464:21): [True: 7, False: 0]
  ------------------
 1465|      7|                        destination_->bool_value(value, tag, context, ec);
 1466|      7|                        break;
 1467|      7|                }
 1468|      7|            }
 1469|       |
 1470|     14|            level_stack_.back().advance();
 1471|     14|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     14|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1472|     14|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_stringERKNS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1072|     24|        {
 1073|     24|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1073:17): [True: 12, False: 12]
  ------------------
 1074|     12|            {
 1075|     12|                switch (level_stack_.back().target_kind())
 1076|     12|                {
 1077|      8|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1077:21): [True: 8, False: 4]
  ------------------
 1078|      8|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1078:29): [True: 8, False: 0]
  ------------------
 1079|      8|                        {
 1080|      8|                            key_buffer_.push_back(',');
 1081|      8|                        }
 1082|      8|                        key_buffer_.push_back('\"');
 1083|      8|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1084|      8|                        key_buffer_.push_back('\"');
 1085|      8|                        key_buffer_.push_back(':');
 1086|      8|                        break;
 1087|      4|                    default:
  ------------------
  |  Branch (1087:21): [True: 4, False: 8]
  ------------------
 1088|      4|                        destination_->key(value, context, ec);
 1089|      4|                        break;
 1090|     12|                }
 1091|     12|            }
 1092|     12|            else
 1093|     12|            {
 1094|     12|                switch (level_stack_.back().target_kind())
 1095|     12|                {
 1096|      6|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1096:21): [True: 6, False: 6]
  ------------------
 1097|      6|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1097:29): [True: 2, False: 4]
  |  Branch (1097:65): [True: 2, False: 0]
  ------------------
 1098|      2|                        {
 1099|      2|                            key_buffer_.push_back(',');
 1100|      2|                        }
 1101|      6|                        key_buffer_.push_back('\"');
 1102|      6|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1103|      6|                        key_buffer_.push_back('\"');
 1104|      6|                        break;
 1105|      6|                    default:
  ------------------
  |  Branch (1105:21): [True: 6, False: 6]
  ------------------
 1106|      6|                        destination_->string_value(value, tag, context, ec);
 1107|      6|                        break;
 1108|     12|                }
 1109|     12|            }
 1110|       |
 1111|     24|            level_stack_.back().advance();
 1112|     24|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     24|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1113|     24|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1119|    456|        {
 1120|    456|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1120:17): [True: 172, False: 284]
  |  Branch (1120:49): [True: 121, False: 163]
  ------------------
 1121|    293|            {
 1122|    293|                key_.clear();
 1123|    293|                switch (tag)
 1124|    293|                {
 1125|      0|                    case semantic_tag::base64:
  ------------------
  |  Branch (1125:21): [True: 0, False: 293]
  ------------------
 1126|      0|                        bytes_to_base64(value.begin(), value.end(), key_);
 1127|      0|                        break;
 1128|      0|                    case semantic_tag::base16:
  ------------------
  |  Branch (1128:21): [True: 0, False: 293]
  ------------------
 1129|      0|                        bytes_to_base16(value.begin(), value.end(),key_);
 1130|      0|                        break;
 1131|    293|                    default:
  ------------------
  |  Branch (1131:21): [True: 293, False: 0]
  ------------------
 1132|    293|                        bytes_to_base64url(value.begin(), value.end(),key_);
 1133|    293|                        break;
 1134|    293|                }
 1135|    293|            }
 1136|       |
 1137|    456|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1137:17): [True: 172, False: 284]
  ------------------
 1138|    172|            {
 1139|    172|                switch (level_stack_.back().target_kind())
 1140|    172|                {
 1141|     16|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1141:21): [True: 16, False: 156]
  ------------------
 1142|     16|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1142:29): [True: 12, False: 4]
  ------------------
 1143|     12|                        {
 1144|     12|                            key_buffer_.push_back(',');
 1145|     12|                        }
 1146|     16|                        key_buffer_.push_back('\"');
 1147|     16|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1148|     16|                        key_buffer_.push_back('\"');
 1149|     16|                        key_buffer_.push_back(':');
 1150|     16|                        break;
 1151|    156|                    default:
  ------------------
  |  Branch (1151:21): [True: 156, False: 16]
  ------------------
 1152|    156|                        destination_->key(key_, context, ec);
 1153|    156|                        break;
 1154|    172|                }
 1155|    172|            }
 1156|    284|            else
 1157|    284|            {
 1158|    284|                switch (level_stack_.back().target_kind())
 1159|    284|                {
 1160|    121|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1160:21): [True: 121, False: 163]
  ------------------
 1161|    121|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1161:29): [True: 98, False: 23]
  |  Branch (1161:65): [True: 96, False: 2]
  ------------------
 1162|     96|                        {
 1163|     96|                            key_buffer_.push_back(',');
 1164|     96|                        }
 1165|    121|                        key_buffer_.push_back('\"');
 1166|    121|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1167|    121|                        key_buffer_.push_back('\"');
 1168|    121|                        break;
 1169|    163|                    default:
  ------------------
  |  Branch (1169:21): [True: 163, False: 121]
  ------------------
 1170|    163|                        destination_->byte_string_value(value, tag, context, ec);
 1171|    163|                        break;
 1172|    284|                }
 1173|    284|            }
 1174|       |
 1175|    456|            level_stack_.back().advance();
 1176|    456|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    456|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1177|    456|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS1_10error_codeE:
 1183|     57|        {
 1184|     57|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1184:17): [True: 12, False: 45]
  |  Branch (1184:49): [True: 44, False: 1]
  ------------------
 1185|     56|            {
 1186|     56|                key_.clear();
 1187|     56|                bytes_to_base64url(value.begin(), value.end(),key_);
 1188|     56|            }
 1189|       |
 1190|     57|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1190:17): [True: 12, False: 45]
  ------------------
 1191|     12|            {
 1192|     12|                switch (level_stack_.back().target_kind())
 1193|     12|                {
 1194|     12|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1194:21): [True: 12, False: 0]
  ------------------
 1195|     12|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1195:29): [True: 12, False: 0]
  ------------------
 1196|     12|                        {
 1197|     12|                            key_buffer_.push_back(',');
 1198|     12|                        }
 1199|     12|                        key_buffer_.push_back('\"');
 1200|     12|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1201|     12|                        key_buffer_.push_back('\"');
 1202|     12|                        key_buffer_.push_back(':');
 1203|     12|                        break;
 1204|      0|                    default:
  ------------------
  |  Branch (1204:21): [True: 0, False: 12]
  ------------------
 1205|      0|                        destination_->key(key_, context, ec);
 1206|      0|                        break;
 1207|     12|                }
 1208|     12|            }
 1209|     45|            else
 1210|     45|            {
 1211|     45|                switch (level_stack_.back().target_kind())
 1212|     45|                {
 1213|     44|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1213:21): [True: 44, False: 1]
  ------------------
 1214|     44|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1214:29): [True: 30, False: 14]
  |  Branch (1214:65): [True: 30, False: 0]
  ------------------
 1215|     30|                        {
 1216|     30|                            key_buffer_.push_back(',');
 1217|     30|                        }
 1218|     44|                        key_buffer_.push_back('\"');
 1219|     44|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1220|     44|                        key_buffer_.push_back('\"');
 1221|     44|                        break;
 1222|      1|                    default:
  ------------------
  |  Branch (1222:21): [True: 1, False: 44]
  ------------------
 1223|      1|                        destination_->byte_string_value(value, raw_tag, context, ec);
 1224|      1|                        break;
 1225|     45|                }
 1226|     45|            }
 1227|       |
 1228|     57|            level_stack_.back().advance();
 1229|     57|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     57|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1230|     57|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE10visit_halfEtNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1325|      9|        {
 1326|      9|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1326:17): [True: 3, False: 6]
  |  Branch (1326:49): [True: 6, False: 0]
  ------------------
 1327|      9|            {
 1328|      9|                key_.clear();
 1329|      9|                jsoncons::string_sink<string_type> sink(key_);
 1330|      9|                jsoncons::write_double f{float_chars_format::general,0};
 1331|      9|                double x = binary::decode_half(value);
 1332|      9|                f(x, sink);
 1333|      9|            }
 1334|       |
 1335|      9|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1335:17): [True: 3, False: 6]
  ------------------
 1336|      3|            {
 1337|      3|                switch (level_stack_.back().target_kind())
 1338|      3|                {
 1339|      3|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1339:21): [True: 3, False: 0]
  ------------------
 1340|      3|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1340:29): [True: 0, False: 3]
  ------------------
 1341|      0|                        {
 1342|      0|                            key_buffer_.push_back(',');
 1343|      0|                        }
 1344|      3|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1345|      3|                        key_buffer_.push_back(':');
 1346|      3|                        break;
 1347|      0|                    default:
  ------------------
  |  Branch (1347:21): [True: 0, False: 3]
  ------------------
 1348|      0|                        destination_->key(key_, context, ec);
 1349|      0|                        break;
 1350|      3|                }
 1351|      3|            }
 1352|      6|            else
 1353|      6|            {
 1354|      6|                switch (level_stack_.back().target_kind())
 1355|      6|                {
 1356|      6|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1356:21): [True: 6, False: 0]
  ------------------
 1357|      6|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1357:29): [True: 4, False: 2]
  |  Branch (1357:65): [True: 4, False: 0]
  ------------------
 1358|      4|                        {
 1359|      4|                            key_buffer_.push_back(',');
 1360|      4|                        }
 1361|      6|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1362|      6|                        break;
 1363|      0|                    default:
  ------------------
  |  Branch (1363:21): [True: 0, False: 6]
  ------------------
 1364|      0|                        destination_->half_value(value, tag, context, ec);
 1365|      0|                        break;
 1366|      6|                }
 1367|      6|            }
 1368|       |
 1369|      9|            level_stack_.back().advance();
 1370|      9|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      9|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1371|      9|        }
_ZN8jsoncons21basic_generic_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  294|  1.66k|    {
  295|  1.66k|        visit_begin_array(length, tag, context, ec);
  296|  1.66k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.66k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  297|  1.66k|    }
_ZN8jsoncons21basic_generic_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  363|  4.20M|    {
  364|  4.20M|        visit_uint64(value, tag, context, ec);
  365|  4.20M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  4.20M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  366|  4.20M|    }
_ZN8jsoncons21basic_generic_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  300|  1.65k|    {
  301|  1.65k|        visit_end_array(context, ec);
  302|  1.65k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.65k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  303|  1.65k|    }
_ZN8jsoncons21basic_generic_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  372|    647|    {
  373|    647|        visit_int64(value, tag, context, ec);
  374|    647|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    647|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  375|    647|    }
_ZN8jsoncons21basic_generic_visitorIcE10half_valueEtNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  381|      9|    {
  382|      9|        visit_half(value, tag, context, ec);
  383|      9|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      9|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  384|      9|    }
_ZN8jsoncons21basic_generic_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  390|      4|    {
  391|      4|        visit_double(value, tag, context, ec);
  392|      4|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      4|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  393|      4|    }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEEC2ERNS_18basic_json_visitorIcEERKS3_:
  855|     17|            : destination_(std::addressof(visitor)), 
  856|     17|              key_(alloc), key_buffer_(alloc), level_stack_(alloc)
  857|     17|        {
  858|     17|            level_stack_.emplace_back(json_target_kind::destination,json_structure_kind::root); // root
  859|     17|        }
_ZN8jsoncons21basic_generic_visitorIcEC2Ev:
   52|     17|    basic_generic_visitor() = default;
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  343|    456|    {
  344|    456|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  345|    456|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    456|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  346|    456|    }
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  354|     57|    {
  355|     57|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), raw_tag, context, ec);
  356|     57|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     57|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  357|     57|    }
_ZN8jsoncons21basic_generic_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  323|     14|    {
  324|     14|        visit_bool(value, tag, context, ec);
  325|     14|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     14|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  326|     14|    }
_ZN8jsoncons21basic_generic_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  314|     33|    {
  315|     33|        visit_null(tag, context, ec);
  316|     33|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     33|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  317|     33|    }
_ZN8jsoncons21basic_generic_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  332|     24|    {
  333|     24|        visit_string(value, tag, context, ec);
  334|     24|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     24|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  335|     24|    }
_ZN8jsoncons21basic_generic_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  288|      3|    {
  289|      3|        visit_begin_array(tag, context, ec);
  290|      3|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  291|      3|    }
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  267|      4|    {
  268|      4|        visit_begin_object(tag, context, ec);
  269|      4|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      4|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  270|      4|    }
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  276|     71|    {
  277|     71|        visit_begin_object(length, tag, context, ec);
  278|     71|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     71|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  279|     71|    }
_ZN8jsoncons21basic_generic_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  282|     55|    {
  283|     55|        visit_end_object(context, ec);
  284|     55|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     55|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  285|     55|    }
_ZN8jsoncons21basic_generic_visitorIcE5flushEv:
   57|      7|    {
   58|      7|        visit_flush();
   59|      7|    }

_ZN8jsoncons19typed_array_visitorD2Ev:
   33|     51|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  345|     88|        {
  346|     88|            visit_begin_array(length, tag, context, ec);
  347|     88|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     88|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  348|     88|        }
_ZN8jsoncons18basic_json_visitorIcE3keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  357|   524k|        {
  358|   524k|            visit_key(name, context, ec);
  359|   524k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   524k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  360|   524k|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  351|     82|        {
  352|     82|            visit_end_array(context, ec);
  353|     82|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     82|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  354|     82|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|   523k|        {
  415|   523k|            visit_uint64(value, tag, context, ec);
  416|   523k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   523k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  417|   523k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|     17|        {
  424|     17|            visit_int64(value, tag, context, ec);
  425|     17|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     17|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  426|     17|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|      2|        {
  442|      2|            visit_double(value, tag, context, ec);
  443|      2|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  444|      2|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|      7|        {
  109|      7|            visit_flush();
  110|      7|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  318|      2|        {
  319|      2|            visit_begin_object(tag, context, ec);
  320|      2|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  321|      2|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  327|      7|        {
  328|      7|            visit_begin_object(length, tag, context, ec);
  329|      7|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      7|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  330|      7|        }
_ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  333|      3|        {
  334|      3|            visit_end_object(context, ec);
  335|      3|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  336|      3|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  365|     15|        {
  366|     15|            visit_null(tag, context, ec);
  367|     15|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     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;
  ------------------
  |  |  276|      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;
  ------------------
  |  |  276|      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|    163|        {
  395|    163|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  396|    163|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    163|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  397|    163|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  405|      1|        {
  406|      1|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), raw_tag, context, ec);
  407|      1|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      1|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  408|      1|        }
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|     34|        basic_json_visitor() = default;
_ZN8jsoncons26basic_default_json_visitorIcEC2Ev:
  811|     17|        basic_default_json_visitor() = default;

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

_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERS7_:
  256|     11|            : buf_ptr(std::addressof(buf))
  257|     11|        {
  258|     11|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9push_backEc:
  287|    135|        {
  288|    135|            buf_ptr->push_back(ch);
  289|    135|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvEC2ERS5_:
  315|     17|            : buf_ptr(std::addressof(buf))
  316|     17|        {
  317|     17|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE9push_backEh:
  334|  1.04M|        {
  335|  1.04M|            buf_ptr->push_back(static_cast<value_type>(ch));
  336|  1.04M|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE5flushEv:
  325|     24|        {
  326|     24|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE6appendEPKhm:
  329|   524k|        {
  330|   524k|            append_impl(*buf_ptr, s, length, 0);
  331|   524k|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE11append_implIS5_EEDTcmcldtfp_6insertcldtfp_3endEfp0_plfp0_fp1_Ecvv_EERT_PKhml:
  349|   524k|        {
  350|   524k|            c.insert(c.end(), s, s + length);
  351|   524k|        }

_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev:
  193|     17|    {
  194|     17|        if (chunk_)
  ------------------
  |  Branch (194:13): [True: 17, False: 0]
  ------------------
  195|     17|        {
  196|     17|            std::allocator_traits<char_allocator_type>::deallocate(alloc_, chunk_, chunk_size_);
  197|     17|        }
  198|     17|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  176|     17|        : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  177|     17|          chunk_size_(default_max_chunk_size)
  178|     17|    {
  179|     17|        chunk_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, chunk_size_);
  180|     17|        data_ = chunk_;
  181|     17|    }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   57|     17|      : std::basic_istream<CharT>(&nb_)
   58|     17|    {
   59|     17|    }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   43|     17|        null_buffer() = default;
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm:
  372|  6.28M|    {
  373|  6.28M|        std::size_t len = 0;
  374|  6.28M|        if (count_ > 0)
  ------------------
  |  Branch (374:13): [True: 6.28M, False: 0]
  ------------------
  375|  6.28M|        {
  376|  6.28M|            len = (std::min)(count_, length);
  377|  6.28M|            std::memcpy(p, data_, len*sizeof(value_type));
  378|  6.28M|            data_ += len;
  379|  6.28M|            count_ -= len;
  380|  6.28M|            position_ += len;
  381|  6.28M|        }
  382|  6.28M|        if (length - len == 0)
  ------------------
  |  Branch (382:13): [True: 6.28M, False: 256]
  ------------------
  383|  6.28M|        {
  384|  6.28M|            return len;
  385|  6.28M|        }
  386|    256|        else if (length - len < chunk_size_)
  ------------------
  |  Branch (386:18): [True: 256, False: 0]
  ------------------
  387|    256|        {
  388|    256|            data_ = chunk_;
  389|    256|            count_ = fill_buffer(chunk_, chunk_size_);
  390|    256|            if (count_ > 0)
  ------------------
  |  Branch (390:17): [True: 252, False: 4]
  ------------------
  391|    252|            {
  392|    252|                std::size_t len2 = (std::min)(count_, length-len);
  393|    252|                std::memcpy(p+len, data_, len2*sizeof(value_type));
  394|    252|                data_ += len2;
  395|    252|                count_ -= len2;
  396|    252|                position_ += len2;
  397|    252|                len += len2;
  398|    252|            }
  399|    256|            return len;
  400|    256|        }
  401|      0|        else
  402|      0|        {
  403|      0|            if (stream_ptr_->eof())
  ------------------
  |  Branch (403:17): [True: 0, False: 0]
  ------------------
  404|      0|            {
  405|      0|                count_ = 0;
  406|      0|                return 0;
  407|      0|            }
  408|      0|            JSONCONS_TRY
  ------------------
  |  |   37|      0|    #define JSONCONS_TRY try
  ------------------
  409|      0|            {
  410|      0|                std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(p+len), length-len);
  411|      0|                std::size_t len2 = static_cast<std::size_t>(count);
  412|      0|                if (len2 < length-len)
  ------------------
  |  Branch (412:21): [True: 0, False: 0]
  ------------------
  413|      0|                {
  414|      0|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  415|      0|                }
  416|      0|                len += len2;
  417|      0|                position_ += len2;
  418|      0|                return len;
  419|      0|            }
  420|      0|            JSONCONS_CATCH(const std::exception&)     
  421|      0|            {
  422|      0|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  423|      0|                return 0;
  424|      0|            }
  425|      0|        }
  426|  6.28M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEPhm:
  430|    657|    {
  431|    657|        if (stream_ptr_->eof())
  ------------------
  |  Branch (431:13): [True: 0, False: 657]
  ------------------
  432|      0|        {
  433|      0|            return 0;
  434|      0|        }
  435|       |
  436|    657|        JSONCONS_TRY
  ------------------
  |  |   37|    657|    #define JSONCONS_TRY try
  ------------------
  437|    657|        {
  438|    657|            std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(chunk), chunk_size);
  439|    657|            std::size_t length = static_cast<std::size_t>(count);
  440|       |
  441|    657|            if (length < chunk_size)
  ------------------
  |  Branch (441:17): [True: 10, False: 647]
  ------------------
  442|     10|            {
  443|     10|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  444|     10|            }
  445|    657|            return length;
  446|    657|        }
  447|    657|        JSONCONS_CATCH(const std::exception&)     
  448|    657|        {
  449|      0|            stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  450|      0|            return 0;
  451|      0|        }
  452|    657|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_6vectorIhS4_EEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr10ext_traits7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSD_m:
  996|  1.43k|    {
  997|  1.43k|        std::size_t unread = length;
  998|       |
  999|  1.65k|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (999:16): [True: 220, False: 1.43k]
  |  Branch (999:30): [True: 217, False: 3]
  ------------------
 1000|    217|        {
 1001|    217|            if (source.count() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (1001:17): [True: 0, False: 217]
  |  Branch (1001:40): [True: 0, False: 0]
  ------------------
 1002|      0|            {
 1003|      0|                std::size_t n = source.chunk_size();
 1004|      0|                std::size_t offset = buffer.size();
 1005|      0|                buffer.resize(buffer.size()+n);
 1006|      0|                std::size_t actual = source.fill_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
 1007|      0|                unread -= actual;
 1008|      0|            }
 1009|    217|            else
 1010|    217|            {
 1011|    217|                std::size_t n = (std::min)(source.chunk_size(), unread);
 1012|    217|                std::size_t offset = buffer.size();
 1013|    217|                buffer.resize(buffer.size()+n);
 1014|    217|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
 1015|    217|                unread -= actual;
 1016|    217|            }
 1017|    217|        }
 1018|  1.43k|        return length - unread;
 1019|  1.43k|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv:
  271|    285|    {
  272|    285|        return count_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:16): [True: 4, False: 281]
  |  Branch (272:31): [True: 4, False: 0]
  ------------------
  273|    285|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE5countEv:
  346|    281|    {
  347|    281|        return count_;
  348|    281|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE10chunk_sizeEv:
  261|    281|    {
  262|    281|        return chunk_size_;
  263|    281|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_6vectorIhS3_EEEENS_6detail4spanIKhLm18446744073709551615EEEmOT_:
  352|    516|    {
  353|    516|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|    516|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 443, False: 73]
  |  |  ------------------
  ------------------
  354|    443|        {
  355|    443|            return span<const value_type>{};
  356|    443|        }
  357|     73|        if (length > count_)
  ------------------
  |  Branch (357:13): [True: 3, False: 70]
  ------------------
  358|      3|        {
  359|      3|            buffer.clear();
  360|      3|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  361|      3|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  362|      3|        }
  363|       |
  364|     70|        const value_type* data = data_;
  365|     70|        data_ += length;
  366|     70|        count_ -= length;
  367|     70|        position_ += length;
  368|     70|        return span<const value_type>(data, length);
  369|     73|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_12basic_stringIcNS2_11char_traitsIcEENS3_IcEEEEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr10ext_traits7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSG_m:
  996|      1|    {
  997|      1|        std::size_t unread = length;
  998|       |
  999|     65|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (999:16): [True: 65, False: 0]
  |  Branch (999:30): [True: 64, False: 1]
  ------------------
 1000|     64|        {
 1001|     64|            if (source.count() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (1001:17): [True: 0, False: 64]
  |  Branch (1001:40): [True: 0, False: 0]
  ------------------
 1002|      0|            {
 1003|      0|                std::size_t n = source.chunk_size();
 1004|      0|                std::size_t offset = buffer.size();
 1005|      0|                buffer.resize(buffer.size()+n);
 1006|      0|                std::size_t actual = source.fill_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
 1007|      0|                unread -= actual;
 1008|      0|            }
 1009|     64|            else
 1010|     64|            {
 1011|     64|                std::size_t n = (std::min)(source.chunk_size(), unread);
 1012|     64|                std::size_t offset = buffer.size();
 1013|     64|                buffer.resize(buffer.size()+n);
 1014|     64|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
 1015|     64|                unread -= actual;
 1016|     64|            }
 1017|     64|        }
 1018|      1|        return length - unread;
 1019|      1|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_12basic_stringIcNS1_11char_traitsIcEENS2_IcEEEEEENS_6detail4spanIKhLm18446744073709551615EEEmOT_:
  352|      3|    {
  353|      3|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 1]
  |  |  ------------------
  ------------------
  354|      2|        {
  355|      2|            return span<const value_type>{};
  356|      2|        }
  357|      1|        if (length > count_)
  ------------------
  |  Branch (357:13): [True: 1, False: 0]
  ------------------
  358|      1|        {
  359|      1|            buffer.clear();
  360|      1|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  361|      1|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  362|      1|        }
  363|       |
  364|      0|        const value_type* data = data_;
  365|      0|        data_ += length;
  366|      0|        count_ -= length;
  367|      0|        position_ += length;
  368|      0|        return span<const value_type>(data, length);
  369|      1|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4peekEv:
  312|  12.6M|    {
  313|  12.6M|        if (count_ == 0)
  ------------------
  |  Branch (313:13): [True: 401, False: 12.6M]
  ------------------
  314|    401|        {
  315|    401|            data_ = chunk_;
  316|    401|            count_ = fill_buffer(chunk_, chunk_size_);
  317|    401|        }
  318|  12.6M|        if (count_ > 0)
  ------------------
  |  Branch (318:13): [True: 12.6M, False: 6]
  ------------------
  319|  12.6M|        {
  320|  12.6M|            value_type c = *data_;
  321|  12.6M|            return char_result<value_type>{c, false};
  322|  12.6M|        }
  323|      6|        else
  324|      6|        {
  325|      6|            return char_result<value_type>{0, true};
  326|      6|        }
  327|  12.6M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE6ignoreEm:
  286|    657|    {
  287|    657|        std::size_t len = 0;
  288|    657|        if (count_ > 0)
  ------------------
  |  Branch (288:13): [True: 657, False: 0]
  ------------------
  289|    657|        {
  290|    657|            len = (std::min)(count_, length);
  291|    657|            position_ += len;
  292|    657|            data_ += len;
  293|    657|            count_ -= len;
  294|    657|        }
  295|    657|        while (len < length)
  ------------------
  |  Branch (295:16): [True: 0, False: 657]
  ------------------
  296|      0|        {
  297|      0|            data_ = chunk_;
  298|      0|            count_ = fill_buffer(chunk_, chunk_size_);
  299|      0|            if (count_ == 0)
  ------------------
  |  Branch (299:17): [True: 0, False: 0]
  ------------------
  300|      0|            {
  301|      0|                break;
  302|      0|            }
  303|      0|            std::size_t len2 = (std::min)(count_, length-len);
  304|      0|            position_ += len2;
  305|      0|            data_ += len2;
  306|      0|            count_ -= len2;
  307|      0|            len += len2;
  308|      0|        }
  309|    657|    }

_ZN8jsoncons16typed_array_castIKhEENS_6detail4spanIT_Lm18446744073709551615EEENS3_IhLm18446744073709551615EEE:
  141|      8|{
  142|      8|    return jsoncons::span<const uint8_t>{reinterpret_cast<const uint8_t*>(bytes.data()), bytes.size()};
  143|      8|}
_ZN8jsoncons16typed_array_castIhEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   81|      8|{
   82|      8|    return bytes;
   83|      8|}
_ZN8jsoncons16typed_array_castItEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   87|     44|{
   88|     44|    return jsoncons::span<uint16_t>{reinterpret_cast<uint16_t*>(bytes.data()), bytes.size()/sizeof(uint16_t)};
   89|     44|}
_ZN8jsoncons16typed_array_castImEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   99|     18|{
  100|     18|    return jsoncons::span<uint64_t>{reinterpret_cast<uint64_t*>(bytes.data()), bytes.size()/sizeof(uint64_t)};
  101|     18|}
_ZN8jsoncons16typed_array_castIsEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  111|  2.77k|{
  112|  2.77k|    return jsoncons::span<int16_t>{reinterpret_cast<int16_t*>(bytes.data()), bytes.size()/sizeof(int16_t)};
  113|  2.77k|}
_ZN8jsoncons16typed_array_castIlEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  123|      4|{
  124|      4|    return jsoncons::span<int64_t>{reinterpret_cast<int64_t*>(bytes.data()), bytes.size()/sizeof(int64_t)};
  125|      4|}
_ZN8jsoncons16typed_array_castIfEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  129|      4|{
  130|      4|    return jsoncons::span<float>{reinterpret_cast<float*>(bytes.data()), bytes.size()/sizeof(float)};
  131|      4|}

_ZN8jsoncons6binary13native_to_bigItNSt3__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: 4, False: 2]
  ------------------
  132|      4|        {
  133|      4|            *d_first++ = item;
  134|      4|        }
  135|      2|    }
_ZN8jsoncons6binary9byte_swapItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|     83|    {
   29|     83|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|     83|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  466|     83|#      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|     83|    }
_ZN8jsoncons6binary13native_to_bigIjNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|      6|    {
  128|      6|        T val2 = byte_swap(val);
  129|      6|        uint8_t buf[sizeof(T)];
  130|      6|        std::memcpy(buf, &val2, sizeof(T));
  131|      6|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 24, False: 6]
  ------------------
  132|     24|        {
  133|     24|            *d_first++ = item;
  134|     24|        }
  135|      6|    }
_ZN8jsoncons6binary9byte_swapIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|     28|    {
   40|     28|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|     28|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  462|     28|#  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|     28|    }
_ZN8jsoncons6binary13native_to_bigImNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|      6|    {
  128|      6|        T val2 = byte_swap(val);
  129|      6|        uint8_t buf[sizeof(T)];
  130|      6|        std::memcpy(buf, &val2, sizeof(T));
  131|      6|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 48, False: 6]
  ------------------
  132|     48|        {
  133|     48|            *d_first++ = item;
  134|     48|        }
  135|      6|    }
_ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|    103|    {
   52|    103|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|    103|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|    103|#  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|    103|    }
_ZN8jsoncons6binary13native_to_bigIhNSt3__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: 2, False: 2]
  ------------------
  132|      2|        {
  133|      2|            *d_first++ = item;
  134|      2|        }
  135|      2|    }
_ZN8jsoncons6binary9byte_swapIhEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_:
   21|      2|    {
   22|      2|        return val;
   23|      2|    }
_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|    }
_ZN8jsoncons6binary13big_to_nativeItNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|     81|    {
  183|     81|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 81]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     81|        T val;
  188|     81|        std::memcpy(&val,first,sizeof(T));
  189|     81|        return byte_swap(val);
  190|     81|    }
_ZN8jsoncons6binary13big_to_nativeIjNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|     20|    {
  183|     20|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 20]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     20|        T val;
  188|     20|        std::memcpy(&val,first,sizeof(T));
  189|     20|        return byte_swap(val);
  190|     20|    }
_ZN8jsoncons6binary13big_to_nativeImNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|     97|    {
  183|     97|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 97]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     97|        T val;
  188|     97|        std::memcpy(&val,first,sizeof(T));
  189|     97|        return byte_swap(val);
  190|     97|    }

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

_ZNK8jsoncons8identityclIRKhEEOT_S5_:
   19|     52|    {
   20|     52|        return std::forward<T>(val);
   21|     52|    }
_ZNK8jsoncons8identityclIRKmEEOT_S5_:
   19|      2|    {
   20|      2|        return std::forward<T>(val);
   21|      2|    }
_ZNK8jsoncons8identityclIRKsEEOT_S5_:
   19|     82|    {
   20|     82|        return std::forward<T>(val);
   21|     82|    }
_ZNK8jsoncons8identityclIRKfEEOT_S5_:
   19|      4|    {
   20|      4|        return std::forward<T>(val);
   21|      4|    }

_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|    }
_ZN8jsoncons14dec_to_integerIlcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  327|      6|{
  328|      6|    if (length == 0)
  ------------------
  |  Branch (328:9): [True: 0, False: 6]
  ------------------
  329|      0|    {
  330|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  331|      0|    }
  332|       |
  333|      6|    bool sign = *s == '-';
  334|      6|    s += sign;
  335|      6|    length -= sign;
  336|       |
  337|      6|    using U = typename ext_traits::make_unsigned<T>::type;
  338|       |
  339|      6|    U num;
  340|      6|    auto ru = dec_to_integer(s, length, num);
  341|      6|    if (ru.ec != std::errc{})
  ------------------
  |  Branch (341:9): [True: 0, False: 6]
  ------------------
  342|      0|    {
  343|      0|        return to_number_result<CharT>(ru.ptr, ru.ec);
  344|      0|    }
  345|      6|    if (sign)
  ------------------
  |  Branch (345:9): [True: 5, False: 1]
  ------------------
  346|      5|    {
  347|      5|        if (num > static_cast<U>(-((ext_traits::integer_limits<T>::lowest)()+T(1))) + U(1))
  ------------------
  |  Branch (347:13): [True: 0, False: 5]
  ------------------
  348|      0|        {
  349|      0|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  350|      0|        }
  351|      5|        else
  352|      5|        {
  353|      5|            value = static_cast<T>(U(0) - num);
  354|      5|            return to_number_result<CharT>(ru.ptr, std::errc{});
  355|      5|        }
  356|      5|    }
  357|      1|    else
  358|      1|    {
  359|      1|        if (num > static_cast<U>((ext_traits::integer_limits<T>::max)()))
  ------------------
  |  Branch (359:13): [True: 0, False: 1]
  ------------------
  360|      0|        {
  361|      0|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  362|      0|        }
  363|      1|        else
  364|      1|        {
  365|      1|            value = static_cast<T>(num);
  366|      1|            return to_number_result<CharT>(ru.ptr, std::errc{});
  367|      1|        }
  368|      1|    }
  369|      6|}
_ZN8jsoncons14dec_to_integerImcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedntsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  265|      6|{
  266|      6|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|      6|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 6]
  |  |  ------------------
  ------------------
  267|      0|    {
  268|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  269|      0|    }
  270|       |
  271|      6|    static constexpr T max_value = (ext_traits::integer_limits<T>::max)();
  272|      6|    static constexpr T max_value_div_10 = max_value / 10;
  273|       |
  274|      6|    T num = 0;
  275|      6|    const CharT* cur = s;
  276|      6|    const CharT* last = s + length;
  277|      6|    static constexpr std::size_t digits10 = static_cast<std::size_t>(ext_traits::integer_limits<T>::digits10);
  278|      6|    const std::size_t n = (std::min)(digits10, length);
  279|      6|    const CharT* stop = s + n;
  280|       |     
  281|     81|    while (cur < stop)
  ------------------
  |  Branch (281:12): [True: 75, False: 6]
  ------------------
  282|     75|    {
  283|     75|        uint8_t d;
  284|     75|        if (JSONCONS_LIKELY((d = static_cast<uint8_t>(*cur - '0')) <= 9) )
  ------------------
  |  |   77|     75|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 75, False: 0]
  |  |  ------------------
  ------------------
  285|     75|        {
  286|     75|            num = static_cast<T>(d) + num*10;
  287|     75|        }
  288|      0|        else
  289|      0|        {
  290|      0|            return to_number_result<CharT>(cur, std::errc::invalid_argument);
  291|      0|        }
  292|     75|        ++cur;
  293|     75|    }
  294|      6|    if (cur == last)
  ------------------
  |  Branch (294:9): [True: 6, False: 0]
  ------------------
  295|      6|    {
  296|      6|        value = num;
  297|      6|        return to_number_result<CharT>(cur, std::errc{});
  298|      6|    }
  299|      0|    if (cur+1 != last)
  ------------------
  |  Branch (299:9): [True: 0, False: 0]
  ------------------
  300|      0|    {
  301|      0|        return to_number_result<CharT>(cur, std::errc::result_out_of_range);
  302|      0|    }
  303|      0|    if (is_digit(*cur))
  ------------------
  |  Branch (303:9): [True: 0, False: 0]
  ------------------
  304|      0|    {
  305|      0|        if (num > max_value_div_10)
  ------------------
  |  Branch (305:13): [True: 0, False: 0]
  ------------------
  306|      0|        {
  307|      0|            return to_number_result<CharT>(cur, std::errc::result_out_of_range);
  308|      0|        }
  309|      0|        uint8_t d = static_cast<uint8_t>(*cur - '0');
  310|      0|        num = num*10;
  311|      0|        if (num > max_value - d)
  ------------------
  |  Branch (311:13): [True: 0, False: 0]
  ------------------
  312|      0|        {
  313|      0|            return to_number_result<CharT>(s, std::errc::result_out_of_range);
  314|      0|        }
  315|      0|        num += d;
  316|      0|        ++cur;
  317|      0|        value = num;
  318|      0|        return to_number_result<CharT>(cur, std::errc{});
  319|      0|    }
  320|       |    
  321|      0|    return to_number_result<CharT>(cur, std::errc::invalid_argument);
  322|      0|}
_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);
  ------------------
  |  |   49|      2|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 2]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      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_14unicode_resultIS4_EEE4typeEPKS4_m:
 1147|   524k|    {
 1148|   524k|        const uint8_t* it = reinterpret_cast<const uint8_t*>(data);
 1149|   524k|        const uint8_t* end = it + length;
 1150|       |
 1151|   524k|        unicode_errc  result{};
 1152|  1.04M|        while (it != end) 
  ------------------
  |  Branch (1152:16): [True: 524k, False: 524k]
  ------------------
 1153|   524k|        {
 1154|   524k|            if ((end - it) >= 8)
  ------------------
  |  Branch (1154:17): [True: 26, False: 524k]
  ------------------
 1155|     26|            {
 1156|    182|                JSONCONS_REPEAT8({if (JSONCONS_LIKELY((*it & 0x80) == 0)) ++it; else goto non_ascii;})
  ------------------
  |  |  281|     52|#define JSONCONS_REPEAT8(x)  { x x x x x x x x }
  |  |  ------------------
  |  |  |  Branch (281:32): [True: 26, False: 0]
  |  |  |  Branch (281:34): [True: 26, False: 0]
  |  |  |  Branch (281:36): [True: 26, False: 0]
  |  |  |  Branch (281:38): [True: 26, False: 0]
  |  |  |  Branch (281:40): [True: 26, False: 0]
  |  |  |  Branch (281:42): [True: 26, False: 0]
  |  |  |  Branch (281:44): [True: 26, False: 0]
  |  |  |  Branch (281:46): [True: 26, False: 0]
  |  |  ------------------
  ------------------
 1157|     26|                continue;
 1158|    182|            }
 1159|   524k|    non_ascii:
 1160|   524k|            const std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[*it]) + 1;
 1161|   524k|            if (len > (std::size_t)(end - it))
  ------------------
  |  Branch (1161:17): [True: 0, False: 524k]
  ------------------
 1162|      0|            {
 1163|      0|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), unicode_errc::source_exhausted};
 1164|      0|            }
 1165|   524k|            if ((result=is_legal_utf8(it, len)) != unicode_errc())
  ------------------
  |  Branch (1165:17): [True: 0, False: 524k]
  ------------------
 1166|      0|            {
 1167|      0|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1168|      0|            }
 1169|   524k|            it += len;
 1170|   524k|        }
 1171|   524k|        return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1172|   524k|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8EPKhm:
  305|   524k|    {
  306|   524k|        const uint8_t* it = reinterpret_cast<const uint8_t*>(bytes);
  307|   524k|        const uint8_t* end = it+length;
  308|       |
  309|   524k|        uint8_t byte;
  310|   524k|        switch (length) {
  311|      0|        default:
  ------------------
  |  Branch (311:9): [True: 0, False: 524k]
  ------------------
  312|      0|            return unicode_errc::over_long_utf8_sequence;
  313|      0|        case 4:
  ------------------
  |  Branch (313:9): [True: 0, False: 524k]
  ------------------
  314|      0|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 0, False: 0]
  ------------------
  315|      0|                return unicode_errc::bad_continuation_byte;
  316|      0|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|      0|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  317|      0|        case 3:
  ------------------
  |  Branch (317:9): [True: 0, False: 524k]
  ------------------
  318|      0|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (318:17): [True: 0, False: 0]
  ------------------
  319|      0|                return unicode_errc::bad_continuation_byte;
  320|      0|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|      0|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  321|      0|        case 2:
  ------------------
  |  Branch (321:9): [True: 0, False: 524k]
  ------------------
  322|      0|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (322:17): [True: 0, False: 0]
  ------------------
  323|      0|                return unicode_errc::bad_continuation_byte;
  324|       |
  325|      0|            switch (*it) 
  326|      0|            {
  327|       |                // no fall-through in this inner switch
  328|      0|                case 0xE0: if (byte < 0xA0) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (328:17): [True: 0, False: 0]
  |  Branch (328:32): [True: 0, False: 0]
  ------------------
  329|      0|                case 0xED: if (byte > 0x9F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (329:17): [True: 0, False: 0]
  |  Branch (329:32): [True: 0, False: 0]
  ------------------
  330|      0|                case 0xF0: if (byte < 0x90) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (330:17): [True: 0, False: 0]
  |  Branch (330:32): [True: 0, False: 0]
  ------------------
  331|      0|                case 0xF4: if (byte > 0x8F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (331:17): [True: 0, False: 0]
  |  Branch (331:32): [True: 0, False: 0]
  ------------------
  332|      0|                default:   if (byte < 0x80) return unicode_errc::source_illegal;
  ------------------
  |  Branch (332:17): [True: 0, False: 0]
  |  Branch (332:32): [True: 0, False: 0]
  ------------------
  333|      0|            }
  334|       |
  335|      0|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|      0|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  336|   524k|        case 1:
  ------------------
  |  Branch (336:9): [True: 524k, False: 0]
  ------------------
  337|   524k|            if (*it >= 0x80 && *it < 0xC2)
  ------------------
  |  Branch (337:17): [True: 0, False: 524k]
  |  Branch (337:32): [True: 0, False: 0]
  ------------------
  338|      0|                return unicode_errc::source_illegal;
  339|   524k|            break;
  340|   524k|        }
  341|   524k|        if (*it > 0xF4) 
  ------------------
  |  Branch (341:13): [True: 0, False: 524k]
  ------------------
  342|      0|            return unicode_errc::source_illegal;
  343|       |
  344|   524k|        return unicode_errc();
  345|   524k|    }

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

_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEEC2EOS8_RKS9_:
  125|     17|       : basic_cbor_encoder(std::forward<Sink>(sink), cbor_encode_options(), alloc)
  126|     17|    {
  127|     17|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEEC2EOS8_RKNS0_19cbor_encode_optionsERKS9_:
  131|     17|       : sink_(std::forward<Sink>(sink)), 
  132|     17|         max_nesting_depth_(options.max_nesting_depth()), 
  133|     17|         pack_strings_(options.pack_strings()),
  134|     17|         use_typed_arrays_(options.use_typed_arrays()),
  135|     17|         alloc_(alloc),
  136|     17|         stack_(alloc),
  137|     17|         stringref_map_(alloc),
  138|     17|         bytestringref_map_(alloc)
  139|     17|    {
  140|     17|        if (options.pack_strings())
  ------------------
  |  Branch (140:13): [True: 0, False: 17]
  ------------------
  141|      0|        {
  142|      0|            write_tag(256);
  143|      0|        }
  144|     17|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9write_tagEm:
 1098|      7|    {
 1099|      7|        write_type_and_length(0xc0, value);
 1100|      7|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE21write_type_and_lengthEhm:
  425|  1.04M|    {
  426|  1.04M|        if (length <= 0x17)
  ------------------
  |  Branch (426:13): [True: 1.04M, False: 18]
  ------------------
  427|  1.04M|        {
  428|  1.04M|            sink_.push_back(static_cast<uint8_t>(major_type + length));
  429|  1.04M|        }
  430|     18|        else if (length <= 0xff)
  ------------------
  |  Branch (430:18): [True: 4, False: 14]
  ------------------
  431|      4|        {
  432|      4|            sink_.push_back(static_cast<uint8_t>(major_type + 0x18));
  433|      4|            sink_.push_back(static_cast<uint8_t>(length));
  434|      4|        }
  435|     14|        else if (length <= 0xffff)
  ------------------
  |  Branch (435:18): [True: 2, False: 12]
  ------------------
  436|      2|        {
  437|      2|            sink_.push_back(static_cast<uint8_t>(major_type + 0x19));
  438|      2|            binary::native_to_big(static_cast<uint16_t>(length),
  439|      2|                                            std::back_inserter(sink_));
  440|      2|        }
  441|     12|        else if (length <= 0xffffffff)
  ------------------
  |  Branch (441:18): [True: 6, False: 6]
  ------------------
  442|      6|        {
  443|      6|            sink_.push_back(static_cast<uint8_t>(major_type + 0x1a));
  444|      6|            binary::native_to_big(static_cast<uint32_t>(length),
  445|      6|                                            std::back_inserter(sink_));
  446|      6|        }
  447|      6|        else
  448|      6|        {
  449|      6|            sink_.push_back(static_cast<uint8_t>(major_type + 0x1b));
  450|      6|            binary::native_to_big(static_cast<uint64_t>(length),
  451|      6|                                            std::back_inserter(sink_));
  452|      6|        }
  453|  1.04M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  334|     94|    {
  335|     94|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|     94|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 94]
  |  |  ------------------
  ------------------
  336|      0|        {
  337|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  338|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  339|      0|        } 
  340|     94|        stack_.emplace_back(cbor_container_type::array, length);
  341|     94|        write_type_and_length(0x80, length);
  342|     94|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     94|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  343|     94|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_itemC2ENS0_19cbor_container_typeEm:
   74|    103|           : type_(type), length_(length)
   75|    103|        {
   76|    103|        }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE15visit_end_arrayERKNS_11ser_contextERNS3_10error_codeE:
  346|     88|    {
  347|     88|        JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   49|     88|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 88]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  348|     88|        --nesting_depth_;
  349|       |
  350|     88|        if (stack_.back().is_indefinite_length())
  ------------------
  |  Branch (350:13): [True: 0, False: 88]
  ------------------
  351|      0|        {
  352|      0|            sink_.push_back(0xff);
  353|      0|        }
  354|     88|        else
  355|     88|        {
  356|     88|            if (stack_.back().count() < stack_.back().length())
  ------------------
  |  Branch (356:17): [True: 0, False: 88]
  ------------------
  357|      0|            {
  358|      0|                ec = cbor_errc::too_few_items;
  359|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  360|      0|            }
  361|     88|            if (stack_.back().count() > stack_.back().length())
  ------------------
  |  Branch (361:17): [True: 0, False: 88]
  ------------------
  362|      0|            {
  363|      0|                ec = cbor_errc::too_many_items;
  364|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  365|      0|            }
  366|     88|        }
  367|       |
  368|     88|        stack_.pop_back();
  369|     88|        end_value();
  370|       |
  371|     88|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     88|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  372|     88|    }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item20is_indefinite_lengthEv:
   96|     91|        {
   97|     91|            return type_ == cbor_container_type::indefinite_length_array || type_ == cbor_container_type::indefinite_length_object;
  ------------------
  |  Branch (97:20): [True: 0, False: 91]
  |  Branch (97:77): [True: 0, False: 91]
  ------------------
   98|     91|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item5countEv:
   86|    182|        {
   87|    182|            return is_object() ? index_/2 : index_;
  ------------------
  |  Branch (87:20): [True: 6, False: 176]
  ------------------
   88|    182|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item9is_objectEv:
   91|    182|        {
   92|    182|            return type_ == cbor_container_type::object || type_ == cbor_container_type::indefinite_length_object;
  ------------------
  |  Branch (92:20): [True: 6, False: 176]
  |  Branch (92:60): [True: 0, False: 176]
  ------------------
   93|    182|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item6lengthEv:
   81|    182|        {
   82|    182|            return length_;
   83|    182|        }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9end_valueEv:
 1615|  1.04M|    {
 1616|  1.04M|        if (!stack_.empty())
  ------------------
  |  Branch (1616:13): [True: 1.04M, False: 7]
  ------------------
 1617|  1.04M|        {
 1618|  1.04M|            ++stack_.back().index_;
 1619|  1.04M|        }
 1620|  1.04M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1079|   523k|    {
 1080|   523k|        switch (tag)
 1081|   523k|        {
 1082|      0|            case semantic_tag::epoch_milli:
  ------------------
  |  Branch (1082:13): [True: 0, False: 523k]
  ------------------
 1083|      0|            case semantic_tag::epoch_nano:
  ------------------
  |  Branch (1083:13): [True: 0, False: 523k]
  ------------------
 1084|      0|                return visit_double(static_cast<double>(value), tag, context, ec);
 1085|      0|            case semantic_tag::epoch_second:
  ------------------
  |  Branch (1085:13): [True: 0, False: 523k]
  ------------------
 1086|      0|                write_tag(1);
 1087|      0|                break;
 1088|   523k|            default:
  ------------------
  |  Branch (1088:13): [True: 523k, False: 0]
  ------------------
 1089|   523k|                break;
 1090|   523k|        }
 1091|       |
 1092|   523k|        write_uint64_value(value);
 1093|   523k|        end_value();
 1094|   523k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   523k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1095|   523k|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18write_uint64_valueEm:
 1103|   523k|    {
 1104|   523k|        write_type_and_length(0x00, value);
 1105|   523k|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1058|     29|    {
 1059|     29|        switch (tag)
 1060|     29|        {
 1061|      0|            case semantic_tag::epoch_milli:
  ------------------
  |  Branch (1061:13): [True: 0, False: 29]
  ------------------
 1062|      0|            case semantic_tag::epoch_nano:
  ------------------
  |  Branch (1062:13): [True: 0, False: 29]
  ------------------
 1063|      0|                return visit_double(static_cast<double>(value), tag, context, ec);
 1064|      0|            case semantic_tag::epoch_second:
  ------------------
  |  Branch (1064:13): [True: 0, False: 29]
  ------------------
 1065|      0|                write_tag(1);
 1066|      0|                break;
 1067|     29|            default:
  ------------------
  |  Branch (1067:13): [True: 29, False: 0]
  ------------------
 1068|     29|                break;
 1069|     29|        }
 1070|     29|        write_int64_value(value);
 1071|     29|        end_value();
 1072|     29|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     29|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1073|     29|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17write_int64_valueEl:
 1108|     29|    {
 1109|     29|        if (value >= 0)
  ------------------
  |  Branch (1109:13): [True: 6, False: 23]
  ------------------
 1110|      6|        {
 1111|      6|            write_type_and_length(0x00, static_cast<uint64_t>(value));
 1112|      6|        }
 1113|     23|        else
 1114|     23|        {
 1115|     23|            write_type_and_length(0x20, static_cast<uint64_t>(-1 - value));
 1116|     23|        }
 1117|     29|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1010|      2|    {
 1011|      2|        switch (tag)
 1012|      2|        {
 1013|      0|            case semantic_tag::epoch_second:
  ------------------
  |  Branch (1013:13): [True: 0, False: 2]
  ------------------
 1014|      0|                write_tag(1);
 1015|      0|                break;
 1016|      0|            case semantic_tag::epoch_milli:
  ------------------
  |  Branch (1016:13): [True: 0, False: 2]
  ------------------
 1017|      0|                write_tag(1);
 1018|      0|                if (val != 0)
  ------------------
  |  Branch (1018:21): [True: 0, False: 0]
  ------------------
 1019|      0|                {
 1020|      0|                    val /= millis_in_second;
 1021|      0|                }
 1022|      0|                break;
 1023|      0|            case semantic_tag::epoch_nano:
  ------------------
  |  Branch (1023:13): [True: 0, False: 2]
  ------------------
 1024|      0|                write_tag(1);
 1025|      0|                if (val != 0)
  ------------------
  |  Branch (1025:21): [True: 0, False: 0]
  ------------------
 1026|      0|                {
 1027|      0|                    val /= nanos_in_second;
 1028|      0|                }
 1029|      0|                break;
 1030|      2|            default:
  ------------------
  |  Branch (1030:13): [True: 2, False: 0]
  ------------------
 1031|      2|                break;
 1032|      2|        }
 1033|       |
 1034|      2|        float valf = (float)val;
 1035|      2|        if ((double)valf == val)
  ------------------
  |  Branch (1035:13): [True: 2, False: 0]
  ------------------
 1036|      2|        {
 1037|      2|            binary::native_to_big(static_cast<uint8_t>(0xfa), 
 1038|      2|                                  std::back_inserter(sink_));
 1039|      2|            binary::native_to_big(valf, std::back_inserter(sink_));
 1040|      2|        }
 1041|      0|        else
 1042|      0|        {
 1043|      0|            binary::native_to_big(static_cast<uint8_t>(0xfb), 
 1044|      0|                                  std::back_inserter(sink_));
 1045|      0|            binary::native_to_big(val, std::back_inserter(sink_));
 1046|      0|        }
 1047|       |
 1048|       |        // write double
 1049|       |
 1050|      2|        end_value();
 1051|      2|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1052|      2|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE11visit_flushEv:
  261|      7|    {
  262|      7|        sink_.flush();
  263|      7|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  266|      2|    {
  267|      2|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  268|      0|        {
  269|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  270|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  271|      0|        } 
  272|      2|        stack_.emplace_back(cbor_container_type::indefinite_length_object);
  273|       |        
  274|      2|        sink_.push_back(0xbf);
  275|      2|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  276|      2|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  279|      7|    {
  280|      7|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|      7|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 7]
  |  |  ------------------
  ------------------
  281|      0|        {
  282|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  283|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  284|      0|        } 
  285|      7|        stack_.emplace_back(cbor_container_type::object, length);
  286|       |
  287|      7|        write_type_and_length(0xa0, length);
  288|       |
  289|      7|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      7|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  290|      7|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE16visit_end_objectERKNS_11ser_contextERNS3_10error_codeE:
  293|      3|    {
  294|      3|        JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   49|      3|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 3]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  295|      3|        --nesting_depth_;
  296|       |
  297|      3|        if (stack_.back().is_indefinite_length())
  ------------------
  |  Branch (297:13): [True: 0, False: 3]
  ------------------
  298|      0|        {
  299|      0|            sink_.push_back(0xff);
  300|      0|        }
  301|      3|        else
  302|      3|        {
  303|      3|            if (stack_.back().count() < stack_.back().length())
  ------------------
  |  Branch (303:17): [True: 0, False: 3]
  ------------------
  304|      0|            {
  305|      0|                ec = cbor_errc::too_few_items;
  306|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  307|      0|            }
  308|      3|            if (stack_.back().count() > stack_.back().length())
  ------------------
  |  Branch (308:17): [True: 0, False: 3]
  ------------------
  309|      0|            {
  310|      0|                ec = cbor_errc::too_many_items;
  311|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  312|      0|            }
  313|      3|        }
  314|       |
  315|      3|        stack_.pop_back();
  316|      3|        end_value();
  317|       |
  318|      3|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  319|      3|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9visit_keyERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKNS_11ser_contextERNS3_10error_codeE:
  375|   524k|    {
  376|   524k|        visit_string(name, semantic_tag::none, context, ec);
  377|   524k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   524k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  378|   524k|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  381|     15|    {
  382|     15|        if (tag == semantic_tag::undefined)
  ------------------
  |  Branch (382:13): [True: 12, False: 3]
  ------------------
  383|     12|        {
  384|     12|            sink_.push_back(0xf7);
  385|     12|        }
  386|      3|        else
  387|      3|        {
  388|      3|            sink_.push_back(0xf6);
  389|      3|        }
  390|       |
  391|     15|        end_value();
  392|     15|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     15|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  393|     15|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1120|      7|    {
 1121|      7|        if (value)
  ------------------
  |  Branch (1121:13): [True: 7, False: 0]
  ------------------
 1122|      7|        {
 1123|      7|            sink_.push_back(0xf5);
 1124|      7|        }
 1125|      0|        else
 1126|      0|        {
 1127|      0|            sink_.push_back(0xf4);
 1128|      0|        }
 1129|       |
 1130|      7|        end_value();
 1131|      7|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      7|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1132|      7|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  850|   524k|    {
  851|   524k|        switch (tag)
  852|   524k|        {
  853|      0|            case semantic_tag::bigint:
  ------------------
  |  Branch (853:13): [True: 0, False: 524k]
  ------------------
  854|      0|            {
  855|      0|                bigint n(sv.data(), sv.length());
  856|      0|                write_bignum(n);
  857|      0|                end_value();
  858|      0|                break;
  859|      0|            }
  860|      5|            case semantic_tag::bigdec:
  ------------------
  |  Branch (860:13): [True: 5, False: 524k]
  ------------------
  861|      5|            {
  862|      5|                write_decimal_value(sv, context, ec);
  863|      5|                break;
  864|      0|            }
  865|      1|            case semantic_tag::bigfloat:
  ------------------
  |  Branch (865:13): [True: 1, False: 524k]
  ------------------
  866|      1|            {
  867|      1|                write_hexfloat_value(sv, context, ec);
  868|      1|                break;
  869|      0|            }
  870|      0|            case semantic_tag::datetime:
  ------------------
  |  Branch (870:13): [True: 0, False: 524k]
  ------------------
  871|      0|            {
  872|      0|                write_tag(0);
  873|       |
  874|      0|                write_string(sv);
  875|      0|                end_value();
  876|      0|                break;
  877|      0|            }
  878|      0|            case semantic_tag::uri:
  ------------------
  |  Branch (878:13): [True: 0, False: 524k]
  ------------------
  879|      0|            {
  880|      0|                write_tag(32);
  881|      0|                write_string(sv);
  882|      0|                end_value();
  883|      0|                break;
  884|      0|            }
  885|      0|            case semantic_tag::base64url:
  ------------------
  |  Branch (885:13): [True: 0, False: 524k]
  ------------------
  886|      0|            {
  887|      0|                write_tag(33);
  888|      0|                write_string(sv);
  889|      0|                end_value();
  890|      0|                break;
  891|      0|            }
  892|      0|            case semantic_tag::base64:
  ------------------
  |  Branch (892:13): [True: 0, False: 524k]
  ------------------
  893|      0|            {
  894|      0|                write_tag(34);
  895|      0|                write_string(sv);
  896|      0|                end_value();
  897|      0|                break;
  898|      0|            }
  899|   524k|            default:
  ------------------
  |  Branch (899:13): [True: 524k, False: 6]
  ------------------
  900|   524k|            {
  901|   524k|                write_string(sv);
  902|   524k|                end_value();
  903|   524k|                break;
  904|      0|            }
  905|   524k|        }
  906|   524k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   524k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  907|   524k|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE19write_decimal_valueERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKNS_11ser_contextERNS3_10error_codeE:
  526|      5|    {
  527|      5|        decimal_parse_state state = decimal_parse_state::start;
  528|      5|        std::basic_string<char> s;
  529|      5|        std::basic_string<char> exponent;
  530|      5|        int64_t scale = 0;
  531|      5|        for (auto c : sv)
  ------------------
  |  Branch (531:21): [True: 85, False: 5]
  ------------------
  532|     85|        {
  533|     85|            switch (state)
  ------------------
  |  Branch (533:21): [True: 85, False: 0]
  ------------------
  534|     85|            {
  535|      5|                case decimal_parse_state::start:
  ------------------
  |  Branch (535:17): [True: 5, False: 80]
  ------------------
  536|      5|                {
  537|      5|                    switch (c)
  538|      5|                    {
  539|      4|                        case '-':
  ------------------
  |  Branch (539:25): [True: 4, False: 1]
  ------------------
  540|      5|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (540:25): [True: 1, False: 4]
  |  Branch (540:34): [True: 0, False: 5]
  |  Branch (540:43): [True: 0, False: 5]
  |  Branch (540:52): [True: 0, False: 5]
  |  Branch (540:61): [True: 0, False: 5]
  |  Branch (540:70): [True: 0, False: 5]
  |  Branch (540:79): [True: 0, False: 5]
  |  Branch (540:88): [True: 0, False: 5]
  |  Branch (540:97): [True: 0, False: 5]
  |  Branch (540:107): [True: 0, False: 5]
  ------------------
  541|      5|                            s.push_back(c);
  542|      5|                            state = decimal_parse_state::integer;
  543|      5|                            break;
  544|      0|                        case '+':
  ------------------
  |  Branch (544:25): [True: 0, False: 5]
  ------------------
  545|      0|                            state = decimal_parse_state::integer;
  546|      0|                            break;
  547|      0|                        case '.':
  ------------------
  |  Branch (547:25): [True: 0, False: 5]
  ------------------
  548|      0|                            state = decimal_parse_state::fraction1;
  549|      0|                            break;
  550|      0|                        default:
  ------------------
  |  Branch (550:25): [True: 0, False: 5]
  ------------------
  551|      0|                        {
  552|      0|                            ec = cbor_errc::invalid_decimal_fraction;
  553|      0|                            return;
  554|      5|                        }
  555|      5|                    }
  556|      5|                    break;
  557|      5|                }
  558|     73|                case decimal_parse_state::integer:
  ------------------
  |  Branch (558:17): [True: 73, False: 12]
  ------------------
  559|     73|                {
  560|     73|                    switch (c)
  561|     73|                    {
  562|     68|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (562:25): [True: 64, False: 9]
  |  Branch (562:34): [True: 0, False: 73]
  |  Branch (562:43): [True: 0, False: 73]
  |  Branch (562:52): [True: 4, False: 69]
  |  Branch (562:61): [True: 0, False: 73]
  |  Branch (562:70): [True: 0, False: 73]
  |  Branch (562:79): [True: 0, False: 73]
  |  Branch (562:88): [True: 0, False: 73]
  |  Branch (562:97): [True: 0, False: 73]
  |  Branch (562:107): [True: 0, False: 73]
  ------------------
  563|     68|                            s.push_back(c);
  564|     68|                            break;
  565|      1|                        case 'e': case 'E':
  ------------------
  |  Branch (565:25): [True: 1, False: 72]
  |  Branch (565:35): [True: 0, False: 73]
  ------------------
  566|      1|                            state = decimal_parse_state::exp1;
  567|      1|                            break;
  568|      4|                        case '.':
  ------------------
  |  Branch (568:25): [True: 4, False: 69]
  ------------------
  569|      4|                            state = decimal_parse_state::fraction1;
  570|      4|                            break;
  571|      0|                        default:
  ------------------
  |  Branch (571:25): [True: 0, False: 73]
  ------------------
  572|      0|                        {
  573|      0|                            ec = cbor_errc::invalid_decimal_fraction;
  574|      0|                            return;
  575|      1|                        }
  576|     73|                    }
  577|     73|                    break;
  578|     73|                }
  579|     73|                case decimal_parse_state::exp1:
  ------------------
  |  Branch (579:17): [True: 1, False: 84]
  ------------------
  580|      1|                {
  581|      1|                    switch (c)
  582|      1|                    {
  583|      0|                        case '+':
  ------------------
  |  Branch (583:25): [True: 0, False: 1]
  ------------------
  584|      0|                            state = decimal_parse_state::exp2;
  585|      0|                            break;
  586|      1|                        case '-':
  ------------------
  |  Branch (586:25): [True: 1, False: 0]
  ------------------
  587|      1|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (587:25): [True: 0, False: 1]
  |  Branch (587:34): [True: 0, False: 1]
  |  Branch (587:43): [True: 0, False: 1]
  |  Branch (587:52): [True: 0, False: 1]
  |  Branch (587:61): [True: 0, False: 1]
  |  Branch (587:70): [True: 0, False: 1]
  |  Branch (587:79): [True: 0, False: 1]
  |  Branch (587:88): [True: 0, False: 1]
  |  Branch (587:97): [True: 0, False: 1]
  |  Branch (587:107): [True: 0, False: 1]
  ------------------
  588|      1|                            exponent.push_back(c);
  589|      1|                            state = decimal_parse_state::exp2;
  590|      1|                            break;
  591|      0|                        default:
  ------------------
  |  Branch (591:25): [True: 0, False: 1]
  ------------------
  592|      0|                        {
  593|      0|                            ec = cbor_errc::invalid_decimal_fraction;
  594|      0|                            return;
  595|      1|                        }
  596|      1|                    }
  597|      1|                    break;
  598|      1|                }
  599|      2|                case decimal_parse_state::exp2:
  ------------------
  |  Branch (599:17): [True: 2, False: 83]
  ------------------
  600|      2|                {
  601|      2|                    switch (c)
  602|      2|                    {
  603|      2|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (603:25): [True: 0, False: 2]
  |  Branch (603:34): [True: 0, False: 2]
  |  Branch (603:43): [True: 2, False: 0]
  |  Branch (603:52): [True: 0, False: 2]
  |  Branch (603:61): [True: 0, False: 2]
  |  Branch (603:70): [True: 0, False: 2]
  |  Branch (603:79): [True: 0, False: 2]
  |  Branch (603:88): [True: 0, False: 2]
  |  Branch (603:97): [True: 0, False: 2]
  |  Branch (603:107): [True: 0, False: 2]
  ------------------
  604|      2|                            exponent.push_back(c);
  605|      2|                            break;
  606|      0|                        default:
  ------------------
  |  Branch (606:25): [True: 0, False: 2]
  ------------------
  607|      0|                        {
  608|      0|                            ec = cbor_errc::invalid_decimal_fraction;
  609|      0|                            return;
  610|      2|                        }
  611|      2|                    }
  612|      2|                    break;
  613|      2|                }
  614|      4|                case decimal_parse_state::fraction1:
  ------------------
  |  Branch (614:17): [True: 4, False: 81]
  ------------------
  615|      4|                {
  616|      4|                    switch (c)
  617|      4|                    {
  618|      4|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (618:25): [True: 4, False: 0]
  |  Branch (618:34): [True: 0, False: 4]
  |  Branch (618:43): [True: 0, False: 4]
  |  Branch (618:52): [True: 0, False: 4]
  |  Branch (618:61): [True: 0, False: 4]
  |  Branch (618:70): [True: 0, False: 4]
  |  Branch (618:79): [True: 0, False: 4]
  |  Branch (618:88): [True: 0, False: 4]
  |  Branch (618:97): [True: 0, False: 4]
  |  Branch (618:107): [True: 0, False: 4]
  ------------------
  619|      4|                            s.push_back(c);
  620|      4|                            --scale;
  621|      4|                            break;
  622|      0|                        case 'e': case 'E':
  ------------------
  |  Branch (622:25): [True: 0, False: 4]
  |  Branch (622:35): [True: 0, False: 4]
  ------------------
  623|      0|                            state = decimal_parse_state::exp1;
  624|      0|                            break;
  625|      0|                        default:
  ------------------
  |  Branch (625:25): [True: 0, False: 4]
  ------------------
  626|      0|                        {
  627|      0|                            ec = cbor_errc::invalid_decimal_fraction;
  628|      0|                            return;
  629|      0|                        }
  630|      4|                    }
  631|      4|                    break;
  632|      4|                }
  633|     85|            }
  634|     85|        }
  635|       |
  636|      5|        write_tag(4);
  637|      5|        visit_begin_array((std::size_t)2, semantic_tag::none, context, ec);
  638|      5|        if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
  639|      5|        if (exponent.length() > 0)
  ------------------
  |  Branch (639:13): [True: 1, False: 4]
  ------------------
  640|      1|        {
  641|      1|            int64_t val{};
  642|      1|            auto r = jsoncons::dec_to_integer(exponent.data(), exponent.length(), val);
  643|      1|            if (!r)
  ------------------
  |  Branch (643:17): [True: 0, False: 1]
  ------------------
  644|      0|            {
  645|      0|                ec = r.error_code();
  646|      0|                return;
  647|      0|            }
  648|      1|            scale += val;
  649|      1|        }
  650|      5|        visit_int64(scale, semantic_tag::none, context, ec);
  651|      5|        if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
  652|       |
  653|      5|        int64_t val{ 0 };
  654|      5|        auto r = jsoncons::dec_to_integer(s.data(),s.length(), val);
  655|      5|        if (r)
  ------------------
  |  Branch (655:13): [True: 5, False: 0]
  ------------------
  656|      5|        {
  657|      5|            visit_int64(val, semantic_tag::none, context, ec);
  658|      5|            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
  659|      5|        }
  660|      0|        else if (r.error_code() == std::errc::result_out_of_range)
  ------------------
  |  Branch (660:18): [True: 0, False: 0]
  ------------------
  661|      0|        {
  662|      0|            bigint n(s.data(), s.length());
  663|      0|            write_bignum(n);
  664|      0|            end_value();
  665|      0|        }
  666|      0|        else
  667|      0|        {
  668|      0|            ec = r.error_code();
  669|      0|            return;
  670|      0|        }
  671|      5|        visit_end_array(context, ec);
  672|      5|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE20write_hexfloat_valueERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKNS_11ser_contextERNS3_10error_codeE:
  675|      1|    {
  676|      1|        hexfloat_parse_state state = hexfloat_parse_state::start;
  677|      1|        std::basic_string<char> s;
  678|      1|        std::basic_string<char> exponent;
  679|      1|        int64_t scale = 0;
  680|       |
  681|      1|        for (auto c : sv)
  ------------------
  |  Branch (681:21): [True: 22, False: 1]
  ------------------
  682|     22|        {
  683|     22|            switch (state)
  ------------------
  |  Branch (683:21): [True: 22, False: 0]
  ------------------
  684|     22|            {
  685|      1|                case hexfloat_parse_state::start:
  ------------------
  |  Branch (685:17): [True: 1, False: 21]
  ------------------
  686|      1|                {
  687|      1|                    switch (c)
  688|      1|                    {
  689|      1|                        case '-':
  ------------------
  |  Branch (689:25): [True: 1, False: 0]
  ------------------
  690|      1|                            s.push_back(c);
  691|      1|                            state = hexfloat_parse_state::expect_0;
  692|      1|                            break;
  693|      0|                        case '0':
  ------------------
  |  Branch (693:25): [True: 0, False: 1]
  ------------------
  694|      0|                            state = hexfloat_parse_state::expect_x;
  695|      0|                            break;
  696|      0|                        default:
  ------------------
  |  Branch (696:25): [True: 0, False: 1]
  ------------------
  697|      0|                        {
  698|      0|                            ec = cbor_errc::invalid_bigfloat;
  699|      0|                            return;
  700|      0|                        }
  701|      1|                    }
  702|      1|                    break;
  703|      1|                }
  704|      1|                case hexfloat_parse_state::expect_0:
  ------------------
  |  Branch (704:17): [True: 1, False: 21]
  ------------------
  705|      1|                {
  706|      1|                    switch (c)
  707|      1|                    {
  708|      1|                        case '0':
  ------------------
  |  Branch (708:25): [True: 1, False: 0]
  ------------------
  709|      1|                            state = hexfloat_parse_state::expect_x;
  710|      1|                            break;
  711|      0|                        default:
  ------------------
  |  Branch (711:25): [True: 0, False: 1]
  ------------------
  712|      0|                        {
  713|      0|                            ec = cbor_errc::invalid_bigfloat;
  714|      0|                            return;
  715|      0|                        }
  716|      1|                    }
  717|      1|                    break;
  718|      1|                }
  719|      1|                case hexfloat_parse_state::expect_x:
  ------------------
  |  Branch (719:17): [True: 1, False: 21]
  ------------------
  720|      1|                {
  721|      1|                    switch (c)
  722|      1|                    {
  723|      1|                        case 'x':
  ------------------
  |  Branch (723:25): [True: 1, False: 0]
  ------------------
  724|      1|                        case 'X':
  ------------------
  |  Branch (724:25): [True: 0, False: 1]
  ------------------
  725|      1|                            state = hexfloat_parse_state::integer;
  726|      1|                            break;
  727|      0|                        default:
  ------------------
  |  Branch (727:25): [True: 0, False: 1]
  ------------------
  728|      0|                        {
  729|      0|                            ec = cbor_errc::invalid_bigfloat;
  730|      0|                            return;
  731|      1|                        }
  732|      1|                    }
  733|      1|                    break;
  734|      1|                }
  735|     17|                case hexfloat_parse_state::integer:
  ------------------
  |  Branch (735:17): [True: 17, False: 5]
  ------------------
  736|     17|                {
  737|     17|                    switch (c)
  738|     17|                    {
  739|     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 (739:25): [True: 12, False: 5]
  |  Branch (739:34): [True: 1, False: 16]
  |  Branch (739:43): [True: 1, False: 16]
  |  Branch (739:52): [True: 0, False: 17]
  |  Branch (739:61): [True: 0, False: 17]
  |  Branch (739:70): [True: 0, False: 17]
  |  Branch (739:79): [True: 0, False: 17]
  |  Branch (739:88): [True: 2, False: 15]
  |  Branch (739:97): [True: 0, False: 17]
  |  Branch (739:107): [True: 0, False: 17]
  |  Branch (739:116): [True: 0, False: 17]
  |  Branch (739:125): [True: 0, False: 17]
  |  Branch (739:134): [True: 0, False: 17]
  |  Branch (739:143): [True: 0, False: 17]
  |  Branch (739:152): [True: 0, False: 17]
  |  Branch (739:161): [True: 0, False: 17]
  |  Branch (739:170): [True: 0, False: 17]
  |  Branch (739:179): [True: 0, False: 17]
  |  Branch (739:188): [True: 0, False: 17]
  |  Branch (739:197): [True: 0, False: 17]
  |  Branch (739:206): [True: 0, False: 17]
  |  Branch (739:215): [True: 0, False: 17]
  ------------------
  740|     16|                            s.push_back(c);
  741|     16|                            break;
  742|      1|                        case 'p': case 'P':
  ------------------
  |  Branch (742:25): [True: 1, False: 16]
  |  Branch (742:35): [True: 0, False: 17]
  ------------------
  743|      1|                            state = hexfloat_parse_state::exp1;
  744|      1|                            break;
  745|      0|                        case '.':
  ------------------
  |  Branch (745:25): [True: 0, False: 17]
  ------------------
  746|      0|                            state = hexfloat_parse_state::fraction1;
  747|      0|                            break;
  748|      0|                        default:
  ------------------
  |  Branch (748:25): [True: 0, False: 17]
  ------------------
  749|      0|                        {
  750|      0|                            ec = cbor_errc::invalid_bigfloat;
  751|      0|                            return;
  752|      1|                        }
  753|     17|                    }
  754|     17|                    break;
  755|     17|                }
  756|     17|                case hexfloat_parse_state::exp1:
  ------------------
  |  Branch (756:17): [True: 1, False: 21]
  ------------------
  757|      1|                {
  758|      1|                    switch (c)
  759|      1|                    {
  760|      0|                        case '+':
  ------------------
  |  Branch (760:25): [True: 0, False: 1]
  ------------------
  761|      0|                            state = hexfloat_parse_state::exp2;
  762|      0|                            break;
  763|      1|                        case '-':
  ------------------
  |  Branch (763:25): [True: 1, False: 0]
  ------------------
  764|      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 (764:25): [True: 0, False: 1]
  |  Branch (764:34): [True: 0, False: 1]
  |  Branch (764:43): [True: 0, False: 1]
  |  Branch (764:52): [True: 0, False: 1]
  |  Branch (764:61): [True: 0, False: 1]
  |  Branch (764:70): [True: 0, False: 1]
  |  Branch (764:79): [True: 0, False: 1]
  |  Branch (764:88): [True: 0, False: 1]
  |  Branch (764:97): [True: 0, False: 1]
  |  Branch (764:107): [True: 0, False: 1]
  |  Branch (764:116): [True: 0, False: 1]
  |  Branch (764:125): [True: 0, False: 1]
  |  Branch (764:134): [True: 0, False: 1]
  |  Branch (764:143): [True: 0, False: 1]
  |  Branch (764:152): [True: 0, False: 1]
  |  Branch (764:161): [True: 0, False: 1]
  |  Branch (764:170): [True: 0, False: 1]
  |  Branch (764:179): [True: 0, False: 1]
  |  Branch (764:188): [True: 0, False: 1]
  |  Branch (764:197): [True: 0, False: 1]
  |  Branch (764:206): [True: 0, False: 1]
  |  Branch (764:215): [True: 0, False: 1]
  ------------------
  765|      1|                            exponent.push_back(c);
  766|      1|                            state = hexfloat_parse_state::exp2;
  767|      1|                            break;
  768|      0|                        default:
  ------------------
  |  Branch (768:25): [True: 0, False: 1]
  ------------------
  769|      0|                        {
  770|      0|                            ec = cbor_errc::invalid_bigfloat;
  771|      0|                            return;
  772|      1|                        }
  773|      1|                    }
  774|      1|                    break;
  775|      1|                }
  776|      1|                case hexfloat_parse_state::exp2:
  ------------------
  |  Branch (776:17): [True: 1, False: 21]
  ------------------
  777|      1|                {
  778|      1|                    switch (c)
  779|      1|                    {
  780|      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 (780:25): [True: 0, False: 1]
  |  Branch (780:34): [True: 0, False: 1]
  |  Branch (780:43): [True: 0, False: 1]
  |  Branch (780:52): [True: 0, False: 1]
  |  Branch (780:61): [True: 0, False: 1]
  |  Branch (780:70): [True: 0, False: 1]
  |  Branch (780:79): [True: 0, False: 1]
  |  Branch (780:88): [True: 0, False: 1]
  |  Branch (780:97): [True: 0, False: 1]
  |  Branch (780:107): [True: 0, False: 1]
  |  Branch (780:116): [True: 0, False: 1]
  |  Branch (780:125): [True: 0, False: 1]
  |  Branch (780:134): [True: 0, False: 1]
  |  Branch (780:143): [True: 0, False: 1]
  |  Branch (780:152): [True: 0, False: 1]
  |  Branch (780:161): [True: 0, False: 1]
  |  Branch (780:170): [True: 0, False: 1]
  |  Branch (780:179): [True: 0, False: 1]
  |  Branch (780:188): [True: 0, False: 1]
  |  Branch (780:197): [True: 0, False: 1]
  |  Branch (780:206): [True: 0, False: 1]
  |  Branch (780:215): [True: 1, False: 0]
  ------------------
  781|      1|                            exponent.push_back(c);
  782|      1|                            break;
  783|      0|                        default:
  ------------------
  |  Branch (783:25): [True: 0, False: 1]
  ------------------
  784|      0|                        {
  785|      0|                            ec = cbor_errc::invalid_bigfloat;
  786|      0|                            return;
  787|      0|                        }
  788|      1|                    }
  789|      1|                    break;
  790|      1|                }
  791|      1|                case hexfloat_parse_state::fraction1:
  ------------------
  |  Branch (791:17): [True: 0, False: 22]
  ------------------
  792|      0|                {
  793|      0|                    switch (c)
  794|      0|                    {
  795|      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 (795:25): [True: 0, False: 0]
  |  Branch (795:34): [True: 0, False: 0]
  |  Branch (795:43): [True: 0, False: 0]
  |  Branch (795:52): [True: 0, False: 0]
  |  Branch (795:61): [True: 0, False: 0]
  |  Branch (795:70): [True: 0, False: 0]
  |  Branch (795:79): [True: 0, False: 0]
  |  Branch (795:88): [True: 0, False: 0]
  |  Branch (795:97): [True: 0, False: 0]
  |  Branch (795:107): [True: 0, False: 0]
  |  Branch (795:116): [True: 0, False: 0]
  |  Branch (795:125): [True: 0, False: 0]
  |  Branch (795:134): [True: 0, False: 0]
  |  Branch (795:143): [True: 0, False: 0]
  |  Branch (795:152): [True: 0, False: 0]
  |  Branch (795:161): [True: 0, False: 0]
  |  Branch (795:170): [True: 0, False: 0]
  |  Branch (795:179): [True: 0, False: 0]
  |  Branch (795:188): [True: 0, False: 0]
  |  Branch (795:197): [True: 0, False: 0]
  |  Branch (795:206): [True: 0, False: 0]
  |  Branch (795:215): [True: 0, False: 0]
  ------------------
  796|      0|                            s.push_back(c);
  797|      0|                            scale -= 4;
  798|      0|                            break;
  799|      0|                        default:
  ------------------
  |  Branch (799:25): [True: 0, False: 0]
  ------------------
  800|      0|                        {
  801|      0|                            ec = cbor_errc::invalid_bigfloat;
  802|      0|                            return;
  803|      0|                        }
  804|      0|                    }
  805|      0|                    break;
  806|      0|                }
  807|     22|            }
  808|     22|        }
  809|       |
  810|      1|        write_tag(5);
  811|      1|        visit_begin_array((std::size_t)2, semantic_tag::none, context, ec);
  812|      1|        if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  813|       |
  814|      1|        if (exponent.length() > 0)
  ------------------
  |  Branch (814:13): [True: 1, False: 0]
  ------------------
  815|      1|        {
  816|      1|            int64_t val{ 0 };
  817|      1|            auto r = jsoncons::hex_to_integer(exponent.data(), exponent.length(), val);
  818|      1|            if (!r)
  ------------------
  |  Branch (818:17): [True: 0, False: 1]
  ------------------
  819|      0|            {
  820|      0|                ec = r.error_code();
  821|      0|                return;
  822|      0|            }
  823|      1|            scale += val;
  824|      1|        }
  825|      1|        visit_int64(scale, semantic_tag::none, context, ec);
  826|      1|        if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  827|       |
  828|      1|        int64_t val{ 0 };
  829|      1|        auto r = jsoncons::hex_to_integer(s.data(),s.length(), val);
  830|      1|        if (r)
  ------------------
  |  Branch (830:13): [True: 1, False: 0]
  ------------------
  831|      1|        {
  832|      1|            visit_int64(val, semantic_tag::none, context, ec);
  833|      1|            if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  834|      1|        }
  835|      0|        else if (r.error_code() == std::errc::result_out_of_range)
  ------------------
  |  Branch (835:18): [True: 0, False: 0]
  ------------------
  836|      0|        {
  837|      0|            bigint n = bigint::parse_radix(s.data(), s.length(), 16);
  838|      0|            write_bignum(n);
  839|      0|            end_value();
  840|      0|        }
  841|      0|        else
  842|      0|        {
  843|      0|            ec = r.error_code();
  844|      0|            return;
  845|      0|        }
  846|      1|        visit_end_array(context, ec);
  847|      1|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12write_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEE:
  396|   524k|    {
  397|   524k|        auto sink = unicode_traits::validate(sv.data(), sv.size());
  398|   524k|        if (sink.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (398:13): [True: 0, False: 524k]
  ------------------
  399|      0|        {
  400|      0|            JSONCONS_THROW(ser_error(cbor_errc::invalid_utf8_text_string));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  401|      0|        }
  402|       |
  403|   524k|        if (pack_strings_ && sv.size() >= jsoncons::cbor::detail::min_length_for_stringref(next_stringref_))
  ------------------
  |  Branch (403:13): [True: 0, False: 524k]
  |  Branch (403:30): [True: 0, False: 0]
  ------------------
  404|      0|        {
  405|      0|            string_type s(sv.data(), sv.size(), alloc_);
  406|      0|            auto it = stringref_map_.find(s);
  407|      0|            if (it == stringref_map_.end())
  ------------------
  |  Branch (407:17): [True: 0, False: 0]
  ------------------
  408|      0|            {
  409|      0|                stringref_map_.emplace(std::make_pair(std::move(s), next_stringref_++));
  410|      0|                write_utf8_string(sv);
  411|      0|            }
  412|      0|            else
  413|      0|            {
  414|      0|                write_tag(25);
  415|      0|                write_uint64_value((*it).second);
  416|      0|            }
  417|      0|        }
  418|   524k|        else
  419|   524k|        {
  420|   524k|            write_utf8_string(sv);
  421|   524k|        }
  422|   524k|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17write_utf8_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEE:
  456|   524k|    {
  457|   524k|        write_type_and_length(0x60, sv.size());
  458|       |
  459|   524k|        sink_.append(reinterpret_cast<const uint8_t*>(sv.data()), sv.size());
  460|   524k|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  913|    163|    {
  914|    163|        byte_string_chars_format encoding_hint;
  915|    163|        switch (tag)
  916|    163|        {
  917|      0|            case semantic_tag::base16:
  ------------------
  |  Branch (917:13): [True: 0, False: 163]
  ------------------
  918|      0|                encoding_hint = byte_string_chars_format::base16;
  919|      0|                break;
  920|      0|            case semantic_tag::base64:
  ------------------
  |  Branch (920:13): [True: 0, False: 163]
  ------------------
  921|      0|                encoding_hint = byte_string_chars_format::base64;
  922|      0|                break;
  923|      0|            case semantic_tag::base64url:
  ------------------
  |  Branch (923:13): [True: 0, False: 163]
  ------------------
  924|      0|                encoding_hint = byte_string_chars_format::base64url;
  925|      0|                break;
  926|    163|            default:
  ------------------
  |  Branch (926:13): [True: 163, False: 0]
  ------------------
  927|    163|                encoding_hint = byte_string_chars_format::none;
  928|    163|                break;
  929|    163|        }
  930|    163|        switch (encoding_hint)
  931|    163|        {
  932|      0|            case byte_string_chars_format::base64url:
  ------------------
  |  Branch (932:13): [True: 0, False: 163]
  ------------------
  933|      0|                write_tag(21);
  934|      0|                break;
  935|      0|            case byte_string_chars_format::base64:
  ------------------
  |  Branch (935:13): [True: 0, False: 163]
  ------------------
  936|      0|                write_tag(22);
  937|      0|                break;
  938|      0|            case byte_string_chars_format::base16:
  ------------------
  |  Branch (938:13): [True: 0, False: 163]
  ------------------
  939|      0|                write_tag(23);
  940|      0|                break;
  941|    163|            default:
  ------------------
  |  Branch (941:13): [True: 163, False: 0]
  ------------------
  942|    163|                break;
  943|    163|        }
  944|    163|        if (pack_strings_ && b.size() >= jsoncons::cbor::detail::min_length_for_stringref(next_stringref_))
  ------------------
  |  Branch (944:13): [True: 0, False: 163]
  |  Branch (944:30): [True: 0, False: 0]
  ------------------
  945|      0|        {
  946|      0|            byte_string_type bs(b.data(), b.size(), alloc_);
  947|      0|            auto it = bytestringref_map_.find(bs);
  948|      0|            if (it == bytestringref_map_.end())
  ------------------
  |  Branch (948:17): [True: 0, False: 0]
  ------------------
  949|      0|            {
  950|      0|                bytestringref_map_.emplace(std::make_pair(bs, next_stringref_++));
  951|      0|                write_byte_string(bs);
  952|      0|            }
  953|      0|            else
  954|      0|            {
  955|      0|                write_tag(25);
  956|      0|                write_uint64_value((*it).second);
  957|      0|            }
  958|      0|        }
  959|    163|        else
  960|    163|        {
  961|    163|            write_byte_string(b);
  962|    163|        }
  963|       |
  964|    163|        end_value();
  965|    163|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    163|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  966|    163|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17write_byte_stringERKNS_16byte_string_viewE:
 1000|    164|    {
 1001|    164|        write_type_and_length(0x40, b.size());
 1002|       |
 1003|    164|        sink_.append(b.data(), b.size());
 1004|    164|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS3_10error_codeE:
  972|      1|    {
  973|      1|        if (pack_strings_ && b.size() >= jsoncons::cbor::detail::min_length_for_stringref(next_stringref_))
  ------------------
  |  Branch (973:13): [True: 0, False: 1]
  |  Branch (973:30): [True: 0, False: 0]
  ------------------
  974|      0|        {
  975|      0|            byte_string_type bs(b.data(), b.size(), alloc_);
  976|      0|            auto it = bytestringref_map_.find(bs);
  977|      0|            if (it == bytestringref_map_.end())
  ------------------
  |  Branch (977:17): [True: 0, False: 0]
  ------------------
  978|      0|            {
  979|      0|                bytestringref_map_.emplace(std::make_pair(bs, next_stringref_++));
  980|      0|                write_tag(raw_tag);
  981|      0|                write_byte_string(bs);
  982|      0|            }
  983|      0|            else
  984|      0|            {
  985|      0|                write_tag(25);
  986|      0|                write_uint64_value((*it).second);
  987|      0|            }
  988|      0|        }
  989|      1|        else
  990|      1|        {
  991|      1|            write_tag(raw_tag);
  992|      1|            write_byte_string(b);
  993|      1|        }
  994|       |
  995|      1|        end_value();
  996|      1|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      1|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  997|      1|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEED2Ev:
  147|     17|    {
  148|     17|        JSONCONS_TRY
  ------------------
  |  |   37|     17|    #define JSONCONS_TRY try
  ------------------
  149|     17|        {
  150|     17|            sink_.flush();
  151|     17|        }
  152|     17|        JSONCONS_CATCH(...)
  153|     17|        {
  154|      0|        }
  155|     17|    }

_ZN8jsoncons4cbor15make_error_codeENS0_9cbor_errcE:
   93|     10|{
   94|     10|    return std::error_code(static_cast<int>(e),cbor_error_category());
   95|     10|}
_ZN8jsoncons4cbor19cbor_error_categoryEv:
   86|     10|{
   87|     10|  static cbor_error_category_impl instance;
   88|     10|  return instance;
   89|     10|}

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

_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEED2Ev:
  234|     17|    ~basic_cbor_parser() = default;
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RKNS0_19cbor_decode_optionsERKS7_:
  218|     17|       : alloc_(alloc),
  219|     17|         source_(std::forward<Sourceable>(source)),
  220|     17|         max_nesting_depth_(options.max_nesting_depth()),
  221|     17|         text_buffer_(alloc),
  222|     17|         bytes_buffer_(alloc),
  223|     17|         state_stack_(alloc),
  224|     17|         stringref_map_stack_(alloc)
  225|     17|    {
  226|     17|        state_stack_.emplace_back(parse_mode::root,0);
  227|     17|    }
_ZN8jsoncons4cbor11parse_stateC2ENS0_10parse_modeEmb:
   51|  1.78k|        : mode(mode), length(length), pop_stringref_map_stack(pop_stringref_map_stack)
   52|  1.78k|    {
   53|  1.78k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5resetEv:
  242|     17|    {
  243|     17|        more_ = true;
  244|     17|        done_ = false;
  245|     17|        text_buffer_.clear();
  246|     17|        bytes_buffer_.clear();
  247|     17|        raw_tag_ = 0;
  248|     17|        state_stack_.clear();
  249|     17|        state_stack_.emplace_back(parse_mode::root,0);
  250|     17|        stringref_map_stack_.clear();
  251|     17|        nesting_depth_ = 0;
  252|     17|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  345|     17|    {
  346|  4.20M|        while (!done_ && more_)
  ------------------
  |  Branch (346:16): [True: 4.20M, False: 7]
  |  Branch (346:26): [True: 4.20M, False: 0]
  ------------------
  347|  4.20M|        {
  348|  4.20M|            switch (state_stack_.back().mode)
  ------------------
  |  Branch (348:21): [True: 4.20M, False: 0]
  ------------------
  349|  4.20M|            {
  350|     15|                case parse_mode::multi_dim:
  ------------------
  |  Branch (350:17): [True: 15, False: 4.20M]
  ------------------
  351|     15|                {
  352|     15|                    JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   49|     15|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 15]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  353|     15|                    typed_array_stack_.pop_back();
  354|     15|                    state_stack_.pop_back();
  355|     15|                    break;
  356|     15|                }
  357|  1.57k|                case parse_mode::typed_array:
  ------------------
  |  Branch (357:17): [True: 1.57k, False: 4.20M]
  ------------------
  358|  1.57k|                {
  359|  1.57k|                    JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   49|  1.57k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 1.57k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  360|  1.57k|                    read_typed_array_item(visitor, ec);
  361|  1.57k|                    auto iter = typed_array_stack_.back();
  362|  1.57k|                    if (iter->done())
  ------------------
  |  Branch (362:25): [True: 1.43k, False: 140]
  ------------------
  363|  1.43k|                    {
  364|  1.43k|                        if (!is_multi_dim())
  ------------------
  |  Branch (364:29): [True: 1.41k, False: 15]
  ------------------
  365|  1.41k|                        {
  366|  1.41k|                            typed_array_stack_.pop_back();
  367|  1.41k|                        }
  368|  1.43k|                        state_stack_.pop_back();
  369|  1.43k|                    }
  370|  1.57k|                    break;
  371|  1.57k|                }
  372|   955k|                case parse_mode::array:
  ------------------
  |  Branch (372:17): [True: 955k, False: 3.25M]
  ------------------
  373|   955k|                {
  374|   955k|                    if (is_multi_dim())
  ------------------
  |  Branch (374:25): [True: 0, False: 955k]
  ------------------
  375|      0|                    {
  376|      0|                        JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   49|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  377|      0|                        auto iter = typed_array_stack_.back();
  378|      0|                        if (!iter->done())
  ------------------
  |  Branch (378:29): [True: 0, False: 0]
  ------------------
  379|      0|                        {
  380|      0|                            iter->next(visitor, *this, ec);
  381|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  382|      0|                            {
  383|      0|                                return;
  384|      0|                            }
  385|      0|                        }
  386|      0|                        else
  387|      0|                        {
  388|      0|                            if (iter->count() != state_stack_.back().length)
  ------------------
  |  Branch (388:33): [True: 0, False: 0]
  ------------------
  389|      0|                            {
  390|       |                                //std::cout << state_stack_.back().index << "!=" << state_stack_.back().length << "\n";
  391|      0|                                ec = cbor_errc::bad_mdarray;
  392|      0|                                return;
  393|      0|                            }
  394|      0|                            end_classical_array_storage(ec);
  395|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  396|      0|                            {
  397|      0|                                return;
  398|      0|                            }
  399|      0|                        }
  400|      0|                    }
  401|   955k|                    else
  402|   955k|                    {
  403|   955k|                        if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (403:29): [True: 954k, False: 220]
  ------------------
  404|   954k|                        {
  405|   954k|                            ++state_stack_.back().index;
  406|   954k|                            read_item(visitor, ec);
  407|   954k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   954k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 954k]
  |  |  ------------------
  ------------------
  408|      2|                            {
  409|      2|                                return;
  410|      2|                            }
  411|   954k|                        }
  412|    220|                        else
  413|    220|                        {
  414|    220|                            end_array(visitor, ec);
  415|    220|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    220|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 220]
  |  |  ------------------
  ------------------
  416|      0|                            {
  417|      0|                                return;
  418|      0|                            }
  419|    220|                        }
  420|   955k|                    }
  421|   955k|                    break;
  422|   955k|                }
  423|  1.04M|                case parse_mode::indefinite_array:
  ------------------
  |  Branch (423:17): [True: 1.04M, False: 3.15M]
  ------------------
  424|  1.04M|                {
  425|  1.04M|                    if (is_multi_dim()) 
  ------------------
  |  Branch (425:25): [True: 0, False: 1.04M]
  ------------------
  426|      0|                    {
  427|      0|                        JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   49|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  428|      0|                        auto iter = typed_array_stack_.back();
  429|      0|                        if (!iter->done())
  ------------------
  |  Branch (429:29): [True: 0, False: 0]
  ------------------
  430|      0|                        {
  431|      0|                            iter->next(visitor, *this, ec);
  432|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  433|      0|                            {
  434|      0|                                return;
  435|      0|                            }
  436|      0|                        }
  437|      0|                        else
  438|      0|                        {
  439|      0|                            auto c = source_.peek();
  440|      0|                            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  441|      0|                            {
  442|      0|                                ec = cbor_errc::unexpected_eof;
  443|      0|                                more_ = false;
  444|      0|                                return;
  445|      0|                            }
  446|      0|                            if (c.value == 0xff)
  ------------------
  |  Branch (446:33): [True: 0, False: 0]
  ------------------
  447|      0|                            {
  448|      0|                                source_.ignore(1);
  449|      0|                            }
  450|      0|                            else
  451|      0|                            {
  452|      0|                                ec = cbor_errc::bad_mdarray;
  453|      0|                                return;
  454|      0|                            }
  455|      0|                            end_classical_array_storage(ec);
  456|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  457|      0|                            {
  458|      0|                                return;
  459|      0|                            }
  460|      0|                        }
  461|      0|                    }
  462|  1.04M|                    else
  463|  1.04M|                    {
  464|  1.04M|                        auto c = source_.peek();
  465|  1.04M|                        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.04M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 1.04M]
  |  |  ------------------
  ------------------
  466|      1|                        {
  467|      1|                            ec = cbor_errc::unexpected_eof;
  468|      1|                            more_ = false;
  469|      1|                            return;
  470|      1|                        }
  471|  1.04M|                        if (c.value == 0xff)
  ------------------
  |  Branch (471:29): [True: 0, False: 1.04M]
  ------------------
  472|      0|                        {
  473|      0|                            source_.ignore(1);
  474|      0|                            end_array(visitor, ec);
  475|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  476|      0|                            {
  477|      0|                                return;
  478|      0|                            }
  479|      0|                        }
  480|  1.04M|                        else
  481|  1.04M|                        {
  482|  1.04M|                            read_item(visitor, ec);
  483|  1.04M|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.04M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.04M]
  |  |  ------------------
  ------------------
  484|      0|                            {
  485|      0|                                return;
  486|      0|                            }
  487|  1.04M|                        }
  488|  1.04M|                    }
  489|  1.04M|                    break;
  490|  1.04M|                }
  491|  1.04M|                case parse_mode::map_key:
  ------------------
  |  Branch (491:17): [True: 7.48k, False: 4.19M]
  ------------------
  492|  7.48k|                {
  493|  7.48k|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (493:25): [True: 7.42k, False: 53]
  ------------------
  494|  7.42k|                    {
  495|  7.42k|                        ++state_stack_.back().index;
  496|  7.42k|                        state_stack_.back().mode = parse_mode::map_value;
  497|  7.42k|                        read_item(visitor, ec);
  498|  7.42k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  7.42k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 7.42k]
  |  |  ------------------
  ------------------
  499|      0|                        {
  500|      0|                            return;
  501|      0|                        }
  502|  7.42k|                    }
  503|     53|                    else
  504|     53|                    {
  505|     53|                        end_object(visitor, ec);
  506|     53|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     53|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 53]
  |  |  ------------------
  ------------------
  507|      0|                        {
  508|      0|                            return;
  509|      0|                        }
  510|     53|                    }
  511|  7.48k|                    break;
  512|  7.48k|                }
  513|  7.48k|                case parse_mode::map_value:
  ------------------
  |  Branch (513:17): [True: 7.42k, False: 4.19M]
  ------------------
  514|  7.42k|                {
  515|  7.42k|                    state_stack_.back().mode = parse_mode::map_key;
  516|  7.42k|                    read_item(visitor, ec);
  517|  7.42k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  7.42k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 7.41k]
  |  |  ------------------
  ------------------
  518|      2|                    {
  519|      2|                        return;
  520|      2|                    }
  521|  7.41k|                    break;
  522|  7.42k|                }
  523|  1.09M|                case parse_mode::indefinite_map_key:
  ------------------
  |  Branch (523:17): [True: 1.09M, False: 3.11M]
  ------------------
  524|  1.09M|                {
  525|  1.09M|                    auto c = source_.peek();
  526|  1.09M|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.09M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 1.09M]
  |  |  ------------------
  ------------------
  527|      1|                    {
  528|      1|                        ec = cbor_errc::unexpected_eof;
  529|      1|                        more_ = false;
  530|      1|                        return;
  531|      1|                    }
  532|  1.09M|                    if (c.value == 0xff)
  ------------------
  |  Branch (532:25): [True: 2, False: 1.09M]
  ------------------
  533|      2|                    {
  534|      2|                        source_.ignore(1);
  535|      2|                        end_object(visitor, ec);
  536|      2|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  537|      0|                        {
  538|      0|                            return;
  539|      0|                        }
  540|      2|                    }
  541|  1.09M|                    else
  542|  1.09M|                    {
  543|  1.09M|                        state_stack_.back().mode = parse_mode::indefinite_map_value;
  544|  1.09M|                        read_item(visitor, ec);
  545|  1.09M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.09M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.09M]
  |  |  ------------------
  ------------------
  546|      0|                        {
  547|      0|                            return;
  548|      0|                        }
  549|  1.09M|                    }
  550|  1.09M|                    break;
  551|  1.09M|                }
  552|  1.09M|                case parse_mode::indefinite_map_value:
  ------------------
  |  Branch (552:17): [True: 1.09M, False: 3.11M]
  ------------------
  553|  1.09M|                {
  554|  1.09M|                    state_stack_.back().mode = parse_mode::indefinite_map_key;
  555|  1.09M|                    read_item(visitor, ec);
  556|  1.09M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.09M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.09M]
  |  |  ------------------
  ------------------
  557|      0|                    {
  558|      0|                        return;
  559|      0|                    }
  560|  1.09M|                    break;
  561|  1.09M|                }
  562|  1.09M|                case parse_mode::root:
  ------------------
  |  Branch (562:17): [True: 17, False: 4.20M]
  ------------------
  563|     17|                {
  564|     17|                    state_stack_.back().mode = parse_mode::accept;
  565|     17|                    read_item(visitor, ec);
  566|     17|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     17|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 13]
  |  |  ------------------
  ------------------
  567|      4|                    {
  568|      4|                        return;
  569|      4|                    }
  570|     13|                    break;
  571|     17|                }
  572|     13|                case parse_mode::accept:
  ------------------
  |  Branch (572:17): [True: 7, False: 4.20M]
  ------------------
  573|      7|                {
  574|      7|                    JSONCONS_ASSERT(state_stack_.size() == 1);
  ------------------
  |  |   49|      7|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 7]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  575|      7|                    state_stack_.clear();
  576|      7|                    more_ = false;
  577|      7|                    done_ = true;
  578|      7|                    visitor.flush();
  579|      7|                    break;
  580|      7|                }
  581|  4.20M|            }
  582|  4.20M|        }
  583|     17|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_typed_array_itemERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  586|  1.57k|    {
  587|  1.57k|        JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   49|  1.57k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 1.57k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  588|  1.57k|        auto iter = typed_array_stack_.back();
  589|  1.57k|        if (!iter->done())
  ------------------
  |  Branch (589:13): [True: 1.57k, False: 0]
  ------------------
  590|  1.57k|        {
  591|  1.57k|            iter->next(visitor, *this, ec);
  592|  1.57k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.57k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.57k]
  |  |  ------------------
  ------------------
  593|      0|            {
  594|      0|                return;
  595|      0|            }
  596|  1.57k|            more_ = !cursor_mode_;
  597|  1.57k|        }
  598|  1.57k|    }
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12is_multi_dimEv:
  260|  2.00M|    {
  261|  2.00M|        return state_stack_.size() >=2 && state_stack_[state_stack_.size()-2].mode == parse_mode::multi_dim;
  ------------------
  |  Branch (261:16): [True: 2.00M, False: 0]
  |  Branch (261:43): [True: 15, False: 2.00M]
  ------------------
  262|  2.00M|    }
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5levelEv:
  300|    275|    {
  301|    275|        return static_cast<int>(state_stack_.size());
  302|    275|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_itemERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  601|  4.20M|    {
  602|  4.20M|        read_tags(ec);
  603|  4.20M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.20M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 4.20M]
  |  |  ------------------
  ------------------
  604|      2|        {
  605|      2|            return;
  606|      2|        }
  607|  4.20M|        auto c = source_.peek();
  608|  4.20M|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  4.20M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4.20M]
  |  |  ------------------
  ------------------
  609|      0|        {
  610|      0|            ec = cbor_errc::unexpected_eof;
  611|      0|            more_ = false;
  612|      0|            return;
  613|      0|        }
  614|  4.20M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
  615|  4.20M|        uint8_t info = get_additional_information_value(c.value);
  616|       |
  617|  4.20M|        switch (major_type)
  618|  4.20M|        {
  619|  4.20M|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (619:13): [True: 4.20M, False: 2.90k]
  ------------------
  620|  4.20M|            {
  621|  4.20M|                uint64_t val = read_uint64(ec);
  622|  4.20M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.20M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4.20M]
  |  |  ------------------
  ------------------
  623|      0|                {
  624|      0|                    return;
  625|      0|                }
  626|  4.20M|                if (!stringref_map_stack_.empty() && other_tags_[stringref_tag])
  ------------------
  |  Branch (626:21): [True: 0, False: 4.20M]
  |  Branch (626:21): [True: 0, False: 4.20M]
  |  Branch (626:54): [True: 0, False: 0]
  ------------------
  627|      0|                {
  628|      0|                    other_tags_[stringref_tag] = false;
  629|      0|                    if (val >= stringref_map_stack_.back().size())
  ------------------
  |  Branch (629:25): [True: 0, False: 0]
  ------------------
  630|      0|                    {
  631|      0|                        ec = cbor_errc::stringref_too_large;
  632|      0|                        more_ = false;
  633|      0|                        return;
  634|      0|                    }
  635|      0|                    auto index = static_cast<typename stringref_map::size_type>(val);
  636|      0|                    if (index != val)
  ------------------
  |  Branch (636:25): [True: 0, False: 0]
  ------------------
  637|      0|                    {
  638|      0|                        ec = cbor_errc::number_too_large;
  639|      0|                        more_ = false;
  640|      0|                        return;
  641|      0|                    }
  642|      0|                    auto& str = stringref_map_stack_.back().at(index);
  643|      0|                    switch (str.type)
  644|      0|                    {
  645|      0|                        case jsoncons::cbor::detail::cbor_major_type::text_string:
  ------------------
  |  Branch (645:25): [True: 0, False: 0]
  ------------------
  646|      0|                        {
  647|      0|                            handle_string(visitor, jsoncons::string_view(str.str.data(),str.str.length()),ec);
  648|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  649|      0|                            {
  650|      0|                                return;
  651|      0|                            }
  652|      0|                            break;
  653|      0|                        }
  654|      0|                        case jsoncons::cbor::detail::cbor_major_type::byte_string:
  ------------------
  |  Branch (654:25): [True: 0, False: 0]
  ------------------
  655|      0|                        {
  656|      0|                            read_byte_string_from_buffer read(byte_string_view(str.bytes));
  657|      0|                            read_byte_string(read, visitor, ec);
  658|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  659|      0|                            {
  660|      0|                                return;
  661|      0|                            }
  662|      0|                            break;
  663|      0|                        }
  664|      0|                        default:
  ------------------
  |  Branch (664:25): [True: 0, False: 0]
  ------------------
  665|      0|                            JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
  666|      0|                            break;
  667|      0|                    }
  668|      0|                }
  669|  4.20M|                else
  670|  4.20M|                {
  671|  4.20M|                    semantic_tag tag = semantic_tag::none;
  672|  4.20M|                    if (other_tags_[item_tag])
  ------------------
  |  Branch (672:25): [True: 26, False: 4.20M]
  ------------------
  673|     26|                    {
  674|     26|                        if (raw_tag_ == 1)
  ------------------
  |  Branch (674:29): [True: 0, False: 26]
  ------------------
  675|      0|                        {
  676|      0|                            tag = semantic_tag::epoch_second;
  677|      0|                        }
  678|     26|                        other_tags_[item_tag] = false;
  679|     26|                    }
  680|  4.20M|                    visitor.uint64_value(val, tag, *this, ec);
  681|  4.20M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.20M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4.20M]
  |  |  ------------------
  ------------------
  682|      0|                    {
  683|      0|                        return;
  684|      0|                    }
  685|  4.20M|                    more_ = !cursor_mode_;
  686|  4.20M|                }
  687|  4.20M|                break;
  688|  4.20M|            }
  689|  4.20M|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (689:13): [True: 565, False: 4.20M]
  ------------------
  690|    565|            {
  691|    565|                int64_t val = read_int64(ec);
  692|    565|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    565|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 565]
  |  |  ------------------
  ------------------
  693|      0|                {
  694|      0|                    return;
  695|      0|                }
  696|    565|                semantic_tag tag = semantic_tag::none;
  697|    565|                if (other_tags_[item_tag])
  ------------------
  |  Branch (697:21): [True: 8, False: 557]
  ------------------
  698|      8|                {
  699|      8|                    if (raw_tag_ == 1)
  ------------------
  |  Branch (699:25): [True: 0, False: 8]
  ------------------
  700|      0|                    {
  701|      0|                        tag = semantic_tag::epoch_second;
  702|      0|                    }
  703|      8|                    other_tags_[item_tag] = false;
  704|      8|                }
  705|    565|                visitor.int64_value(val, tag, *this, ec);
  706|    565|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    565|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 565]
  |  |  ------------------
  ------------------
  707|      0|                {
  708|      0|                    return;
  709|      0|                }
  710|    565|                more_ = !cursor_mode_;
  711|    565|                break;
  712|    565|            }
  713|  1.93k|            case jsoncons::cbor::detail::cbor_major_type::byte_string:
  ------------------
  |  Branch (713:13): [True: 1.93k, False: 4.20M]
  ------------------
  714|  1.93k|            {
  715|  1.93k|                read_byte_string_from_source read(this);
  716|  1.93k|                read_byte_string(read, visitor, ec);
  717|  1.93k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.93k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 1.92k]
  |  |  ------------------
  ------------------
  718|      3|                {
  719|      3|                    return;
  720|      3|                }
  721|  1.92k|                break;
  722|  1.93k|            }
  723|  1.92k|            case jsoncons::cbor::detail::cbor_major_type::text_string:
  ------------------
  |  Branch (723:13): [True: 3, False: 4.20M]
  ------------------
  724|      3|            {
  725|      3|                auto sv = read_text_string_view(ec);
  726|      3|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 2]
  |  |  ------------------
  ------------------
  727|      1|                {
  728|      1|                    return;
  729|      1|                }
  730|      2|                auto result = unicode_traits::validate(sv.data(),sv.size());
  731|      2|                if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (731:21): [True: 0, False: 2]
  ------------------
  732|      0|                {
  733|      0|                    ec = cbor_errc::invalid_utf8_text_string;
  734|      0|                    more_ = false;
  735|      0|                    return;
  736|      0|                }
  737|      2|                handle_string(visitor, sv, ec);
  738|      2|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  739|      0|                {
  740|      0|                    return;
  741|      0|                }
  742|      2|                break;
  743|      2|            }
  744|      2|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (744:13): [True: 0, False: 4.20M]
  ------------------
  745|      0|            {
  746|      0|                JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
  747|      0|                break;
  748|      2|            }
  749|     56|            case jsoncons::cbor::detail::cbor_major_type::simple:
  ------------------
  |  Branch (749:13): [True: 56, False: 4.20M]
  ------------------
  750|     56|            {
  751|     56|                switch (info)
  752|     56|                {
  753|      0|                    case 0x14:
  ------------------
  |  Branch (753:21): [True: 0, False: 56]
  ------------------
  754|      0|                        visitor.bool_value(false, semantic_tag::none, *this, ec);
  755|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  756|      0|                        {
  757|      0|                            return;
  758|      0|                        }
  759|      0|                        more_ = !cursor_mode_;
  760|      0|                        source_.ignore(1);
  761|      0|                        break;
  762|     14|                    case 0x15:
  ------------------
  |  Branch (762:21): [True: 14, False: 42]
  ------------------
  763|     14|                        visitor.bool_value(true, semantic_tag::none, *this, ec);
  764|     14|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     14|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 14]
  |  |  ------------------
  ------------------
  765|      0|                        {
  766|      0|                            return;
  767|      0|                        }
  768|     14|                        more_ = !cursor_mode_;
  769|     14|                        source_.ignore(1);
  770|     14|                        break;
  771|      9|                    case 0x16:
  ------------------
  |  Branch (771:21): [True: 9, False: 47]
  ------------------
  772|      9|                        visitor.null_value(semantic_tag::none, *this, ec);
  773|      9|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      9|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 9]
  |  |  ------------------
  ------------------
  774|      0|                        {
  775|      0|                            return;
  776|      0|                        }
  777|      9|                        more_ = !cursor_mode_;
  778|      9|                        source_.ignore(1);
  779|      9|                        break;
  780|     24|                    case 0x17:
  ------------------
  |  Branch (780:21): [True: 24, False: 32]
  ------------------
  781|     24|                        visitor.null_value(semantic_tag::undefined, *this, ec);
  782|     24|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     24|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 24]
  |  |  ------------------
  ------------------
  783|      0|                        {
  784|      0|                            return;
  785|      0|                        }
  786|     24|                        more_ = !cursor_mode_;
  787|     24|                        source_.ignore(1);
  788|     24|                        break;
  789|      9|                    case 0x19: // Half-Precision Float (two-byte IEEE 754)
  ------------------
  |  Branch (789:21): [True: 9, False: 47]
  ------------------
  790|      9|                    {
  791|      9|                        uint64_t val = read_uint64(ec);
  792|      9|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      9|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 9]
  |  |  ------------------
  ------------------
  793|      0|                        {
  794|      0|                            return;
  795|      0|                        }
  796|      9|                        visitor.half_value(static_cast<uint16_t>(val), semantic_tag::none, *this, ec);
  797|      9|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      9|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 9]
  |  |  ------------------
  ------------------
  798|      0|                        {
  799|      0|                            return;
  800|      0|                        }
  801|      9|                        more_ = !cursor_mode_;
  802|      9|                        break;
  803|      9|                    }
  804|      0|                    case 0x1a: // Single-Precision Float (four-byte IEEE 754)
  ------------------
  |  Branch (804:21): [True: 0, False: 56]
  ------------------
  805|      0|                    case 0x1b: // Double-Precision Float (eight-byte IEEE 754)
  ------------------
  |  Branch (805:21): [True: 0, False: 56]
  ------------------
  806|      0|                    {
  807|      0|                        double val = read_double(ec);
  808|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  809|      0|                        {
  810|      0|                            return;
  811|      0|                        }
  812|      0|                        semantic_tag tag = semantic_tag::none;
  813|      0|                        if (other_tags_[item_tag])
  ------------------
  |  Branch (813:29): [True: 0, False: 0]
  ------------------
  814|      0|                        {
  815|      0|                            if (raw_tag_ == 1)
  ------------------
  |  Branch (815:33): [True: 0, False: 0]
  ------------------
  816|      0|                            {
  817|      0|                                tag = semantic_tag::epoch_second;
  818|      0|                            }
  819|      0|                            other_tags_[item_tag] = false;
  820|      0|                        }
  821|      0|                        visitor.double_value(val, tag, *this, ec);
  822|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  823|      0|                        {
  824|      0|                            return;
  825|      0|                        }
  826|      0|                        more_ = !cursor_mode_;
  827|      0|                        break;
  828|      0|                    }
  829|      0|                    default:
  ------------------
  |  Branch (829:21): [True: 0, False: 56]
  ------------------
  830|      0|                    {
  831|      0|                        ec = cbor_errc::unknown_type;
  832|      0|                        more_ = false;
  833|      0|                        return;
  834|      0|                    }
  835|     56|                }
  836|     56|                break;
  837|     56|            }
  838|    273|            case jsoncons::cbor::detail::cbor_major_type::array:
  ------------------
  |  Branch (838:13): [True: 273, False: 4.20M]
  ------------------
  839|    273|            {
  840|    273|                if (other_tags_[item_tag])
  ------------------
  |  Branch (840:21): [True: 42, False: 231]
  ------------------
  841|     42|                {
  842|     42|                    switch (raw_tag_)
  843|     42|                    {
  844|     17|                        case 0x04:
  ------------------
  |  Branch (844:25): [True: 17, False: 25]
  ------------------
  845|     17|                            text_buffer_.clear();
  846|     17|                            read_decimal_fraction(text_buffer_, ec);
  847|     17|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     17|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 17]
  |  |  ------------------
  ------------------
  848|      0|                            {
  849|      0|                                return;
  850|      0|                            }
  851|     17|                            visitor.string_value(text_buffer_, semantic_tag::bigdec, *this, ec);
  852|     17|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     17|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 17]
  |  |  ------------------
  ------------------
  853|      0|                            {
  854|      0|                                return;
  855|      0|                            }
  856|     17|                            more_ = !cursor_mode_;
  857|     17|                            break;
  858|      5|                        case 0x05:
  ------------------
  |  Branch (858:25): [True: 5, False: 37]
  ------------------
  859|      5|                            text_buffer_.clear();
  860|      5|                            read_bigfloat(text_buffer_, ec);
  861|      5|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
  862|      0|                            {
  863|      0|                                return;
  864|      0|                            }
  865|      5|                            visitor.string_value(text_buffer_, semantic_tag::bigfloat, *this, ec);
  866|      5|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
  867|      0|                            {
  868|      0|                                return;
  869|      0|                            }
  870|      5|                            more_ = !cursor_mode_;
  871|      5|                            break;
  872|     17|                        case 40: // row-major storage
  ------------------
  |  Branch (872:25): [True: 17, False: 25]
  ------------------
  873|     17|                            order_ = mdarray_order::row_major;
  874|     17|                            read_mdarray_header(visitor, ec);
  875|     17|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     17|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 15]
  |  |  ------------------
  ------------------
  876|      2|                            {
  877|      2|                                return;
  878|      2|                            }
  879|     15|                            break;
  880|     15|                        case 1040: // column-major storage
  ------------------
  |  Branch (880:25): [True: 0, False: 42]
  ------------------
  881|      0|                            order_ = mdarray_order::column_major;
  882|      0|                            read_mdarray_header(visitor, ec);
  883|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  884|      0|                            {
  885|      0|                                return;
  886|      0|                            }
  887|      0|                            break;
  888|      3|                        default:
  ------------------
  |  Branch (888:25): [True: 3, False: 39]
  ------------------
  889|      3|                            begin_array(visitor, info, ec);
  890|      3|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
  891|      0|                            {
  892|      0|                                return;
  893|      0|                            }
  894|      3|                            break;
  895|     42|                    }
  896|     40|                    other_tags_[item_tag] = false;
  897|     40|                }
  898|    231|                else
  899|    231|                {
  900|    231|                    begin_array(visitor, info, ec);
  901|    231|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    231|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 231]
  |  |  ------------------
  ------------------
  902|      0|                    {
  903|      0|                        return;
  904|      0|                    }
  905|    231|                }
  906|    271|                break;
  907|    273|            }
  908|    271|            case jsoncons::cbor::detail::cbor_major_type::map:
  ------------------
  |  Branch (908:13): [True: 75, False: 4.20M]
  ------------------
  909|     75|            {
  910|     75|                begin_object(visitor, info, ec);
  911|     75|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     75|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 75]
  |  |  ------------------
  ------------------
  912|      0|                {
  913|      0|                    return;
  914|      0|                }
  915|     75|                break;
  916|     75|            }
  917|     75|            default:
  ------------------
  |  Branch (917:13): [True: 0, False: 4.20M]
  ------------------
  918|      0|                break;
  919|  4.20M|        }
  920|  4.20M|        other_tags_[item_tag] = false;
  921|  4.20M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_tagsERNS3_10error_codeE:
 1904|  4.20M|    {
 1905|  4.20M|        auto c = source_.peek();
 1906|  4.20M|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  4.20M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 4.20M]
  |  |  ------------------
  ------------------
 1907|      2|        {
 1908|      2|            ec = cbor_errc::unexpected_eof;
 1909|      2|            more_ = false;
 1910|      2|            return;
 1911|      2|        }
 1912|  4.20M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1913|       |
 1914|  4.20M|        while (major_type == jsoncons::cbor::detail::cbor_major_type::semantic_tag)
  ------------------
  |  Branch (1914:16): [True: 1.62k, False: 4.20M]
  ------------------
 1915|  1.62k|        {
 1916|  1.62k|            uint64_t val = read_uint64(ec);
 1917|  1.62k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.62k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.62k]
  |  |  ------------------
  ------------------
 1918|      0|            {
 1919|      0|                return;
 1920|      0|            }
 1921|  1.62k|            switch(val)
 1922|  1.62k|            {
 1923|      8|                case 25: // stringref
  ------------------
  |  Branch (1923:17): [True: 8, False: 1.61k]
  ------------------
 1924|      8|                    other_tags_[stringref_tag] = true;
 1925|      8|                    break;
 1926|      0|                case 256: // stringref-namespace
  ------------------
  |  Branch (1926:17): [True: 0, False: 1.62k]
  ------------------
 1927|      0|                    other_tags_[stringref_namespace_tag] = true;
 1928|      0|                    break;
 1929|  1.61k|                default:
  ------------------
  |  Branch (1929:17): [True: 1.61k, False: 8]
  ------------------
 1930|  1.61k|                    other_tags_[item_tag] = true;
 1931|  1.61k|                    raw_tag_ = val;
 1932|  1.61k|                    break;
 1933|  1.62k|            }
 1934|  1.62k|            c = source_.peek();
 1935|  1.62k|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.62k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.62k]
  |  |  ------------------
  ------------------
 1936|      0|            {
 1937|      0|                ec = cbor_errc::unexpected_eof;
 1938|      0|                more_ = false;
 1939|      0|                return;
 1940|      0|            }
 1941|  1.62k|            major_type = get_major_type(c.value);
 1942|  1.62k|        }
 1943|  4.20M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE14get_major_typeEh:
 1890|  8.41M|    {
 1891|  8.41M|        static constexpr uint8_t major_type_shift = 0x05;
 1892|  8.41M|        uint8_t value = type >> major_type_shift;
 1893|  8.41M|        return static_cast<jsoncons::cbor::detail::cbor_major_type>(value);
 1894|  8.41M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE32get_additional_information_valueEh:
 1897|  10.4M|    {
 1898|  10.4M|        static constexpr uint8_t additional_information_mask = (1U << 5) - 1;
 1899|  10.4M|        uint8_t value = type & additional_information_mask;
 1900|  10.4M|        return value;
 1901|  10.4M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11read_uint64ERNS3_10error_codeE:
 1364|  6.28M|    {
 1365|  6.28M|        uint64_t val = 0;
 1366|       |
 1367|  6.28M|        uint8_t initial_b;
 1368|  6.28M|        if (source_.read(&initial_b, 1) == 0)
  ------------------
  |  Branch (1368:13): [True: 0, False: 6.28M]
  ------------------
 1369|      0|        {
 1370|      0|            ec = cbor_errc::unexpected_eof;
 1371|      0|            more_ = false;
 1372|      0|            return 0;
 1373|      0|        }
 1374|  6.28M|        uint8_t info = get_additional_information_value(initial_b);
 1375|  6.28M|        switch (info)
 1376|  6.28M|        {
 1377|  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: 72, False: 6.28M]
  |  |  |  Branch (18:20): [True: 43, False: 6.28M]
  |  |  |  Branch (18:30): [True: 24, False: 6.28M]
  |  |  |  Branch (18:40): [True: 214, False: 6.28M]
  |  |  |  Branch (18:50): [True: 865, False: 6.28M]
  |  |  |  Branch (18:60): [True: 47, False: 6.28M]
  |  |  |  Branch (18:70): [True: 2, False: 6.28M]
  |  |  |  Branch (18:80): [True: 15, False: 6.28M]
  |  |  |  Branch (18:90): [True: 40, False: 6.28M]
  |  |  |  Branch (18:100): [True: 531, False: 6.28M]
  |  |  |  Branch (18:110): [True: 84, False: 6.28M]
  |  |  |  Branch (18:120): [True: 1, False: 6.28M]
  |  |  |  Branch (18:130): [True: 67, False: 6.28M]
  |  |  |  Branch (18:140): [True: 154, False: 6.28M]
  |  |  |  Branch (18:150): [True: 8, False: 6.28M]
  |  |  |  Branch (18:160): [True: 21, False: 6.28M]
  |  |  |  Branch (18:170): [True: 26, False: 6.28M]
  |  |  |  Branch (18:180): [True: 7, False: 6.28M]
  |  |  |  Branch (18:190): [True: 25, False: 6.28M]
  |  |  |  Branch (18:200): [True: 2, False: 6.28M]
  |  |  |  Branch (18:210): [True: 2.10k, False: 6.28M]
  |  |  |  Branch (18:220): [True: 9, False: 6.28M]
  |  |  ------------------
  ------------------
  |  Branch (1377:13): [True: 6.27M, False: 7.93k]
  ------------------
 1378|  6.28M|            {
 1379|  6.28M|                val = info;
 1380|  6.28M|                break;
 1381|   138M|            }
 1382|       |
 1383|  2.37k|            case 0x18: // Unsigned integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1383:13): [True: 2.37k, False: 6.28M]
  ------------------
 1384|  2.37k|            {
 1385|  2.37k|                uint8_t b;
 1386|  2.37k|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1386:21): [True: 0, False: 2.37k]
  ------------------
 1387|      0|                {
 1388|      0|                    ec = cbor_errc::unexpected_eof;
 1389|      0|                    more_ = false;
 1390|      0|                    return val;
 1391|      0|                }
 1392|  2.37k|                val = b;
 1393|  2.37k|                break;
 1394|  2.37k|            }
 1395|       |
 1396|     75|            case 0x19: // Unsigned integer (two-byte uint16_t follows)
  ------------------
  |  Branch (1396:13): [True: 75, False: 6.28M]
  ------------------
 1397|     75|            {
 1398|     75|                uint8_t buf[sizeof(uint16_t)];
 1399|     75|                source_.read(buf, sizeof(uint16_t));
 1400|     75|                val = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1401|     75|                break;
 1402|  2.37k|            }
 1403|       |
 1404|     20|            case 0x1a: // Unsigned integer (four-byte uint32_t follows)
  ------------------
  |  Branch (1404:13): [True: 20, False: 6.28M]
  ------------------
 1405|     20|            {
 1406|     20|                uint8_t buf[sizeof(uint32_t)];
 1407|     20|                source_.read(buf, sizeof(uint32_t));
 1408|     20|                val = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1409|     20|                break;
 1410|  2.37k|            }
 1411|       |
 1412|     89|            case 0x1b: // Unsigned integer (eight-byte uint64_t follows)
  ------------------
  |  Branch (1412:13): [True: 89, False: 6.28M]
  ------------------
 1413|     89|            {
 1414|     89|                uint8_t buf[sizeof(uint64_t)];
 1415|     89|                source_.read(buf, sizeof(uint64_t));
 1416|     89|                val = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1417|     89|                break;
 1418|  2.37k|            }
 1419|    953|            default:
  ------------------
  |  Branch (1419:13): [True: 953, False: 6.28M]
  ------------------
 1420|    953|                break;
 1421|  6.28M|        }
 1422|  6.28M|        return val;
 1423|  6.28M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13handle_stringERNS_21basic_generic_visitorIcEERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERNS3_10error_codeE:
 1946|      2|    {
 1947|      2|        semantic_tag tag = semantic_tag::none;
 1948|      2|        if (other_tags_[item_tag])
  ------------------
  |  Branch (1948:13): [True: 2, False: 0]
  ------------------
 1949|      2|        {
 1950|      2|            switch (raw_tag_)
 1951|      2|            {
 1952|      0|                case 0:
  ------------------
  |  Branch (1952:17): [True: 0, False: 2]
  ------------------
 1953|      0|                    tag = semantic_tag::datetime;
 1954|      0|                    break;
 1955|      0|                case 32:
  ------------------
  |  Branch (1955:17): [True: 0, False: 2]
  ------------------
 1956|      0|                    tag = semantic_tag::uri;
 1957|      0|                    break;
 1958|      0|                case 33:
  ------------------
  |  Branch (1958:17): [True: 0, False: 2]
  ------------------
 1959|      0|                    tag = semantic_tag::base64url;
 1960|      0|                    break;
 1961|      0|                case 34:
  ------------------
  |  Branch (1961:17): [True: 0, False: 2]
  ------------------
 1962|      0|                    tag = semantic_tag::base64;
 1963|      0|                    break;
 1964|      2|                default:
  ------------------
  |  Branch (1964:17): [True: 2, False: 0]
  ------------------
 1965|      2|                    break;
 1966|      2|            }
 1967|      2|            other_tags_[item_tag] = false;
 1968|      2|        }
 1969|      2|        visitor.string_value(v, tag, *this, ec);
 1970|      2|        more_ = !cursor_mode_;
 1971|      2|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE26get_typed_array_endiannessEh:
 1974|  1.42k|    {
 1975|  1.42k|        return ((tag & detail::cbor_array_tags_e_mask) >> detail::cbor_array_tags_e_shift) == 0 ? jsoncons::endian::big : jsoncons::endian::little; 
  ------------------
  |  Branch (1975:16): [True: 10, False: 1.41k]
  ------------------
 1976|  1.42k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10read_int64ERNS3_10error_codeE:
 1426|    586|    {
 1427|    586|        int64_t val = 0;
 1428|       |
 1429|    586|        auto ch = source_.peek();
 1430|    586|        if (ch.eof)
  ------------------
  |  Branch (1430:13): [True: 0, False: 586]
  ------------------
 1431|      0|        {
 1432|      0|            ec = cbor_errc::unexpected_eof;
 1433|      0|            more_ = false;
 1434|      0|            return val;
 1435|      0|        }
 1436|       |
 1437|    586|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(ch.value);
 1438|    586|        uint8_t info = get_additional_information_value(ch.value);
 1439|    586|        switch (major_type)
 1440|    586|        {
 1441|    586|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1441:13): [True: 586, False: 0]
  ------------------
 1442|    586|                source_.ignore(1);
 1443|    586|                switch (info)
  ------------------
  |  Branch (1443:25): [True: 571, False: 15]
  ------------------
 1444|    586|                {
 1445|    557|                    case JSONCONS_EXT_CBOR_0x00_0x17: // 0x00..0x17 (0..23)
  ------------------
  |  |   18|    557|    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: 586]
  |  |  |  Branch (18:20): [True: 35, False: 551]
  |  |  |  Branch (18:30): [True: 0, False: 586]
  |  |  |  Branch (18:40): [True: 0, False: 586]
  |  |  |  Branch (18:50): [True: 16, False: 570]
  |  |  |  Branch (18:60): [True: 0, False: 586]
  |  |  |  Branch (18:70): [True: 1, False: 585]
  |  |  |  Branch (18:80): [True: 2, False: 584]
  |  |  |  Branch (18:90): [True: 15, False: 571]
  |  |  |  Branch (18:100): [True: 0, False: 586]
  |  |  |  Branch (18:110): [True: 0, False: 586]
  |  |  |  Branch (18:120): [True: 2, False: 584]
  |  |  |  Branch (18:130): [True: 2, False: 584]
  |  |  |  Branch (18:140): [True: 5, False: 581]
  |  |  |  Branch (18:150): [True: 0, False: 586]
  |  |  |  Branch (18:160): [True: 5, False: 581]
  |  |  |  Branch (18:170): [True: 2, False: 584]
  |  |  |  Branch (18:180): [True: 344, False: 242]
  |  |  |  Branch (18:190): [True: 2, False: 584]
  |  |  |  Branch (18:200): [True: 4, False: 582]
  |  |  |  Branch (18:210): [True: 9, False: 577]
  |  |  |  Branch (18:220): [True: 2, False: 584]
  |  |  ------------------
  ------------------
  |  Branch (1445:21): [True: 111, False: 475]
  ------------------
 1446|    557|                    {
 1447|    557|                        val = static_cast<int8_t>(- 1 - info);
 1448|    557|                        break;
 1449|  5.61k|                    }
 1450|      0|                    case 0x18: // Negative integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1450:21): [True: 0, False: 586]
  ------------------
 1451|      0|                        {
 1452|      0|                            uint8_t b;
 1453|      0|                            if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1453:33): [True: 0, False: 0]
  ------------------
 1454|      0|                            {
 1455|      0|                                ec = cbor_errc::unexpected_eof;
 1456|      0|                                more_ = false;
 1457|      0|                                return val;
 1458|      0|                            }
 1459|      0|                            val = static_cast<int64_t>(-1) - static_cast<int64_t>(b);
 1460|      0|                            break;
 1461|      0|                        }
 1462|       |
 1463|      6|                    case 0x19: // Negative integer -1-n (two-byte uint16_t follows)
  ------------------
  |  Branch (1463:21): [True: 6, False: 580]
  ------------------
 1464|      6|                        {
 1465|      6|                            uint8_t buf[sizeof(uint16_t)];
 1466|      6|                            if (source_.read(buf, sizeof(uint16_t)) != sizeof(uint16_t))
  ------------------
  |  Branch (1466:33): [True: 0, False: 6]
  ------------------
 1467|      0|                            {
 1468|      0|                                ec = cbor_errc::unexpected_eof;
 1469|      0|                                more_ = false;
 1470|      0|                                return val;
 1471|      0|                            }
 1472|      6|                            auto x = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1473|      6|                            val = static_cast<int64_t>(-1)- x;
 1474|      6|                            break;
 1475|      6|                        }
 1476|       |
 1477|      0|                    case 0x1a: // Negative integer -1-n (four-byte uint32_t follows)
  ------------------
  |  Branch (1477:21): [True: 0, False: 586]
  ------------------
 1478|      0|                        {
 1479|      0|                            uint8_t buf[sizeof(uint32_t)];
 1480|      0|                            if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (1480:33): [True: 0, False: 0]
  ------------------
 1481|      0|                            {
 1482|      0|                                ec = cbor_errc::unexpected_eof;
 1483|      0|                                more_ = false;
 1484|      0|                                return val;
 1485|      0|                            }
 1486|      0|                            auto x = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1487|      0|                            val = static_cast<int64_t>(-1)- x;
 1488|      0|                            break;
 1489|      0|                        }
 1490|       |
 1491|      8|                    case 0x1b: // Negative integer -1-n (eight-byte uint64_t follows)
  ------------------
  |  Branch (1491:21): [True: 8, False: 578]
  ------------------
 1492|      8|                        {
 1493|      8|                            uint8_t buf[sizeof(uint64_t)];
 1494|      8|                            if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (1494:33): [True: 0, False: 8]
  ------------------
 1495|      0|                            {
 1496|      0|                                ec = cbor_errc::unexpected_eof;
 1497|      0|                                more_ = false;
 1498|      0|                                return val;
 1499|      0|                            }
 1500|      8|                            auto x = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1501|      8|                            val = static_cast<int64_t>(-1)- static_cast<int64_t>(x);
 1502|      8|                            break;
 1503|      8|                        }
 1504|    586|                }
 1505|    586|                break;
 1506|       |
 1507|    586|                case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1507:17): [True: 0, False: 586]
  ------------------
 1508|      0|                {
 1509|      0|                    uint64_t x = read_uint64(ec);
 1510|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1511|      0|                    {
 1512|      0|                        return 0;
 1513|      0|                    }
 1514|      0|                    if (x <= static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1514:25): [True: 0, False: 0]
  ------------------
 1515|      0|                    {
 1516|      0|                        val = x;
 1517|      0|                    }
 1518|      0|                    else
 1519|      0|                    {
 1520|       |                        // error;
 1521|      0|                    }
 1522|       |                    
 1523|      0|                    break;
 1524|      0|                }
 1525|      0|                break;
 1526|      0|            default:
  ------------------
  |  Branch (1526:13): [True: 0, False: 586]
  ------------------
 1527|      0|                break;
 1528|    586|        }
 1529|       |
 1530|    586|        return val;
 1531|    586|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_sourceC2EPS8_:
  198|  1.94k|            : source(source)
  199|  1.94k|        {
  200|  1.94k|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringINS8_28read_byte_string_from_sourceEEEvT_RNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 1988|  1.94k|    {
 1989|  1.94k|        if (other_tags_[item_tag])
  ------------------
  |  Branch (1989:13): [True: 1.48k, False: 459]
  ------------------
 1990|  1.48k|        {
 1991|  1.48k|            switch (raw_tag_)
 1992|  1.48k|            {
 1993|      0|                case 0x2:
  ------------------
  |  Branch (1993:17): [True: 0, False: 1.48k]
  ------------------
 1994|      0|                {
 1995|      0|                    auto bytes = read.view(ec);
 1996|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1997|      0|                    {
 1998|      0|                        more_ = false;
 1999|      0|                        return;
 2000|      0|                    }
 2001|      0|                    bigint n = bigint::from_bytes_be(1, bytes.data(), bytes.size());
 2002|      0|                    text_buffer_.clear();
 2003|      0|                    n.write_string(text_buffer_);
 2004|      0|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2005|      0|                    more_ = !cursor_mode_;
 2006|      0|                    break;
 2007|      0|                }
 2008|      0|                case 0x3:
  ------------------
  |  Branch (2008:17): [True: 0, False: 1.48k]
  ------------------
 2009|      0|                {
 2010|      0|                    auto bytes = read.view(ec);
 2011|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2012|      0|                    {
 2013|      0|                        more_ = false;
 2014|      0|                        return;
 2015|      0|                    }
 2016|      0|                    bigint n = bigint::from_bytes_be(1, bytes.data(), bytes.size());
 2017|      0|                    n = -1 - n;
 2018|      0|                    text_buffer_.clear();
 2019|      0|                    n.write_string(text_buffer_);
 2020|      0|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2021|      0|                    more_ = !cursor_mode_;
 2022|      0|                    break;
 2023|      0|                }
 2024|      0|                case 0x15:
  ------------------
  |  Branch (2024:17): [True: 0, False: 1.48k]
  ------------------
 2025|      0|                case 0x16:
  ------------------
  |  Branch (2025:17): [True: 0, False: 1.48k]
  ------------------
 2026|      0|                case 0x17:
  ------------------
  |  Branch (2026:17): [True: 0, False: 1.48k]
  ------------------
 2027|      0|                {
 2028|      0|                    auto bytes = read.view(ec);
 2029|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2030|      0|                    {
 2031|      0|                        more_ = false;
 2032|      0|                        return;
 2033|      0|                    }
 2034|      0|                    const semantic_tag tag = raw_tag_ == 0x15 ? semantic_tag::base64url
  ------------------
  |  Branch (2034:46): [True: 0, False: 0]
  ------------------
 2035|      0|                        : raw_tag_ == 0x16 ? semantic_tag::base64
  ------------------
  |  Branch (2035:27): [True: 0, False: 0]
  ------------------
 2036|      0|                        : semantic_tag::base16;
 2037|      0|                    visitor.byte_string_value(bytes, tag, *this, ec);
 2038|      0|                    more_ = !cursor_mode_;
 2039|      0|                    break;
 2040|      0|                }
 2041|      8|                case 0x40:
  ------------------
  |  Branch (2041:17): [True: 8, False: 1.47k]
  ------------------
 2042|      8|                {
 2043|      8|                    array_tag_ = typed_array_tags::uint8;
 2044|      8|                    byte_string_type array_buffer(alloc_);
 2045|      8|                    read(array_buffer, ec);
 2046|      8|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 8]
  |  |  ------------------
  ------------------
 2047|      0|                    {
 2048|      0|                        more_ = false;
 2049|      0|                        return;
 2050|      0|                    }
 2051|      8|                    auto ta = typed_array_cast<const uint8_t>(array_buffer);
 2052|      8|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2052:25): [True: 8, False: 0]
  |  Branch (2052:42): [True: 0, False: 8]
  ------------------
 2053|      0|                    {
 2054|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2054:29): [True: 0, False: 0]
  ------------------
 2055|      0|                        {
 2056|      0|                            ec = cbor_errc::bad_extents;
 2057|      0|                            more_ = false;
 2058|      0|                            return;
 2059|      0|                        }
 2060|      0|                        auto iter = std::make_shared<mdarray_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2061|      0|                            typed_array_tags::uint8, extents_, order_);
 2062|      0|                        typed_array_stack_.push_back(iter);
 2063|      0|                        iter->next(visitor, *this, ec);
 2064|      0|                    }
 2065|      8|                    else
 2066|      8|                    {
 2067|      8|                        auto iter = std::make_shared<oned_typed_array_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2068|      8|                            typed_array_tags::uint8);
 2069|      8|                        typed_array_stack_.push_back(iter);
 2070|      8|                        iter->next(visitor, *this, ec);
 2071|      8|                    }
 2072|      8|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2073|      8|                    more_ = !cursor_mode_;
 2074|      8|                    break;
 2075|      8|                }
 2076|      0|                case 0x44:
  ------------------
  |  Branch (2076:17): [True: 0, False: 1.48k]
  ------------------
 2077|      0|                {
 2078|      0|                    array_tag_ = typed_array_tags::uint8;
 2079|      0|                    typed_array_tag_ = semantic_tag::clamped;
 2080|      0|                    byte_string_type array_buffer(alloc_);
 2081|      0|                    read(array_buffer, ec);
 2082|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2083|      0|                    {
 2084|      0|                        more_ = false;
 2085|      0|                        return;
 2086|      0|                    }
 2087|      0|                    auto ta = typed_array_cast<const uint8_t>(array_buffer);
 2088|      0|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2088:25): [True: 0, False: 0]
  |  Branch (2088:42): [True: 0, False: 0]
  ------------------
 2089|      0|                    {
 2090|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2090:29): [True: 0, False: 0]
  ------------------
 2091|      0|                        {
 2092|      0|                            ec = cbor_errc::bad_extents;
 2093|      0|                            more_ = false;
 2094|      0|                            return;
 2095|      0|                        }
 2096|      0|                        auto iter = std::make_shared<mdarray_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2097|      0|                            typed_array_tags::uint8, extents_, order_);
 2098|      0|                        typed_array_stack_.push_back(iter);
 2099|      0|                        iter->next(visitor, *this, ec);
 2100|      0|                    }
 2101|      0|                    else
 2102|      0|                    {
 2103|      0|                        auto iter = std::make_shared<oned_typed_array_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2104|      0|                            typed_array_tags::uint8, semantic_tag::clamped);
 2105|      0|                        typed_array_stack_.push_back(iter);
 2106|      0|                        iter->next(visitor, *this, ec);
 2107|      0|                    }
 2108|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2109|      0|                    more_ = !cursor_mode_;
 2110|      0|                    break;
 2111|      0|                }
 2112|      2|                case 0x41:
  ------------------
  |  Branch (2112:17): [True: 2, False: 1.48k]
  ------------------
 2113|     22|                case 0x45:
  ------------------
  |  Branch (2113:17): [True: 20, False: 1.46k]
  ------------------
 2114|     22|                {
 2115|     22|                    array_tag_ = typed_array_tags::uint16;
 2116|     22|                    byte_string_type array_buffer(alloc_);
 2117|     22|                    read(array_buffer, ec);
 2118|     22|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     22|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 22]
  |  |  ------------------
  ------------------
 2119|      0|                    {
 2120|      0|                        more_ = false;
 2121|      0|                        return;
 2122|      0|                    }
 2123|     22|                    const uint8_t tag = (uint8_t)raw_tag_;
 2124|     22|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2125|     22|                    auto ta = typed_array_cast<uint16_t>(array_buffer);
 2126|     22|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2126:25): [True: 2, False: 20]
  ------------------
 2127|      2|                    {
 2128|      2|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2128:49): [True: 0, False: 2]
  ------------------
 2129|      0|                        {
 2130|      0|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2131|      0|                        }
 2132|      2|                    }
 2133|     22|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2133:25): [True: 22, False: 0]
  |  Branch (2133:42): [True: 10, False: 12]
  ------------------
 2134|     10|                    {
 2135|     10|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2135:29): [True: 0, False: 10]
  ------------------
 2136|      0|                        {
 2137|      0|                            ec = cbor_errc::bad_extents;
 2138|      0|                            more_ = false;
 2139|      0|                            return;
 2140|      0|                        }
 2141|     10|                        auto iter = std::make_shared<mdarray_iterator<uint16_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2142|     10|                            typed_array_tags::uint16, extents_, order_);
 2143|     10|                        typed_array_stack_.push_back(iter);
 2144|     10|                        iter->next(visitor, *this, ec);
 2145|     10|                    }
 2146|     12|                    else
 2147|     12|                    {
 2148|     12|                        auto iter = std::make_shared<oned_typed_array_iterator<uint16_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2149|     12|                            typed_array_tags::uint16);
 2150|     12|                        typed_array_stack_.push_back(iter);
 2151|     12|                        iter->next(visitor, *this, ec);
 2152|     12|                    }
 2153|     22|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2154|     22|                    more_ = !cursor_mode_;
 2155|     22|                    break;
 2156|     22|                }
 2157|      0|                case 0x42:
  ------------------
  |  Branch (2157:17): [True: 0, False: 1.48k]
  ------------------
 2158|      0|                case 0x46:
  ------------------
  |  Branch (2158:17): [True: 0, False: 1.48k]
  ------------------
 2159|      0|                {
 2160|      0|                    array_tag_ = typed_array_tags::uint32;
 2161|      0|                    byte_string_type array_buffer(alloc_);
 2162|      0|                    read(array_buffer, ec);
 2163|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2164|      0|                    {
 2165|      0|                        more_ = false;
 2166|      0|                        return;
 2167|      0|                    }
 2168|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2169|      0|                    jsoncons::endian e = get_typed_array_endianness(tag);
 2170|      0|                    auto ta = typed_array_cast<uint32_t>(array_buffer);
 2171|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2171:25): [True: 0, False: 0]
  ------------------
 2172|      0|                    {
 2173|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2173:49): [True: 0, False: 0]
  ------------------
 2174|      0|                        {
 2175|      0|                            ta[i] = binary::byte_swap<uint32_t>(ta[i]);
 2176|      0|                        }
 2177|      0|                    }
 2178|      0|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2178:25): [True: 0, False: 0]
  |  Branch (2178:42): [True: 0, False: 0]
  ------------------
 2179|      0|                    {
 2180|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2180:29): [True: 0, False: 0]
  ------------------
 2181|      0|                        {
 2182|      0|                            ec = cbor_errc::bad_extents;
 2183|      0|                            more_ = false;
 2184|      0|                            return;
 2185|      0|                        }
 2186|      0|                        auto iter = std::make_shared<mdarray_iterator<uint32_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2187|      0|                            typed_array_tags::uint32, extents_, order_);
 2188|      0|                        typed_array_stack_.push_back(iter);
 2189|      0|                        iter->next(visitor, *this, ec);
 2190|      0|                    }
 2191|      0|                    else
 2192|      0|                    {
 2193|      0|                        auto iter = std::make_shared<oned_typed_array_iterator<uint32_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2194|      0|                            typed_array_tags::uint32);
 2195|      0|                        typed_array_stack_.push_back(iter);
 2196|      0|                        iter->next(visitor, *this, ec);
 2197|      0|                    }
 2198|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2199|      0|                    more_ = !cursor_mode_;
 2200|      0|                    break;
 2201|      0|                }
 2202|      5|                case 0x43:
  ------------------
  |  Branch (2202:17): [True: 5, False: 1.48k]
  ------------------
 2203|      9|                case 0x47:
  ------------------
  |  Branch (2203:17): [True: 4, False: 1.48k]
  ------------------
 2204|      9|                {
 2205|      9|                    array_tag_ = typed_array_tags::uint64;
 2206|      9|                    byte_string_type array_buffer(alloc_);
 2207|      9|                    read(array_buffer, ec);
 2208|      9|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      9|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 9]
  |  |  ------------------
  ------------------
 2209|      0|                    {
 2210|      0|                        more_ = false;
 2211|      0|                        return;
 2212|      0|                    }
 2213|      9|                    const uint8_t tag = (uint8_t)raw_tag_;
 2214|      9|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2215|      9|                    auto ta = typed_array_cast<uint64_t>(array_buffer);
 2216|      9|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2216:25): [True: 5, False: 4]
  ------------------
 2217|      5|                    {
 2218|      5|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2218:49): [True: 0, False: 5]
  ------------------
 2219|      0|                        {
 2220|      0|                            ta[i] = binary::byte_swap<uint64_t>(ta[i]);
 2221|      0|                        }
 2222|      5|                    }
 2223|      9|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2223:25): [True: 9, False: 0]
  |  Branch (2223:42): [True: 2, False: 7]
  ------------------
 2224|      2|                    {
 2225|      2|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2225:29): [True: 0, False: 2]
  ------------------
 2226|      0|                        {
 2227|      0|                            ec = cbor_errc::bad_extents;
 2228|      0|                            more_ = false;
 2229|      0|                            return;
 2230|      0|                        }
 2231|      2|                        auto iter = std::make_shared<mdarray_iterator<uint64_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2232|      2|                            typed_array_tags::uint64, extents_, order_);
 2233|      2|                        typed_array_stack_.push_back(iter);
 2234|      2|                        iter->next(visitor, *this, ec);
 2235|      2|                    }
 2236|      7|                    else
 2237|      7|                    {
 2238|      7|                        auto iter = std::make_shared<oned_typed_array_iterator<uint64_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2239|      7|                            typed_array_tags::uint64);
 2240|      7|                        typed_array_stack_.push_back(iter);
 2241|      7|                        iter->next(visitor, *this, ec);
 2242|      7|                    }
 2243|      9|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2244|      9|                    more_ = !cursor_mode_;
 2245|      9|                    break;
 2246|      9|                }
 2247|      0|                case 0x48:
  ------------------
  |  Branch (2247:17): [True: 0, False: 1.48k]
  ------------------
 2248|      0|                {
 2249|      0|                    array_tag_ = typed_array_tags::int8;
 2250|      0|                    byte_string_type array_buffer(alloc_);
 2251|      0|                    read(array_buffer, ec);
 2252|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2253|      0|                    {
 2254|      0|                        more_ = false;
 2255|      0|                        return;
 2256|      0|                    }
 2257|      0|                    auto ta = typed_array_cast<int8_t>(array_buffer);
 2258|      0|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2258:25): [True: 0, False: 0]
  |  Branch (2258:42): [True: 0, False: 0]
  ------------------
 2259|      0|                    {
 2260|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2260:29): [True: 0, False: 0]
  ------------------
 2261|      0|                        {
 2262|      0|                            ec = cbor_errc::bad_extents;
 2263|      0|                            more_ = false;
 2264|      0|                            return;
 2265|      0|                        }
 2266|      0|                        auto iter = std::make_shared<mdarray_iterator<int8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2267|      0|                            typed_array_tags::int8, extents_, order_);
 2268|      0|                        typed_array_stack_.push_back(iter);
 2269|      0|                        iter->next(visitor, *this, ec);
 2270|      0|                    }
 2271|      0|                    else
 2272|      0|                    {
 2273|      0|                        auto iter = std::make_shared<oned_typed_array_iterator<int8_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2274|      0|                            typed_array_tags::int8);
 2275|      0|                        typed_array_stack_.push_back(iter);
 2276|      0|                        iter->next(visitor, *this, ec);
 2277|      0|                    }
 2278|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2279|      0|                    more_ = !cursor_mode_;
 2280|      0|                    break;
 2281|      0|                }
 2282|      3|                case 0x49:
  ------------------
  |  Branch (2282:17): [True: 3, False: 1.48k]
  ------------------
 2283|  1.38k|                case 0x4d:
  ------------------
  |  Branch (2283:17): [True: 1.38k, False: 103]
  ------------------
 2284|  1.38k|                {
 2285|  1.38k|                    array_tag_ = typed_array_tags::int16;
 2286|  1.38k|                    byte_string_type array_buffer(alloc_);
 2287|  1.38k|                    read(array_buffer, ec);
 2288|  1.38k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.38k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.38k]
  |  |  ------------------
  ------------------
 2289|      0|                    {
 2290|      0|                        more_ = false;
 2291|      0|                        return;
 2292|      0|                    }
 2293|  1.38k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2294|  1.38k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2295|  1.38k|                    auto ta = typed_array_cast<int16_t>(array_buffer);
 2296|  1.38k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2296:25): [True: 3, False: 1.38k]
  ------------------
 2297|      3|                    {
 2298|      3|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2298:49): [True: 0, False: 3]
  ------------------
 2299|      0|                        {
 2300|      0|                            ta[i] = binary::byte_swap<int16_t>(ta[i]);
 2301|      0|                        }
 2302|      3|                    }
 2303|  1.38k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2303:25): [True: 1.38k, False: 0]
  |  Branch (2303:42): [True: 3, False: 1.38k]
  ------------------
 2304|      3|                    {
 2305|      3|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2305:29): [True: 0, False: 3]
  ------------------
 2306|      0|                        {
 2307|      0|                            ec = cbor_errc::bad_extents;
 2308|      0|                            more_ = false;
 2309|      0|                            return;
 2310|      0|                        }
 2311|      3|                        auto iter = std::make_shared<mdarray_iterator<int16_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2312|      3|                            typed_array_tags::int16, extents_, order_);
 2313|      3|                        typed_array_stack_.push_back(iter);
 2314|      3|                        iter->next(visitor, *this, ec);
 2315|      3|                    }
 2316|  1.38k|                    else
 2317|  1.38k|                    {
 2318|  1.38k|                        auto iter = std::make_shared<oned_typed_array_iterator<int16_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2319|  1.38k|                            typed_array_tags::int16);
 2320|  1.38k|                        typed_array_stack_.push_back(iter);
 2321|  1.38k|                        iter->next(visitor, *this, ec);
 2322|  1.38k|                    }
 2323|  1.38k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2324|  1.38k|                    more_ = !cursor_mode_;
 2325|  1.38k|                    break;
 2326|  1.38k|                }
 2327|      0|                case 0x4a:
  ------------------
  |  Branch (2327:17): [True: 0, False: 1.48k]
  ------------------
 2328|      0|                case 0x4e:
  ------------------
  |  Branch (2328:17): [True: 0, False: 1.48k]
  ------------------
 2329|      0|                {
 2330|      0|                    array_tag_ = typed_array_tags::int32;
 2331|      0|                    byte_string_type array_buffer(alloc_);
 2332|      0|                    read(array_buffer, ec);
 2333|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2334|      0|                    {
 2335|      0|                        more_ = false;
 2336|      0|                        return;
 2337|      0|                    }
 2338|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2339|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2340|      0|                    auto ta = typed_array_cast<int32_t>(array_buffer);
 2341|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2341:25): [True: 0, False: 0]
  ------------------
 2342|      0|                    {
 2343|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2343:49): [True: 0, False: 0]
  ------------------
 2344|      0|                        {
 2345|      0|                            ta[i] = binary::byte_swap<int32_t>(ta[i]);
 2346|      0|                        }
 2347|      0|                    }
 2348|      0|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2348:25): [True: 0, False: 0]
  |  Branch (2348:42): [True: 0, False: 0]
  ------------------
 2349|      0|                    {
 2350|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2350:29): [True: 0, False: 0]
  ------------------
 2351|      0|                        {
 2352|      0|                            ec = cbor_errc::bad_extents;
 2353|      0|                            more_ = false;
 2354|      0|                            return;
 2355|      0|                        }
 2356|      0|                        auto iter = std::make_shared<mdarray_iterator<int32_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2357|      0|                            typed_array_tags::int32, extents_, order_);
 2358|      0|                        typed_array_stack_.push_back(iter);
 2359|      0|                        iter->next(visitor, *this, ec);
 2360|      0|                    }
 2361|      0|                    else
 2362|      0|                    {
 2363|      0|                        auto iter = std::make_shared<oned_typed_array_iterator<int32_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2364|      0|                            typed_array_tags::int32);
 2365|      0|                        typed_array_stack_.push_back(iter);
 2366|      0|                        iter->next(visitor, *this, ec);
 2367|      0|                    }
 2368|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2369|      0|                    more_ = !cursor_mode_;
 2370|      0|                    break;
 2371|      0|                }
 2372|      0|                case 0x4b:
  ------------------
  |  Branch (2372:17): [True: 0, False: 1.48k]
  ------------------
 2373|      2|                case 0x4f:
  ------------------
  |  Branch (2373:17): [True: 2, False: 1.48k]
  ------------------
 2374|      2|                {
 2375|      2|                    array_tag_ = typed_array_tags::int64;
 2376|      2|                    byte_string_type array_buffer(alloc_);
 2377|      2|                    read(array_buffer, ec);
 2378|      2|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 2379|      0|                    {
 2380|      0|                        more_ = false;
 2381|      0|                        return;
 2382|      0|                    }
 2383|      2|                    const uint8_t tag = (uint8_t)raw_tag_;
 2384|      2|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2385|      2|                    auto ta = typed_array_cast<int64_t>(array_buffer);
 2386|      2|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2386:25): [True: 0, False: 2]
  ------------------
 2387|      0|                    {
 2388|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2388:49): [True: 0, False: 0]
  ------------------
 2389|      0|                        {
 2390|      0|                            ta[i] = binary::byte_swap<int64_t>(ta[i]);
 2391|      0|                        }
 2392|      0|                    }
 2393|      2|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2393:25): [True: 2, False: 0]
  |  Branch (2393:42): [True: 0, False: 2]
  ------------------
 2394|      0|                    {
 2395|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2395:29): [True: 0, False: 0]
  ------------------
 2396|      0|                        {
 2397|      0|                            ec = cbor_errc::bad_extents;
 2398|      0|                            more_ = false;
 2399|      0|                            return;
 2400|      0|                        }
 2401|      0|                        auto iter = std::make_shared<mdarray_iterator<int64_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2402|      0|                            typed_array_tags::int64, extents_, order_);
 2403|      0|                        typed_array_stack_.push_back(iter);
 2404|      0|                        iter->next(visitor, *this, ec);
 2405|      0|                    }
 2406|      2|                    else
 2407|      2|                    {
 2408|      2|                        auto iter = std::make_shared<oned_typed_array_iterator<int64_t,jsoncons::identity,Allocator>>(std::move(array_buffer), typed_array_tags::int64);
 2409|      2|                        typed_array_stack_.push_back(iter);
 2410|      2|                        iter->next(visitor, *this, ec);
 2411|      2|                    }
 2412|      2|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2413|      2|                    more_ = !cursor_mode_;
 2414|      2|                    break;
 2415|      2|                }
 2416|      0|                case 0x50:
  ------------------
  |  Branch (2416:17): [True: 0, False: 1.48k]
  ------------------
 2417|      0|                case 0x54:
  ------------------
  |  Branch (2417:17): [True: 0, False: 1.48k]
  ------------------
 2418|      0|                {
 2419|      0|                    array_tag_ = typed_array_tags::half_float;
 2420|      0|                    byte_string_type array_buffer(alloc_);
 2421|      0|                    read(array_buffer, ec);
 2422|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2423|      0|                    {
 2424|      0|                        more_ = false;
 2425|      0|                        return;
 2426|      0|                    }
 2427|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2428|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2429|      0|                    auto ta = typed_array_cast<uint16_t>(array_buffer);
 2430|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2430:25): [True: 0, False: 0]
  ------------------
 2431|      0|                    {
 2432|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2432:49): [True: 0, False: 0]
  ------------------
 2433|      0|                        {
 2434|      0|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2435|      0|                        }
 2436|      0|                    }
 2437|      0|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2437:25): [True: 0, False: 0]
  |  Branch (2437:42): [True: 0, False: 0]
  ------------------
 2438|      0|                    {
 2439|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2439:29): [True: 0, False: 0]
  ------------------
 2440|      0|                        {
 2441|      0|                            ec = cbor_errc::bad_extents;
 2442|      0|                            more_ = false;
 2443|      0|                            return;
 2444|      0|                        }
 2445|      0|                        auto iter = std::make_shared<mdarray_iterator<uint16_t,decode_half,Allocator>>(std::move(array_buffer), 
 2446|      0|                            typed_array_tags::half_float, extents_, order_);
 2447|      0|                        typed_array_stack_.push_back(iter);
 2448|      0|                        iter->next(visitor, *this, ec);
 2449|      0|                    }
 2450|      0|                    else
 2451|      0|                    {
 2452|      0|                        auto iter = std::make_shared<oned_typed_array_iterator<uint16_t,decode_half,Allocator>>(std::move(array_buffer),
 2453|      0|                            typed_array_tags::half_float);
 2454|      0|                        typed_array_stack_.push_back(iter);
 2455|      0|                        iter->next(visitor, *this, ec);
 2456|      0|                    }
 2457|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2458|      0|                    more_ = !cursor_mode_;
 2459|      0|                    break;
 2460|      0|                }
 2461|      0|                case 0x51:
  ------------------
  |  Branch (2461:17): [True: 0, False: 1.48k]
  ------------------
 2462|      2|                case 0x55:
  ------------------
  |  Branch (2462:17): [True: 2, False: 1.48k]
  ------------------
 2463|      2|                {
 2464|      2|                    array_tag_ = typed_array_tags::float32;
 2465|      2|                    byte_string_type array_buffer(alloc_);
 2466|      2|                    read(array_buffer, ec);
 2467|      2|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 2468|      0|                    {
 2469|      0|                        more_ = false;
 2470|      0|                        return;
 2471|      0|                    }
 2472|      2|                    const uint8_t tag = (uint8_t)raw_tag_;
 2473|      2|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2474|      2|                    auto ta = typed_array_cast<float>(array_buffer);
 2475|      2|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2475:25): [True: 0, False: 2]
  ------------------
 2476|      0|                    {
 2477|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2477:49): [True: 0, False: 0]
  ------------------
 2478|      0|                        {
 2479|      0|                            ta[i] = binary::byte_swap<float>(ta[i]);
 2480|      0|                        }
 2481|      0|                    }
 2482|      2|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2482:25): [True: 2, False: 0]
  |  Branch (2482:42): [True: 0, False: 2]
  ------------------
 2483|      0|                    {
 2484|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2484:29): [True: 0, False: 0]
  ------------------
 2485|      0|                        {
 2486|      0|                            ec = cbor_errc::bad_extents;
 2487|      0|                            more_ = false;
 2488|      0|                            return;
 2489|      0|                        }
 2490|      0|                        auto iter = std::make_shared<mdarray_iterator<float,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2491|      0|                            typed_array_tags::float32, extents_, order_);
 2492|      0|                        typed_array_stack_.push_back(iter);
 2493|      0|                        iter->next(visitor, *this, ec);
 2494|      0|                    }
 2495|      2|                    else
 2496|      2|                    {
 2497|      2|                        auto iter = std::make_shared<oned_typed_array_iterator<float,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2498|      2|                            typed_array_tags::float32);
 2499|      2|                        typed_array_stack_.push_back(iter);
 2500|      2|                        iter->next(visitor, *this, ec);
 2501|      2|                    }
 2502|      2|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2503|      2|                    more_ = !cursor_mode_;
 2504|      2|                    break;
 2505|      2|                }
 2506|      0|                case 0x52:
  ------------------
  |  Branch (2506:17): [True: 0, False: 1.48k]
  ------------------
 2507|      0|                case 0x56:
  ------------------
  |  Branch (2507:17): [True: 0, False: 1.48k]
  ------------------
 2508|      0|                {
 2509|      0|                    array_tag_ = typed_array_tags::float64;
 2510|      0|                    byte_string_type array_buffer(alloc_);
 2511|      0|                    read(array_buffer, ec);
 2512|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2513|      0|                    {
 2514|      0|                        more_ = false;
 2515|      0|                        return;
 2516|      0|                    }
 2517|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2518|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2519|      0|                    auto ta = typed_array_cast<double>(array_buffer);
 2520|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2520:25): [True: 0, False: 0]
  ------------------
 2521|      0|                    {
 2522|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2522:49): [True: 0, False: 0]
  ------------------
 2523|      0|                        {
 2524|      0|                            ta[i] = binary::byte_swap<double>(ta[i]);
 2525|      0|                        }
 2526|      0|                    }
 2527|      0|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2527:25): [True: 0, False: 0]
  |  Branch (2527:42): [True: 0, False: 0]
  ------------------
 2528|      0|                    {
 2529|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2529:29): [True: 0, False: 0]
  ------------------
 2530|      0|                        {
 2531|      0|                            ec = cbor_errc::bad_extents;
 2532|      0|                            more_ = false;
 2533|      0|                            return;
 2534|      0|                        }
 2535|      0|                        auto iter = std::make_shared<mdarray_iterator<double,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2536|      0|                            typed_array_tags::float64, extents_, order_);
 2537|      0|                        typed_array_stack_.push_back(iter);
 2538|      0|                        iter->next(visitor, *this, ec);
 2539|      0|                    }
 2540|      0|                    else
 2541|      0|                    {
 2542|      0|                        auto iter = std::make_shared<oned_typed_array_iterator<double,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2543|      0|                            typed_array_tags::float64);
 2544|      0|                        typed_array_stack_.push_back(iter);
 2545|      0|                        iter->next(visitor, *this, ec);
 2546|      0|                    }
 2547|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2548|      0|                    more_ = !cursor_mode_;
 2549|      0|                    break;
 2550|      0|                }
 2551|     57|                default:
  ------------------
  |  Branch (2551:17): [True: 57, False: 1.43k]
  ------------------
 2552|     57|                {
 2553|     57|                    auto bytes = read.view(ec);
 2554|     57|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     57|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 57]
  |  |  ------------------
  ------------------
 2555|      0|                    {
 2556|      0|                        more_ = false;
 2557|      0|                        return;
 2558|      0|                    }
 2559|     57|                    visitor.byte_string_value(bytes, raw_tag_, *this, ec);
 2560|     57|                    more_ = !cursor_mode_;
 2561|     57|                    break;
 2562|     57|                }
 2563|  1.48k|            }
 2564|  1.48k|            other_tags_[item_tag] = false;
 2565|  1.48k|        }
 2566|    459|        else
 2567|    459|        {
 2568|    459|            auto bytes = read.view(ec);
 2569|    459|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    459|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 456]
  |  |  ------------------
  ------------------
 2570|      3|            {
 2571|      3|                return;
 2572|      3|            }
 2573|    456|            visitor.byte_string_value(bytes, semantic_tag::none, *this, ec);
 2574|    456|            more_ = !cursor_mode_;
 2575|    456|        }
 2576|  1.94k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_source4viewERNS3_10error_codeE:
  208|    516|        {
  209|    516|            return source->read_byte_string_view(ec);
  210|    516|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_byte_string_viewERNS3_10error_codeE:
 1206|    516|    {
 1207|    516|        auto c = source_.peek();
 1208|    516|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|    516|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 516]
  |  |  ------------------
  ------------------
 1209|      0|        {
 1210|      0|            ec = cbor_errc::unexpected_eof;
 1211|      0|            more_ = false;
 1212|      0|            return byte_string_view();
 1213|      0|        }
 1214|    516|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1215|    516|        uint8_t info = get_additional_information_value(c.value);
 1216|       |
 1217|    516|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::byte_string);
  ------------------
  |  |   49|    516|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 516]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1218|       |
 1219|    516|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1219:13): [True: 0, False: 516]
  ------------------
 1220|      0|        {
 1221|      0|            bytes_buffer_.clear();
 1222|      0|            source_.ignore(1);
 1223|      0|            iterate_string_chunks(bytes_buffer_, major_type, ec);
 1224|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1225|      0|            {
 1226|      0|                return byte_string_view();
 1227|      0|            }
 1228|      0|            return byte_string_view(bytes_buffer_.data(), bytes_buffer_.size());
 1229|      0|        }
 1230|       |
 1231|    516|        std::size_t length = read_size(ec);
 1232|    516|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    516|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 516]
  |  |  ------------------
  ------------------
 1233|      0|        {
 1234|      0|            return byte_string_view();
 1235|      0|        }
 1236|    516|        auto data = source_.read_span(length, bytes_buffer_);
 1237|    516|        if (data.size() != length)
  ------------------
  |  Branch (1237:13): [True: 3, False: 513]
  ------------------
 1238|      3|        {
 1239|      3|            ec = cbor_errc::unexpected_eof;
 1240|      3|            more_ = false;
 1241|      3|            return byte_string_view();
 1242|      3|        }
 1243|       |        
 1244|    513|        byte_string_view bytes(data.data(), data.size());
 1245|    513|        if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1245:13): [True: 0, False: 513]
  ------------------
 1246|      0|            bytes.size() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1246:13): [True: 0, False: 0]
  ------------------
 1247|      0|        {
 1248|      0|            stringref_map_stack_.back().emplace_back(mapped_string(bytes, alloc_));
 1249|      0|        }
 1250|    513|        return bytes;
 1251|    516|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_sizeERNS3_10error_codeE:
 1254|  2.08M|    {
 1255|  2.08M|        uint64_t u = read_uint64(ec);
 1256|  2.08M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.08M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.08M]
  |  |  ------------------
  ------------------
 1257|      0|        {
 1258|      0|            return 0;
 1259|      0|        }
 1260|  2.08M|        std::size_t len = static_cast<std::size_t>(u);
 1261|  2.08M|        if (len != u)
  ------------------
  |  Branch (1261:13): [True: 0, False: 2.08M]
  ------------------
 1262|      0|        {
 1263|      0|            ec = cbor_errc::number_too_large;
 1264|      0|            more_ = false;
 1265|      0|        }
 1266|  2.08M|        return len;
 1267|  2.08M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_sourceclINS3_6vectorIhS5_EEEEvRT_RNS3_10error_codeE:
  203|  1.43k|        {
  204|  1.43k|            source->read_byte_string(cont,ec);
  205|  1.43k|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringERNS3_6vectorIhS5_EERNS3_10error_codeE:
 1270|  1.43k|    {
 1271|  1.43k|        v.clear();
 1272|  1.43k|        auto c = source_.peek();
 1273|  1.43k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.43k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.43k]
  |  |  ------------------
  ------------------
 1274|      0|        {
 1275|      0|            ec = cbor_errc::unexpected_eof;
 1276|      0|            return;
 1277|      0|        }
 1278|  1.43k|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1279|  1.43k|        uint8_t info = get_additional_information_value(c.value);
 1280|       |
 1281|  1.43k|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::byte_string);
  ------------------
  |  |   49|  1.43k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 1.43k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1282|       |
 1283|  1.43k|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1283:13): [True: 0, False: 1.43k]
  ------------------
 1284|      0|        {
 1285|      0|            source_.ignore(1);
 1286|      0|            iterate_string_chunks(v, major_type, ec);
 1287|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1288|      0|            {
 1289|      0|                return;
 1290|      0|            }
 1291|      0|        }
 1292|  1.43k|        else 
 1293|  1.43k|        {
 1294|  1.43k|            std::size_t length = read_size(ec);
 1295|  1.43k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.43k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.43k]
  |  |  ------------------
  ------------------
 1296|      0|            {
 1297|      0|                return;
 1298|      0|            }
 1299|  1.43k|            if (source_reader<Source>::read(source_, v, length) != length)
  ------------------
  |  Branch (1299:17): [True: 0, False: 1.43k]
  ------------------
 1300|      0|            {
 1301|      0|                ec = cbor_errc::unexpected_eof;
 1302|      0|                return;
 1303|      0|            }
 1304|  1.43k|            if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1304:17): [True: 0, False: 1.43k]
  ------------------
 1305|      0|                v.size() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1305:17): [True: 0, False: 0]
  ------------------
 1306|      0|            {
 1307|      0|                stringref_map_stack_.back().emplace_back(mapped_string(v, alloc_));
 1308|      0|            }
 1309|  1.43k|        }
 1310|  1.43k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_text_string_viewERNS3_10error_codeE:
 1117|      3|    {
 1118|      3|        auto c = source_.peek();
 1119|      3|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
 1120|      0|        {
 1121|      0|            ec = cbor_errc::unexpected_eof;
 1122|      0|            more_ = false;
 1123|      0|            return string_view_type();
 1124|      0|        }
 1125|      3|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1126|      3|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::text_string);
  ------------------
  |  |   49|      3|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 3]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1127|      3|        uint8_t info = get_additional_information_value(c.value);
 1128|       |
 1129|      3|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1129:13): [True: 0, False: 3]
  ------------------
 1130|      0|        {
 1131|      0|            text_buffer_.clear();
 1132|      0|            source_.ignore(1);
 1133|      0|            iterate_string_chunks(text_buffer_, major_type, ec);
 1134|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1135|      0|            {
 1136|      0|                return string_view_type();
 1137|      0|            }
 1138|      0|            return string_view_type(text_buffer_.data(), text_buffer_.size());
 1139|      0|        }
 1140|       |
 1141|      3|        std::size_t length = read_size(ec);
 1142|      3|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
 1143|      0|        {
 1144|      0|            return string_view_type();
 1145|      0|        }
 1146|      3|        auto data = source_.read_span(length, text_buffer_);
 1147|      3|        if (data.size() != length)
  ------------------
  |  Branch (1147:13): [True: 1, False: 2]
  ------------------
 1148|      1|        {
 1149|      1|            ec = cbor_errc::unexpected_eof;
 1150|      1|            more_ = false;
 1151|      1|            return string_view_type();
 1152|      1|        }
 1153|      2|        string_view_type sv(reinterpret_cast<const char_type*>(data.data()), data.size());
 1154|      2|        if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1154:13): [True: 0, False: 2]
  ------------------
 1155|      0|            sv.length() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1155:13): [True: 0, False: 0]
  ------------------
 1156|      0|        {
 1157|      0|            stringref_map_stack_.back().emplace_back(mapped_string(sv,alloc_));
 1158|      0|        }
 1159|      2|        return sv;
 1160|      3|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_decimal_fractionERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 1580|     17|    {
 1581|     17|        std::size_t size = read_size(ec);
 1582|     17|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     17|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 17]
  |  |  ------------------
  ------------------
 1583|      0|        {
 1584|      0|            return;
 1585|      0|        }
 1586|     17|        if (size != 2)
  ------------------
  |  Branch (1586:13): [True: 0, False: 17]
  ------------------
 1587|      0|        {
 1588|      0|            ec = cbor_errc::invalid_decimal_fraction;
 1589|      0|            more_ = false;
 1590|      0|            return;
 1591|      0|        }
 1592|       |
 1593|     17|        auto c = source_.peek();
 1594|     17|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|     17|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 17]
  |  |  ------------------
  ------------------
 1595|      0|        {
 1596|      0|            ec = cbor_errc::unexpected_eof;
 1597|      0|            more_ = false;
 1598|      0|            return;
 1599|      0|        }
 1600|     17|        int64_t exponent = 0;
 1601|     17|        switch (get_major_type(c.value))
 1602|     17|        {
 1603|      8|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1603:13): [True: 8, False: 9]
  ------------------
 1604|      8|            {
 1605|      8|                exponent = read_uint64(ec);
 1606|      8|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 8]
  |  |  ------------------
  ------------------
 1607|      0|                {
 1608|      0|                    return;
 1609|      0|                }
 1610|      8|                break;
 1611|      8|            }
 1612|      9|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1612:13): [True: 9, False: 8]
  ------------------
 1613|      9|            {
 1614|      9|                exponent = read_int64(ec);
 1615|      9|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      9|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 9]
  |  |  ------------------
  ------------------
 1616|      0|                {
 1617|      0|                    return;
 1618|      0|                }
 1619|      9|                break;
 1620|      9|            }
 1621|      9|            default:
  ------------------
  |  Branch (1621:13): [True: 0, False: 17]
  ------------------
 1622|      0|            {
 1623|      0|                ec = cbor_errc::invalid_decimal_fraction;
 1624|      0|                more_ = false;
 1625|      0|                return;
 1626|      9|            }
 1627|     17|        }
 1628|       |
 1629|     17|        string_type str(alloc_);
 1630|       |
 1631|     17|        c = source_.peek();
 1632|     17|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|     17|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 17]
  |  |  ------------------
  ------------------
 1633|      0|        {
 1634|      0|            ec = cbor_errc::unexpected_eof;
 1635|      0|            more_ = false;
 1636|      0|            return;
 1637|      0|        }
 1638|       |
 1639|     17|        switch (get_major_type(c.value))
 1640|     17|        {
 1641|      9|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1641:13): [True: 9, False: 8]
  ------------------
 1642|      9|            {
 1643|      9|                uint64_t val = read_uint64(ec);
 1644|      9|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      9|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 9]
  |  |  ------------------
  ------------------
 1645|      0|                {
 1646|      0|                    return;
 1647|      0|                }
 1648|      9|                jsoncons::from_integer(val, str);
 1649|      9|                break;
 1650|      9|            }
 1651|      8|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1651:13): [True: 8, False: 9]
  ------------------
 1652|      8|            {
 1653|      8|                int64_t val = read_int64(ec);
 1654|      8|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 8]
  |  |  ------------------
  ------------------
 1655|      0|                {
 1656|      0|                    return;
 1657|      0|                }
 1658|      8|                jsoncons::from_integer(val, str);
 1659|      8|                break;
 1660|      8|            }
 1661|      0|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (1661:13): [True: 0, False: 17]
  ------------------
 1662|      0|            {
 1663|      0|                uint8_t b;
 1664|      0|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1664:21): [True: 0, False: 0]
  ------------------
 1665|      0|                {
 1666|      0|                    ec = cbor_errc::unexpected_eof;
 1667|      0|                    more_ = false;
 1668|      0|                    return;
 1669|      0|                }
 1670|      0|                uint8_t tag = get_additional_information_value(b);
 1671|      0|                c = source_.peek();
 1672|      0|                if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1673|      0|                {
 1674|      0|                    ec = cbor_errc::unexpected_eof;
 1675|      0|                    more_ = false;
 1676|      0|                    return;
 1677|      0|                }
 1678|       |
 1679|      0|                if (get_major_type(c.value) == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (1679:21): [True: 0, False: 0]
  ------------------
 1680|      0|                {
 1681|      0|                    bytes_buffer_.clear();
 1682|      0|                    read_byte_string(bytes_buffer_, ec);
 1683|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1684|      0|                    {
 1685|      0|                        more_ = false;
 1686|      0|                        return;
 1687|      0|                    }
 1688|      0|                    if (tag == 2)
  ------------------
  |  Branch (1688:25): [True: 0, False: 0]
  ------------------
 1689|      0|                    {
 1690|      0|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1691|      0|                        n.write_string(str);
 1692|      0|                    }
 1693|      0|                    else if (tag == 3)
  ------------------
  |  Branch (1693:30): [True: 0, False: 0]
  ------------------
 1694|      0|                    {
 1695|      0|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1696|      0|                        n = -1 - n;
 1697|      0|                        n.write_string(str);
 1698|      0|                    }
 1699|      0|                }
 1700|      0|                break;
 1701|      0|            }
 1702|      0|            default:
  ------------------
  |  Branch (1702:13): [True: 0, False: 17]
  ------------------
 1703|      0|            {
 1704|      0|                ec = cbor_errc::invalid_decimal_fraction;
 1705|      0|                more_ = false;
 1706|      0|                return;
 1707|      0|            }
 1708|     17|        }
 1709|       |
 1710|     17|        if (str.size() >= static_cast<std::size_t>((std::numeric_limits<int32_t>::max)()) || 
  ------------------
  |  Branch (1710:13): [True: 0, False: 17]
  ------------------
 1711|     17|            exponent >= (std::numeric_limits<int32_t>::max)() || 
  ------------------
  |  Branch (1711:13): [True: 0, False: 17]
  ------------------
 1712|     17|            exponent <= (std::numeric_limits<int32_t>::min)())
  ------------------
  |  Branch (1712:13): [True: 0, False: 17]
  ------------------
 1713|      0|        {
 1714|      0|            ec = cbor_errc::invalid_decimal_fraction;
 1715|      0|            more_ = false;
 1716|      0|            return;
 1717|      0|        }
 1718|     17|        else if (str.size() > 0)
  ------------------
  |  Branch (1718:18): [True: 17, False: 0]
  ------------------
 1719|     17|        {
 1720|     17|            if (str[0] == '-')
  ------------------
  |  Branch (1720:17): [True: 8, False: 9]
  ------------------
 1721|      8|            {
 1722|      8|                result.push_back('-');
 1723|      8|                jsoncons::prettify_string(str.c_str()+1, str.size()-1, (int)exponent, -4, 17, result);
 1724|      8|            }
 1725|      9|            else
 1726|      9|            {
 1727|      9|                jsoncons::prettify_string(str.c_str(), str.size(), (int)exponent, -4, 17, result);
 1728|      9|            }
 1729|     17|        }
 1730|      0|        else
 1731|      0|        {
 1732|      0|            ec = cbor_errc::invalid_decimal_fraction;
 1733|      0|            more_ = false;
 1734|      0|            return;
 1735|      0|        }
 1736|     17|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13read_bigfloatERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 1739|      5|    {
 1740|      5|        std::size_t size = read_size(ec);
 1741|      5|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
 1742|      0|        {
 1743|      0|            return;
 1744|      0|        }
 1745|      5|        if (size != 2)
  ------------------
  |  Branch (1745:13): [True: 0, False: 5]
  ------------------
 1746|      0|        {
 1747|      0|            ec = cbor_errc::invalid_bigfloat;
 1748|      0|            more_ = false;
 1749|      0|            return;
 1750|      0|        }
 1751|       |
 1752|      5|        auto c = source_.peek();
 1753|      5|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
 1754|      0|        {
 1755|      0|            ec = cbor_errc::unexpected_eof;
 1756|      0|            more_ = false;
 1757|      0|            return;
 1758|      0|        }
 1759|      5|        int64_t exponent = 0;
 1760|      5|        switch (get_major_type(c.value))
 1761|      5|        {
 1762|      4|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1762:13): [True: 4, False: 1]
  ------------------
 1763|      4|            {
 1764|      4|                exponent = read_uint64(ec);
 1765|      4|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 1766|      0|                {
 1767|      0|                    return;
 1768|      0|                }
 1769|      4|                break;
 1770|      4|            }
 1771|      4|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1771:13): [True: 1, False: 4]
  ------------------
 1772|      1|            {
 1773|      1|                exponent = read_int64(ec);
 1774|      1|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1775|      0|                {
 1776|      0|                    return;
 1777|      0|                }
 1778|      1|                break;
 1779|      1|            }
 1780|      1|            default:
  ------------------
  |  Branch (1780:13): [True: 0, False: 5]
  ------------------
 1781|      0|            {
 1782|      0|                ec = cbor_errc::invalid_bigfloat;
 1783|      0|                more_ = false;
 1784|      0|                return;
 1785|      1|            }
 1786|      5|        }
 1787|       |
 1788|      5|        c = source_.peek();
 1789|      5|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
 1790|      0|        {
 1791|      0|            ec = cbor_errc::unexpected_eof;
 1792|      0|            more_ = false;
 1793|      0|            return;
 1794|      0|        }
 1795|      5|        switch (get_major_type(c.value))
 1796|      5|        {
 1797|      2|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1797:13): [True: 2, False: 3]
  ------------------
 1798|      2|            {
 1799|      2|                uint64_t val = read_uint64(ec);
 1800|      2|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 1801|      0|                {
 1802|      0|                    return;
 1803|      0|                }
 1804|      2|                str.push_back('0');
 1805|      2|                str.push_back('x');
 1806|      2|                jsoncons::integer_to_hex(val, str);
 1807|      2|                break;
 1808|      2|            }
 1809|      3|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1809:13): [True: 3, False: 2]
  ------------------
 1810|      3|            {
 1811|      3|                int64_t val = read_int64(ec);
 1812|      3|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
 1813|      0|                {
 1814|      0|                    return;
 1815|      0|                }
 1816|      3|                str.push_back('-');
 1817|      3|                str.push_back('0');
 1818|      3|                str.push_back('x');
 1819|      3|                jsoncons::integer_to_hex(static_cast<uint64_t>(-val), str);
 1820|      3|                break;
 1821|      3|            }
 1822|      0|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (1822:13): [True: 0, False: 5]
  ------------------
 1823|      0|            {
 1824|      0|                uint8_t b;
 1825|      0|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1825:21): [True: 0, False: 0]
  ------------------
 1826|      0|                {
 1827|      0|                    ec = cbor_errc::unexpected_eof;
 1828|      0|                    more_ = false;
 1829|      0|                    return;
 1830|      0|                }
 1831|      0|                uint8_t tag = get_additional_information_value(b);
 1832|       |
 1833|      0|                c = source_.peek();
 1834|      0|                if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1835|      0|                {
 1836|      0|                    ec = cbor_errc::unexpected_eof;
 1837|      0|                    more_ = false;
 1838|      0|                    return;
 1839|      0|                }
 1840|       |
 1841|      0|                if (get_major_type(c.value) == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (1841:21): [True: 0, False: 0]
  ------------------
 1842|      0|                {
 1843|      0|                    bytes_buffer_.clear(); 
 1844|      0|                    read_byte_string(bytes_buffer_, ec);
 1845|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1846|      0|                    {
 1847|      0|                        more_ = false;
 1848|      0|                        return;
 1849|      0|                    }
 1850|      0|                    if (tag == 2)
  ------------------
  |  Branch (1850:25): [True: 0, False: 0]
  ------------------
 1851|      0|                    {
 1852|      0|                        str.push_back('0');
 1853|      0|                        str.push_back('x');
 1854|      0|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1855|      0|                        n.write_string_hex(str);
 1856|      0|                    }
 1857|      0|                    else if (tag == 3)
  ------------------
  |  Branch (1857:30): [True: 0, False: 0]
  ------------------
 1858|      0|                    {
 1859|      0|                        str.push_back('-');
 1860|      0|                        str.push_back('0');
 1861|      0|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1862|      0|                        n = -1 - n;
 1863|      0|                        n.write_string_hex(str);
 1864|      0|                        str[2] = 'x'; // overwrite minus
 1865|      0|                    }
 1866|      0|                }
 1867|      0|                break;
 1868|      0|            }
 1869|      0|            default:
  ------------------
  |  Branch (1869:13): [True: 0, False: 5]
  ------------------
 1870|      0|            {
 1871|      0|                ec = cbor_errc::invalid_bigfloat;
 1872|      0|                more_ = false;
 1873|      0|                return;
 1874|      0|            }
 1875|      5|        }
 1876|       |
 1877|      5|        str.push_back('p');
 1878|      5|        if (exponent >=0)
  ------------------
  |  Branch (1878:13): [True: 4, False: 1]
  ------------------
 1879|      4|        {
 1880|      4|            jsoncons::integer_to_hex(static_cast<uint64_t>(exponent), str);
 1881|      4|        }
 1882|      1|        else
 1883|      1|        {
 1884|      1|            str.push_back('-');
 1885|      1|            jsoncons::integer_to_hex(static_cast<uint64_t>(-exponent), str);
 1886|      1|        }
 1887|      5|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE19read_mdarray_headerERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 2579|     17|    {
 2580|     17|        uint8_t b;
 2581|     17|        if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (2581:13): [True: 0, False: 17]
  ------------------
 2582|      0|        {
 2583|      0|            ec = cbor_errc::unexpected_eof;
 2584|      0|            more_ = false;
 2585|      0|            return;
 2586|      0|        }
 2587|     17|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(b);
 2588|     17|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::array);
  ------------------
  |  |   49|     17|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 17]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 2589|     17|        uint8_t info = get_additional_information_value(b);
 2590|       |       
 2591|     17|        read_extents(ec);   
 2592|     17|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     17|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 15]
  |  |  ------------------
  ------------------
 2593|      2|        {
 2594|      2|            return;
 2595|      2|        }
 2596|       |
 2597|     15|        read_tags(ec);
 2598|     15|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     15|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 15]
  |  |  ------------------
  ------------------
 2599|      0|        {
 2600|      0|            return;
 2601|      0|        }
 2602|     15|        auto c = source_.peek();
 2603|     15|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|     15|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 15]
  |  |  ------------------
  ------------------
 2604|      0|        {
 2605|      0|            ec = cbor_errc::unexpected_eof;
 2606|      0|            more_ = false;
 2607|      0|            return;
 2608|      0|        }
 2609|     15|        major_type = get_major_type(c.value);
 2610|     15|        info = get_additional_information_value(c.value);
 2611|     15|        state_stack_.emplace_back(parse_mode::multi_dim, 0);
 2612|     15|        ++state_stack_.back().index;
 2613|       |
 2614|     15|        if (major_type == jsoncons::cbor::detail::cbor_major_type::array && order_ == mdarray_order::row_major) 
  ------------------
  |  Branch (2614:13): [True: 0, False: 15]
  |  Branch (2614:77): [True: 0, False: 0]
  ------------------
 2615|      0|        {
 2616|      0|            begin_classical_array_storage(info, ec);
 2617|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2618|      0|            {
 2619|      0|                return;
 2620|      0|            }
 2621|      0|            auto iter = std::make_shared<cbor_mdarray_row_major_iterator<Source,Allocator>>(extents_, this, cursor_mode_);
 2622|      0|            typed_array_stack_.push_back(iter);
 2623|      0|            if (!iter->done())
  ------------------
  |  Branch (2623:17): [True: 0, False: 0]
  ------------------
 2624|      0|            {
 2625|      0|                iter->next(visitor, *this, ec);
 2626|      0|            }
 2627|      0|        }
 2628|     15|        else if (major_type == jsoncons::cbor::detail::cbor_major_type::array && order_ == mdarray_order::column_major) 
  ------------------
  |  Branch (2628:18): [True: 0, False: 15]
  |  Branch (2628:82): [True: 0, False: 0]
  ------------------
 2629|      0|        {
 2630|      0|            begin_classical_array_storage(info, ec);
 2631|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2632|      0|            {
 2633|      0|                return;
 2634|      0|            }
 2635|      0|            auto iter = std::make_shared<cbor_mdarray_column_major_iterator<Source,Allocator>>(extents_, this, cursor_mode_);
 2636|      0|            typed_array_stack_.push_back(iter);
 2637|      0|            if (!iter->done())
  ------------------
  |  Branch (2637:17): [True: 0, False: 0]
  ------------------
 2638|      0|            {
 2639|      0|                iter->next(visitor, *this, ec);
 2640|      0|            }
 2641|      0|        }
 2642|     15|        else if (major_type == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (2642:18): [True: 15, False: 0]
  ------------------
 2643|     15|        {
 2644|     15|            read_byte_string_from_source read(this);
 2645|     15|            read_byte_string(read, visitor, ec);
 2646|     15|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     15|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 15]
  |  |  ------------------
  ------------------
 2647|      0|            {
 2648|      0|                return;
 2649|      0|            }
 2650|     15|        }
 2651|      0|        else
 2652|      0|        {
 2653|      0|            ec = cbor_errc::bad_mdarray;
 2654|      0|            return;
 2655|      0|        }
 2656|       |        // cursor case
 2657|     15|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12read_extentsERNS3_10error_codeE:
 2660|     17|    {
 2661|     17|        extents_.clear();
 2662|       |
 2663|     17|        auto b = source_.peek();
 2664|     17|        if (JSONCONS_UNLIKELY(b.eof))
  ------------------
  |  |   78|     17|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 17]
  |  |  ------------------
  ------------------
 2665|      0|        {
 2666|      0|            ec = cbor_errc::unexpected_eof;
 2667|      0|            more_ = false;
 2668|      0|            return;
 2669|      0|        }
 2670|     17|        uint8_t info = get_additional_information_value(b.value);
 2671|       |
 2672|     17|        switch (info)
 2673|     17|        {
 2674|     17|            case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (2674:13): [True: 17, False: 0]
  ------------------
 2675|     17|            {
 2676|  2.08M|                while (true)
  ------------------
  |  Branch (2676:24): [True: 2.08M, Folded]
  ------------------
 2677|  2.08M|                {
 2678|  2.08M|                    auto c = source_.peek();
 2679|  2.08M|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  2.08M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 2.08M]
  |  |  ------------------
  ------------------
 2680|      2|                    {
 2681|      2|                        ec = cbor_errc::unexpected_eof;
 2682|      2|                        more_ = false;
 2683|      2|                        return;
 2684|      2|                    }
 2685|  2.08M|                    if (c.value == 0xff)
  ------------------
  |  Branch (2685:25): [True: 15, False: 2.08M]
  ------------------
 2686|     15|                    {
 2687|     15|                        source_.ignore(1);
 2688|     15|                        return;
 2689|     15|                    }
 2690|  2.08M|                    else
 2691|  2.08M|                    {
 2692|  2.08M|                        std::size_t extent = read_size(ec);
 2693|  2.08M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.08M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.08M]
  |  |  ------------------
  ------------------
 2694|      0|                        {
 2695|      0|                            more_ = false;
 2696|      0|                            return;
 2697|      0|                        }
 2698|  2.08M|                        extents_.push_back(extent);
 2699|  2.08M|                    }
 2700|  2.08M|                }
 2701|      0|                break;
 2702|     17|            }
 2703|      0|            default:
  ------------------
  |  Branch (2703:13): [True: 0, False: 17]
  ------------------
 2704|      0|            {
 2705|      0|                std::size_t size = read_size(ec);
 2706|      0|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2707|      0|                {
 2708|      0|                    more_ = false;
 2709|      0|                    return;
 2710|      0|                }
 2711|      0|                for (std::size_t i = 0; more_ && i < size; ++i)
  ------------------
  |  Branch (2711:41): [True: 0, False: 0]
  |  Branch (2711:50): [True: 0, False: 0]
  ------------------
 2712|      0|                {
 2713|      0|                    std::size_t extent = read_size(ec);
 2714|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2715|      0|                    {
 2716|      0|                        more_ = false;
 2717|      0|                        return;
 2718|      0|                    }
 2719|      0|                    extents_.push_back(extent);
 2720|      0|                }
 2721|      0|                break;
 2722|      0|            }
 2723|     17|        }
 2724|      0|        auto r = calculate_mdarray_size(extents_);
 2725|      0|        if (!r || *r == 0)
  ------------------
  |  Branch (2725:13): [True: 0, False: 0]
  |  Branch (2725:19): [True: 0, False: 0]
  ------------------
 2726|      0|        {
 2727|      0|            ec = cbor_errc::bad_extents;
 2728|      0|            more_ = false;
 2729|      0|            return;
 2730|      0|        }
 2731|      0|        mdarray_size_ = *r;
 2732|      0|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayERNS_21basic_generic_visitorIcEEhRNS3_10error_codeE:
  925|    234|    {
  926|    234|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|    234|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 234]
  |  |  ------------------
  ------------------
  927|      0|        {
  928|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  929|      0|            more_ = false;
  930|      0|            return;
  931|      0|        } 
  932|    234|        semantic_tag tag = semantic_tag::none;
  933|    234|        bool pop_stringref_map_stack = false;
  934|    234|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (934:13): [True: 0, False: 234]
  ------------------
  935|      0|        {
  936|      0|            stringref_map_stack_.emplace_back();
  937|      0|            other_tags_[stringref_namespace_tag] = false;
  938|      0|            pop_stringref_map_stack = true;
  939|      0|        }
  940|    234|        switch (info)
  941|    234|        {
  942|      3|            case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (942:13): [True: 3, False: 231]
  ------------------
  943|      3|            {
  944|      3|                state_stack_.emplace_back(parse_mode::indefinite_array,0,pop_stringref_map_stack);
  945|      3|                visitor.begin_array(tag, *this, ec);
  946|      3|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
  947|      0|                {
  948|      0|                    return;
  949|      0|                }
  950|      3|                more_ = !cursor_mode_;
  951|      3|                source_.ignore(1);
  952|      3|                break;
  953|      3|            }
  954|    231|            default: // definite length
  ------------------
  |  Branch (954:13): [True: 231, False: 3]
  ------------------
  955|    231|            {
  956|    231|                std::size_t len = read_size(ec);
  957|    231|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    231|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 231]
  |  |  ------------------
  ------------------
  958|      0|                {
  959|      0|                    return;
  960|      0|                }
  961|    231|                state_stack_.emplace_back(parse_mode::array,len,pop_stringref_map_stack);
  962|    231|                visitor.begin_array(len, tag, *this, ec);
  963|    231|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    231|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 231]
  |  |  ------------------
  ------------------
  964|      0|                {
  965|      0|                    return;
  966|      0|                }
  967|    231|                more_ = !cursor_mode_;
  968|    231|                break;
  969|    231|            }
  970|    234|        }
  971|    234|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12begin_objectERNS_21basic_generic_visitorIcEEhRNS3_10error_codeE:
 1049|     75|    {
 1050|     75|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|     75|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 75]
  |  |  ------------------
  ------------------
 1051|      0|        {
 1052|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
 1053|      0|            more_ = false;
 1054|      0|            return;
 1055|      0|        } 
 1056|     75|        bool pop_stringref_map_stack = false;
 1057|     75|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (1057:13): [True: 0, False: 75]
  ------------------
 1058|      0|        {
 1059|      0|            stringref_map_stack_.emplace_back();
 1060|      0|            other_tags_[stringref_namespace_tag] = false;
 1061|      0|            pop_stringref_map_stack = true;
 1062|      0|        }
 1063|     75|        switch (info)
 1064|     75|        {
 1065|      4|            case jsoncons::cbor::detail::additional_info::indefinite_length: 
  ------------------
  |  Branch (1065:13): [True: 4, False: 71]
  ------------------
 1066|      4|            {
 1067|      4|                state_stack_.emplace_back(parse_mode::indefinite_map_key,0,pop_stringref_map_stack);
 1068|      4|                visitor.begin_object(semantic_tag::none, *this, ec);
 1069|      4|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 1070|      0|                {
 1071|      0|                    return;
 1072|      0|                }
 1073|      4|                more_ = !cursor_mode_;
 1074|      4|                source_.ignore(1);
 1075|      4|                break;
 1076|      4|            }
 1077|     71|            default: // definite_length
  ------------------
  |  Branch (1077:13): [True: 71, False: 4]
  ------------------
 1078|     71|            {
 1079|     71|                std::size_t len = read_size(ec);
 1080|     71|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     71|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 71]
  |  |  ------------------
  ------------------
 1081|      0|                {
 1082|      0|                    return;
 1083|      0|                }
 1084|     71|                state_stack_.emplace_back(parse_mode::map_key,len,pop_stringref_map_stack);
 1085|     71|                visitor.begin_object(len, semantic_tag::none, *this, ec);
 1086|     71|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     71|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 71]
  |  |  ------------------
  ------------------
 1087|      0|                {
 1088|      0|                    return;
 1089|      0|                }
 1090|     71|                more_ = !cursor_mode_;
 1091|     71|                break;
 1092|     71|            }
 1093|     75|        }
 1094|     75|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9end_arrayERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  974|    220|    {
  975|    220|        --nesting_depth_;
  976|       |
  977|    220|        visitor.end_array(*this, ec);
  978|    220|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    220|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 220]
  |  |  ------------------
  ------------------
  979|      0|        {
  980|      0|            return;
  981|      0|        }
  982|    220|        more_ = !cursor_mode_;
  983|    220|        if (level() == mark_level_)
  ------------------
  |  Branch (983:13): [True: 0, False: 220]
  ------------------
  984|      0|        {
  985|      0|            more_ = false;
  986|      0|        }
  987|    220|        if (state_stack_.back().pop_stringref_map_stack)
  ------------------
  |  Branch (987:13): [True: 0, False: 220]
  ------------------
  988|      0|        {
  989|      0|            stringref_map_stack_.pop_back();
  990|      0|        }
  991|    220|        state_stack_.pop_back();
  992|    220|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10end_objectERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 1097|     55|    {
 1098|     55|        --nesting_depth_;
 1099|     55|        visitor.end_object(*this, ec);
 1100|     55|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     55|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 55]
  |  |  ------------------
  ------------------
 1101|      0|        {
 1102|      0|            return;
 1103|      0|        }
 1104|     55|        more_ = !cursor_mode_;
 1105|     55|        if (level() == mark_level_)
  ------------------
  |  Branch (1105:13): [True: 0, False: 55]
  ------------------
 1106|      0|        {
 1107|      0|            more_ = false;
 1108|      0|        }
 1109|     55|        if (state_stack_.back().pop_stringref_map_stack)
  ------------------
  |  Branch (1109:13): [True: 0, False: 55]
  ------------------
 1110|      0|        {
 1111|      0|            stringref_map_stack_.pop_back();
 1112|      0|        }
 1113|     55|        state_stack_.pop_back();
 1114|     55|    }

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

_ZN8jsoncons4cbor20typed_array_iteratorD2Ev:
   43|  1.43k|    virtual ~typed_array_iterator() = default;
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIhEENSt3__19enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   72|     52|    {
   73|     52|        visitor.uint64_value(val, tag, context, ec);
   74|     52|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagES2_:
  105|      8|        : data_(std::move(data)), 
  106|      8|          span_(typed_array_cast<ValueType>(data_)), 
  107|      8|          array_tag_(array_tag), 
  108|      8|          extent_(span_.size()), 
  109|      8|          tag_(tag), 
  110|      8|          func_(func)
  111|      8|    {
  112|      8|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEE4doneEv:
  140|    120|    {
  141|    120|        return done_;
  142|    120|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  146|     68|    {
  147|     68|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|     68|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 8, False: 60]
  |  |  ------------------
  ------------------
  148|      8|        {
  149|      8|            visitor.begin_array(span_.size(), tag_, context, ec);
  150|      8|            first_ = false;
  151|      8|        }
  152|     60|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|     60|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 52, False: 8]
  |  |  ------------------
  ------------------
  153|     52|        {
  154|     52|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  155|     52|            ++index_;
  156|     52|        }
  157|      8|        else if (!done_)
  ------------------
  |  Branch (157:18): [True: 8, False: 0]
  ------------------
  158|      8|        {
  159|      8|            visitor.end_array(context, ec);
  160|      8|            done_ = true;
  161|      8|        }
  162|     68|    }
_ZN8jsoncons4cbor16mdarray_iteratorItNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsERKNS7_ImNS4_ImEEEENS_13mdarray_orderES2_:
  195|     10|        : data_(std::move(data)), 
  196|     10|          span_(typed_array_cast<ValueType>(data_)), 
  197|     10|          array_tag_(array_tag), extents_(extents), order_(order), func_(func), dimensions_(extents.size(), mdarray_dimension{})
  198|     10|    {
  199|     10|        std::vector<std::size_t> strides(extents.size(), 0);
  200|     10|        if (order == mdarray_order::column_major)
  ------------------
  |  Branch (200:13): [True: 0, False: 10]
  ------------------
  201|      0|        {
  202|      0|            std::size_t stride = 1;
  203|      0|            const size_t num_extents = extents.size();
  204|      0|            for (size_t i = 0; i < num_extents; ++i)
  ------------------
  |  Branch (204:32): [True: 0, False: 0]
  ------------------
  205|      0|            {
  206|      0|                strides[i] = stride;
  207|      0|                stride *= extents[i];
  208|      0|            }
  209|      0|        }
  210|     10|        else
  211|     10|        {
  212|     10|            std::size_t stride = 1;
  213|     10|            const size_t num_extents = extents.size();
  214|   540k|            for (size_t i = 0; i < num_extents; ++i)
  ------------------
  |  Branch (214:32): [True: 540k, False: 10]
  ------------------
  215|   540k|            {
  216|   540k|                strides[num_extents-i-1] = stride;
  217|   540k|                stride *= extents[num_extents-i-1];
  218|   540k|            }
  219|     10|        }
  220|   540k|        for (std::size_t i = 0; i < strides.size(); ++i)
  ------------------
  |  Branch (220:33): [True: 540k, False: 10]
  ------------------
  221|   540k|        {
  222|   540k|            dimensions_[i].extent = extents[i];
  223|   540k|            dimensions_[i].stride = strides[i];
  224|   540k|            dimensions_[i].index = 0;
  225|   540k|            dimensions_[i].end = strides[i]*extents[i];
  226|   540k|        }
  227|     10|    }
_ZNK8jsoncons4cbor16mdarray_iteratorItNS_8identityENSt3__19allocatorIcEEE4doneEv:
  255|     20|    {
  256|     20|        return done_;
  257|     20|    }
_ZN8jsoncons4cbor16mdarray_iteratorItNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  261|     20|    {
  262|     20|        JSONCONS_ASSERT(!dimensions_.empty());
  ------------------
  |  |   49|     20|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 20]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  263|       |
  264|     20|        if (dim_ == 0)
  ------------------
  |  Branch (264:13): [True: 20, False: 0]
  ------------------
  265|     20|        {
  266|     20|            if (first_)
  ------------------
  |  Branch (266:17): [True: 10, False: 10]
  ------------------
  267|     10|            {
  268|     10|                visitor.begin_array(dimensions_[dim_].extent, tag_, context, ec);
  269|     10|                first_ = false;
  270|     10|                return;
  271|     10|            }
  272|     10|            if (dimensions_[dim_].index == dimensions_[dim_].end)
  ------------------
  |  Branch (272:17): [True: 10, False: 0]
  ------------------
  273|     10|            {
  274|     10|                visitor.end_array(context, ec);
  275|     10|                done_ = true;
  276|     10|                return;
  277|     10|            }
  278|     10|        }
  279|      0|        if (dim_+1 < dimensions_.size() && dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (279:13): [True: 0, False: 0]
  |  Branch (279:44): [True: 0, False: 0]
  ------------------
  280|      0|        {
  281|      0|            visitor.begin_array(dimensions_[dim_].extent, semantic_tag::none, context, ec);
  282|      0|            ++dim_;
  283|      0|            return;
  284|      0|        }
  285|      0|        if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (285:13): [True: 0, False: 0]
  ------------------
  286|      0|        {
  287|      0|            this->write_value(func_(span_[dimensions_[dim_].index]), semantic_tag::none, visitor, context, ec);
  288|      0|            dimensions_[dim_].index += dimensions_[dim_].stride;
  289|      0|            ++count_;
  290|      0|            return;
  291|      0|        }
  292|      0|        if (dimensions_[dim_].index + dimensions_[dim_].stride >= dimensions_[dim_].end)
  ------------------
  |  Branch (292:13): [True: 0, False: 0]
  ------------------
  293|      0|        {
  294|      0|            visitor.end_array(context, ec);
  295|      0|            if (dim_ > 0)
  ------------------
  |  Branch (295:17): [True: 0, False: 0]
  ------------------
  296|      0|            {
  297|      0|                --dim_;
  298|      0|                dimensions_[dim_].index += dimensions_[dim_].stride;
  299|      0|                if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (299:21): [True: 0, False: 0]
  ------------------
  300|      0|                {
  301|      0|                    for (std::size_t i = dim_+1; i < dimensions_.size(); ++i)
  ------------------
  |  Branch (301:50): [True: 0, False: 0]
  ------------------
  302|      0|                    {
  303|      0|                        dimensions_[i].index = dimensions_[i-1].index;
  304|      0|                        dimensions_[i].end = dimensions_[i].index + dimensions_[i].stride*dimensions_[i].extent;
  305|      0|                    }
  306|      0|                }
  307|      0|            }
  308|      0|        }
  309|      0|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagES2_:
  105|     12|        : data_(std::move(data)), 
  106|     12|          span_(typed_array_cast<ValueType>(data_)), 
  107|     12|          array_tag_(array_tag), 
  108|     12|          extent_(span_.size()), 
  109|     12|          tag_(tag), 
  110|     12|          func_(func)
  111|     12|    {
  112|     12|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEE4doneEv:
  140|     24|    {
  141|     24|        return done_;
  142|     24|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  146|     24|    {
  147|     24|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|     24|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 12, False: 12]
  |  |  ------------------
  ------------------
  148|     12|        {
  149|     12|            visitor.begin_array(span_.size(), tag_, context, ec);
  150|     12|            first_ = false;
  151|     12|        }
  152|     12|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|     12|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 0, False: 12]
  |  |  ------------------
  ------------------
  153|      0|        {
  154|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  155|      0|            ++index_;
  156|      0|        }
  157|     12|        else if (!done_)
  ------------------
  |  Branch (157:18): [True: 12, False: 0]
  ------------------
  158|     12|        {
  159|     12|            visitor.end_array(context, ec);
  160|     12|            done_ = true;
  161|     12|        }
  162|     24|    }
_ZN8jsoncons4cbor16mdarray_iteratorImNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsERKNS7_ImNS4_ImEEEENS_13mdarray_orderES2_:
  195|      2|        : data_(std::move(data)), 
  196|      2|          span_(typed_array_cast<ValueType>(data_)), 
  197|      2|          array_tag_(array_tag), extents_(extents), order_(order), func_(func), dimensions_(extents.size(), mdarray_dimension{})
  198|      2|    {
  199|      2|        std::vector<std::size_t> strides(extents.size(), 0);
  200|      2|        if (order == mdarray_order::column_major)
  ------------------
  |  Branch (200:13): [True: 0, False: 2]
  ------------------
  201|      0|        {
  202|      0|            std::size_t stride = 1;
  203|      0|            const size_t num_extents = extents.size();
  204|      0|            for (size_t i = 0; i < num_extents; ++i)
  ------------------
  |  Branch (204:32): [True: 0, False: 0]
  ------------------
  205|      0|            {
  206|      0|                strides[i] = stride;
  207|      0|                stride *= extents[i];
  208|      0|            }
  209|      0|        }
  210|      2|        else
  211|      2|        {
  212|      2|            std::size_t stride = 1;
  213|      2|            const size_t num_extents = extents.size();
  214|    624|            for (size_t i = 0; i < num_extents; ++i)
  ------------------
  |  Branch (214:32): [True: 622, False: 2]
  ------------------
  215|    622|            {
  216|    622|                strides[num_extents-i-1] = stride;
  217|    622|                stride *= extents[num_extents-i-1];
  218|    622|            }
  219|      2|        }
  220|    624|        for (std::size_t i = 0; i < strides.size(); ++i)
  ------------------
  |  Branch (220:33): [True: 622, False: 2]
  ------------------
  221|    622|        {
  222|    622|            dimensions_[i].extent = extents[i];
  223|    622|            dimensions_[i].stride = strides[i];
  224|    622|            dimensions_[i].index = 0;
  225|    622|            dimensions_[i].end = strides[i]*extents[i];
  226|    622|        }
  227|      2|    }
_ZNK8jsoncons4cbor16mdarray_iteratorImNS_8identityENSt3__19allocatorIcEEE4doneEv:
  255|      4|    {
  256|      4|        return done_;
  257|      4|    }
_ZN8jsoncons4cbor16mdarray_iteratorImNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  261|      4|    {
  262|      4|        JSONCONS_ASSERT(!dimensions_.empty());
  ------------------
  |  |   49|      4|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 4]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  263|       |
  264|      4|        if (dim_ == 0)
  ------------------
  |  Branch (264:13): [True: 4, False: 0]
  ------------------
  265|      4|        {
  266|      4|            if (first_)
  ------------------
  |  Branch (266:17): [True: 2, False: 2]
  ------------------
  267|      2|            {
  268|      2|                visitor.begin_array(dimensions_[dim_].extent, tag_, context, ec);
  269|      2|                first_ = false;
  270|      2|                return;
  271|      2|            }
  272|      2|            if (dimensions_[dim_].index == dimensions_[dim_].end)
  ------------------
  |  Branch (272:17): [True: 2, False: 0]
  ------------------
  273|      2|            {
  274|      2|                visitor.end_array(context, ec);
  275|      2|                done_ = true;
  276|      2|                return;
  277|      2|            }
  278|      2|        }
  279|      0|        if (dim_+1 < dimensions_.size() && dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (279:13): [True: 0, False: 0]
  |  Branch (279:44): [True: 0, False: 0]
  ------------------
  280|      0|        {
  281|      0|            visitor.begin_array(dimensions_[dim_].extent, semantic_tag::none, context, ec);
  282|      0|            ++dim_;
  283|      0|            return;
  284|      0|        }
  285|      0|        if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (285:13): [True: 0, False: 0]
  ------------------
  286|      0|        {
  287|      0|            this->write_value(func_(span_[dimensions_[dim_].index]), semantic_tag::none, visitor, context, ec);
  288|      0|            dimensions_[dim_].index += dimensions_[dim_].stride;
  289|      0|            ++count_;
  290|      0|            return;
  291|      0|        }
  292|      0|        if (dimensions_[dim_].index + dimensions_[dim_].stride >= dimensions_[dim_].end)
  ------------------
  |  Branch (292:13): [True: 0, False: 0]
  ------------------
  293|      0|        {
  294|      0|            visitor.end_array(context, ec);
  295|      0|            if (dim_ > 0)
  ------------------
  |  Branch (295:17): [True: 0, False: 0]
  ------------------
  296|      0|            {
  297|      0|                --dim_;
  298|      0|                dimensions_[dim_].index += dimensions_[dim_].stride;
  299|      0|                if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (299:21): [True: 0, False: 0]
  ------------------
  300|      0|                {
  301|      0|                    for (std::size_t i = dim_+1; i < dimensions_.size(); ++i)
  ------------------
  |  Branch (301:50): [True: 0, False: 0]
  ------------------
  302|      0|                    {
  303|      0|                        dimensions_[i].index = dimensions_[i-1].index;
  304|      0|                        dimensions_[i].end = dimensions_[i].index + dimensions_[i].stride*dimensions_[i].extent;
  305|      0|                    }
  306|      0|                }
  307|      0|            }
  308|      0|        }
  309|      0|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueImEENSt3__19enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   72|      2|    {
   73|      2|        visitor.uint64_value(val, tag, context, ec);
   74|      2|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagES2_:
  105|      7|        : data_(std::move(data)), 
  106|      7|          span_(typed_array_cast<ValueType>(data_)), 
  107|      7|          array_tag_(array_tag), 
  108|      7|          extent_(span_.size()), 
  109|      7|          tag_(tag), 
  110|      7|          func_(func)
  111|      7|    {
  112|      7|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEE4doneEv:
  140|     18|    {
  141|     18|        return done_;
  142|     18|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  146|     16|    {
  147|     16|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|     16|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 9]
  |  |  ------------------
  ------------------
  148|      7|        {
  149|      7|            visitor.begin_array(span_.size(), tag_, context, ec);
  150|      7|            first_ = false;
  151|      7|        }
  152|      9|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|      9|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 2, False: 7]
  |  |  ------------------
  ------------------
  153|      2|        {
  154|      2|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  155|      2|            ++index_;
  156|      2|        }
  157|      7|        else if (!done_)
  ------------------
  |  Branch (157:18): [True: 7, False: 0]
  ------------------
  158|      7|        {
  159|      7|            visitor.end_array(context, ec);
  160|      7|            done_ = true;
  161|      7|        }
  162|     16|    }
_ZN8jsoncons4cbor16mdarray_iteratorIsNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsERKNS7_ImNS4_ImEEEENS_13mdarray_orderES2_:
  195|      3|        : data_(std::move(data)), 
  196|      3|          span_(typed_array_cast<ValueType>(data_)), 
  197|      3|          array_tag_(array_tag), extents_(extents), order_(order), func_(func), dimensions_(extents.size(), mdarray_dimension{})
  198|      3|    {
  199|      3|        std::vector<std::size_t> strides(extents.size(), 0);
  200|      3|        if (order == mdarray_order::column_major)
  ------------------
  |  Branch (200:13): [True: 0, False: 3]
  ------------------
  201|      0|        {
  202|      0|            std::size_t stride = 1;
  203|      0|            const size_t num_extents = extents.size();
  204|      0|            for (size_t i = 0; i < num_extents; ++i)
  ------------------
  |  Branch (204:32): [True: 0, False: 0]
  ------------------
  205|      0|            {
  206|      0|                strides[i] = stride;
  207|      0|                stride *= extents[i];
  208|      0|            }
  209|      0|        }
  210|      3|        else
  211|      3|        {
  212|      3|            std::size_t stride = 1;
  213|      3|            const size_t num_extents = extents.size();
  214|     42|            for (size_t i = 0; i < num_extents; ++i)
  ------------------
  |  Branch (214:32): [True: 39, False: 3]
  ------------------
  215|     39|            {
  216|     39|                strides[num_extents-i-1] = stride;
  217|     39|                stride *= extents[num_extents-i-1];
  218|     39|            }
  219|      3|        }
  220|     42|        for (std::size_t i = 0; i < strides.size(); ++i)
  ------------------
  |  Branch (220:33): [True: 39, False: 3]
  ------------------
  221|     39|        {
  222|     39|            dimensions_[i].extent = extents[i];
  223|     39|            dimensions_[i].stride = strides[i];
  224|     39|            dimensions_[i].index = 0;
  225|     39|            dimensions_[i].end = strides[i]*extents[i];
  226|     39|        }
  227|      3|    }
_ZNK8jsoncons4cbor16mdarray_iteratorIsNS_8identityENSt3__19allocatorIcEEE4doneEv:
  255|      6|    {
  256|      6|        return done_;
  257|      6|    }
_ZN8jsoncons4cbor16mdarray_iteratorIsNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  261|      6|    {
  262|      6|        JSONCONS_ASSERT(!dimensions_.empty());
  ------------------
  |  |   49|      6|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 6]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  263|       |
  264|      6|        if (dim_ == 0)
  ------------------
  |  Branch (264:13): [True: 6, False: 0]
  ------------------
  265|      6|        {
  266|      6|            if (first_)
  ------------------
  |  Branch (266:17): [True: 3, False: 3]
  ------------------
  267|      3|            {
  268|      3|                visitor.begin_array(dimensions_[dim_].extent, tag_, context, ec);
  269|      3|                first_ = false;
  270|      3|                return;
  271|      3|            }
  272|      3|            if (dimensions_[dim_].index == dimensions_[dim_].end)
  ------------------
  |  Branch (272:17): [True: 3, False: 0]
  ------------------
  273|      3|            {
  274|      3|                visitor.end_array(context, ec);
  275|      3|                done_ = true;
  276|      3|                return;
  277|      3|            }
  278|      3|        }
  279|      0|        if (dim_+1 < dimensions_.size() && dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (279:13): [True: 0, False: 0]
  |  Branch (279:44): [True: 0, False: 0]
  ------------------
  280|      0|        {
  281|      0|            visitor.begin_array(dimensions_[dim_].extent, semantic_tag::none, context, ec);
  282|      0|            ++dim_;
  283|      0|            return;
  284|      0|        }
  285|      0|        if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (285:13): [True: 0, False: 0]
  ------------------
  286|      0|        {
  287|      0|            this->write_value(func_(span_[dimensions_[dim_].index]), semantic_tag::none, visitor, context, ec);
  288|      0|            dimensions_[dim_].index += dimensions_[dim_].stride;
  289|      0|            ++count_;
  290|      0|            return;
  291|      0|        }
  292|      0|        if (dimensions_[dim_].index + dimensions_[dim_].stride >= dimensions_[dim_].end)
  ------------------
  |  Branch (292:13): [True: 0, False: 0]
  ------------------
  293|      0|        {
  294|      0|            visitor.end_array(context, ec);
  295|      0|            if (dim_ > 0)
  ------------------
  |  Branch (295:17): [True: 0, False: 0]
  ------------------
  296|      0|            {
  297|      0|                --dim_;
  298|      0|                dimensions_[dim_].index += dimensions_[dim_].stride;
  299|      0|                if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (299:21): [True: 0, False: 0]
  ------------------
  300|      0|                {
  301|      0|                    for (std::size_t i = dim_+1; i < dimensions_.size(); ++i)
  ------------------
  |  Branch (301:50): [True: 0, False: 0]
  ------------------
  302|      0|                    {
  303|      0|                        dimensions_[i].index = dimensions_[i-1].index;
  304|      0|                        dimensions_[i].end = dimensions_[i].index + dimensions_[i].stride*dimensions_[i].extent;
  305|      0|                    }
  306|      0|                }
  307|      0|            }
  308|      0|        }
  309|      0|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIsEENSt3__19enable_ifIXsr10ext_traits17is_signed_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   64|     82|    {
   65|     82|        visitor.int64_value(val, tag, context, ec);
   66|     82|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIsNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagES2_:
  105|  1.38k|        : data_(std::move(data)), 
  106|  1.38k|          span_(typed_array_cast<ValueType>(data_)), 
  107|  1.38k|          array_tag_(array_tag), 
  108|  1.38k|          extent_(span_.size()), 
  109|  1.38k|          tag_(tag), 
  110|  1.38k|          func_(func)
  111|  1.38k|    {
  112|  1.38k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIsNS_8identityENSt3__19allocatorIcEEE4doneEv:
  140|  2.93k|    {
  141|  2.93k|        return done_;
  142|  2.93k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIsNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  146|  2.85k|    {
  147|  2.85k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|  2.85k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.38k, False: 1.46k]
  |  |  ------------------
  ------------------
  148|  1.38k|        {
  149|  1.38k|            visitor.begin_array(span_.size(), tag_, context, ec);
  150|  1.38k|            first_ = false;
  151|  1.38k|        }
  152|  1.46k|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|  1.46k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 82, False: 1.38k]
  |  |  ------------------
  ------------------
  153|     82|        {
  154|     82|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  155|     82|            ++index_;
  156|     82|        }
  157|  1.38k|        else if (!done_)
  ------------------
  |  Branch (157:18): [True: 1.38k, False: 0]
  ------------------
  158|  1.38k|        {
  159|  1.38k|            visitor.end_array(context, ec);
  160|  1.38k|            done_ = true;
  161|  1.38k|        }
  162|  2.85k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagES2_:
  105|      2|        : data_(std::move(data)), 
  106|      2|          span_(typed_array_cast<ValueType>(data_)), 
  107|      2|          array_tag_(array_tag), 
  108|      2|          extent_(span_.size()), 
  109|      2|          tag_(tag), 
  110|      2|          func_(func)
  111|      2|    {
  112|      2|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEE4doneEv:
  140|      4|    {
  141|      4|        return done_;
  142|      4|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  146|      4|    {
  147|      4|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 2]
  |  |  ------------------
  ------------------
  148|      2|        {
  149|      2|            visitor.begin_array(span_.size(), tag_, context, ec);
  150|      2|            first_ = false;
  151|      2|        }
  152|      2|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|      2|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  153|      0|        {
  154|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  155|      0|            ++index_;
  156|      0|        }
  157|      2|        else if (!done_)
  ------------------
  |  Branch (157:18): [True: 2, False: 0]
  ------------------
  158|      2|        {
  159|      2|            visitor.end_array(context, ec);
  160|      2|            done_ = true;
  161|      2|        }
  162|      4|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIfEENSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   80|      4|    {
   81|      4|        visitor.double_value(val, tag, context, ec);
   82|      4|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagES2_:
  105|      2|        : data_(std::move(data)), 
  106|      2|          span_(typed_array_cast<ValueType>(data_)), 
  107|      2|          array_tag_(array_tag), 
  108|      2|          extent_(span_.size()), 
  109|      2|          tag_(tag), 
  110|      2|          func_(func)
  111|      2|    {
  112|      2|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEE4doneEv:
  140|     12|    {
  141|     12|        return done_;
  142|     12|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  146|      8|    {
  147|      8|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 6]
  |  |  ------------------
  ------------------
  148|      2|        {
  149|      2|            visitor.begin_array(span_.size(), tag_, context, ec);
  150|      2|            first_ = false;
  151|      2|        }
  152|      6|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|      6|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 4, False: 2]
  |  |  ------------------
  ------------------
  153|      4|        {
  154|      4|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  155|      4|            ++index_;
  156|      4|        }
  157|      2|        else if (!done_)
  ------------------
  |  Branch (157:18): [True: 2, False: 0]
  ------------------
  158|      2|        {
  159|      2|            visitor.end_array(context, ec);
  160|      2|            done_ = true;
  161|      2|        }
  162|      8|    }