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

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

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

_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4sizeEv:
  116|  1.06k|        {
  117|  1.06k|            return size_;
  118|  1.06k|        }
_ZNK8jsoncons6detail4spanIKtLm18446744073709551615EE4sizeEv:
  116|      6|        {
  117|      6|            return size_;
  118|      6|        }
_ZNK8jsoncons6detail4spanIKmLm18446744073709551615EE4sizeEv:
  116|     20|        {
  117|     20|            return size_;
  118|     20|        }
_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|    489|        {
  112|    489|            return data_;
  113|    489|        }
_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2EPS2_m:
   61|     64|            : data_(data), size_(size)
   62|     64|        {
   63|     64|        }
_ZNK8jsoncons6detail4spanIhLm18446744073709551615EE4dataEv:
  111|  2.80k|        {
  112|  2.80k|            return data_;
  113|  2.80k|        }
_ZNK8jsoncons6detail4spanIhLm18446744073709551615EE4sizeEv:
  116|  2.80k|        {
  117|  2.80k|            return size_;
  118|  2.80k|        }
_ZN8jsoncons6detail4spanIhLm18446744073709551615EEC2INSt3__16vectorIhNS4_9allocatorIhEEEEEERT_PNS4_9enable_ifIXaaaaaantsr7is_spanIS9_EE5valuentsr10ext_traits12is_std_arrayIS9_EE5valuesr10ext_traits21is_compatible_elementIS9_hEE5valuesr10ext_traits17has_data_and_sizeIS9_EE5valueEvE4typeE:
   68|  2.80k|            : data_(c.data()), size_(c.size())
   69|  2.80k|        {
   70|  2.80k|        }
_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|      4|            : data_(data), size_(size)
   62|      4|        {
   63|      4|        }
_ZNK8jsoncons6detail4spanItLm18446744073709551615EE4sizeEv:
  116|      6|        {
  117|      6|            return size_;
  118|      6|        }
_ZN8jsoncons6detail4spanIKtLm18446744073709551615EEC2ItLm18446744073709551615EEERKNS1_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|        }
_ZNK8jsoncons6detail4spanItLm18446744073709551615EE4dataEv:
  111|      2|        {
  112|      2|            return data_;
  113|      2|        }
_ZN8jsoncons6detail4spanImLm18446744073709551615EEC2EPmm:
   61|     12|            : data_(data), size_(size)
   62|     12|        {
   63|     12|        }
_ZNK8jsoncons6detail4spanImLm18446744073709551615EE4sizeEv:
  116|     16|        {
  117|     16|            return size_;
  118|     16|        }
_ZN8jsoncons6detail4spanIKmLm18446744073709551615EEC2ImLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|      6|            : data_(s.data()), size_(s.size())
  103|      6|        {
  104|      6|        }
_ZNK8jsoncons6detail4spanImLm18446744073709551615EE4dataEv:
  111|      6|        {
  112|      6|            return data_;
  113|      6|        }
_ZNK8jsoncons6detail4spanIKmLm18446744073709551615EEixEm:
  126|      2|         {
  127|      2|             return data_[index];
  128|      2|         }
_ZN8jsoncons6detail4spanIsLm18446744073709551615EEC2EPsm:
   61|  2.76k|            : data_(data), size_(size)
   62|  2.76k|        {
   63|  2.76k|        }
_ZNK8jsoncons6detail4spanIsLm18446744073709551615EE4sizeEv:
  116|  2.76k|        {
  117|  2.76k|            return size_;
  118|  2.76k|        }
_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|    437|        {
   59|    437|        }

_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1008|  1.62k|        {
 1009|  1.62k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1009:17): [True: 292, False: 1.33k]
  ------------------
 1010|    292|            {
 1011|    292|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1011:21): [True: 212, False: 80]
  |  Branch (1011:86): [True: 212, False: 0]
  ------------------
 1012|    212|                {
 1013|    212|                    key_buffer_.push_back(',');
 1014|    212|                }
 1015|    292|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
 1016|    292|                key_buffer_.push_back('[');
 1017|    292|            }
 1018|  1.33k|            else
 1019|  1.33k|            {
 1020|  1.33k|                switch (level_stack_.back().target_kind())
 1021|  1.33k|                {
 1022|  1.25k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1022:21): [True: 1.25k, False: 87]
  ------------------
 1023|  1.25k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1023:29): [True: 1.03k, False: 214]
  |  Branch (1023:65): [True: 1.03k, False: 1]
  ------------------
 1024|  1.03k|                        {
 1025|  1.03k|                            key_buffer_.push_back(',');
 1026|  1.03k|                        }
 1027|  1.25k|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
 1028|  1.25k|                        key_buffer_.push_back('[');
 1029|  1.25k|                        break;
 1030|     87|                    default:
  ------------------
  |  Branch (1030:21): [True: 87, False: 1.25k]
  ------------------
 1031|     87|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::array);
 1032|     87|                        destination_->begin_array(length, tag, context, ec);
 1033|     87|                        break;
 1034|  1.33k|                }
 1035|  1.33k|            }
 1036|  1.62k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.62k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1037|  1.62k|        }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure6is_keyEv:
  815|  9.42M|            {
  816|  9.42M|                return even_odd_ == 0;
  817|  9.42M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure11target_kindEv:
  825|  5.19M|            {
  826|  5.19M|                return target_kind_;
  827|  5.19M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure5countEv:
  830|  1.52M|            {
  831|  1.52M|                return count_;
  832|  1.52M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structureC2ENS4_16json_target_kindENS4_19json_structure_kindE:
  798|  1.68k|                : target_kind_(state), structure_kind_(type), even_odd_(type == json_structure_kind::object ? 0 : 1)
  ------------------
  |  Branch (798:73): [True: 39, False: 1.64k]
  ------------------
  799|  1.68k|            {
  800|  1.68k|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure9is_objectEv:
  820|  4.66M|            {
  821|  4.66M|                return structure_kind_ == json_structure_kind::object;
  822|  4.66M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE15visit_end_arrayERKNS_11ser_contextERNS1_10error_codeE:
 1040|  1.62k|        {
 1041|  1.62k|            switch (level_stack_.back().target_kind())
 1042|  1.62k|            {
 1043|  1.54k|                case json_target_kind::buffer:
  ------------------
  |  Branch (1043:17): [True: 1.54k, False: 81]
  ------------------
 1044|  1.54k|                    key_buffer_.push_back(']');
 1045|  1.54k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|  1.54k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 1.54k]
  |  |  ------------------
  |  |   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.54k|                    level_stack_.pop_back();
 1047|  1.54k|                    if (level_stack_.back().target_kind() == json_target_kind::destination)
  ------------------
  |  Branch (1047:25): [True: 78, False: 1.46k]
  ------------------
 1048|     78|                    {
 1049|     78|                        destination_->key(key_buffer_, context, ec);
 1050|     78|                        key_buffer_.clear();
 1051|     78|                    }
 1052|  1.46k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (1052:30): [True: 212, False: 1.25k]
  ------------------
 1053|    212|                    {
 1054|    212|                        key_buffer_.push_back(':');
 1055|    212|                    }
 1056|  1.54k|                    level_stack_.back().advance();
 1057|  1.54k|                    break;
 1058|     81|                default:
  ------------------
  |  Branch (1058:17): [True: 81, False: 1.54k]
  ------------------
 1059|     81|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|     81|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 81]
  |  |  ------------------
  |  |   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|     81|                    level_stack_.pop_back();
 1061|     81|                    level_stack_.back().advance();
 1062|     81|                    destination_->end_array(context, ec);
 1063|     81|                    break;
 1064|  1.62k|            }
 1065|  1.62k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.62k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1066|  1.62k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure7advanceEv:
  803|  3.14M|            {
  804|  3.14M|                if (!is_key())
  ------------------
  |  Branch (804:21): [True: 2.04M, False: 1.09M]
  ------------------
  805|  2.04M|                {
  806|  2.04M|                    ++count_;
  807|  2.04M|                }
  808|  3.14M|                if (is_object())
  ------------------
  |  Branch (808:21): [True: 2.18M, False: 954k]
  ------------------
  809|  2.18M|                {
  810|  2.18M|                    even_odd_ = !even_odd_;
  811|  2.18M|                }
  812|  3.14M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1233|  3.13M|        {
 1234|  3.13M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1234:17): [True: 1.09M, False: 2.04M]
  |  Branch (1234:49): [True: 1.52M, False: 523k]
  ------------------
 1235|  2.61M|            {
 1236|  2.61M|                key_.clear();
 1237|  2.61M|                jsoncons::from_integer(value,key_);
 1238|  2.61M|            }
 1239|       |
 1240|  3.13M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1240:17): [True: 1.09M, False: 2.04M]
  ------------------
 1241|  1.09M|            {
 1242|  1.09M|                switch (level_stack_.back().target_kind())
 1243|  1.09M|                {
 1244|   568k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1244:21): [True: 568k, False: 523k]
  ------------------
 1245|   568k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1245:29): [True: 568k, False: 4]
  ------------------
 1246|   568k|                        {
 1247|   568k|                            key_buffer_.push_back(',');
 1248|   568k|                        }
 1249|   568k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1250|   568k|                        key_buffer_.push_back(':');
 1251|   568k|                        break;
 1252|   523k|                    default:
  ------------------
  |  Branch (1252:21): [True: 523k, False: 568k]
  ------------------
 1253|   523k|                        destination_->key(key_, context, ec);
 1254|   523k|                        break;
 1255|  1.09M|                }
 1256|  1.09M|            }
 1257|  2.04M|            else
 1258|  2.04M|            {
 1259|  2.04M|                switch (level_stack_.back().target_kind())
 1260|  2.04M|                {
 1261|  1.52M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1261:21): [True: 1.52M, False: 523k]
  ------------------
 1262|  1.52M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1262:29): [True: 953k, False: 568k]
  |  Branch (1262:65): [True: 953k, False: 6]
  ------------------
 1263|   953k|                        {
 1264|   953k|                            key_buffer_.push_back(',');
 1265|   953k|                        }
 1266|  1.52M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1267|  1.52M|                        break;
 1268|   523k|                    default:
  ------------------
  |  Branch (1268:21): [True: 523k, False: 1.52M]
  ------------------
 1269|   523k|                        destination_->uint64_value(value, tag, context, ec);
 1270|   523k|                        break;
 1271|  2.04M|                }
 1272|  2.04M|            }
 1273|       |
 1274|  3.13M|            level_stack_.back().advance();
 1275|  3.13M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.13M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1276|  3.13M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1279|    527|        {
 1280|    527|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1280:17): [True: 219, False: 308]
  |  Branch (1280:49): [True: 298, False: 10]
  ------------------
 1281|    517|            {
 1282|    517|                key_.clear();
 1283|    517|                jsoncons::from_integer(value,key_);
 1284|    517|            }
 1285|       |
 1286|    527|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1286:17): [True: 219, False: 308]
  ------------------
 1287|    219|            {
 1288|    219|                switch (level_stack_.back().target_kind())
 1289|    219|                {
 1290|    206|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1290:21): [True: 206, False: 13]
  ------------------
 1291|    206|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1291:29): [True: 205, False: 1]
  ------------------
 1292|    205|                        {
 1293|    205|                            key_buffer_.push_back(',');
 1294|    205|                        }
 1295|    206|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1296|    206|                        key_buffer_.push_back(':');
 1297|    206|                        break;
 1298|     13|                    default:
  ------------------
  |  Branch (1298:21): [True: 13, False: 206]
  ------------------
 1299|     13|                        destination_->key(key_, context, ec);
 1300|     13|                        break;
 1301|    219|                }
 1302|    219|            }
 1303|    308|            else
 1304|    308|            {
 1305|    308|                switch (level_stack_.back().target_kind())
 1306|    308|                {
 1307|    298|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1307:21): [True: 298, False: 10]
  ------------------
 1308|    298|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1308:29): [True: 98, False: 200]
  |  Branch (1308:65): [True: 78, False: 20]
  ------------------
 1309|     78|                        {
 1310|     78|                            key_buffer_.push_back(',');
 1311|     78|                        }
 1312|    298|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1313|    298|                        break;
 1314|     10|                    default:
  ------------------
  |  Branch (1314:21): [True: 10, False: 298]
  ------------------
 1315|     10|                        destination_->int64_value(value, tag, context, ec);
 1316|     10|                        break;
 1317|    308|                }
 1318|    308|            }
 1319|       |
 1320|    527|            level_stack_.back().advance();
 1321|    527|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    527|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1322|    527|        }
_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|      5|        {
  882|      5|            destination_->flush();
  883|      5|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  886|      3|        {
  887|      3|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (887:17): [True: 0, False: 3]
  ------------------
  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|      3|            else
  897|      3|            {
  898|      3|                switch (level_stack_.back().target_kind())
  899|      3|                {
  900|      2|                    case json_target_kind::buffer:
  ------------------
  |  Branch (900:21): [True: 2, False: 1]
  ------------------
  901|      2|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  902|      2|                        key_buffer_.push_back('{');
  903|      2|                        break;
  904|      1|                    default:
  ------------------
  |  Branch (904:21): [True: 1, False: 2]
  ------------------
  905|      1|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::object);
  906|      1|                        destination_->begin_object(tag, context, ec);
  907|      1|                        break;
  908|      3|                }
  909|      3|            }
  910|      3|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  911|      3|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  914|     36|        {
  915|     36|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (915:17): [True: 20, False: 16]
  ------------------
  916|     20|            {
  917|     20|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (917:21): [True: 15, False: 5]
  |  Branch (917:86): [True: 4, False: 11]
  ------------------
  918|      4|                {
  919|      4|                    key_buffer_.push_back(',');
  920|      4|                }
  921|     20|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  922|     20|                key_buffer_.push_back('{');
  923|     20|            }
  924|     16|            else
  925|     16|            {
  926|     16|                switch (level_stack_.back().target_kind())
  927|     16|                {
  928|     11|                    case json_target_kind::buffer:
  ------------------
  |  Branch (928:21): [True: 11, False: 5]
  ------------------
  929|     11|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (929:29): [True: 8, False: 3]
  |  Branch (929:65): [True: 8, False: 0]
  ------------------
  930|      8|                        {
  931|      8|                            key_buffer_.push_back(',');
  932|      8|                        }
  933|     11|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  934|     11|                        key_buffer_.push_back('{');
  935|     11|                        break;
  936|      5|                    default:
  ------------------
  |  Branch (936:21): [True: 5, False: 11]
  ------------------
  937|      5|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::object);
  938|      5|                        destination_->begin_object(length, tag, context, ec);
  939|      5|                        break;
  940|     16|                }
  941|     16|            }
  942|     36|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     36|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  943|     36|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE16visit_end_objectERKNS_11ser_contextERNS1_10error_codeE:
  946|     36|        {
  947|     36|            switch (level_stack_.back().target_kind())
  948|     36|            {
  949|     33|                case json_target_kind::buffer:
  ------------------
  |  Branch (949:17): [True: 33, False: 3]
  ------------------
  950|     33|                    key_buffer_.push_back('}');
  951|     33|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|     33|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 33]
  |  |  ------------------
  |  |   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|     33|                    level_stack_.pop_back();
  953|       |                    
  954|     33|                    if (level_stack_.back().target_kind() == json_target_kind::destination)
  ------------------
  |  Branch (954:25): [True: 5, False: 28]
  ------------------
  955|      5|                    {
  956|      5|                        destination_->key(key_buffer_,context, ec);
  957|      5|                        key_buffer_.clear();
  958|      5|                    }
  959|     28|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (959:30): [True: 15, False: 13]
  ------------------
  960|     15|                    {
  961|     15|                        key_buffer_.push_back(':');
  962|     15|                    }
  963|     33|                    level_stack_.back().advance();
  964|     33|                    break;
  965|      3|                default:
  ------------------
  |  Branch (965:17): [True: 3, False: 33]
  ------------------
  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|     36|            }
  972|     36|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     36|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  973|     36|        }
_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|     18|        {
 1073|     18|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1073:17): [True: 8, False: 10]
  ------------------
 1074|      8|            {
 1075|      8|                switch (level_stack_.back().target_kind())
 1076|      8|                {
 1077|      4|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1077:21): [True: 4, False: 4]
  ------------------
 1078|      4|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1078:29): [True: 4, False: 0]
  ------------------
 1079|      4|                        {
 1080|      4|                            key_buffer_.push_back(',');
 1081|      4|                        }
 1082|      4|                        key_buffer_.push_back('\"');
 1083|      4|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1084|      4|                        key_buffer_.push_back('\"');
 1085|      4|                        key_buffer_.push_back(':');
 1086|      4|                        break;
 1087|      4|                    default:
  ------------------
  |  Branch (1087:21): [True: 4, False: 4]
  ------------------
 1088|      4|                        destination_->key(value, context, ec);
 1089|      4|                        break;
 1090|      8|                }
 1091|      8|            }
 1092|     10|            else
 1093|     10|            {
 1094|     10|                switch (level_stack_.back().target_kind())
 1095|     10|                {
 1096|      4|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1096:21): [True: 4, False: 6]
  ------------------
 1097|      4|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1097:29): [True: 0, False: 4]
  |  Branch (1097:65): [True: 0, False: 0]
  ------------------
 1098|      0|                        {
 1099|      0|                            key_buffer_.push_back(',');
 1100|      0|                        }
 1101|      4|                        key_buffer_.push_back('\"');
 1102|      4|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1103|      4|                        key_buffer_.push_back('\"');
 1104|      4|                        break;
 1105|      6|                    default:
  ------------------
  |  Branch (1105:21): [True: 6, False: 4]
  ------------------
 1106|      6|                        destination_->string_value(value, tag, context, ec);
 1107|      6|                        break;
 1108|     10|                }
 1109|     10|            }
 1110|       |
 1111|     18|            level_stack_.back().advance();
 1112|     18|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     18|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1113|     18|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1119|    446|        {
 1120|    446|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1120:17): [True: 168, False: 278]
  |  Branch (1120:49): [True: 117, False: 161]
  ------------------
 1121|    285|            {
 1122|    285|                key_.clear();
 1123|    285|                switch (tag)
 1124|    285|                {
 1125|      0|                    case semantic_tag::base64:
  ------------------
  |  Branch (1125:21): [True: 0, False: 285]
  ------------------
 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: 285]
  ------------------
 1129|      0|                        bytes_to_base16(value.begin(), value.end(),key_);
 1130|      0|                        break;
 1131|    285|                    default:
  ------------------
  |  Branch (1131:21): [True: 285, False: 0]
  ------------------
 1132|    285|                        bytes_to_base64url(value.begin(), value.end(),key_);
 1133|    285|                        break;
 1134|    285|                }
 1135|    285|            }
 1136|       |
 1137|    446|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1137:17): [True: 168, False: 278]
  ------------------
 1138|    168|            {
 1139|    168|                switch (level_stack_.back().target_kind())
 1140|    168|                {
 1141|     12|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1141:21): [True: 12, False: 156]
  ------------------
 1142|     12|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1142:29): [True: 8, False: 4]
  ------------------
 1143|      8|                        {
 1144|      8|                            key_buffer_.push_back(',');
 1145|      8|                        }
 1146|     12|                        key_buffer_.push_back('\"');
 1147|     12|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1148|     12|                        key_buffer_.push_back('\"');
 1149|     12|                        key_buffer_.push_back(':');
 1150|     12|                        break;
 1151|    156|                    default:
  ------------------
  |  Branch (1151:21): [True: 156, False: 12]
  ------------------
 1152|    156|                        destination_->key(key_, context, ec);
 1153|    156|                        break;
 1154|    168|                }
 1155|    168|            }
 1156|    278|            else
 1157|    278|            {
 1158|    278|                switch (level_stack_.back().target_kind())
 1159|    278|                {
 1160|    117|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1160:21): [True: 117, False: 161]
  ------------------
 1161|    117|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1161:29): [True: 98, False: 19]
  |  Branch (1161:65): [True: 96, False: 2]
  ------------------
 1162|     96|                        {
 1163|     96|                            key_buffer_.push_back(',');
 1164|     96|                        }
 1165|    117|                        key_buffer_.push_back('\"');
 1166|    117|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1167|    117|                        key_buffer_.push_back('\"');
 1168|    117|                        break;
 1169|    161|                    default:
  ------------------
  |  Branch (1169:21): [True: 161, False: 117]
  ------------------
 1170|    161|                        destination_->byte_string_value(value, tag, context, ec);
 1171|    161|                        break;
 1172|    278|                }
 1173|    278|            }
 1174|       |
 1175|    446|            level_stack_.back().advance();
 1176|    446|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    446|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1177|    446|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS1_10error_codeE:
 1183|     43|        {
 1184|     43|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1184:17): [True: 6, False: 37]
  |  Branch (1184:49): [True: 36, False: 1]
  ------------------
 1185|     42|            {
 1186|     42|                key_.clear();
 1187|     42|                bytes_to_base64url(value.begin(), value.end(),key_);
 1188|     42|            }
 1189|       |
 1190|     43|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1190:17): [True: 6, False: 37]
  ------------------
 1191|      6|            {
 1192|      6|                switch (level_stack_.back().target_kind())
 1193|      6|                {
 1194|      6|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1194:21): [True: 6, False: 0]
  ------------------
 1195|      6|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1195:29): [True: 6, False: 0]
  ------------------
 1196|      6|                        {
 1197|      6|                            key_buffer_.push_back(',');
 1198|      6|                        }
 1199|      6|                        key_buffer_.push_back('\"');
 1200|      6|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1201|      6|                        key_buffer_.push_back('\"');
 1202|      6|                        key_buffer_.push_back(':');
 1203|      6|                        break;
 1204|      0|                    default:
  ------------------
  |  Branch (1204:21): [True: 0, False: 6]
  ------------------
 1205|      0|                        destination_->key(key_, context, ec);
 1206|      0|                        break;
 1207|      6|                }
 1208|      6|            }
 1209|     37|            else
 1210|     37|            {
 1211|     37|                switch (level_stack_.back().target_kind())
 1212|     37|                {
 1213|     36|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1213:21): [True: 36, False: 1]
  ------------------
 1214|     36|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1214:29): [True: 30, False: 6]
  |  Branch (1214:65): [True: 30, False: 0]
  ------------------
 1215|     30|                        {
 1216|     30|                            key_buffer_.push_back(',');
 1217|     30|                        }
 1218|     36|                        key_buffer_.push_back('\"');
 1219|     36|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1220|     36|                        key_buffer_.push_back('\"');
 1221|     36|                        break;
 1222|      1|                    default:
  ------------------
  |  Branch (1222:21): [True: 1, False: 36]
  ------------------
 1223|      1|                        destination_->byte_string_value(value, raw_tag, context, ec);
 1224|      1|                        break;
 1225|     37|                }
 1226|     37|            }
 1227|       |
 1228|     43|            level_stack_.back().advance();
 1229|     43|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     43|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1230|     43|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE10visit_halfEtNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1325|      6|        {
 1326|      6|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1326:17): [True: 0, False: 6]
  |  Branch (1326:49): [True: 6, False: 0]
  ------------------
 1327|      6|            {
 1328|      6|                key_.clear();
 1329|      6|                jsoncons::string_sink<string_type> sink(key_);
 1330|      6|                jsoncons::write_double f{float_chars_format::general,0};
 1331|      6|                double x = binary::decode_half(value);
 1332|      6|                f(x, sink);
 1333|      6|            }
 1334|       |
 1335|      6|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1335:17): [True: 0, False: 6]
  ------------------
 1336|      0|            {
 1337|      0|                switch (level_stack_.back().target_kind())
 1338|      0|                {
 1339|      0|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1339:21): [True: 0, False: 0]
  ------------------
 1340|      0|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1340:29): [True: 0, False: 0]
  ------------------
 1341|      0|                        {
 1342|      0|                            key_buffer_.push_back(',');
 1343|      0|                        }
 1344|      0|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1345|      0|                        key_buffer_.push_back(':');
 1346|      0|                        break;
 1347|      0|                    default:
  ------------------
  |  Branch (1347:21): [True: 0, False: 0]
  ------------------
 1348|      0|                        destination_->key(key_, context, ec);
 1349|      0|                        break;
 1350|      0|                }
 1351|      0|            }
 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|      6|            level_stack_.back().advance();
 1370|      6|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1371|      6|        }
_ZN8jsoncons21basic_generic_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  294|  1.62k|    {
  295|  1.62k|        visit_begin_array(length, tag, context, ec);
  296|  1.62k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.62k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  297|  1.62k|    }
_ZN8jsoncons21basic_generic_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  363|  3.13M|    {
  364|  3.13M|        visit_uint64(value, tag, context, ec);
  365|  3.13M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.13M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  366|  3.13M|    }
_ZN8jsoncons21basic_generic_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  300|  1.62k|    {
  301|  1.62k|        visit_end_array(context, ec);
  302|  1.62k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.62k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  303|  1.62k|    }
_ZN8jsoncons21basic_generic_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  372|    527|    {
  373|    527|        visit_int64(value, tag, context, ec);
  374|    527|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    527|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  375|    527|    }
_ZN8jsoncons21basic_generic_visitorIcE10half_valueEtNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  381|      6|    {
  382|      6|        visit_half(value, tag, context, ec);
  383|      6|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  384|      6|    }
_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|     12|            : destination_(std::addressof(visitor)), 
  856|     12|              key_(alloc), key_buffer_(alloc), level_stack_(alloc)
  857|     12|        {
  858|     12|            level_stack_.emplace_back(json_target_kind::destination,json_structure_kind::root); // root
  859|     12|        }
_ZN8jsoncons21basic_generic_visitorIcEC2Ev:
   52|     12|    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|    446|    {
  344|    446|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  345|    446|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    446|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  346|    446|    }
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  354|     43|    {
  355|     43|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), raw_tag, context, ec);
  356|     43|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     43|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  357|     43|    }
_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|     18|    {
  333|     18|        visit_string(value, tag, context, ec);
  334|     18|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     18|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  335|     18|    }
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  267|      3|    {
  268|      3|        visit_begin_object(tag, context, ec);
  269|      3|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  270|      3|    }
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  276|     36|    {
  277|     36|        visit_begin_object(length, tag, context, ec);
  278|     36|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     36|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  279|     36|    }
_ZN8jsoncons21basic_generic_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  282|     36|    {
  283|     36|        visit_end_object(context, ec);
  284|     36|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     36|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  285|     36|    }
_ZN8jsoncons21basic_generic_visitorIcE5flushEv:
   57|      5|    {
   58|      5|        visit_flush();
   59|      5|    }

_ZN8jsoncons19typed_array_visitorD2Ev:
   33|     36|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  345|     87|        {
  346|     87|            visit_begin_array(length, tag, context, ec);
  347|     87|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     87|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  348|     87|        }
_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|     81|        {
  352|     81|            visit_end_array(context, ec);
  353|     81|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     81|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  354|     81|        }
_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|     10|        {
  424|     10|            visit_int64(value, tag, context, ec);
  425|     10|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     10|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  426|     10|        }
_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|      5|        {
  109|      5|            visit_flush();
  110|      5|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  318|      1|        {
  319|      1|            visit_begin_object(tag, context, ec);
  320|      1|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      1|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  321|      1|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  327|      5|        {
  328|      5|            visit_begin_object(length, tag, context, ec);
  329|      5|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      5|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  330|      5|        }
_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|    161|        {
  395|    161|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  396|    161|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    161|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  397|    161|        }
_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|     24|        basic_json_visitor() = default;
_ZN8jsoncons26basic_default_json_visitorIcEC2Ev:
  811|     12|        basic_default_json_visitor() = default;

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

_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERS7_:
  256|      8|            : buf_ptr(std::addressof(buf))
  257|      8|        {
  258|      8|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9push_backEc:
  287|     93|        {
  288|     93|            buf_ptr->push_back(ch);
  289|     93|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvEC2ERS5_:
  315|     12|            : buf_ptr(std::addressof(buf))
  316|     12|        {
  317|     12|        }
_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|     17|        {
  326|     17|        }
_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|     12|    {
  194|     12|        if (chunk_)
  ------------------
  |  Branch (194:13): [True: 12, False: 0]
  ------------------
  195|     12|        {
  196|     12|            std::allocator_traits<char_allocator_type>::deallocate(alloc_, chunk_, chunk_size_);
  197|     12|        }
  198|     12|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  176|     12|        : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  177|     12|          chunk_size_(default_max_chunk_size)
  178|     12|    {
  179|     12|        chunk_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, chunk_size_);
  180|     12|        data_end_ = chunk_;
  181|     12|    }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   57|     12|      : std::basic_istream<CharT>(&nb_)
   58|     12|    {
   59|     12|    }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   43|     12|        null_buffer() = default;
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm:
  377|  3.14M|    {
  378|  3.14M|        std::size_t len = 0;
  379|  3.14M|        if (remaining_ > 0)
  ------------------
  |  Branch (379:13): [True: 3.14M, False: 0]
  ------------------
  380|  3.14M|        {
  381|  3.14M|            len = (std::min)(remaining_, length);
  382|  3.14M|            std::memcpy(p, data_end_, len*sizeof(value_type));
  383|  3.14M|            data_end_ += len;
  384|  3.14M|            remaining_ -= len;
  385|  3.14M|            position_ += len;
  386|  3.14M|        }
  387|  3.14M|        if (length - len == 0)
  ------------------
  |  Branch (387:13): [True: 3.14M, False: 256]
  ------------------
  388|  3.14M|        {
  389|  3.14M|            return len;
  390|  3.14M|        }
  391|    256|        else if (length - len < chunk_size_)
  ------------------
  |  Branch (391:18): [True: 256, False: 0]
  ------------------
  392|    256|        {
  393|    256|            data_end_ = chunk_;
  394|    256|            remaining_ = fill_buffer(chunk_, chunk_size_);
  395|    256|            if (remaining_ > 0)
  ------------------
  |  Branch (395:17): [True: 252, False: 4]
  ------------------
  396|    252|            {
  397|    252|                std::size_t len2 = (std::min)(remaining_, length-len);
  398|    252|                std::memcpy(p+len, data_end_, len2*sizeof(value_type));
  399|    252|                data_end_ += len2;
  400|    252|                remaining_ -= len2;
  401|    252|                position_ += len2;
  402|    252|                len += len2;
  403|    252|            }
  404|    256|            return len;
  405|    256|        }
  406|      0|        else
  407|      0|        {
  408|      0|            if (stream_ptr_->eof())
  ------------------
  |  Branch (408:17): [True: 0, False: 0]
  ------------------
  409|      0|            {
  410|      0|                remaining_ = 0;
  411|      0|                return 0;
  412|      0|            }
  413|      0|            JSONCONS_TRY
  ------------------
  |  |   37|      0|    #define JSONCONS_TRY try
  ------------------
  414|      0|            {
  415|      0|                std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(p+len), length-len);
  416|      0|                std::size_t len2 = static_cast<std::size_t>(count);
  417|      0|                if (len2 < length-len)
  ------------------
  |  Branch (417:21): [True: 0, False: 0]
  ------------------
  418|      0|                {
  419|      0|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  420|      0|                }
  421|      0|                len += len2;
  422|      0|                position_ += len2;
  423|      0|                return len;
  424|      0|            }
  425|      0|            JSONCONS_CATCH(const std::exception&)     
  426|      0|            {
  427|      0|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  428|      0|                return 0;
  429|      0|            }
  430|      0|        }
  431|  3.14M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEPhm:
  442|    460|    {
  443|    460|        if (stream_ptr_->eof())
  ------------------
  |  Branch (443:13): [True: 0, False: 460]
  ------------------
  444|      0|        {
  445|      0|            return 0;
  446|      0|        }
  447|       |
  448|    460|        JSONCONS_TRY
  ------------------
  |  |   37|    460|    #define JSONCONS_TRY try
  ------------------
  449|    460|        {
  450|    460|            std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(chunk), chunk_size);
  451|    460|            std::size_t length = static_cast<std::size_t>(count);
  452|       |
  453|    460|            if (length < chunk_size)
  ------------------
  |  Branch (453:17): [True: 7, False: 453]
  ------------------
  454|      7|            {
  455|      7|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  456|      7|            }
  457|    460|            return length;
  458|    460|        }
  459|    460|        JSONCONS_CATCH(const std::exception&)     
  460|    460|        {
  461|      0|            stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  462|      0|            return 0;
  463|      0|        }
  464|    460|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_6vectorIhS4_EEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr10ext_traits7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSD_m:
  746|  1.40k|    {
  747|  1.40k|        std::size_t unread = length;
  748|       |
  749|  1.62k|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (749:16): [True: 219, False: 1.40k]
  |  Branch (749:30): [True: 216, False: 3]
  ------------------
  750|    216|        {
  751|    216|            if (source.remaining() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (751:17): [True: 0, False: 216]
  |  Branch (751:44): [True: 0, False: 0]
  ------------------
  752|      0|            {
  753|      0|                std::size_t n = source.chunk_size();
  754|      0|                std::size_t offset = buffer.size();
  755|      0|                buffer.resize(offset+n);
  756|      0|                std::size_t actual = source.read_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  757|      0|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  758|      0|                {
  759|      0|                    buffer.resize(offset+actual);
  760|      0|                }
  761|      0|                unread -= actual;
  762|      0|            }
  763|    216|            else
  764|    216|            {
  765|    216|                std::size_t n = (std::min)(source.chunk_size(), unread);
  766|    216|                std::size_t offset = buffer.size();
  767|    216|                buffer.resize(offset+n);
  768|    216|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  769|    216|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   78|    216|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 213]
  |  |  ------------------
  ------------------
  770|      3|                {
  771|      3|                    buffer.resize(offset + actual);
  772|      3|                }
  773|    216|                unread -= actual;
  774|    216|            }
  775|    216|        }
  776|  1.40k|        return length - unread;
  777|  1.40k|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv:
  271|    284|    {
  272|    284|        return remaining_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:16): [True: 4, False: 280]
  |  Branch (272:35): [True: 4, False: 0]
  ------------------
  273|    284|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9remainingEv:
  346|    280|    {
  347|    280|        return remaining_;
  348|    280|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE10chunk_sizeEv:
  261|    280|    {
  262|    280|        return chunk_size_;
  263|    280|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_6vectorIhS3_EEEENS_6detail4spanIKhLm18446744073709551615EEEmOT_:
  352|    492|    {
  353|    492|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|    492|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 437, False: 55]
  |  |  ------------------
  ------------------
  354|    437|        {
  355|    437|            return span<const value_type>{};
  356|    437|        }
  357|     55|        if (remaining_ == 0 && length <= chunk_size_)
  ------------------
  |  Branch (357:13): [True: 0, False: 55]
  |  Branch (357:32): [True: 0, False: 0]
  ------------------
  358|      0|        {
  359|      0|            remaining_ = fill_buffer(chunk_, chunk_size_);
  360|      0|            data_end_ = chunk_;
  361|      0|        }
  362|     55|        if (length > remaining_)
  ------------------
  |  Branch (362:13): [True: 3, False: 52]
  ------------------
  363|      3|        {
  364|      3|            buffer.clear();
  365|      3|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  366|      3|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  367|      3|        }
  368|       |
  369|     52|        const value_type* data = data_end_;
  370|     52|        data_end_ += length;
  371|     52|        remaining_ -= length;
  372|     52|        position_ += length;
  373|     52|        return span<const value_type>(data, length);
  374|     55|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_12basic_stringIcNS2_11char_traitsIcEENS3_IcEEEEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr10ext_traits7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSG_m:
  746|      1|    {
  747|      1|        std::size_t unread = length;
  748|       |
  749|     65|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (749:16): [True: 65, False: 0]
  |  Branch (749:30): [True: 64, False: 1]
  ------------------
  750|     64|        {
  751|     64|            if (source.remaining() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (751:17): [True: 0, False: 64]
  |  Branch (751:44): [True: 0, False: 0]
  ------------------
  752|      0|            {
  753|      0|                std::size_t n = source.chunk_size();
  754|      0|                std::size_t offset = buffer.size();
  755|      0|                buffer.resize(offset+n);
  756|      0|                std::size_t actual = source.read_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  757|      0|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  758|      0|                {
  759|      0|                    buffer.resize(offset+actual);
  760|      0|                }
  761|      0|                unread -= actual;
  762|      0|            }
  763|     64|            else
  764|     64|            {
  765|     64|                std::size_t n = (std::min)(source.chunk_size(), unread);
  766|     64|                std::size_t offset = buffer.size();
  767|     64|                buffer.resize(offset+n);
  768|     64|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  769|     64|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   78|     64|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 63]
  |  |  ------------------
  ------------------
  770|      1|                {
  771|      1|                    buffer.resize(offset + actual);
  772|      1|                }
  773|     64|                unread -= actual;
  774|     64|            }
  775|     64|        }
  776|      1|        return length - unread;
  777|      1|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_12basic_stringIcNS1_11char_traitsIcEENS2_IcEEEEEENS_6detail4spanIKhLm18446744073709551615EEEmOT_:
  352|      1|    {
  353|      1|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  354|      0|        {
  355|      0|            return span<const value_type>{};
  356|      0|        }
  357|      1|        if (remaining_ == 0 && length <= chunk_size_)
  ------------------
  |  Branch (357:13): [True: 0, False: 1]
  |  Branch (357:32): [True: 0, False: 0]
  ------------------
  358|      0|        {
  359|      0|            remaining_ = fill_buffer(chunk_, chunk_size_);
  360|      0|            data_end_ = chunk_;
  361|      0|        }
  362|      1|        if (length > remaining_)
  ------------------
  |  Branch (362:13): [True: 1, False: 0]
  ------------------
  363|      1|        {
  364|      1|            buffer.clear();
  365|      1|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  366|      1|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  367|      1|        }
  368|       |
  369|      0|        const value_type* data = data_end_;
  370|      0|        data_end_ += length;
  371|      0|        remaining_ -= length;
  372|      0|        position_ += length;
  373|      0|        return span<const value_type>(data, length);
  374|      1|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4peekEv:
  312|  7.38M|    {
  313|  7.38M|        if (remaining_ == 0)
  ------------------
  |  Branch (313:13): [True: 204, False: 7.38M]
  ------------------
  314|    204|        {
  315|    204|            data_end_ = chunk_;
  316|    204|            remaining_ = fill_buffer(chunk_, chunk_size_);
  317|    204|        }
  318|  7.38M|        if (remaining_ > 0)
  ------------------
  |  Branch (318:13): [True: 7.38M, False: 3]
  ------------------
  319|  7.38M|        {
  320|  7.38M|            value_type c = *data_end_;
  321|  7.38M|            return char_result<value_type>{c, false};
  322|  7.38M|        }
  323|      3|        else
  324|      3|        {
  325|      3|            return char_result<value_type>{0, true};
  326|      3|        }
  327|  7.38M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE6ignoreEm:
  286|    516|    {
  287|    516|        std::size_t len = 0;
  288|    516|        if (remaining_ > 0)
  ------------------
  |  Branch (288:13): [True: 516, False: 0]
  ------------------
  289|    516|        {
  290|    516|            len = (std::min)(remaining_, length);
  291|    516|            position_ += len;
  292|    516|            data_end_ += len;
  293|    516|            remaining_ -= len;
  294|    516|        }
  295|    516|        while (len < length)
  ------------------
  |  Branch (295:16): [True: 0, False: 516]
  ------------------
  296|      0|        {
  297|      0|            data_end_ = chunk_;
  298|      0|            remaining_ = fill_buffer(chunk_, chunk_size_);
  299|      0|            if (remaining_ == 0)
  ------------------
  |  Branch (299:17): [True: 0, False: 0]
  ------------------
  300|      0|            {
  301|      0|                break;
  302|      0|            }
  303|      0|            std::size_t len2 = (std::min)(remaining_, length-len);
  304|      0|            position_ += len2;
  305|      0|            data_end_ += len2;
  306|      0|            remaining_ -= len2;
  307|      0|            len += len2;
  308|      0|        }
  309|    516|    }

_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|      4|{
   88|      4|    return jsoncons::span<uint16_t>{reinterpret_cast<uint16_t*>(bytes.data()), bytes.size()/sizeof(uint16_t)};
   89|      4|}
_ZN8jsoncons16typed_array_castImEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   99|     12|{
  100|     12|    return jsoncons::span<uint64_t>{reinterpret_cast<uint64_t*>(bytes.data()), bytes.size()/sizeof(uint64_t)};
  101|     12|}
_ZN8jsoncons16typed_array_castIsEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  111|  2.76k|{
  112|  2.76k|    return jsoncons::span<int16_t>{reinterpret_cast<int16_t*>(bytes.data()), bytes.size()/sizeof(int16_t)};
  113|  2.76k|}
_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|}

_ZN8jsoncons6binary9byte_swapItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|     13|    {
   29|     13|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|     13|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  466|     13|#      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|     13|    }
_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|     18|    {
   40|     18|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|     18|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  462|     18|#  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|     18|    }
_ZN8jsoncons6binary13native_to_bigImNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6detail6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|      5|    {
  128|      5|        T val2 = byte_swap(val);
  129|      5|        uint8_t buf[sizeof(T)];
  130|      5|        std::memcpy(buf, &val2, sizeof(T));
  131|      5|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 40, False: 5]
  ------------------
  132|     40|        {
  133|     40|            *d_first++ = item;
  134|     40|        }
  135|      5|    }
_ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|     16|    {
   52|     16|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|     16|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|     16|#  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|     16|    }
_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|     13|    {
  183|     13|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 13]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     13|        T val;
  188|     13|        std::memcpy(&val,first,sizeof(T));
  189|     13|        return byte_swap(val);
  190|     13|    }
_ZN8jsoncons6binary13big_to_nativeIjNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|     10|    {
  183|     10|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 10]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     10|        T val;
  188|     10|        std::memcpy(&val,first,sizeof(T));
  189|     10|        return byte_swap(val);
  190|     10|    }
_ZN8jsoncons6binary13big_to_nativeImNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|     11|    {
  183|     11|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 11]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     11|        T val;
  188|     11|        std::memcpy(&val,first,sizeof(T));
  189|     11|        return byte_swap(val);
  190|     11|    }

_ZN8jsoncons6detail23bytes_to_base64_genericIPKhNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS4_9enable_ifIXsr3std7is_sameINS4_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESD_SD_PKcRT0_:
   44|    327|    {
   45|    327|        std::size_t count = 0;
   46|    327|        unsigned char a3[3];
   47|    327|        unsigned char a4[4];
   48|    327|        unsigned char fill = alphabet[64];
   49|    327|        int i = 0;
   50|    327|        int j = 0;
   51|       |
   52|    931|        while (first != last)
  ------------------
  |  Branch (52:16): [True: 604, False: 327]
  ------------------
   53|    604|        {
   54|    604|            a3[i++] = *first++;
   55|    604|            if (i == 3)
  ------------------
  |  Branch (55:17): [True: 186, False: 418]
  ------------------
   56|    186|            {
   57|    186|                a4[0] = (a3[0] & 0xfc) >> 2;
   58|    186|                a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   59|    186|                a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   60|    186|                a4[3] = a3[2] & 0x3f;
   61|       |
   62|    930|                for (i = 0; i < 4; i++) 
  ------------------
  |  Branch (62:29): [True: 744, False: 186]
  ------------------
   63|    744|                {
   64|    744|                    result.push_back(alphabet[a4[i]]);
   65|    744|                    ++count;
   66|    744|                }
   67|    186|                i = 0;
   68|    186|            }
   69|    604|        }
   70|       |
   71|    327|        if (i > 0)
  ------------------
  |  Branch (71:13): [True: 46, False: 281]
  ------------------
   72|     46|        {
   73|    138|            for (j = i; j < 3; ++j) 
  ------------------
  |  Branch (73:25): [True: 92, False: 46]
  ------------------
   74|     92|            {
   75|     92|                a3[j] = 0;
   76|     92|            }
   77|       |
   78|     46|            a4[0] = (a3[0] & 0xfc) >> 2;
   79|     46|            a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   80|     46|            a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   81|       |
   82|    138|            for (j = 0; j < i + 1; ++j) 
  ------------------
  |  Branch (82:25): [True: 92, False: 46]
  ------------------
   83|     92|            {
   84|     92|                result.push_back(alphabet[a4[j]]);
   85|     92|                ++count;
   86|     92|            }
   87|       |
   88|     46|            if (fill != 0)
  ------------------
  |  Branch (88:17): [True: 0, False: 46]
  ------------------
   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|     46|        }
   97|       |
   98|    327|        return count;
   99|    327|    }
_ZNK8jsoncons16byte_string_view5beginEv:
  409|    327|        {
  410|    327|            return data_;
  411|    327|        }
_ZNK8jsoncons16byte_string_view3endEv:
  413|    327|        {
  414|    327|            return data_ + size_;
  415|    327|        }
_ZN8jsoncons18bytes_to_base64urlIPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  177|    327|    {
  178|    327|        static constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  179|    327|                                                      "abcdefghijklmnopqrstuvwxyz"
  180|    327|                                                      "0123456789-_"
  181|    327|                                                      "\0";
  182|    327|        return detail::bytes_to_base64_generic(first, last, alphabet, result);
  183|    327|    }
_ZNK8jsoncons16byte_string_view4dataEv:
  399|    813|        {
  400|    813|            return data_;
  401|    813|        }
_ZNK8jsoncons16byte_string_view4sizeEv:
  403|    975|        {
  404|    975|            return size_;
  405|    975|        }
_ZN8jsoncons16byte_string_viewC2EPKhm:
  362|  1.14k|            : data_(data), size_(length)
  363|  1.14k|        {
  364|  1.14k|        }
_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|  2.61M|{
   43|  2.61M|    using char_type = typename Result::value_type;
   44|       |
   45|  2.61M|    char_type buf[255];
   46|  2.61M|    char_type *p = buf;
   47|  2.61M|    const char_type* last = buf+255;
   48|       |
   49|  2.61M|    bool is_negative = value < 0;
   50|       |
   51|  2.61M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 2.61M]
  ------------------
   52|      0|    {
   53|      0|        do
   54|      0|        {
   55|      0|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|      0|        }
   57|      0|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 0, False: 0]
  |  Branch (57:33): [True: 0, False: 0]
  ------------------
   58|      0|    }
   59|  2.61M|    else
   60|  2.61M|    {
   61|       |
   62|  2.61M|        do
   63|  2.61M|        {
   64|  2.61M|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  2.61M|        }
   66|  2.61M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 139, False: 2.61M]
  |  Branch (66:33): [True: 139, False: 0]
  ------------------
   67|  2.61M|    }
   68|  2.61M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   49|  2.61M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 2.61M]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|  2.61M|    std::size_t count = (p - buf);
   71|  2.61M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 2.61M]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  5.23M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 2.61M, False: 2.61M]
  ------------------
   77|  2.61M|    {
   78|  2.61M|        result.push_back(*p);
   79|  2.61M|    }
   80|       |
   81|  2.61M|    return count;
   82|  2.61M|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|    525|{
   43|    525|    using char_type = typename Result::value_type;
   44|       |
   45|    525|    char_type buf[255];
   46|    525|    char_type *p = buf;
   47|    525|    const char_type* last = buf+255;
   48|       |
   49|    525|    bool is_negative = value < 0;
   50|       |
   51|    525|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 446, False: 79]
  ------------------
   52|    446|    {
   53|    446|        do
   54|    917|        {
   55|    917|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|    917|        }
   57|    917|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 471, False: 446]
  |  Branch (57:33): [True: 471, False: 0]
  ------------------
   58|    446|    }
   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|    525|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   49|    525|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 525]
  |  |  ------------------
  |  |   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|    525|    std::size_t count = (p - buf);
   71|    525|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 446, False: 79]
  ------------------
   72|    446|    {
   73|    446|        result.push_back('-');
   74|    446|        ++count;
   75|    446|    }
   76|  1.82k|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 1.30k, False: 525]
  ------------------
   77|  1.30k|    {
   78|  1.30k|        result.push_back(*p);
   79|  1.30k|    }
   80|       |
   81|    525|    return count;
   82|    525|}
_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|      8|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|      8|    {
  489|      8|#if !defined(JSONCONS_NO_LOCALECONV)
  490|      8|        struct lconv *lc = localeconv();
  491|      8|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 8, False: 0]
  |  Branch (491:30): [True: 8, False: 0]
  ------------------
  492|      8|        {
  493|      8|            decimal_point_ = lc->decimal_point[0];
  494|      8|        }
  495|      8|#endif
  496|      8|    }
_ZN8jsoncons12write_doubleclINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEmdRT_:
  503|      8|    {
  504|      8|        std::size_t count = 0;
  505|       |
  506|      8|        char number_buffer[200];
  507|      8|        int length = 0;
  508|       |
  509|      8|        switch (float_format_)
  510|      8|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 8]
  ------------------
  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: 8]
  ------------------
  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|      8|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 8, False: 0]
  ------------------
  552|      8|            {
  553|      8|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 8]
  ------------------
  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|      8|                else
  563|      8|                {
  564|      8|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 8]
  ------------------
  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|      8|                }             
  569|      8|                break;
  570|      8|            }
  571|      8|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 8]
  ------------------
  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|      8|        }
  575|      8|        return count;
  576|      8|    }
_ZN8jsoncons15prettify_stringINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKciiiiRT_:
  171|      8|{
  172|      8|    int nb_digits = length;
  173|      8|    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|      8|    int kk = nb_digits + k;
  179|       |
  180|      8|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 2, False: 6]
  |  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|      8|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 8, False: 0]
  |  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|      2|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 2, False: 0]
  |  Branch (209:30): [True: 0, False: 2]
  ------------------
  210|      0|    {
  211|      0|        offset = 2 - kk;
  212|       |
  213|      0|        result.push_back('0');
  214|      0|        result.push_back('.');
  215|      0|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 0, False: 0]
  ------------------
  216|      0|            result.push_back('0');
  217|      0|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 0, False: 0]
  ------------------
  218|      0|        {
  219|      0|            result.push_back(buffer[i]);
  220|      0|        }
  221|      0|    } 
  222|      2|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 0, False: 2]
  ------------------
  223|      0|    {
  224|      0|        result.push_back(buffer[0]);
  225|      0|        result.push_back('e');
  226|      0|        fill_exponent(kk - 1, result);
  227|      0|    } 
  228|      2|    else
  229|      2|    {
  230|      2|        result.push_back(buffer[0]);
  231|      2|        result.push_back('.');
  232|     33|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 31, False: 2]
  ------------------
  233|     31|        {
  234|     31|            result.push_back(buffer[i]);
  235|     31|        }
  236|      2|        result.push_back('e');
  237|      2|        fill_exponent(kk - 1, result);
  238|      2|    }
  239|      8|}
_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|      8|{
  476|      8|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|      8|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb1EEE:
  366|      8|{
  367|      8|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 0, False: 8]
  ------------------
  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|      8|    int length = 0;
  376|      8|    int k;
  377|       |
  378|      8|    char buffer[100];
  379|       |
  380|      8|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 2, False: 6]
  ------------------
  381|      8|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 8, False: 0]
  ------------------
  382|      8|    {
  383|      8|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 2, False: 6]
  ------------------
  384|      2|        {
  385|      2|            result.push_back('-');
  386|      2|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|      8|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|      8|        return true;
  391|      8|    }
  392|      0|    else
  393|      0|    {
  394|      0|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|      0|    }
  396|      8|}
_ZN8jsoncons15prettify_stringINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKciiiiRT_:
  171|     17|{
  172|     17|    int nb_digits = 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|      2|{
   90|      2|    using char_type = typename Result::value_type;
   91|       |
   92|      2|    char_type buf[255];
   93|      2|    char_type *p = buf;
   94|      2|    const char_type* last = buf+255;
   95|       |
   96|      2|    bool is_negative = value < 0;
   97|       |
   98|      2|    if (value < 0)
  ------------------
  |  Branch (98:9): [True: 0, False: 2]
  ------------------
   99|      0|    {
  100|      0|        do
  101|      0|        {
  102|      0|            *p++ = to_hex_character(0-(value % 16));
  103|      0|        }
  104|      0|        while ((value /= 16) && (p < last));
  ------------------
  |  Branch (104:16): [True: 0, False: 0]
  |  Branch (104:33): [True: 0, False: 0]
  ------------------
  105|      0|    }
  106|      2|    else
  107|      2|    {
  108|       |
  109|      2|        do
  110|     17|        {
  111|     17|            *p++ = to_hex_character(value % 16);
  112|     17|        }
  113|     17|        while ((value /= 16) && (p < last));
  ------------------
  |  Branch (113:16): [True: 15, False: 2]
  |  Branch (113:33): [True: 15, False: 0]
  ------------------
  114|      2|    }
  115|      2|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   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 ))); }
  ------------------
  116|       |
  117|      2|    std::size_t count = (p - buf);
  118|      2|    if (is_negative)
  ------------------
  |  Branch (118:9): [True: 0, False: 2]
  ------------------
  119|      0|    {
  120|      0|        result.push_back('-');
  121|      0|        ++count;
  122|      0|    }
  123|     19|    while (--p >= buf)
  ------------------
  |  Branch (123:12): [True: 17, False: 2]
  ------------------
  124|     17|    {
  125|     17|        result.push_back(*p);
  126|     17|    }
  127|       |
  128|      2|    return count;
  129|      2|}
_ZN8jsoncons16to_hex_characterEh:
   33|     17|{
   34|     17|    return (char)((c < 10) ? ('0' + c) : ('A' - 10 + c));
  ------------------
  |  Branch (34:19): [True: 16, False: 1]
  ------------------
   35|     17|}

_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEEC2EOS8_RKS9_:
  125|     12|       : basic_cbor_encoder(std::forward<Sink>(sink), cbor_encode_options(), alloc)
  126|     12|    {
  127|     12|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEEC2EOS8_RKNS0_19cbor_encode_optionsERKS9_:
  131|     12|       : sink_(std::forward<Sink>(sink)), 
  132|     12|         max_nesting_depth_(options.max_nesting_depth()), 
  133|     12|         pack_strings_(options.pack_strings()),
  134|     12|         use_typed_arrays_(options.use_typed_arrays()),
  135|     12|         alloc_(alloc),
  136|     12|         stack_(alloc),
  137|     12|         stringref_map_(alloc),
  138|     12|         bytestringref_map_(alloc)
  139|     12|    {
  140|     12|        if (options.pack_strings())
  ------------------
  |  Branch (140:13): [True: 0, False: 12]
  ------------------
  141|      0|        {
  142|      0|            write_tag(256);
  143|      0|        }
  144|     12|    }
_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: 15]
  ------------------
  427|  1.04M|        {
  428|  1.04M|            sink_.push_back(static_cast<uint8_t>(major_type + length));
  429|  1.04M|        }
  430|     15|        else if (length <= 0xff)
  ------------------
  |  Branch (430:18): [True: 4, False: 11]
  ------------------
  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|     11|        else if (length <= 0xffff)
  ------------------
  |  Branch (435:18): [True: 0, False: 11]
  ------------------
  436|      0|        {
  437|      0|            sink_.push_back(static_cast<uint8_t>(major_type + 0x19));
  438|      0|            binary::native_to_big(static_cast<uint16_t>(length),
  439|      0|                                            std::back_inserter(sink_));
  440|      0|        }
  441|     11|        else if (length <= 0xffffffff)
  ------------------
  |  Branch (441:18): [True: 6, False: 5]
  ------------------
  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|      5|        else
  448|      5|        {
  449|      5|            sink_.push_back(static_cast<uint8_t>(major_type + 0x1b));
  450|      5|            binary::native_to_big(static_cast<uint64_t>(length),
  451|      5|                                            std::back_inserter(sink_));
  452|      5|        }
  453|  1.04M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  334|     93|    {
  335|     93|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|     93|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 93]
  |  |  ------------------
  ------------------
  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|     93|        stack_.emplace_back(cbor_container_type::array, length);
  341|     93|        write_type_and_length(0x80, length);
  342|     93|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     93|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  343|     93|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_itemC2ENS0_19cbor_container_typeEm:
   74|     99|           : type_(type), length_(length)
   75|     99|        {
   76|     99|        }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE15visit_end_arrayERKNS_11ser_contextERNS3_10error_codeE:
  346|     87|    {
  347|     87|        JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   49|     87|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 87]
  |  |  ------------------
  |  |   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|     87|        --nesting_depth_;
  349|       |
  350|     87|        if (stack_.back().is_indefinite_length())
  ------------------
  |  Branch (350:13): [True: 0, False: 87]
  ------------------
  351|      0|        {
  352|      0|            sink_.push_back(0xff);
  353|      0|        }
  354|     87|        else
  355|     87|        {
  356|     87|            if (stack_.back().count() < stack_.back().length())
  ------------------
  |  Branch (356:17): [True: 0, False: 87]
  ------------------
  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|     87|            if (stack_.back().count() > stack_.back().length())
  ------------------
  |  Branch (361:17): [True: 0, False: 87]
  ------------------
  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|     87|        }
  367|       |
  368|     87|        stack_.pop_back();
  369|     87|        end_value();
  370|       |
  371|     87|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     87|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  372|     87|    }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item20is_indefinite_lengthEv:
   96|     90|        {
   97|     90|            return type_ == cbor_container_type::indefinite_length_array || type_ == cbor_container_type::indefinite_length_object;
  ------------------
  |  Branch (97:20): [True: 0, False: 90]
  |  Branch (97:77): [True: 0, False: 90]
  ------------------
   98|     90|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item5countEv:
   86|    180|        {
   87|    180|            return is_object() ? index_/2 : index_;
  ------------------
  |  Branch (87:20): [True: 6, False: 174]
  ------------------
   88|    180|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item9is_objectEv:
   91|    180|        {
   92|    180|            return type_ == cbor_container_type::object || type_ == cbor_container_type::indefinite_length_object;
  ------------------
  |  Branch (92:20): [True: 6, False: 174]
  |  Branch (92:60): [True: 0, False: 174]
  ------------------
   93|    180|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item6lengthEv:
   81|    180|        {
   82|    180|            return length_;
   83|    180|        }
_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: 5]
  ------------------
 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|     22|    {
 1059|     22|        switch (tag)
 1060|     22|        {
 1061|      0|            case semantic_tag::epoch_milli:
  ------------------
  |  Branch (1061:13): [True: 0, False: 22]
  ------------------
 1062|      0|            case semantic_tag::epoch_nano:
  ------------------
  |  Branch (1062:13): [True: 0, False: 22]
  ------------------
 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: 22]
  ------------------
 1065|      0|                write_tag(1);
 1066|      0|                break;
 1067|     22|            default:
  ------------------
  |  Branch (1067:13): [True: 22, False: 0]
  ------------------
 1068|     22|                break;
 1069|     22|        }
 1070|     22|        write_int64_value(value);
 1071|     22|        end_value();
 1072|     22|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     22|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1073|     22|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17write_int64_valueEl:
 1108|     22|    {
 1109|     22|        if (value >= 0)
  ------------------
  |  Branch (1109:13): [True: 5, False: 17]
  ------------------
 1110|      5|        {
 1111|      5|            write_type_and_length(0x00, static_cast<uint64_t>(value));
 1112|      5|        }
 1113|     17|        else
 1114|     17|        {
 1115|     17|            write_type_and_length(0x20, static_cast<uint64_t>(-1 - value));
 1116|     17|        }
 1117|     22|    }
_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|      5|    {
  262|      5|        sink_.flush();
  263|      5|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  266|      1|    {
  267|      1|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  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|      1|        stack_.emplace_back(cbor_container_type::indefinite_length_object);
  273|       |        
  274|      1|        sink_.push_back(0xbf);
  275|      1|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      1|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  276|      1|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  279|      5|    {
  280|      5|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5]
  |  |  ------------------
  ------------------
  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|      5|        stack_.emplace_back(cbor_container_type::object, length);
  286|       |
  287|      5|        write_type_and_length(0xa0, length);
  288|       |
  289|      5|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      5|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  290|      5|    }
_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|    161|    {
  914|    161|        byte_string_chars_format encoding_hint;
  915|    161|        switch (tag)
  916|    161|        {
  917|      0|            case semantic_tag::base16:
  ------------------
  |  Branch (917:13): [True: 0, False: 161]
  ------------------
  918|      0|                encoding_hint = byte_string_chars_format::base16;
  919|      0|                break;
  920|      0|            case semantic_tag::base64:
  ------------------
  |  Branch (920:13): [True: 0, False: 161]
  ------------------
  921|      0|                encoding_hint = byte_string_chars_format::base64;
  922|      0|                break;
  923|      0|            case semantic_tag::base64url:
  ------------------
  |  Branch (923:13): [True: 0, False: 161]
  ------------------
  924|      0|                encoding_hint = byte_string_chars_format::base64url;
  925|      0|                break;
  926|    161|            default:
  ------------------
  |  Branch (926:13): [True: 161, False: 0]
  ------------------
  927|    161|                encoding_hint = byte_string_chars_format::none;
  928|    161|                break;
  929|    161|        }
  930|    161|        switch (encoding_hint)
  931|    161|        {
  932|      0|            case byte_string_chars_format::base64url:
  ------------------
  |  Branch (932:13): [True: 0, False: 161]
  ------------------
  933|      0|                write_tag(21);
  934|      0|                break;
  935|      0|            case byte_string_chars_format::base64:
  ------------------
  |  Branch (935:13): [True: 0, False: 161]
  ------------------
  936|      0|                write_tag(22);
  937|      0|                break;
  938|      0|            case byte_string_chars_format::base16:
  ------------------
  |  Branch (938:13): [True: 0, False: 161]
  ------------------
  939|      0|                write_tag(23);
  940|      0|                break;
  941|    161|            default:
  ------------------
  |  Branch (941:13): [True: 161, False: 0]
  ------------------
  942|    161|                break;
  943|    161|        }
  944|    161|        if (pack_strings_ && b.size() >= jsoncons::cbor::detail::min_length_for_stringref(next_stringref_))
  ------------------
  |  Branch (944:13): [True: 0, False: 161]
  |  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|    161|        else
  960|    161|        {
  961|    161|            write_byte_string(b);
  962|    161|        }
  963|       |
  964|    161|        end_value();
  965|    161|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    161|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  966|    161|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17write_byte_stringERKNS_16byte_string_viewE:
 1000|    162|    {
 1001|    162|        write_type_and_length(0x40, b.size());
 1002|       |
 1003|    162|        sink_.append(b.data(), b.size());
 1004|    162|    }
_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|     12|    {
  148|     12|        JSONCONS_TRY
  ------------------
  |  |   37|     12|    #define JSONCONS_TRY try
  ------------------
  149|     12|        {
  150|     12|            sink_.flush();
  151|     12|        }
  152|     12|        JSONCONS_CATCH(...)
  153|     12|        {
  154|      0|        }
  155|     12|    }

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

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

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

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

_ZN8jsoncons4cbor20typed_array_iteratorD2Ev:
   43|  1.40k|    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_tagERKS5_:
  106|      8|        : data_(std::move(data), alloc), 
  107|      8|          span_(typed_array_cast<ValueType>(data_)), 
  108|      8|          array_tag_(array_tag), 
  109|      8|          extent_(span_.size()), 
  110|      8|          tag_(tag), 
  111|      8|          func_(Func{})
  112|      8|    {
  113|      8|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|    120|    {
  142|    120|        return done_;
  143|    120|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|     68|    {
  148|     68|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|     68|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 8, False: 60]
  |  |  ------------------
  ------------------
  149|      8|        {
  150|      8|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|      8|            first_ = false;
  152|      8|        }
  153|     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]
  |  |  ------------------
  ------------------
  154|     52|        {
  155|     52|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|     52|            ++index_;
  157|     52|        }
  158|      8|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 8, False: 0]
  ------------------
  159|      8|        {
  160|      8|            visitor.end_array(context, ec);
  161|      8|            done_ = true;
  162|      8|        }
  163|     68|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|      2|        : data_(std::move(data), alloc), 
  107|      2|          span_(typed_array_cast<ValueType>(data_)), 
  108|      2|          array_tag_(array_tag), 
  109|      2|          extent_(span_.size()), 
  110|      2|          tag_(tag), 
  111|      2|          func_(Func{})
  112|      2|    {
  113|      2|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|      4|    {
  142|      4|        return done_;
  143|      4|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|      4|    {
  148|      4|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 2]
  |  |  ------------------
  ------------------
  149|      2|        {
  150|      2|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|      2|            first_ = false;
  152|      2|        }
  153|      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]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      2|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 2, False: 0]
  ------------------
  159|      2|        {
  160|      2|            visitor.end_array(context, ec);
  161|      2|            done_ = true;
  162|      2|        }
  163|      4|    }
_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_tagERKS5_:
  106|      6|        : data_(std::move(data), alloc), 
  107|      6|          span_(typed_array_cast<ValueType>(data_)), 
  108|      6|          array_tag_(array_tag), 
  109|      6|          extent_(span_.size()), 
  110|      6|          tag_(tag), 
  111|      6|          func_(Func{})
  112|      6|    {
  113|      6|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|     16|    {
  142|     16|        return done_;
  143|     16|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|     14|    {
  148|     14|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|     14|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 6, False: 8]
  |  |  ------------------
  ------------------
  149|      6|        {
  150|      6|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|      6|            first_ = false;
  152|      6|        }
  153|      8|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|      8|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 2, False: 6]
  |  |  ------------------
  ------------------
  154|      2|        {
  155|      2|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      2|            ++index_;
  157|      2|        }
  158|      6|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 6, False: 0]
  ------------------
  159|      6|        {
  160|      6|            visitor.end_array(context, ec);
  161|      6|            done_ = true;
  162|      6|        }
  163|     14|    }
_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_tagERKS5_:
  106|  1.38k|        : data_(std::move(data), alloc), 
  107|  1.38k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  1.38k|          array_tag_(array_tag), 
  109|  1.38k|          extent_(span_.size()), 
  110|  1.38k|          tag_(tag), 
  111|  1.38k|          func_(Func{})
  112|  1.38k|    {
  113|  1.38k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIsNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|  2.93k|    {
  142|  2.93k|        return done_;
  143|  2.93k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIsNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|  2.85k|    {
  148|  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]
  |  |  ------------------
  ------------------
  149|  1.38k|        {
  150|  1.38k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  1.38k|            first_ = false;
  152|  1.38k|        }
  153|  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]
  |  |  ------------------
  ------------------
  154|     82|        {
  155|     82|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|     82|            ++index_;
  157|     82|        }
  158|  1.38k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 1.38k, False: 0]
  ------------------
  159|  1.38k|        {
  160|  1.38k|            visitor.end_array(context, ec);
  161|  1.38k|            done_ = true;
  162|  1.38k|        }
  163|  2.85k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|      2|        : data_(std::move(data), alloc), 
  107|      2|          span_(typed_array_cast<ValueType>(data_)), 
  108|      2|          array_tag_(array_tag), 
  109|      2|          extent_(span_.size()), 
  110|      2|          tag_(tag), 
  111|      2|          func_(Func{})
  112|      2|    {
  113|      2|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|      4|    {
  142|      4|        return done_;
  143|      4|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|      4|    {
  148|      4|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 2]
  |  |  ------------------
  ------------------
  149|      2|        {
  150|      2|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|      2|            first_ = false;
  152|      2|        }
  153|      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]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      2|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 2, False: 0]
  ------------------
  159|      2|        {
  160|      2|            visitor.end_array(context, ec);
  161|      2|            done_ = true;
  162|      2|        }
  163|      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_tagERKS5_:
  106|      2|        : data_(std::move(data), alloc), 
  107|      2|          span_(typed_array_cast<ValueType>(data_)), 
  108|      2|          array_tag_(array_tag), 
  109|      2|          extent_(span_.size()), 
  110|      2|          tag_(tag), 
  111|      2|          func_(Func{})
  112|      2|    {
  113|      2|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|     12|    {
  142|     12|        return done_;
  143|     12|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|      8|    {
  148|      8|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 6]
  |  |  ------------------
  ------------------
  149|      2|        {
  150|      2|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|      2|            first_ = false;
  152|      2|        }
  153|      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]
  |  |  ------------------
  ------------------
  154|      4|        {
  155|      4|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      4|            ++index_;
  157|      4|        }
  158|      2|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 2, False: 0]
  ------------------
  159|      2|        {
  160|      2|            visitor.end_array(context, ec);
  161|      2|            done_ = true;
  162|      2|        }
  163|      8|    }