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

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

_ZN8jsoncons6detail8expectedImNSt3__14errcEEC2ImEENS2_9enable_ifIXsr3std24is_default_constructibleIT_EE5valueEiE4typeE:
   41|      2|        : expected(T{})
   42|      2|    {
   43|      2|    }
_ZN8jsoncons6detail8expectedImNSt3__14errcEEC2EOm:
   52|    462|        : has_value_(true)
   53|    462|    {
   54|    462|        construct(std::move(value));
   55|    462|    }
_ZN8jsoncons6detail8expectedImNSt3__14errcEE9constructEOm:
  274|    462|    {
  275|    462|        ::new (&value_) T(std::move(value));
  276|    462|        has_value_ = true;
  277|    462|    }
_ZN8jsoncons6detail8expectedImNSt3__14errcEEC2IJS3_EEENS0_10unexpect_tEDpOT_:
   66|     17|        : has_value_(false)
   67|     17|    {
   68|     17|        ::new (&error_) E(std::forward<Args>(args)...);
   69|     17|    }
_ZNK8jsoncons6detail8expectedImNSt3__14errcEEcvbEv:
  146|    479|    {
  147|    479|        return has_value_;
  148|    479|    }
_ZNR8jsoncons6detail8expectedImNSt3__14errcEEdeEv:
  231|    921|    {
  232|    921|        return this->value_;
  233|    921|    }
_ZN8jsoncons6detail8expectedImNSt3__14errcEED2Ev:
  100|    479|    {
  101|    479|        destroy();
  102|    479|    }
_ZN8jsoncons6detail8expectedImNSt3__14errcEE7destroyEv:
  280|    479|    {
  281|    479|        if (has_value_) 
  ------------------
  |  Branch (281:13): [True: 462, False: 17]
  ------------------
  282|    462|        {
  283|    462|            value_.~T();
  284|    462|            has_value_ = false;
  285|    462|        }
  286|     17|        else
  287|     17|        {
  288|     17|            error_.~E();
  289|     17|        }
  290|    479|    }

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

_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4sizeEv:
  116|  18.9M|        {
  117|  18.9M|            return size_;
  118|  18.9M|        }
_ZNK8jsoncons6detail4spanIKtLm18446744073709551615EE4sizeEv:
  116|  13.2M|        {
  117|  13.2M|            return size_;
  118|  13.2M|        }
_ZNK8jsoncons6detail4spanIKjLm18446744073709551615EE4sizeEv:
  116|  2.74M|        {
  117|  2.74M|            return size_;
  118|  2.74M|        }
_ZNK8jsoncons6detail4spanIKmLm18446744073709551615EE4sizeEv:
  116|   510k|        {
  117|   510k|            return size_;
  118|   510k|        }
_ZNK8jsoncons6detail4spanIKaLm18446744073709551615EE4sizeEv:
  116|  4.68M|        {
  117|  4.68M|            return size_;
  118|  4.68M|        }
_ZNK8jsoncons6detail4spanIKsLm18446744073709551615EE4sizeEv:
  116|  1.07M|        {
  117|  1.07M|            return size_;
  118|  1.07M|        }
_ZNK8jsoncons6detail4spanIKiLm18446744073709551615EE4sizeEv:
  116|   805k|        {
  117|   805k|            return size_;
  118|   805k|        }
_ZNK8jsoncons6detail4spanIKlLm18446744073709551615EE4sizeEv:
  116|   613k|        {
  117|   613k|            return size_;
  118|   613k|        }
_ZNK8jsoncons6detail4spanIKfLm18446744073709551615EE4sizeEv:
  116|   556k|        {
  117|   556k|            return size_;
  118|   556k|        }
_ZNK8jsoncons6detail4spanIKdLm18446744073709551615EE4sizeEv:
  116|   237k|        {
  117|   237k|            return size_;
  118|   237k|        }
_ZNK8jsoncons6detail4spanIhLm18446744073709551615EE4dataEv:
  111|   196k|        {
  112|   196k|            return data_;
  113|   196k|        }
_ZNK8jsoncons6detail4spanIhLm18446744073709551615EE4sizeEv:
  116|   196k|        {
  117|   196k|            return size_;
  118|   196k|        }
_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2EPS2_m:
   61|  3.87M|            : data_(data), size_(size)
   62|  3.87M|        {
   63|  3.87M|        }
_ZN8jsoncons6detail4spanIhLm18446744073709551615EEC2INSt3__16vectorIhNS4_9allocatorIhEEEEEERT_PNS4_9enable_ifIXaaaaaantsr7is_spanIS9_EE5valuentsr10ext_traits12is_std_arrayIS9_EE5valuesr10ext_traits21is_compatible_elementIS9_hEE5valuesr10ext_traits17has_data_and_sizeIS9_EE5valueEvE4typeE:
   68|   196k|            : data_(c.data()), size_(c.size())
   69|   196k|        {
   70|   196k|        }
_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2IhLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|  7.28k|            : data_(s.data()), size_(s.size())
  103|  7.28k|        {
  104|  7.28k|        }
_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EEixEm:
  126|  2.25M|         {
  127|  2.25M|             return data_[index];
  128|  2.25M|         }
_ZN8jsoncons6detail4spanItLm18446744073709551615EEC2EPtm:
   61|  46.7k|            : data_(data), size_(size)
   62|  46.7k|        {
   63|  46.7k|        }
_ZNK8jsoncons6detail4spanItLm18446744073709551615EE4sizeEv:
  116|  1.80M|        {
  117|  1.80M|            return size_;
  118|  1.80M|        }
_ZNK8jsoncons6detail4spanItLm18446744073709551615EEixEm:
  126|  3.49M|         {
  127|  3.49M|             return data_[index];
  128|  3.49M|         }
_ZN8jsoncons6detail4spanIKtLm18446744073709551615EEC2ItLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|  23.3k|            : data_(s.data()), size_(s.size())
  103|  23.3k|        {
  104|  23.3k|        }
_ZNK8jsoncons6detail4spanItLm18446744073709551615EE4dataEv:
  111|  23.3k|        {
  112|  23.3k|            return data_;
  113|  23.3k|        }
_ZNK8jsoncons6detail4spanIKtLm18446744073709551615EEixEm:
  126|  13.2M|         {
  127|  13.2M|             return data_[index];
  128|  13.2M|         }
_ZN8jsoncons6detail4spanIjLm18446744073709551615EEC2EPjm:
   61|  11.1k|            : data_(data), size_(size)
   62|  11.1k|        {
   63|  11.1k|        }
_ZNK8jsoncons6detail4spanIjLm18446744073709551615EE4sizeEv:
  116|  2.73M|        {
  117|  2.73M|            return size_;
  118|  2.73M|        }
_ZNK8jsoncons6detail4spanIjLm18446744073709551615EEixEm:
  126|  5.44M|         {
  127|  5.44M|             return data_[index];
  128|  5.44M|         }
_ZN8jsoncons6detail4spanIKjLm18446744073709551615EEC2IjLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|  5.56k|            : data_(s.data()), size_(s.size())
  103|  5.56k|        {
  104|  5.56k|        }
_ZNK8jsoncons6detail4spanIjLm18446744073709551615EE4dataEv:
  111|  5.56k|        {
  112|  5.56k|            return data_;
  113|  5.56k|        }
_ZNK8jsoncons6detail4spanIKjLm18446744073709551615EEixEm:
  126|  2.72M|         {
  127|  2.72M|             return data_[index];
  128|  2.72M|         }
_ZN8jsoncons6detail4spanImLm18446744073709551615EEC2EPmm:
   61|  36.5k|            : data_(data), size_(size)
   62|  36.5k|        {
   63|  36.5k|        }
_ZNK8jsoncons6detail4spanImLm18446744073709551615EE4sizeEv:
  116|   495k|        {
  117|   495k|            return size_;
  118|   495k|        }
_ZNK8jsoncons6detail4spanImLm18446744073709551615EEixEm:
  126|   906k|         {
  127|   906k|             return data_[index];
  128|   906k|         }
_ZN8jsoncons6detail4spanIKmLm18446744073709551615EEC2ImLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|  18.2k|            : data_(s.data()), size_(s.size())
  103|  18.2k|        {
  104|  18.2k|        }
_ZNK8jsoncons6detail4spanImLm18446744073709551615EE4dataEv:
  111|  18.2k|        {
  112|  18.2k|            return data_;
  113|  18.2k|        }
_ZNK8jsoncons6detail4spanIKmLm18446744073709551615EEixEm:
  126|   456k|         {
  127|   456k|             return data_[index];
  128|   456k|         }
_ZN8jsoncons6detail4spanIaLm18446744073709551615EEC2EPam:
   61|  7.87k|            : data_(data), size_(size)
   62|  7.87k|        {
   63|  7.87k|        }
_ZNK8jsoncons6detail4spanIaLm18446744073709551615EE4sizeEv:
  116|  7.87k|        {
  117|  7.87k|            return size_;
  118|  7.87k|        }
_ZN8jsoncons6detail4spanIKaLm18446744073709551615EEC2IaLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|  3.93k|            : data_(s.data()), size_(s.size())
  103|  3.93k|        {
  104|  3.93k|        }
_ZNK8jsoncons6detail4spanIaLm18446744073709551615EE4dataEv:
  111|  3.93k|        {
  112|  3.93k|            return data_;
  113|  3.93k|        }
_ZNK8jsoncons6detail4spanIKaLm18446744073709551615EEixEm:
  126|  4.66M|         {
  127|  4.66M|             return data_[index];
  128|  4.66M|         }
_ZN8jsoncons6detail4spanIsLm18446744073709551615EEC2EPsm:
   61|  19.1k|            : data_(data), size_(size)
   62|  19.1k|        {
   63|  19.1k|        }
_ZNK8jsoncons6detail4spanIsLm18446744073709551615EE4sizeEv:
  116|   649k|        {
  117|   649k|            return size_;
  118|   649k|        }
_ZNK8jsoncons6detail4spanIsLm18446744073709551615EEixEm:
  126|  1.24M|         {
  127|  1.24M|             return data_[index];
  128|  1.24M|         }
_ZN8jsoncons6detail4spanIKsLm18446744073709551615EEC2IsLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|  9.58k|            : data_(s.data()), size_(s.size())
  103|  9.58k|        {
  104|  9.58k|        }
_ZNK8jsoncons6detail4spanIsLm18446744073709551615EE4dataEv:
  111|  9.58k|        {
  112|  9.58k|            return data_;
  113|  9.58k|        }
_ZNK8jsoncons6detail4spanIKsLm18446744073709551615EEixEm:
  126|  1.05M|         {
  127|  1.05M|             return data_[index];
  128|  1.05M|         }
_ZN8jsoncons6detail4spanIiLm18446744073709551615EEC2EPim:
   61|  16.5k|            : data_(data), size_(size)
   62|  16.5k|        {
   63|  16.5k|        }
_ZNK8jsoncons6detail4spanIiLm18446744073709551615EE4sizeEv:
  116|   786k|        {
  117|   786k|            return size_;
  118|   786k|        }
_ZNK8jsoncons6detail4spanIiLm18446744073709551615EEixEm:
  126|  1.52M|         {
  127|  1.52M|             return data_[index];
  128|  1.52M|         }
_ZN8jsoncons6detail4spanIKiLm18446744073709551615EEC2IiLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|  8.27k|            : data_(s.data()), size_(s.size())
  103|  8.27k|        {
  104|  8.27k|        }
_ZNK8jsoncons6detail4spanIiLm18446744073709551615EE4dataEv:
  111|  8.27k|        {
  112|  8.27k|            return data_;
  113|  8.27k|        }
_ZNK8jsoncons6detail4spanIKiLm18446744073709551615EEixEm:
  126|   780k|         {
  127|   780k|             return data_[index];
  128|   780k|         }
_ZN8jsoncons6detail4spanIlLm18446744073709551615EEC2EPlm:
   61|  7.75k|            : data_(data), size_(size)
   62|  7.75k|        {
   63|  7.75k|        }
_ZNK8jsoncons6detail4spanIlLm18446744073709551615EE4sizeEv:
  116|   612k|        {
  117|   612k|            return size_;
  118|   612k|        }
_ZNK8jsoncons6detail4spanIlLm18446744073709551615EEixEm:
  126|  1.20M|         {
  127|  1.20M|             return data_[index];
  128|  1.20M|         }
_ZN8jsoncons6detail4spanIKlLm18446744073709551615EEC2IlLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|  3.87k|            : data_(s.data()), size_(s.size())
  103|  3.87k|        {
  104|  3.87k|        }
_ZNK8jsoncons6detail4spanIlLm18446744073709551615EE4dataEv:
  111|  3.87k|        {
  112|  3.87k|            return data_;
  113|  3.87k|        }
_ZNK8jsoncons6detail4spanIKlLm18446744073709551615EEixEm:
  126|   601k|         {
  127|   601k|             return data_[index];
  128|   601k|         }
_ZN8jsoncons6detail4spanIfLm18446744073709551615EEC2EPfm:
   61|  25.4k|            : data_(data), size_(size)
   62|  25.4k|        {
   63|  25.4k|        }
_ZNK8jsoncons6detail4spanIfLm18446744073709551615EE4sizeEv:
  116|   475k|        {
  117|   475k|            return size_;
  118|   475k|        }
_ZNK8jsoncons6detail4spanIfLm18446744073709551615EEixEm:
  126|   894k|         {
  127|   894k|             return data_[index];
  128|   894k|         }
_ZN8jsoncons6detail4spanIKfLm18446744073709551615EEC2IfLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|  12.7k|            : data_(s.data()), size_(s.size())
  103|  12.7k|        {
  104|  12.7k|        }
_ZNK8jsoncons6detail4spanIfLm18446744073709551615EE4dataEv:
  111|  12.7k|        {
  112|  12.7k|            return data_;
  113|  12.7k|        }
_ZNK8jsoncons6detail4spanIKfLm18446744073709551615EEixEm:
  126|   518k|         {
  127|   518k|             return data_[index];
  128|   518k|         }
_ZN8jsoncons6detail4spanIdLm18446744073709551615EEC2EPdm:
   61|  10.9k|            : data_(data), size_(size)
   62|  10.9k|        {
   63|  10.9k|        }
_ZNK8jsoncons6detail4spanIdLm18446744073709551615EE4sizeEv:
  116|   189k|        {
  117|   189k|            return size_;
  118|   189k|        }
_ZNK8jsoncons6detail4spanIdLm18446744073709551615EEixEm:
  126|   350k|         {
  127|   350k|             return data_[index];
  128|   350k|         }
_ZN8jsoncons6detail4spanIKdLm18446744073709551615EEC2IdLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|  5.49k|            : data_(s.data()), size_(s.size())
  103|  5.49k|        {
  104|  5.49k|        }
_ZNK8jsoncons6detail4spanIdLm18446744073709551615EE4dataEv:
  111|  5.49k|        {
  112|  5.49k|            return data_;
  113|  5.49k|        }
_ZNK8jsoncons6detail4spanIKdLm18446744073709551615EEixEm:
  126|   221k|         {
  127|   221k|             return data_[index];
  128|   221k|         }
_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2Ev:
   58|  4.45M|        {
   59|  4.45M|        }
_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4dataEv:
  111|  8.32M|        {
  112|  8.32M|            return data_;
  113|  8.32M|        }
_ZNK8jsoncons6detail4spanIKmLm18446744073709551615EE5emptyEv:
  121|    479|        { 
  122|    479|            return size_ == 0; 
  123|    479|        }
_ZN8jsoncons6detail4spanIKmLm18446744073709551615EEC2INSt3__16vectorImNS5_9allocatorImEEEEEERT_PNS5_9enable_ifIXaaaaaantsr7is_spanISA_EE5valuentsr10ext_traits12is_std_arrayISA_EE5valuesr10ext_traits21is_compatible_elementISA_S2_EE5valuesr10ext_traits17has_data_and_sizeISA_EE5valueEvE4typeE:
   68|    479|            : data_(c.data()), size_(c.size())
   69|    479|        {
   70|    479|        }

_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1008|   782k|        {
 1009|   782k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1009:17): [True: 293k, False: 488k]
  ------------------
 1010|   293k|            {
 1011|   293k|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1011:21): [True: 285k, False: 8.69k]
  |  Branch (1011:86): [True: 281k, False: 3.55k]
  ------------------
 1012|   281k|                {
 1013|   281k|                    key_buffer_.push_back(',');
 1014|   281k|                }
 1015|   293k|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
 1016|   293k|                key_buffer_.push_back('[');
 1017|   293k|            }
 1018|   488k|            else
 1019|   488k|            {
 1020|   488k|                switch (level_stack_.back().target_kind())
 1021|   488k|                {
 1022|   457k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1022:21): [True: 457k, False: 30.6k]
  ------------------
 1023|   457k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1023:29): [True: 175k, False: 282k]
  |  Branch (1023:65): [True: 133k, False: 42.0k]
  ------------------
 1024|   133k|                        {
 1025|   133k|                            key_buffer_.push_back(',');
 1026|   133k|                        }
 1027|   457k|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
 1028|   457k|                        key_buffer_.push_back('[');
 1029|   457k|                        break;
 1030|  30.6k|                    default:
  ------------------
  |  Branch (1030:21): [True: 30.6k, False: 457k]
  ------------------
 1031|  30.6k|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::array);
 1032|  30.6k|                        destination_->begin_array(length, tag, context, ec);
 1033|  30.6k|                        break;
 1034|   488k|                }
 1035|   488k|            }
 1036|   782k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   782k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1037|   782k|        }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure6is_keyEv:
  815|   174M|            {
  816|   174M|                return even_odd_ == 0;
  817|   174M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure11target_kindEv:
  825|   116M|            {
  826|   116M|                return target_kind_;
  827|   116M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure5countEv:
  830|  40.4M|            {
  831|  40.4M|                return count_;
  832|  40.4M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structureC2ENS4_16json_target_kindENS4_19json_structure_kindE:
  798|  8.25M|                : target_kind_(state), structure_kind_(type), even_odd_(type == json_structure_kind::object ? 0 : 1)
  ------------------
  |  Branch (798:73): [True: 6.56M, False: 1.68M]
  ------------------
  799|  8.25M|            {
  800|  8.25M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure9is_objectEv:
  820|  99.9M|            {
  821|  99.9M|                return structure_kind_ == json_structure_kind::object;
  822|  99.9M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE15visit_end_arrayERKNS_11ser_contextERNS1_10error_codeE:
 1040|  1.62M|        {
 1041|  1.62M|            switch (level_stack_.back().target_kind())
 1042|  1.62M|            {
 1043|  1.49M|                case json_target_kind::buffer:
  ------------------
  |  Branch (1043:17): [True: 1.49M, False: 128k]
  ------------------
 1044|  1.49M|                    key_buffer_.push_back(']');
 1045|  1.49M|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|  1.49M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 1.49M]
  |  |  ------------------
  |  |   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.49M|                    level_stack_.pop_back();
 1047|  1.49M|                    if (level_stack_.back().target_kind() == json_target_kind::destination)
  ------------------
  |  Branch (1047:25): [True: 15.4k, False: 1.48M]
  ------------------
 1048|  15.4k|                    {
 1049|  15.4k|                        destination_->key(key_buffer_, context, ec);
 1050|  15.4k|                        key_buffer_.clear();
 1051|  15.4k|                    }
 1052|  1.48M|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (1052:30): [True: 286k, False: 1.19M]
  ------------------
 1053|   286k|                    {
 1054|   286k|                        key_buffer_.push_back(':');
 1055|   286k|                    }
 1056|  1.49M|                    level_stack_.back().advance();
 1057|  1.49M|                    break;
 1058|   128k|                default:
  ------------------
  |  Branch (1058:17): [True: 128k, False: 1.49M]
  ------------------
 1059|   128k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|   128k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 128k]
  |  |  ------------------
  |  |   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|   128k|                    level_stack_.pop_back();
 1061|   128k|                    level_stack_.back().advance();
 1062|   128k|                    destination_->end_array(context, ec);
 1063|   128k|                    break;
 1064|  1.62M|            }
 1065|  1.62M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.62M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1066|  1.62M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure7advanceEv:
  803|  58.8M|            {
  804|  58.8M|                if (!is_key())
  ------------------
  |  Branch (804:21): [True: 48.6M, False: 10.1M]
  ------------------
  805|  48.6M|                {
  806|  48.6M|                    ++count_;
  807|  48.6M|                }
  808|  58.8M|                if (is_object())
  ------------------
  |  Branch (808:21): [True: 20.2M, False: 38.5M]
  ------------------
  809|  20.2M|                {
  810|  20.2M|                    even_odd_ = !even_odd_;
  811|  20.2M|                }
  812|  58.8M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1233|  16.0M|        {
 1234|  16.0M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1234:17): [True: 3.52M, False: 12.5M]
  |  Branch (1234:49): [True: 11.1M, False: 1.34M]
  ------------------
 1235|  14.7M|            {
 1236|  14.7M|                key_.clear();
 1237|  14.7M|                jsoncons::from_integer(value,key_);
 1238|  14.7M|            }
 1239|       |
 1240|  16.0M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1240:17): [True: 3.52M, False: 12.5M]
  ------------------
 1241|  3.52M|            {
 1242|  3.52M|                switch (level_stack_.back().target_kind())
 1243|  3.52M|                {
 1244|  2.43M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1244:21): [True: 2.43M, False: 1.09M]
  ------------------
 1245|  2.43M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1245:29): [True: 2.42M, False: 3.62k]
  ------------------
 1246|  2.42M|                        {
 1247|  2.42M|                            key_buffer_.push_back(',');
 1248|  2.42M|                        }
 1249|  2.43M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1250|  2.43M|                        key_buffer_.push_back(':');
 1251|  2.43M|                        break;
 1252|  1.09M|                    default:
  ------------------
  |  Branch (1252:21): [True: 1.09M, False: 2.43M]
  ------------------
 1253|  1.09M|                        destination_->key(key_, context, ec);
 1254|  1.09M|                        break;
 1255|  3.52M|                }
 1256|  3.52M|            }
 1257|  12.5M|            else
 1258|  12.5M|            {
 1259|  12.5M|                switch (level_stack_.back().target_kind())
 1260|  12.5M|                {
 1261|  11.1M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1261:21): [True: 11.1M, False: 1.34M]
  ------------------
 1262|  11.1M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1262:29): [True: 8.75M, False: 2.42M]
  |  Branch (1262:65): [True: 8.72M, False: 28.1k]
  ------------------
 1263|  8.72M|                        {
 1264|  8.72M|                            key_buffer_.push_back(',');
 1265|  8.72M|                        }
 1266|  11.1M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1267|  11.1M|                        break;
 1268|  1.34M|                    default:
  ------------------
  |  Branch (1268:21): [True: 1.34M, False: 11.1M]
  ------------------
 1269|  1.34M|                        destination_->uint64_value(value, tag, context, ec);
 1270|  1.34M|                        break;
 1271|  12.5M|                }
 1272|  12.5M|            }
 1273|       |
 1274|  16.0M|            level_stack_.back().advance();
 1275|  16.0M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  16.0M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1276|  16.0M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1279|  8.92M|        {
 1280|  8.92M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1280:17): [True: 293k, False: 8.63M]
  |  Branch (1280:49): [True: 5.68M, False: 2.95M]
  ------------------
 1281|  5.97M|            {
 1282|  5.97M|                key_.clear();
 1283|  5.97M|                jsoncons::from_integer(value,key_);
 1284|  5.97M|            }
 1285|       |
 1286|  8.92M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1286:17): [True: 293k, False: 8.63M]
  ------------------
 1287|   293k|            {
 1288|   293k|                switch (level_stack_.back().target_kind())
 1289|   293k|                {
 1290|   256k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1290:21): [True: 256k, False: 36.0k]
  ------------------
 1291|   256k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1291:29): [True: 251k, False: 5.44k]
  ------------------
 1292|   251k|                        {
 1293|   251k|                            key_buffer_.push_back(',');
 1294|   251k|                        }
 1295|   256k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1296|   256k|                        key_buffer_.push_back(':');
 1297|   256k|                        break;
 1298|  36.0k|                    default:
  ------------------
  |  Branch (1298:21): [True: 36.0k, False: 256k]
  ------------------
 1299|  36.0k|                        destination_->key(key_, context, ec);
 1300|  36.0k|                        break;
 1301|   293k|                }
 1302|   293k|            }
 1303|  8.63M|            else
 1304|  8.63M|            {
 1305|  8.63M|                switch (level_stack_.back().target_kind())
 1306|  8.63M|                {
 1307|  5.68M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1307:21): [True: 5.68M, False: 2.95M]
  ------------------
 1308|  5.68M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1308:29): [True: 5.42M, False: 253k]
  |  Branch (1308:65): [True: 5.33M, False: 93.1k]
  ------------------
 1309|  5.33M|                        {
 1310|  5.33M|                            key_buffer_.push_back(',');
 1311|  5.33M|                        }
 1312|  5.68M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1313|  5.68M|                        break;
 1314|  2.95M|                    default:
  ------------------
  |  Branch (1314:21): [True: 2.95M, False: 5.68M]
  ------------------
 1315|  2.95M|                        destination_->int64_value(value, tag, context, ec);
 1316|  2.95M|                        break;
 1317|  8.63M|                }
 1318|  8.63M|            }
 1319|       |
 1320|  8.92M|            level_stack_.back().advance();
 1321|  8.92M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  8.92M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1322|  8.92M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1374|  13.1M|        {
 1375|  13.1M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1375:17): [True: 4.82k, False: 13.1M]
  |  Branch (1375:49): [True: 11.1M, False: 1.99M]
  ------------------
 1376|  11.1M|            {
 1377|  11.1M|                key_.clear();
 1378|  11.1M|                string_sink<string_type> sink(key_);
 1379|  11.1M|                jsoncons::write_double f{float_chars_format::general,0};
 1380|  11.1M|                f(value, sink);
 1381|  11.1M|            }
 1382|       |
 1383|  13.1M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1383:17): [True: 4.82k, False: 13.1M]
  ------------------
 1384|  4.82k|            {
 1385|  4.82k|                switch (level_stack_.back().target_kind())
 1386|  4.82k|                {
 1387|  3.48k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1387:21): [True: 3.48k, False: 1.33k]
  ------------------
 1388|  3.48k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1388:29): [True: 2.51k, False: 975]
  ------------------
 1389|  2.51k|                        {
 1390|  2.51k|                            key_buffer_.push_back(',');
 1391|  2.51k|                        }
 1392|  3.48k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1393|  3.48k|                        key_buffer_.push_back(':');
 1394|  3.48k|                        break;
 1395|  1.33k|                    default:
  ------------------
  |  Branch (1395:21): [True: 1.33k, False: 3.48k]
  ------------------
 1396|  1.33k|                        destination_->key(key_, context, ec);
 1397|  1.33k|                        break;
 1398|  4.82k|                }
 1399|  4.82k|            }
 1400|  13.1M|            else
 1401|  13.1M|            {
 1402|  13.1M|                switch (level_stack_.back().target_kind())
 1403|  13.1M|                {
 1404|  11.1M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1404:21): [True: 11.1M, False: 1.99M]
  ------------------
 1405|  11.1M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1405:29): [True: 11.1M, False: 2.57k]
  |  Branch (1405:65): [True: 11.1M, False: 13.5k]
  ------------------
 1406|  11.1M|                        {
 1407|  11.1M|                            key_buffer_.push_back(',');
 1408|  11.1M|                        }
 1409|  11.1M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1410|  11.1M|                        break;
 1411|  1.99M|                    default:
  ------------------
  |  Branch (1411:21): [True: 1.99M, False: 11.1M]
  ------------------
 1412|  1.99M|                        destination_->double_value(value, tag, context, ec);
 1413|  1.99M|                        break;
 1414|  13.1M|                }
 1415|  13.1M|            }
 1416|       |
 1417|  13.1M|            level_stack_.back().advance();
 1418|  13.1M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  13.1M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1419|  13.1M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE11visit_flushEv:
  881|  1.71k|        {
  882|  1.71k|            destination_->flush();
  883|  1.71k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  886|  55.6k|        {
  887|  55.6k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (887:17): [True: 19.3k, False: 36.2k]
  ------------------
  888|  19.3k|            {
  889|  19.3k|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (889:21): [True: 18.2k, False: 1.10k]
  |  Branch (889:86): [True: 13.5k, False: 4.69k]
  ------------------
  890|  13.5k|                {
  891|  13.5k|                    key_buffer_.push_back(',');
  892|  13.5k|                }
  893|  19.3k|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  894|  19.3k|                key_buffer_.push_back('{');
  895|  19.3k|            }
  896|  36.2k|            else
  897|  36.2k|            {
  898|  36.2k|                switch (level_stack_.back().target_kind())
  899|  36.2k|                {
  900|  32.8k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (900:21): [True: 32.8k, False: 3.39k]
  ------------------
  901|  32.8k|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  902|  32.8k|                        key_buffer_.push_back('{');
  903|  32.8k|                        break;
  904|  3.39k|                    default:
  ------------------
  |  Branch (904:21): [True: 3.39k, False: 32.8k]
  ------------------
  905|  3.39k|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::object);
  906|  3.39k|                        destination_->begin_object(tag, context, ec);
  907|  3.39k|                        break;
  908|  36.2k|                }
  909|  36.2k|            }
  910|  55.6k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  55.6k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  911|  55.6k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  914|  6.50M|        {
  915|  6.50M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (915:17): [True: 1.99M, False: 4.51M]
  ------------------
  916|  1.99M|            {
  917|  1.99M|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (917:21): [True: 1.99M, False: 2.69k]
  |  Branch (917:86): [True: 1.97M, False: 18.4k]
  ------------------
  918|  1.97M|                {
  919|  1.97M|                    key_buffer_.push_back(',');
  920|  1.97M|                }
  921|  1.99M|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  922|  1.99M|                key_buffer_.push_back('{');
  923|  1.99M|            }
  924|  4.51M|            else
  925|  4.51M|            {
  926|  4.51M|                switch (level_stack_.back().target_kind())
  927|  4.51M|                {
  928|  4.50M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (928:21): [True: 4.50M, False: 9.55k]
  ------------------
  929|  4.50M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (929:29): [True: 2.51M, False: 1.98M]
  |  Branch (929:65): [True: 2.51M, False: 2.78k]
  ------------------
  930|  2.51M|                        {
  931|  2.51M|                            key_buffer_.push_back(',');
  932|  2.51M|                        }
  933|  4.50M|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  934|  4.50M|                        key_buffer_.push_back('{');
  935|  4.50M|                        break;
  936|  9.55k|                    default:
  ------------------
  |  Branch (936:21): [True: 9.55k, False: 4.50M]
  ------------------
  937|  9.55k|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::object);
  938|  9.55k|                        destination_->begin_object(length, tag, context, ec);
  939|  9.55k|                        break;
  940|  4.51M|                }
  941|  4.51M|            }
  942|  6.50M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  6.50M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  943|  6.50M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE16visit_end_objectERKNS_11ser_contextERNS1_10error_codeE:
  946|  6.51M|        {
  947|  6.51M|            switch (level_stack_.back().target_kind())
  948|  6.51M|            {
  949|  6.50M|                case json_target_kind::buffer:
  ------------------
  |  Branch (949:17): [True: 6.50M, False: 4.31k]
  ------------------
  950|  6.50M|                    key_buffer_.push_back('}');
  951|  6.50M|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|  6.50M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 6.50M]
  |  |  ------------------
  |  |   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|  6.50M|                    level_stack_.pop_back();
  953|       |                    
  954|  6.50M|                    if (level_stack_.back().target_kind() == json_target_kind::destination)
  ------------------
  |  Branch (954:25): [True: 2.31k, False: 6.50M]
  ------------------
  955|  2.31k|                    {
  956|  2.31k|                        destination_->key(key_buffer_,context, ec);
  957|  2.31k|                        key_buffer_.clear();
  958|  2.31k|                    }
  959|  6.50M|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (959:30): [True: 1.98M, False: 4.51M]
  ------------------
  960|  1.98M|                    {
  961|  1.98M|                        key_buffer_.push_back(':');
  962|  1.98M|                    }
  963|  6.50M|                    level_stack_.back().advance();
  964|  6.50M|                    break;
  965|  4.31k|                default:
  ------------------
  |  Branch (965:17): [True: 4.31k, False: 6.50M]
  ------------------
  966|  4.31k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   49|  4.31k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 4.31k]
  |  |  ------------------
  |  |   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|  4.31k|                    level_stack_.pop_back();
  968|  4.31k|                    level_stack_.back().advance();
  969|  4.31k|                    destination_->end_object(context, ec);
  970|  4.31k|                    break;
  971|  6.51M|            }
  972|  6.51M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  6.51M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  973|  6.51M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  976|   895k|        {
  977|   895k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (977:17): [True: 13.7k, False: 881k]
  ------------------
  978|  13.7k|            {
  979|  13.7k|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (979:21): [True: 6.20k, False: 7.58k]
  |  Branch (979:86): [True: 4.16k, False: 2.03k]
  ------------------
  980|  4.16k|                {
  981|  4.16k|                    key_buffer_.push_back(',');
  982|  4.16k|                }
  983|  13.7k|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
  984|  13.7k|                key_buffer_.push_back('[');
  985|  13.7k|            }
  986|   881k|            else
  987|   881k|            {
  988|   881k|                switch (level_stack_.back().target_kind())
  989|   881k|                {
  990|   768k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (990:21): [True: 768k, False: 112k]
  ------------------
  991|   768k|                        if (level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (991:29): [True: 6.44k, False: 762k]
  |  Branch (991:64): [True: 5.25k, False: 1.19k]
  ------------------
  992|  5.25k|                        {
  993|  5.25k|                            key_buffer_.push_back(',');
  994|  5.25k|                        }
  995|   768k|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
  996|   768k|                        key_buffer_.push_back('[');
  997|   768k|                        break;
  998|   112k|                    default:
  ------------------
  |  Branch (998:21): [True: 112k, False: 768k]
  ------------------
  999|   112k|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::array);
 1000|   112k|                        destination_->begin_array(tag, context, ec);
 1001|   112k|                        break;
 1002|   881k|                }
 1003|   881k|            }
 1004|   895k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   895k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1005|   895k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1475|  1.47M|        {
 1476|  1.47M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1476:17): [True: 673k, False: 803k]
  |  Branch (1476:49): [True: 801k, False: 2.47k]
  ------------------
 1477|  1.47M|            {
 1478|  1.47M|                key_.clear(); 
 1479|  1.47M|                key_.insert(key_.begin(), json_literals<char_type>::null_literal.begin(), json_literals<char_type>::null_literal.end());
 1480|  1.47M|            }
 1481|       |
 1482|  1.47M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1482:17): [True: 673k, False: 803k]
  ------------------
 1483|   673k|            {
 1484|   673k|                switch (level_stack_.back().target_kind())
 1485|   673k|                {
 1486|   672k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1486:21): [True: 672k, False: 1.00k]
  ------------------
 1487|   672k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1487:29): [True: 671k, False: 1.26k]
  ------------------
 1488|   671k|                        {
 1489|   671k|                            key_buffer_.push_back(',');
 1490|   671k|                        }
 1491|   672k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1492|   672k|                        key_buffer_.push_back(':');
 1493|   672k|                        break;
 1494|  1.00k|                    default:
  ------------------
  |  Branch (1494:21): [True: 1.00k, False: 672k]
  ------------------
 1495|  1.00k|                        destination_->key(key_, context, ec);
 1496|  1.00k|                        break;
 1497|   673k|                }
 1498|   673k|            }
 1499|   803k|            else
 1500|   803k|            {
 1501|   803k|                switch (level_stack_.back().target_kind())
 1502|   803k|                {
 1503|   801k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1503:21): [True: 801k, False: 2.47k]
  ------------------
 1504|   801k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1504:29): [True: 129k, False: 672k]
  |  Branch (1504:65): [True: 128k, False: 542]
  ------------------
 1505|   128k|                        {
 1506|   128k|                            key_buffer_.push_back(',');
 1507|   128k|                        }
 1508|   801k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1509|   801k|                        break;
 1510|  2.47k|                    default:
  ------------------
  |  Branch (1510:21): [True: 2.47k, False: 801k]
  ------------------
 1511|  2.47k|                        destination_->null_value(tag, context, ec);
 1512|  2.47k|                        break;
 1513|   803k|                }
 1514|   803k|            }
 1515|       |
 1516|  1.47M|            level_stack_.back().advance();
 1517|  1.47M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.47M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1518|  1.47M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1422|  1.63M|        {
 1423|  1.63M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1423:17): [True: 594k, False: 1.03M]
  |  Branch (1423:49): [True: 1.03M, False: 2.25k]
  ------------------
 1424|  1.62M|            {
 1425|  1.62M|                key_.clear(); 
 1426|  1.62M|                if (value)
  ------------------
  |  Branch (1426:21): [True: 1.48M, False: 142k]
  ------------------
 1427|  1.48M|                {
 1428|  1.48M|                    key_.insert(key_.begin(), json_literals<char_type>::true_literal.begin(), json_literals<char_type>::true_literal.end());
 1429|  1.48M|                }
 1430|   142k|                else
 1431|   142k|                {
 1432|   142k|                    key_.insert(key_.begin(), json_literals<char_type>::false_literal.begin(), json_literals<char_type>::false_literal.end());
 1433|   142k|                }
 1434|  1.62M|            }
 1435|       |
 1436|  1.63M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1436:17): [True: 594k, False: 1.03M]
  ------------------
 1437|   594k|            {
 1438|   594k|                switch (level_stack_.back().target_kind())
 1439|   594k|                {
 1440|   592k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1440:21): [True: 592k, False: 1.57k]
  ------------------
 1441|   592k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1441:29): [True: 591k, False: 1.35k]
  ------------------
 1442|   591k|                        {
 1443|   591k|                            key_buffer_.push_back(',');
 1444|   591k|                        }
 1445|   592k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1446|   592k|                        key_buffer_.push_back(':');
 1447|   592k|                        break;
 1448|  1.57k|                    default:
  ------------------
  |  Branch (1448:21): [True: 1.57k, False: 592k]
  ------------------
 1449|  1.57k|                        destination_->key(key_, context, ec);
 1450|  1.57k|                        break;
 1451|   594k|                }
 1452|   594k|            }
 1453|  1.03M|            else
 1454|  1.03M|            {
 1455|  1.03M|                switch (level_stack_.back().target_kind())
 1456|  1.03M|                {
 1457|  1.03M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1457:21): [True: 1.03M, False: 2.25k]
  ------------------
 1458|  1.03M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1458:29): [True: 443k, False: 592k]
  |  Branch (1458:65): [True: 443k, False: 517]
  ------------------
 1459|   443k|                        {
 1460|   443k|                            key_buffer_.push_back(',');
 1461|   443k|                        }
 1462|  1.03M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1463|  1.03M|                        break;
 1464|  2.25k|                    default:
  ------------------
  |  Branch (1464:21): [True: 2.25k, False: 1.03M]
  ------------------
 1465|  2.25k|                        destination_->bool_value(value, tag, context, ec);
 1466|  2.25k|                        break;
 1467|  1.03M|                }
 1468|  1.03M|            }
 1469|       |
 1470|  1.63M|            level_stack_.back().advance();
 1471|  1.63M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.63M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1472|  1.63M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_stringERKNS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1072|  1.61M|        {
 1073|  1.61M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1073:17): [True: 408k, False: 1.20M]
  ------------------
 1074|   408k|            {
 1075|   408k|                switch (level_stack_.back().target_kind())
 1076|   408k|                {
 1077|   350k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1077:21): [True: 350k, False: 57.4k]
  ------------------
 1078|   350k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1078:29): [True: 343k, False: 7.14k]
  ------------------
 1079|   343k|                        {
 1080|   343k|                            key_buffer_.push_back(',');
 1081|   343k|                        }
 1082|   350k|                        key_buffer_.push_back('\"');
 1083|   350k|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1084|   350k|                        key_buffer_.push_back('\"');
 1085|   350k|                        key_buffer_.push_back(':');
 1086|   350k|                        break;
 1087|  57.4k|                    default:
  ------------------
  |  Branch (1087:21): [True: 57.4k, False: 350k]
  ------------------
 1088|  57.4k|                        destination_->key(value, context, ec);
 1089|  57.4k|                        break;
 1090|   408k|                }
 1091|   408k|            }
 1092|  1.20M|            else
 1093|  1.20M|            {
 1094|  1.20M|                switch (level_stack_.back().target_kind())
 1095|  1.20M|                {
 1096|  1.12M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1096:21): [True: 1.12M, False: 87.9k]
  ------------------
 1097|  1.12M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1097:29): [True: 778k, False: 341k]
  |  Branch (1097:65): [True: 746k, False: 32.4k]
  ------------------
 1098|   746k|                        {
 1099|   746k|                            key_buffer_.push_back(',');
 1100|   746k|                        }
 1101|  1.12M|                        key_buffer_.push_back('\"');
 1102|  1.12M|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1103|  1.12M|                        key_buffer_.push_back('\"');
 1104|  1.12M|                        break;
 1105|  87.9k|                    default:
  ------------------
  |  Branch (1105:21): [True: 87.9k, False: 1.12M]
  ------------------
 1106|  87.9k|                        destination_->string_value(value, tag, context, ec);
 1107|  87.9k|                        break;
 1108|  1.20M|                }
 1109|  1.20M|            }
 1110|       |
 1111|  1.61M|            level_stack_.back().advance();
 1112|  1.61M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.61M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1113|  1.61M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1119|  7.70M|        {
 1120|  7.70M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1120:17): [True: 2.33M, False: 5.36M]
  |  Branch (1120:49): [True: 4.33M, False: 1.03M]
  ------------------
 1121|  6.66M|            {
 1122|  6.66M|                key_.clear();
 1123|  6.66M|                switch (tag)
 1124|  6.66M|                {
 1125|  1.28k|                    case semantic_tag::base64:
  ------------------
  |  Branch (1125:21): [True: 1.28k, False: 6.66M]
  ------------------
 1126|  1.28k|                        bytes_to_base64(value.begin(), value.end(), key_);
 1127|  1.28k|                        break;
 1128|    690|                    case semantic_tag::base16:
  ------------------
  |  Branch (1128:21): [True: 690, False: 6.66M]
  ------------------
 1129|    690|                        bytes_to_base16(value.begin(), value.end(),key_);
 1130|    690|                        break;
 1131|  6.66M|                    default:
  ------------------
  |  Branch (1131:21): [True: 6.66M, False: 1.97k]
  ------------------
 1132|  6.66M|                        bytes_to_base64url(value.begin(), value.end(),key_);
 1133|  6.66M|                        break;
 1134|  6.66M|                }
 1135|  6.66M|            }
 1136|       |
 1137|  7.70M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1137:17): [True: 2.33M, False: 5.36M]
  ------------------
 1138|  2.33M|            {
 1139|  2.33M|                switch (level_stack_.back().target_kind())
 1140|  2.33M|                {
 1141|  1.51M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1141:21): [True: 1.51M, False: 819k]
  ------------------
 1142|  1.51M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1142:29): [True: 1.51M, False: 2.99k]
  ------------------
 1143|  1.51M|                        {
 1144|  1.51M|                            key_buffer_.push_back(',');
 1145|  1.51M|                        }
 1146|  1.51M|                        key_buffer_.push_back('\"');
 1147|  1.51M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1148|  1.51M|                        key_buffer_.push_back('\"');
 1149|  1.51M|                        key_buffer_.push_back(':');
 1150|  1.51M|                        break;
 1151|   819k|                    default:
  ------------------
  |  Branch (1151:21): [True: 819k, False: 1.51M]
  ------------------
 1152|   819k|                        destination_->key(key_, context, ec);
 1153|   819k|                        break;
 1154|  2.33M|                }
 1155|  2.33M|            }
 1156|  5.36M|            else
 1157|  5.36M|            {
 1158|  5.36M|                switch (level_stack_.back().target_kind())
 1159|  5.36M|                {
 1160|  4.33M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1160:21): [True: 4.33M, False: 1.03M]
  ------------------
 1161|  4.33M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1161:29): [True: 2.81M, False: 1.52M]
  |  Branch (1161:65): [True: 2.80M, False: 10.0k]
  ------------------
 1162|  2.80M|                        {
 1163|  2.80M|                            key_buffer_.push_back(',');
 1164|  2.80M|                        }
 1165|  4.33M|                        key_buffer_.push_back('\"');
 1166|  4.33M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1167|  4.33M|                        key_buffer_.push_back('\"');
 1168|  4.33M|                        break;
 1169|  1.03M|                    default:
  ------------------
  |  Branch (1169:21): [True: 1.03M, False: 4.33M]
  ------------------
 1170|  1.03M|                        destination_->byte_string_value(value, tag, context, ec);
 1171|  1.03M|                        break;
 1172|  5.36M|                }
 1173|  5.36M|            }
 1174|       |
 1175|  7.70M|            level_stack_.back().advance();
 1176|  7.70M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  7.70M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1177|  7.70M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS1_10error_codeE:
 1183|  66.5k|        {
 1184|  66.5k|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1184:17): [True: 17.3k, False: 49.1k]
  |  Branch (1184:49): [True: 47.3k, False: 1.77k]
  ------------------
 1185|  64.7k|            {
 1186|  64.7k|                key_.clear();
 1187|  64.7k|                bytes_to_base64url(value.begin(), value.end(),key_);
 1188|  64.7k|            }
 1189|       |
 1190|  66.5k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1190:17): [True: 17.3k, False: 49.1k]
  ------------------
 1191|  17.3k|            {
 1192|  17.3k|                switch (level_stack_.back().target_kind())
 1193|  17.3k|                {
 1194|  16.2k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1194:21): [True: 16.2k, False: 1.11k]
  ------------------
 1195|  16.2k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1195:29): [True: 15.4k, False: 799]
  ------------------
 1196|  15.4k|                        {
 1197|  15.4k|                            key_buffer_.push_back(',');
 1198|  15.4k|                        }
 1199|  16.2k|                        key_buffer_.push_back('\"');
 1200|  16.2k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1201|  16.2k|                        key_buffer_.push_back('\"');
 1202|  16.2k|                        key_buffer_.push_back(':');
 1203|  16.2k|                        break;
 1204|  1.11k|                    default:
  ------------------
  |  Branch (1204:21): [True: 1.11k, False: 16.2k]
  ------------------
 1205|  1.11k|                        destination_->key(key_, context, ec);
 1206|  1.11k|                        break;
 1207|  17.3k|                }
 1208|  17.3k|            }
 1209|  49.1k|            else
 1210|  49.1k|            {
 1211|  49.1k|                switch (level_stack_.back().target_kind())
 1212|  49.1k|                {
 1213|  47.3k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1213:21): [True: 47.3k, False: 1.77k]
  ------------------
 1214|  47.3k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1214:29): [True: 29.7k, False: 17.6k]
  |  Branch (1214:65): [True: 26.6k, False: 3.10k]
  ------------------
 1215|  26.6k|                        {
 1216|  26.6k|                            key_buffer_.push_back(',');
 1217|  26.6k|                        }
 1218|  47.3k|                        key_buffer_.push_back('\"');
 1219|  47.3k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1220|  47.3k|                        key_buffer_.push_back('\"');
 1221|  47.3k|                        break;
 1222|  1.77k|                    default:
  ------------------
  |  Branch (1222:21): [True: 1.77k, False: 47.3k]
  ------------------
 1223|  1.77k|                        destination_->byte_string_value(value, raw_tag, context, ec);
 1224|  1.77k|                        break;
 1225|  49.1k|                }
 1226|  49.1k|            }
 1227|       |
 1228|  66.5k|            level_stack_.back().advance();
 1229|  66.5k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  66.5k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1230|  66.5k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE10visit_halfEtNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1325|  10.5k|        {
 1326|  10.5k|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1326:17): [True: 4.94k, False: 5.58k]
  |  Branch (1326:49): [True: 4.93k, False: 654]
  ------------------
 1327|  9.88k|            {
 1328|  9.88k|                key_.clear();
 1329|  9.88k|                jsoncons::string_sink<string_type> sink(key_);
 1330|  9.88k|                jsoncons::write_double f{float_chars_format::general,0};
 1331|  9.88k|                double x = binary::decode_half(value);
 1332|  9.88k|                f(x, sink);
 1333|  9.88k|            }
 1334|       |
 1335|  10.5k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1335:17): [True: 4.94k, False: 5.58k]
  ------------------
 1336|  4.94k|            {
 1337|  4.94k|                switch (level_stack_.back().target_kind())
 1338|  4.94k|                {
 1339|  4.24k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1339:21): [True: 4.24k, False: 707]
  ------------------
 1340|  4.24k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1340:29): [True: 2.53k, False: 1.70k]
  ------------------
 1341|  2.53k|                        {
 1342|  2.53k|                            key_buffer_.push_back(',');
 1343|  2.53k|                        }
 1344|  4.24k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1345|  4.24k|                        key_buffer_.push_back(':');
 1346|  4.24k|                        break;
 1347|    707|                    default:
  ------------------
  |  Branch (1347:21): [True: 707, False: 4.24k]
  ------------------
 1348|    707|                        destination_->key(key_, context, ec);
 1349|    707|                        break;
 1350|  4.94k|                }
 1351|  4.94k|            }
 1352|  5.58k|            else
 1353|  5.58k|            {
 1354|  5.58k|                switch (level_stack_.back().target_kind())
 1355|  5.58k|                {
 1356|  4.93k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1356:21): [True: 4.93k, False: 654]
  ------------------
 1357|  4.93k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1357:29): [True: 2.12k, False: 2.80k]
  |  Branch (1357:65): [True: 1.46k, False: 661]
  ------------------
 1358|  1.46k|                        {
 1359|  1.46k|                            key_buffer_.push_back(',');
 1360|  1.46k|                        }
 1361|  4.93k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1362|  4.93k|                        break;
 1363|    654|                    default:
  ------------------
  |  Branch (1363:21): [True: 654, False: 4.93k]
  ------------------
 1364|    654|                        destination_->half_value(value, tag, context, ec);
 1365|    654|                        break;
 1366|  5.58k|                }
 1367|  5.58k|            }
 1368|       |
 1369|  10.5k|            level_stack_.back().advance();
 1370|  10.5k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  10.5k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1371|  10.5k|        }
_ZN8jsoncons21basic_generic_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  294|   782k|    {
  295|   782k|        visit_begin_array(length, tag, context, ec);
  296|   782k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   782k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  297|   782k|    }
_ZN8jsoncons21basic_generic_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  363|  16.0M|    {
  364|  16.0M|        visit_uint64(value, tag, context, ec);
  365|  16.0M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  16.0M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  366|  16.0M|    }
_ZN8jsoncons21basic_generic_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  300|  1.62M|    {
  301|  1.62M|        visit_end_array(context, ec);
  302|  1.62M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.62M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  303|  1.62M|    }
_ZN8jsoncons21basic_generic_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  372|  8.92M|    {
  373|  8.92M|        visit_int64(value, tag, context, ec);
  374|  8.92M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  8.92M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  375|  8.92M|    }
_ZN8jsoncons21basic_generic_visitorIcE10half_valueEtNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  381|  10.5k|    {
  382|  10.5k|        visit_half(value, tag, context, ec);
  383|  10.5k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  10.5k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  384|  10.5k|    }
_ZN8jsoncons21basic_generic_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  390|  13.1M|    {
  391|  13.1M|        visit_double(value, tag, context, ec);
  392|  13.1M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  13.1M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  393|  13.1M|    }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEEC2ERNS_18basic_json_visitorIcEERKS3_:
  855|  8.86k|            : destination_(std::addressof(visitor)), 
  856|  8.86k|              key_(alloc), key_buffer_(alloc), level_stack_(alloc)
  857|  8.86k|        {
  858|  8.86k|            level_stack_.emplace_back(json_target_kind::destination,json_structure_kind::root); // root
  859|  8.86k|        }
_ZN8jsoncons21basic_generic_visitorIcEC2Ev:
   52|  8.86k|    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|  7.70M|    {
  344|  7.70M|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  345|  7.70M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  7.70M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  346|  7.70M|    }
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  354|  66.5k|    {
  355|  66.5k|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), raw_tag, context, ec);
  356|  66.5k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  66.5k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  357|  66.5k|    }
_ZN8jsoncons21basic_generic_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  323|  1.63M|    {
  324|  1.63M|        visit_bool(value, tag, context, ec);
  325|  1.63M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.63M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  326|  1.63M|    }
_ZN8jsoncons21basic_generic_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  314|  1.47M|    {
  315|  1.47M|        visit_null(tag, context, ec);
  316|  1.47M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.47M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  317|  1.47M|    }
_ZN8jsoncons21basic_generic_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  332|  1.61M|    {
  333|  1.61M|        visit_string(value, tag, context, ec);
  334|  1.61M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.61M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  335|  1.61M|    }
_ZN8jsoncons21basic_generic_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  288|   895k|    {
  289|   895k|        visit_begin_array(tag, context, ec);
  290|   895k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   895k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  291|   895k|    }
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  267|  55.6k|    {
  268|  55.6k|        visit_begin_object(tag, context, ec);
  269|  55.6k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  55.6k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  270|  55.6k|    }
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  276|  6.50M|    {
  277|  6.50M|        visit_begin_object(length, tag, context, ec);
  278|  6.50M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  6.50M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  279|  6.50M|    }
_ZN8jsoncons21basic_generic_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  282|  6.51M|    {
  283|  6.51M|        visit_end_object(context, ec);
  284|  6.51M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  6.51M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  285|  6.51M|    }
_ZN8jsoncons21basic_generic_visitorIcE5flushEv:
   57|  1.71k|    {
   58|  1.71k|        visit_flush();
   59|  1.71k|    }

_ZN8jsoncons26basic_default_json_visitorIcEC2Ev:
  811|  17.7k|        basic_default_json_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|  17.7k|        basic_json_visitor() = default;
_ZN8jsoncons19typed_array_visitorD2Ev:
   33|  26.5k|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  560|  30.6k|        {
  561|  30.6k|            visit_begin_array(tag, context, ec);
  562|  30.6k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  30.6k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  563|  30.6k|        }
_ZN8jsoncons26basic_default_json_visitorIcE15visit_end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  833|   128k|        {
  834|   128k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   128k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  835|   128k|        }
_ZN8jsoncons26basic_default_json_visitorIcE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  858|  1.34M|        {
  859|  1.34M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.34M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  860|  1.34M|        }
_ZN8jsoncons26basic_default_json_visitorIcE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  863|  2.95M|        {
  864|  2.95M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  2.95M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  865|  2.95M|        }
_ZN8jsoncons26basic_default_json_visitorIcE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  873|  1.99M|        {
  874|  1.99M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.99M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  875|  1.99M|        }
_ZN8jsoncons26basic_default_json_visitorIcE11visit_flushEv:
  814|  1.71k|        {
  815|  1.71k|        }
_ZN8jsoncons26basic_default_json_visitorIcE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  818|  12.9k|        {
  819|  12.9k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  12.9k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  820|  12.9k|        }
_ZN8jsoncons18basic_json_visitorIcE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  544|  9.55k|        {
  545|  9.55k|            visit_begin_object(tag, context, ec);
  546|  9.55k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  9.55k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  547|  9.55k|        }
_ZN8jsoncons26basic_default_json_visitorIcE16visit_end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  823|  4.31k|        {
  824|  4.31k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  4.31k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  825|  4.31k|        }
_ZN8jsoncons26basic_default_json_visitorIcE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  828|   143k|        {
  829|   143k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   143k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  830|   143k|        }
_ZN8jsoncons26basic_default_json_visitorIcE9visit_keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  838|  2.02M|        {
  839|  2.02M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  2.02M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  840|  2.02M|        }
_ZN8jsoncons26basic_default_json_visitorIcE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  843|  2.47k|        {
  844|  2.47k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  2.47k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  845|  2.47k|        }
_ZN8jsoncons26basic_default_json_visitorIcE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  878|  2.25k|        {
  879|  2.25k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  2.25k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  880|  2.25k|        }
_ZN8jsoncons26basic_default_json_visitorIcE12visit_stringERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  848|  87.9k|        {
  849|  87.9k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  87.9k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  850|  87.9k|        }
_ZN8jsoncons26basic_default_json_visitorIcE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  853|  1.04M|        {
  854|  1.04M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.04M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  855|  1.04M|        }
_ZN8jsoncons18basic_json_visitorIcE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNSt3__110error_codeE:
  595|  1.77k|        {
  596|  1.77k|            visit_byte_string(value, semantic_tag::none, context, ec);
  597|  1.77k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.77k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  598|  1.77k|        }
_ZN8jsoncons26basic_default_json_visitorIcE10visit_halfEtNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  868|    654|        {
  869|    654|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    654|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  870|    654|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  345|  30.6k|        {
  346|  30.6k|            visit_begin_array(length, tag, context, ec);
  347|  30.6k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  30.6k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  348|  30.6k|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|  1.34M|        {
  415|  1.34M|            visit_uint64(value, tag, context, ec);
  416|  1.34M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.34M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  417|  1.34M|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  351|   128k|        {
  352|   128k|            visit_end_array(context, ec);
  353|   128k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   128k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  354|   128k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|  2.95M|        {
  424|  2.95M|            visit_int64(value, tag, context, ec);
  425|  2.95M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  2.95M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  426|  2.95M|        }
_ZN8jsoncons18basic_json_visitorIcE10half_valueEtNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  432|    654|        {
  433|    654|            visit_half(value, tag, context, ec);
  434|    654|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    654|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  435|    654|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|  1.99M|        {
  442|  1.99M|            visit_double(value, tag, context, ec);
  443|  1.99M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.99M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  444|  1.99M|        }
_ZN8jsoncons18basic_json_visitorIcE3keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  357|  2.02M|        {
  358|  2.02M|            visit_key(name, context, ec);
  359|  2.02M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  2.02M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  360|  2.02M|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|  1.71k|        {
  109|  1.71k|            visit_flush();
  110|  1.71k|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  318|  3.39k|        {
  319|  3.39k|            visit_begin_object(tag, context, ec);
  320|  3.39k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.39k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  321|  3.39k|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  327|  9.55k|        {
  328|  9.55k|            visit_begin_object(length, tag, context, ec);
  329|  9.55k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  9.55k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  330|  9.55k|        }
_ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  333|  4.31k|        {
  334|  4.31k|            visit_end_object(context, ec);
  335|  4.31k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  4.31k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  336|  4.31k|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  339|   112k|        {
  340|   112k|            visit_begin_array(tag, context, ec);
  341|   112k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   112k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  342|   112k|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  365|  2.47k|        {
  366|  2.47k|            visit_null(tag, context, ec);
  367|  2.47k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  2.47k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  368|  2.47k|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  374|  2.25k|        {
  375|  2.25k|            visit_bool(value, tag, context, ec);
  376|  2.25k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  2.25k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  377|  2.25k|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  383|  87.9k|        {
  384|  87.9k|            visit_string(value, tag, context, ec);
  385|  87.9k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  87.9k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  386|  87.9k|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  394|  1.03M|        {
  395|  1.03M|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  396|  1.03M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.03M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  397|  1.03M|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  405|  1.77k|        {
  406|  1.77k|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), raw_tag, context, ec);
  407|  1.77k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.77k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  408|  1.77k|        }

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

_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERS7_:
  256|  11.1M|            : buf_ptr(std::addressof(buf))
  257|  11.1M|        {
  258|  11.1M|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9push_backEc:
  287|   149M|        {
  288|   149M|            buf_ptr->push_back(ch);
  289|   149M|        }

_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev:
  193|  8.86k|    {
  194|  8.86k|        if (chunk_)
  ------------------
  |  Branch (194:13): [True: 8.86k, False: 0]
  ------------------
  195|  8.86k|        {
  196|  8.86k|            std::allocator_traits<char_allocator_type>::deallocate(alloc_, chunk_, chunk_size_);
  197|  8.86k|        }
  198|  8.86k|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  176|  8.86k|        : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  177|  8.86k|          chunk_size_(default_max_chunk_size)
  178|  8.86k|    {
  179|  8.86k|        chunk_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, chunk_size_);
  180|  8.86k|        data_end_ = chunk_;
  181|  8.86k|    }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   57|  8.86k|      : std::basic_istream<CharT>(&nb_)
   58|  8.86k|    {
   59|  8.86k|    }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   43|  8.86k|        null_buffer() = default;
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm:
  377|  33.3M|    {
  378|  33.3M|        std::size_t len = 0;
  379|  33.3M|        if (remaining_ > 0)
  ------------------
  |  Branch (379:13): [True: 33.3M, False: 404]
  ------------------
  380|  33.3M|        {
  381|  33.3M|            len = (std::min)(remaining_, length);
  382|  33.3M|            std::memcpy(p, data_end_, len*sizeof(value_type));
  383|  33.3M|            data_end_ += len;
  384|  33.3M|            remaining_ -= len;
  385|  33.3M|            position_ += len;
  386|  33.3M|        }
  387|  33.3M|        if (length - len == 0)
  ------------------
  |  Branch (387:13): [True: 33.3M, False: 4.11k]
  ------------------
  388|  33.3M|        {
  389|  33.3M|            return len;
  390|  33.3M|        }
  391|  4.11k|        else if (length - len < chunk_size_)
  ------------------
  |  Branch (391:18): [True: 4.11k, False: 0]
  ------------------
  392|  4.11k|        {
  393|  4.11k|            data_end_ = chunk_;
  394|  4.11k|            remaining_ = fill_buffer(chunk_, chunk_size_);
  395|  4.11k|            if (remaining_ > 0)
  ------------------
  |  Branch (395:17): [True: 2.07k, False: 2.03k]
  ------------------
  396|  2.07k|            {
  397|  2.07k|                std::size_t len2 = (std::min)(remaining_, length-len);
  398|  2.07k|                std::memcpy(p+len, data_end_, len2*sizeof(value_type));
  399|  2.07k|                data_end_ += len2;
  400|  2.07k|                remaining_ -= len2;
  401|  2.07k|                position_ += len2;
  402|  2.07k|                len += len2;
  403|  2.07k|            }
  404|  4.11k|            return len;
  405|  4.11k|        }
  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|  33.3M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEPhm:
  442|  19.9k|    {
  443|  19.9k|        if (stream_ptr_->eof())
  ------------------
  |  Branch (443:13): [True: 6.14k, False: 13.8k]
  ------------------
  444|  6.14k|        {
  445|  6.14k|            return 0;
  446|  6.14k|        }
  447|       |
  448|  13.8k|        JSONCONS_TRY
  ------------------
  |  |   37|  13.8k|    #define JSONCONS_TRY try
  ------------------
  449|  13.8k|        {
  450|  13.8k|            std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(chunk), chunk_size);
  451|  13.8k|            std::size_t length = static_cast<std::size_t>(count);
  452|       |
  453|  13.8k|            if (length < chunk_size)
  ------------------
  |  Branch (453:17): [True: 8.83k, False: 4.99k]
  ------------------
  454|  8.83k|            {
  455|  8.83k|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  456|  8.83k|            }
  457|  13.8k|            return length;
  458|  13.8k|        }
  459|  13.8k|        JSONCONS_CATCH(const std::exception&)     
  460|  13.8k|        {
  461|      0|            stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  462|      0|            return 0;
  463|      0|        }
  464|  13.8k|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_6vectorIhS4_EEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr10ext_traits7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSD_m:
  746|   632k|    {
  747|   632k|        std::size_t unread = length;
  748|       |
  749|   949k|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (749:16): [True: 317k, False: 631k]
  |  Branch (749:30): [True: 317k, False: 579]
  ------------------
  750|   317k|        {
  751|   317k|            if (source.remaining() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (751:17): [True: 261, False: 316k]
  |  Branch (751:44): [True: 254, False: 7]
  ------------------
  752|    254|            {
  753|    254|                std::size_t n = source.chunk_size();
  754|    254|                std::size_t offset = buffer.size();
  755|    254|                buffer.resize(offset+n);
  756|    254|                std::size_t actual = source.read_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  757|    254|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   78|    254|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 15, False: 239]
  |  |  ------------------
  ------------------
  758|     15|                {
  759|     15|                    buffer.resize(offset+actual);
  760|     15|                }
  761|    254|                unread -= actual;
  762|    254|            }
  763|   316k|            else
  764|   316k|            {
  765|   316k|                std::size_t n = (std::min)(source.chunk_size(), unread);
  766|   316k|                std::size_t offset = buffer.size();
  767|   316k|                buffer.resize(offset+n);
  768|   316k|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  769|   316k|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   78|   316k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 474, False: 316k]
  |  |  ------------------
  ------------------
  770|    474|                {
  771|    474|                    buffer.resize(offset + actual);
  772|    474|                }
  773|   316k|                unread -= actual;
  774|   316k|            }
  775|   317k|        }
  776|   632k|        return length - unread;
  777|   632k|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv:
  271|   319k|    {
  272|   319k|        return remaining_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:16): [True: 1.19k, False: 317k]
  |  Branch (272:35): [True: 934, False: 261]
  ------------------
  273|   319k|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9remainingEv:
  346|   318k|    {
  347|   318k|        return remaining_;
  348|   318k|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE10chunk_sizeEv:
  261|   318k|    {
  262|   318k|        return chunk_size_;
  263|   318k|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11read_bufferEPhm:
  435|    254|    {
  436|    254|        auto len = fill_buffer(chunk, chunk_size);
  437|    254|        position_ += len;
  438|    254|        return len;
  439|    254|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_6vectorIhS3_EEEENS_6detail4spanIKhLm18446744073709551615EEEmOT_:
  352|  7.79M|    {
  353|  7.79M|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|  7.79M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4.39M, False: 3.40M]
  |  |  ------------------
  ------------------
  354|  4.39M|        {
  355|  4.39M|            return span<const value_type>{};
  356|  4.39M|        }
  357|  3.40M|        if (remaining_ == 0 && length <= chunk_size_)
  ------------------
  |  Branch (357:13): [True: 258, False: 3.40M]
  |  Branch (357:32): [True: 232, False: 26]
  ------------------
  358|    232|        {
  359|    232|            remaining_ = fill_buffer(chunk_, chunk_size_);
  360|    232|            data_end_ = chunk_;
  361|    232|        }
  362|  3.40M|        if (length > remaining_)
  ------------------
  |  Branch (362:13): [True: 1.24k, False: 3.40M]
  ------------------
  363|  1.24k|        {
  364|  1.24k|            buffer.clear();
  365|  1.24k|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  366|  1.24k|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  367|  1.24k|        }
  368|       |
  369|  3.40M|        const value_type* data = data_end_;
  370|  3.40M|        data_end_ += length;
  371|  3.40M|        remaining_ -= length;
  372|  3.40M|        position_ += length;
  373|  3.40M|        return span<const value_type>(data, length);
  374|  3.40M|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_12basic_stringIcNS2_11char_traitsIcEENS3_IcEEEEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr10ext_traits7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSG_m:
  746|    939|    {
  747|    939|        std::size_t unread = length;
  748|       |
  749|  1.96k|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (749:16): [True: 1.37k, False: 584]
  |  Branch (749:30): [True: 1.02k, False: 355]
  ------------------
  750|  1.02k|        {
  751|  1.02k|            if (source.remaining() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (751:17): [True: 0, False: 1.02k]
  |  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|  1.02k|            else
  764|  1.02k|            {
  765|  1.02k|                std::size_t n = (std::min)(source.chunk_size(), unread);
  766|  1.02k|                std::size_t offset = buffer.size();
  767|  1.02k|                buffer.resize(offset+n);
  768|  1.02k|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  769|  1.02k|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   78|  1.02k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 296, False: 727]
  |  |  ------------------
  ------------------
  770|    296|                {
  771|    296|                    buffer.resize(offset + actual);
  772|    296|                }
  773|  1.02k|                unread -= actual;
  774|  1.02k|            }
  775|  1.02k|        }
  776|    939|        return length - unread;
  777|    939|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_12basic_stringIcNS1_11char_traitsIcEENS2_IcEEEEEENS_6detail4spanIKhLm18446744073709551615EEEmOT_:
  352|   531k|    {
  353|   531k|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|   531k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 61.7k, False: 470k]
  |  |  ------------------
  ------------------
  354|  61.7k|        {
  355|  61.7k|            return span<const value_type>{};
  356|  61.7k|        }
  357|   470k|        if (remaining_ == 0 && length <= chunk_size_)
  ------------------
  |  Branch (357:13): [True: 84, False: 470k]
  |  Branch (357:32): [True: 68, False: 16]
  ------------------
  358|     68|        {
  359|     68|            remaining_ = fill_buffer(chunk_, chunk_size_);
  360|     68|            data_end_ = chunk_;
  361|     68|        }
  362|   470k|        if (length > remaining_)
  ------------------
  |  Branch (362:13): [True: 429, False: 469k]
  ------------------
  363|    429|        {
  364|    429|            buffer.clear();
  365|    429|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  366|    429|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  367|    429|        }
  368|       |
  369|   469k|        const value_type* data = data_end_;
  370|   469k|        data_end_ += length;
  371|   469k|        remaining_ -= length;
  372|   469k|        position_ += length;
  373|   469k|        return span<const value_type>(data, length);
  374|   470k|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4peekEv:
  312|   103M|    {
  313|   103M|        if (remaining_ == 0)
  ------------------
  |  Branch (313:13): [True: 15.3k, False: 103M]
  ------------------
  314|  15.3k|        {
  315|  15.3k|            data_end_ = chunk_;
  316|  15.3k|            remaining_ = fill_buffer(chunk_, chunk_size_);
  317|  15.3k|        }
  318|   103M|        if (remaining_ > 0)
  ------------------
  |  Branch (318:13): [True: 103M, False: 4.09k]
  ------------------
  319|   103M|        {
  320|   103M|            value_type c = *data_end_;
  321|   103M|            return char_result<value_type>{c, false};
  322|   103M|        }
  323|  4.09k|        else
  324|  4.09k|        {
  325|  4.09k|            return char_result<value_type>{0, true};
  326|  4.09k|        }
  327|   103M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE6ignoreEm:
  286|  8.14M|    {
  287|  8.14M|        std::size_t len = 0;
  288|  8.14M|        if (remaining_ > 0)
  ------------------
  |  Branch (288:13): [True: 8.14M, False: 0]
  ------------------
  289|  8.14M|        {
  290|  8.14M|            len = (std::min)(remaining_, length);
  291|  8.14M|            position_ += len;
  292|  8.14M|            data_end_ += len;
  293|  8.14M|            remaining_ -= len;
  294|  8.14M|        }
  295|  8.14M|        while (len < length)
  ------------------
  |  Branch (295:16): [True: 0, False: 8.14M]
  ------------------
  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|  8.14M|    }

_ZN8jsoncons16typed_array_castIKhEENS_6detail4spanIT_Lm18446744073709551615EEENS3_IhLm18446744073709551615EEE:
  141|  7.28k|{
  142|  7.28k|    return jsoncons::span<const uint8_t>{reinterpret_cast<const uint8_t*>(bytes.data()), bytes.size()};
  143|  7.28k|}
_ZN8jsoncons16typed_array_castIhEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   81|  7.28k|{
   82|  7.28k|    return bytes;
   83|  7.28k|}
_ZN8jsoncons16typed_array_castItEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   87|  46.7k|{
   88|  46.7k|    return jsoncons::span<uint16_t>{reinterpret_cast<uint16_t*>(bytes.data()), bytes.size()/sizeof(uint16_t)};
   89|  46.7k|}
_ZN8jsoncons16typed_array_castIjEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   93|  11.1k|{
   94|  11.1k|    return jsoncons::span<uint32_t>{reinterpret_cast<uint32_t*>(bytes.data()), bytes.size()/sizeof(uint32_t)};
   95|  11.1k|}
_ZN8jsoncons16typed_array_castImEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   99|  36.5k|{
  100|  36.5k|    return jsoncons::span<uint64_t>{reinterpret_cast<uint64_t*>(bytes.data()), bytes.size()/sizeof(uint64_t)};
  101|  36.5k|}
_ZN8jsoncons16typed_array_castIaEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  105|  7.87k|{
  106|  7.87k|    return jsoncons::span<int8_t>{reinterpret_cast<int8_t*>(bytes.data()), bytes.size()};
  107|  7.87k|}
_ZN8jsoncons16typed_array_castIsEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  111|  19.1k|{
  112|  19.1k|    return jsoncons::span<int16_t>{reinterpret_cast<int16_t*>(bytes.data()), bytes.size()/sizeof(int16_t)};
  113|  19.1k|}
_ZN8jsoncons16typed_array_castIiEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  117|  16.5k|{
  118|  16.5k|    return jsoncons::span<int32_t>{reinterpret_cast<int32_t*>(bytes.data()), bytes.size()/sizeof(int32_t)};
  119|  16.5k|}
_ZN8jsoncons16typed_array_castIlEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  123|  7.75k|{
  124|  7.75k|    return jsoncons::span<int64_t>{reinterpret_cast<int64_t*>(bytes.data()), bytes.size()/sizeof(int64_t)};
  125|  7.75k|}
_ZN8jsoncons16typed_array_castIfEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  129|  25.4k|{
  130|  25.4k|    return jsoncons::span<float>{reinterpret_cast<float*>(bytes.data()), bytes.size()/sizeof(float)};
  131|  25.4k|}
_ZN8jsoncons16typed_array_castIdEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  135|  10.9k|{
  136|  10.9k|    return jsoncons::span<double>{reinterpret_cast<double*>(bytes.data()), bytes.size()/sizeof(double)};
  137|  10.9k|}
_ZN8jsoncons22calculate_mdarray_sizeENS_6detail4spanIKmLm18446744073709551615EEE:
  247|    479|{
  248|    479|    using result_type = jsoncons::expected<std::size_t,std::errc>;
  249|       |
  250|    479|    if (extents.empty())
  ------------------
  |  Branch (250:9): [True: 2, False: 477]
  ------------------
  251|      2|    {
  252|      2|        return result_type(0);
  253|      2|    }
  254|    477|    std::size_t n = extents[0];
  255|  1.17k|    for (std::size_t i = 1; i < extents.size(); ++i)
  ------------------
  |  Branch (255:29): [True: 717, False: 460]
  ------------------
  256|    717|    {
  257|    717|        if (extents[i] == 0 || JSONCONS_UNLIKELY(n > (std::numeric_limits<std::size_t>::max)()/extents[i]))
  ------------------
  |  |   78|    707|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 700]
  |  |  ------------------
  ------------------
  |  Branch (257:13): [True: 10, False: 707]
  ------------------
  258|     17|        {
  259|     17|            return result_type(jsoncons::unexpect, std::errc::value_too_large);
  260|     17|        }
  261|    700|        n *= extents[i];
  262|    700|    }
  263|    460|    return n;
  264|    477|}

_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE13from_bytes_beEiPKhm:
  792|   267k|    {
  793|   267k|        static const double radix_log2 = std::log2(next_power_of_two(256));
  794|       |        // Estimate how big the result will be, so we can pre-allocate it.
  795|   267k|        double bits = radix_log2 * n;
  796|   267k|        double big_digits = std::ceil(bits / 64.0);
  797|       |        //std::cout << "ESTIMATED: " << big_digits << "\n";
  798|       |
  799|   267k|        basic_bigint<Allocator> v = 0;
  800|   267k|        v.reserve(static_cast<size_type>(big_digits));
  801|       |
  802|  3.90M|        for (size_type i = 0; i < n; i++)
  ------------------
  |  Branch (802:31): [True: 3.64M, False: 267k]
  ------------------
  803|  3.64M|        {
  804|  3.64M|            v *= 256;
  805|  3.64M|            v += (word_type)(bytes[i]);
  806|  3.64M|        }
  807|       |        //std::cout << "ACTUAL: " << v.size() << "\n";
  808|       |
  809|   267k|        if (signum < 0)
  ------------------
  |  Branch (809:13): [True: 0, False: 267k]
  ------------------
  810|      0|        {
  811|      0|            v.set_negative(true);
  812|      0|        }
  813|       |
  814|   267k|        return v;
  815|   267k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE17next_power_of_twoEm:
 1921|      1|    static word_type next_power_of_two(word_type n) {
 1922|      1|        n = n - 1;
 1923|      1|        n |= n >> 1u;
 1924|      1|        n |= n >> 2u;
 1925|      1|        n |= n >> 4u;
 1926|      1|        n |= n >> 8u;
 1927|      1|        n |= n >> 16u;
 1928|      1|        n |= n >> 32u;
 1929|      1|        return n + 1;
 1930|      1|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE7reserveEm:
  823|   267k|    {
  824|   267k|        storage_.reserve(n);
  825|   267k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7reserveEm:
  452|  8.94M|    {
  453|  8.94M|       if (capacity() < n)
  ------------------
  |  Branch (453:12): [True: 106k, False: 8.84M]
  ------------------
  454|   106k|       {
  455|   106k|           if (!is_allocated())
  ------------------
  |  Branch (455:16): [True: 106k, False: 0]
  ------------------
  456|   106k|           {
  457|   106k|               size_type size = inlined_.size_;
  458|   106k|               size_type is_neg = inlined_.is_negative_;
  459|   106k|               word_type values[inlined_capacity] = {inlined_.values_[0], inlined_.values_[1]};
  460|       |
  461|   106k|               ::new (&allocated_) allocated_storage();
  462|   106k|               allocated_.reserve(n, get_allocator());
  463|   106k|               allocated_.size_ = size;
  464|   106k|               allocated_.is_negative_ = is_neg;
  465|   106k|               if (n >= 1)
  ------------------
  |  Branch (465:20): [True: 106k, False: 0]
  ------------------
  466|   106k|               {
  467|   106k|                   allocated_.data_[0] = values[0];
  468|   106k|               }
  469|   106k|               if (n >= 2)
  ------------------
  |  Branch (469:20): [True: 106k, False: 0]
  ------------------
  470|   106k|               {
  471|   106k|                   allocated_.data_[1] = values[1];
  472|   106k|               }
  473|   106k|           }
  474|      0|           else
  475|      0|           {
  476|      0|               allocated_.reserve(n, get_allocator());
  477|      0|           }
  478|   106k|       }
  479|  8.94M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE8capacityEv:
  505|  8.94M|    {
  506|  8.94M|        return is_allocated() ? allocated_.capacity_ : inlined_capacity;
  ------------------
  |  Branch (506:16): [True: 7.71M, False: 1.23M]
  ------------------
  507|  8.94M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12is_allocatedEv:
  500|  22.7M|    {
  501|  22.7M|        return common_.is_allocated_;
  502|  22.7M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2Ev:
  203|   106k|            : is_allocated_(true),
  204|   106k|            is_negative_(false)
  205|   106k|        {
  206|   106k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7reserveEmRKS4_:
  255|   106k|        {
  256|   106k|            JSONCONS_ASSERT(n < max_size);
  ------------------
  |  |   49|   106k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 106k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  257|   106k|            size_type capacity_new = round_up(n);
  258|       |
  259|   106k|            real_allocator_type alloc(a);
  260|   106k|            word_type* data_new = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_new);
  261|   106k|            if (size_ > 0)
  ------------------
  |  Branch (261:17): [True: 0, False: 106k]
  ------------------
  262|      0|            {
  263|      0|                std::memcpy(data_new, data_, size_type(size_ * sizeof(word_type)));
  264|      0|            }
  265|   106k|            if (data_ != nullptr)
  ------------------
  |  Branch (265:17): [True: 0, False: 106k]
  ------------------
  266|      0|            {
  267|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  268|      0|            }
  269|   106k|            capacity_ = capacity_new;
  270|   106k|            data_ = data_new;
  271|   106k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage8round_upEm:
  275|   106k|        {
  276|   106k|            size_type remainder = i % mem_unit;
  277|   106k|            size_type off = mem_unit - remainder;
  278|   106k|            bool testoff = i < max_size - off;
  279|   106k|            JSONCONS_ASSERT(testoff);
  ------------------
  |  |   49|   106k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 106k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  280|       |
  281|   106k|            return i + off;
  282|   106k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE13get_allocatorEv:
  482|  4.05M|    {
  483|  4.05M|        return static_cast<const word_allocator_type&>(*this);
  484|  4.05M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLIiEENS1_9enable_ifIXsr10ext_traits17is_signed_integerIT_EE5valueERS4_E4typeES7_:
  988|  3.64M|    {
  989|  3.64M|        *this *= word_type(y < 0 ? -y : y);
  ------------------
  |  Branch (989:28): [True: 0, False: 3.64M]
  ------------------
  990|  3.64M|        if ( y < 0 )
  ------------------
  |  Branch (990:14): [True: 0, False: 3.64M]
  ------------------
  991|      0|            set_negative(!is_negative());
  992|  3.64M|        return *this;
  993|  3.64M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLImEENS1_9enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
  998|  3.64M|    {
  999|  3.64M|        auto this_view = get_storage_view();
 1000|  3.64M|        size_type len0 = this_view.size();
 1001|  3.64M|        word_type dig = this_view[0];
 1002|  3.64M|        word_type carry = 0;
 1003|       |
 1004|  3.64M|        resize(this_view.size() + 1);
 1005|  3.64M|        this_view = get_storage_view();
 1006|       |
 1007|  3.64M|        size_type i = 0;
 1008|  1.72G|        for (; i < len0; i++ )
  ------------------
  |  Branch (1008:16): [True: 1.72G, False: 3.64M]
  ------------------
 1009|  1.72G|        {
 1010|  1.72G|            word_type hi;
 1011|  1.72G|            word_type lo;
 1012|  1.72G|            DDproduct( dig, y, hi, lo );
 1013|  1.72G|            this_view[i] = lo + carry;
 1014|  1.72G|            dig = this_view[i+1];
 1015|  1.72G|            carry = hi + (this_view[i] < lo);
 1016|  1.72G|        }
 1017|  3.64M|        this_view[i] = carry;
 1018|  3.64M|        reduce();
 1019|  3.64M|        return *this;
 1020|  3.64M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  718|  20.8M|    {
  719|  20.8M|        return storage_.get_storage_view();
  720|  20.8M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  520|  30.5M|    {
  521|  30.5M|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (521:16): [True: 25.5M, False: 5.06M]
  ------------------
  522|  25.5M|            storage_view<word_type>{allocated_.data_, allocated_.size_} :
  523|  30.5M|            storage_view<word_type>{inlined_.values_, inlined_.size_};
  524|  30.5M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEC2EPmm:
   64|  30.5M|            : data_(data), size_(size)
   65|  30.5M|        {
   66|  30.5M|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4sizeEv:
   84|  28.6M|        {
   85|  28.6M|            return size_;
   86|  28.6M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEixEm:
   69|  6.21G|        {
   70|  6.21G|            return data_[i];
   71|  6.21G|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6resizeEm:
  818|  7.76M|    {
  819|  7.76M|        storage_.resize(new_length);
  820|  7.76M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6resizeEm:
  534|  8.67M|    {
  535|  8.67M|        size_type old_length = common_.size_;
  536|  8.67M|        reserve(new_length);
  537|  8.67M|        common_.size_ = new_length;
  538|       |
  539|  8.67M|        if (old_length < new_length)
  ------------------
  |  Branch (539:13): [True: 7.95M, False: 729k]
  ------------------
  540|  7.95M|        {
  541|  7.95M|            if (is_allocated())
  ------------------
  |  Branch (541:17): [True: 7.24M, False: 706k]
  ------------------
  542|  7.24M|            {
  543|  7.24M|                std::memset(allocated_.data_+old_length, 0, size_type((new_length-old_length)*sizeof(word_type)));
  544|  7.24M|            }
  545|   706k|            else
  546|   706k|            {
  547|   706k|                JSONCONS_ASSERT(new_length <= inlined_capacity);
  ------------------
  |  |   49|   706k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 706k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  548|  2.02M|                for (size_type i = old_length; i < inlined_capacity; ++i)
  ------------------
  |  Branch (548:48): [True: 1.32M, False: 706k]
  ------------------
  549|  1.32M|                {
  550|  1.32M|                    inlined_.values_[i] = 0;
  551|  1.32M|                }
  552|   706k|            }
  553|  7.95M|        }
  554|  8.67M|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9DDproductEmmRmS5_:
 1781|  1.94G|    {
 1782|  1.94G|        word_type hiA = A >> word_type_half_bits, loA = A & r_mask,
 1783|  1.94G|                   hiB = B >> word_type_half_bits, loB = B & r_mask;
 1784|       |
 1785|  1.94G|        lo = loA * loB;
 1786|  1.94G|        hi = hiA * hiB;
 1787|  1.94G|        word_type mid1 = loA * hiB;
 1788|  1.94G|        word_type mid2 = hiA * loB;
 1789|  1.94G|        word_type old = lo;
 1790|  1.94G|        lo += mid1 << word_type_half_bits;
 1791|  1.94G|            hi += (lo < old) + (mid1 >> word_type_half_bits);
 1792|  1.94G|        old = lo;
 1793|  1.94G|        lo += mid2 << word_type_half_bits;
 1794|  1.94G|            hi += (lo < old) + (mid2 >> word_type_half_bits);
 1795|  1.94G|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6reduceEv:
 1917|  8.84M|    {
 1918|  8.84M|        storage_.reduce();
 1919|  8.84M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6reduceEv:
  429|  8.84M|    {
  430|  8.84M|        if (common_.size_ > 0)
  ------------------
  |  Branch (430:13): [True: 8.84M, False: 0]
  ------------------
  431|  8.84M|        {
  432|  8.84M|            auto this_view = get_storage_view();
  433|  8.84M|            word_type* p = this_view.end() - 1;
  434|  8.84M|            word_type* first = this_view.begin();
  435|   235M|            while ( p >= first )
  ------------------
  |  Branch (435:21): [True: 234M, False: 604k]
  ------------------
  436|   234M|            {
  437|   234M|                if ( *p )
  ------------------
  |  Branch (437:22): [True: 8.24M, False: 226M]
  ------------------
  438|  8.24M|                {
  439|  8.24M|                    break;
  440|  8.24M|                }
  441|   226M|                --common_.size_;
  442|   226M|                --p;
  443|   226M|            }
  444|  8.84M|        }
  445|  8.84M|        if (common_.size_ == 0)
  ------------------
  |  Branch (445:13): [True: 604k, False: 8.24M]
  ------------------
  446|   604k|        {
  447|   604k|            common_.is_negative_ = false;
  448|   604k|        }
  449|  8.84M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE3endEv:
   93|  8.84M|        {
   94|  8.84M|            return data_ + size_;
   95|  8.84M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE5beginEv:
   88|  8.84M|        {
   89|  8.84M|            return data_;
   90|  8.84M|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11is_negativeEv:
  728|  7.82M|    {
  729|  7.82M|        return storage_.is_negative();
  730|  7.82M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE11is_negativeEv:
  510|  7.82M|    {
  511|  7.82M|        return common_.is_negative_;
  512|  7.82M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLImEENS1_9enable_ifIXaasr10ext_traits19is_unsigned_integerIT_EE5valuelestS7_Lm8EERS4_E4typeES7_:
  889|  3.64M|    {
  890|  3.64M|        if ( is_negative())
  ------------------
  |  Branch (890:14): [True: 0, False: 3.64M]
  ------------------
  891|      0|            return *this -= -basic_bigint<Allocator>(y);
  892|       |
  893|  3.64M|        word_type d;
  894|  3.64M|        word_type carry = 0;
  895|       |
  896|  3.64M|        auto this_view = get_storage_view();
  897|  3.64M|        resize(this_view.size() + 1);
  898|       |
  899|  3.64M|        this_view = get_storage_view();
  900|  3.64M|        const size_type this_size = this_view.size();
  901|  3.64M|        size_type y_size = 1;
  902|       |
  903|  3.64M|        d = this_view[0] + carry;
  904|  3.64M|        carry = d < carry;
  905|  3.64M|        this_view[0] = d + y;
  906|  3.64M|        if (this_view[0] < d)
  ------------------
  |  Branch (906:13): [True: 0, False: 3.64M]
  ------------------
  907|      0|            carry = 1;
  908|       |
  909|  3.64M|        for (size_type i = y_size; i < this_size && carry != 0; ++i)
  ------------------
  |  Branch (909:36): [True: 3.23M, False: 410k]
  |  Branch (909:53): [True: 0, False: 3.23M]
  ------------------
  910|      0|        {
  911|      0|            d = this_view[i] + carry;
  912|      0|            carry = d < carry;
  913|      0|            this_view[i] = d;
  914|      0|        }
  915|  3.64M|        reduce();
  916|  3.64M|        return *this;
  917|  3.64M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ImEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  693|   502k|        : storage_(n, alloc)
  694|   502k|    {
  695|   502k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ImEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  360|   502k|        : word_allocator_type(alloc)
  361|   502k|    {
  362|   502k|        ::new (&inlined_) inlined_storage(n);
  363|   502k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ImEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  138|   502k|            : is_allocated_(false),
  139|   502k|            is_negative_(false),
  140|   502k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (140:19): [True: 221k, False: 280k]
  ------------------
  141|   502k|        {
  142|   502k|            values_[0] = n;
  143|   502k|            values_[1] = 0;
  144|   502k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEEngEv:
  835|  31.6k|    {
  836|  31.6k|        basic_bigint<Allocator> v(*this);
  837|  31.6k|        v.set_negative(!v.is_negative());
  838|  31.6k|        return v;
  839|  31.6k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_:
  671|   330k|        : storage_(other.storage_)
  672|   330k|    {
  673|   330k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_:
  299|   330k|        : word_allocator_type(other.get_allocator())
  300|   330k|    {
  301|       |#if defined(__GNUC__) && JSONCONS_GCC_AVAILABLE(12,0,0)
  302|       |# pragma GCC diagnostic push
  303|       |# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
  304|       |#endif
  305|   330k|        if (!other.is_allocated())
  ------------------
  |  Branch (305:13): [True: 227k, False: 103k]
  ------------------
  306|   227k|        {
  307|   227k|            ::new (&inlined_) inlined_storage(other.inlined_);
  308|   227k|        }
  309|   103k|        else
  310|   103k|        {
  311|   103k|            ::new (&allocated_) allocated_storage(other.allocated_, get_allocator());
  312|   103k|        }
  313|       |#if defined(__GNUC__) && JSONCONS_GCC_AVAILABLE(12,0,0)
  314|       |# pragma GCC diagnostic pop
  315|       |#endif
  316|   330k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ERKS6_:
  178|  1.43M|            : is_allocated_(false),
  179|  1.43M|            is_negative_(stor.is_negative_),
  180|  1.43M|            size_(stor.size_)
  181|  1.43M|        {
  182|  1.43M|            values_[0] = stor.values_[0];
  183|  1.43M|            values_[1] = stor.values_[1];
  184|  1.43M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2ERKS6_RKS4_:
  209|   933k|            : is_allocated_(true),
  210|   933k|              is_negative_(stor.is_negative_),
  211|   933k|              size_(stor.size_),
  212|   933k|              capacity_(stor.capacity_)
  213|   933k|        {
  214|   933k|            real_allocator_type alloc(a);
  215|       |
  216|   933k|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_);
  217|   933k|            JSONCONS_TRY
  ------------------
  |  |   37|   933k|    #define JSONCONS_TRY try
  ------------------
  218|   933k|            {
  219|   933k|                std::allocator_traits<real_allocator_type>::construct(alloc, ext_traits::to_plain_pointer(data_));
  220|   933k|            }
  221|   933k|            JSONCONS_CATCH(...)
  222|   933k|            {
  223|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  224|      0|                data_ = nullptr;
  225|      0|                JSONCONS_RETHROW;
  ------------------
  |  |   36|      0|    #define JSONCONS_RETHROW throw
  ------------------
  226|      0|            }
  227|   933k|            JSONCONS_ASSERT(stor.data_ != nullptr);
  ------------------
  |  |   49|   933k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 933k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  228|   933k|            std::memcpy(data_, stor.data_, size_type(stor.size_ * sizeof(word_type)));
  229|   933k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmIERKS4_:
  954|  31.6k|    {
  955|  31.6k|        auto y_view = y.get_storage_view();
  956|       |
  957|  31.6k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (957:14): [True: 31.6k, False: 0]
  ------------------
  958|  31.6k|            return *this += -y;
  959|      0|        if ( (!is_negative() && y > *this) || (is_negative() && y < *this) )
  ------------------
  |  Branch (959:15): [True: 0, False: 0]
  |  Branch (959:33): [True: 0, False: 0]
  |  Branch (959:48): [True: 0, False: 0]
  |  Branch (959:65): [True: 0, False: 0]
  ------------------
  960|      0|            return *this = -(y - *this);
  961|      0|        word_type borrow = 0;
  962|      0|        word_type d;
  963|      0|        auto this_view = get_storage_view();
  964|      0|        const size_type this_size = this_view.size();
  965|      0|        const size_type y_size = y_view.size();
  966|       |
  967|      0|        for (size_type i = 0; i < y_size; i++ )
  ------------------
  |  Branch (967:31): [True: 0, False: 0]
  ------------------
  968|      0|        {
  969|      0|            d = this_view[i] - borrow;
  970|      0|            borrow = d > this_view[i];
  971|      0|            this_view[i] = d - y_view[i];
  972|      0|            if ( this_view[i] > d )
  ------------------
  |  Branch (972:18): [True: 0, False: 0]
  ------------------
  973|      0|                borrow = 1;
  974|      0|        }
  975|      0|        for (size_type i = y_size; i < this_size && borrow != 0; i++ )
  ------------------
  |  Branch (975:36): [True: 0, False: 0]
  |  Branch (975:53): [True: 0, False: 0]
  ------------------
  976|      0|        {
  977|      0|            d = this_view[i] - borrow;
  978|      0|            borrow = d > this_view[i];
  979|      0|            this_view[i] = d;
  980|      0|        }
  981|      0|        reduce();
  982|      0|        return *this;
  983|      0|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  723|  1.74M|    {
  724|  1.74M|        return storage_.get_storage_view();
  725|  1.74M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  527|  2.66M|    {
  528|  2.66M|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (528:16): [True: 1.36M, False: 1.29M]
  ------------------
  529|  1.36M|            storage_view<const word_type>{allocated_.data_, allocated_.size_} :
  530|  2.66M|            storage_view<const word_type>{inlined_.values_, inlined_.size_};
  531|  2.66M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEC2EPS7_m:
   64|  2.66M|            : data_(data), size_(size)
   65|  2.66M|        {
   66|  2.66M|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLERKS4_:
  920|  31.6k|    {
  921|  31.6k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (921:14): [True: 0, False: 31.6k]
  ------------------
  922|      0|            return *this -= -y;
  923|       |
  924|  31.6k|        auto y_view = y.get_storage_view();
  925|       |        
  926|  31.6k|        word_type d;
  927|  31.6k|        word_type carry = 0;
  928|       |
  929|  31.6k|        auto this_view = get_storage_view();
  930|  31.6k|        resize( (std::max)(y_view.size(), this_view.size()) + 1 );
  931|  31.6k|        this_view = get_storage_view();
  932|       |
  933|  31.6k|        const size_t this_size = this_view.size();
  934|  31.6k|        const size_t y_size = y_view.size();
  935|   362k|        for (size_type i = 0; i < y_size; i++ )
  ------------------
  |  Branch (935:31): [True: 331k, False: 31.6k]
  ------------------
  936|   331k|        {
  937|   331k|            d = this_view[i] + carry;
  938|   331k|            carry = d < carry;
  939|   331k|            this_view[i] = d + y_view[i];
  940|   331k|            if (this_view[i] < d)
  ------------------
  |  Branch (940:17): [True: 790, False: 330k]
  ------------------
  941|    790|                carry = 1;
  942|   331k|        }
  943|  31.9k|        for (size_type i = y_size; i < this_size && carry != 0; i++ )
  ------------------
  |  Branch (943:36): [True: 31.6k, False: 299]
  |  Branch (943:53): [True: 299, False: 31.3k]
  ------------------
  944|    299|        {
  945|    299|            d = this_view[i] + carry;
  946|    299|            carry = d < carry;
  947|    299|            this_view[i] = d;
  948|    299|        }
  949|  31.6k|        reduce();
  950|  31.6k|        return *this;
  951|  31.6k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7compareERKS4_:
 1641|   634k|    {
 1642|   634k|        auto this_view = get_storage_view();
 1643|   634k|        auto y_view = y.get_storage_view();
 1644|       |
 1645|   634k|        const size_type y_size = y_view.size();
 1646|   634k|        if ( this_view.size() == 0 && y_size == 0 )
  ------------------
  |  Branch (1646:14): [True: 0, False: 634k]
  |  Branch (1646:39): [True: 0, False: 0]
  ------------------
 1647|      0|            return 0;
 1648|   634k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (1648:14): [True: 0, False: 634k]
  ------------------
 1649|      0|            return y.is_negative() - is_negative();
 1650|   634k|        int code = 0;
 1651|   634k|        if ( this_view.size() < y_size)
  ------------------
  |  Branch (1651:14): [True: 0, False: 634k]
  ------------------
 1652|      0|            code = -1;
 1653|   634k|        else if ( this_view.size() > y_size)
  ------------------
  |  Branch (1653:19): [True: 383k, False: 251k]
  ------------------
 1654|   383k|            code = +1;
 1655|   251k|        else
 1656|   251k|        {
 1657|   251k|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1657:50): [True: 251k, False: 344]
  ------------------
 1658|   251k|            {
 1659|   251k|                if (this_view[i] > y_view[i])
  ------------------
  |  Branch (1659:21): [True: 29.1k, False: 221k]
  ------------------
 1660|  29.1k|                {
 1661|  29.1k|                    code = 1;
 1662|  29.1k|                    break;
 1663|  29.1k|                }
 1664|   221k|                else if (this_view[i] < y_view[i])
  ------------------
  |  Branch (1664:26): [True: 221k, False: 344]
  ------------------
 1665|   221k|                {
 1666|   221k|                    code = -1;
 1667|   221k|                    break;
 1668|   221k|                }
 1669|   251k|            }
 1670|   251k|        }
 1671|   634k|        return is_negative() ? -code : code;
  ------------------
  |  Branch (1671:16): [True: 0, False: 634k]
  ------------------
 1672|   634k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEES6_:
 1476|   634k|    {
 1477|   634k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1477:15): [True: 221k, False: 412k]
  ------------------
 1478|   634k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4sizeEv:
   84|  5.38M|        {
   85|  5.38M|            return size_;
   86|  5.38M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEixEm:
   69|  1.27M|        {
   70|  1.27M|            return data_[i];
   71|  1.27M|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE12set_negativeEb:
  733|  2.56M|    {
  734|  2.56M|        storage_.set_negative(value);
  735|  2.56M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12set_negativeEb:
  515|  2.56M|    {
  516|  2.56M|        common_.is_negative_ = value;
  517|  2.56M|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE12write_stringIcNS1_11char_traitsIcEENS2_IcEEEEvRNS1_12basic_stringIT_T0_T1_EE:
 1359|   255k|    {
 1360|   255k|        basic_bigint<Allocator> v(*this);
 1361|   255k|        auto v_view = v.get_storage_view();
 1362|       |
 1363|   255k|        size_type len = (v_view.size() * word_type_bits / 3) + 2;
 1364|   255k|        data.reserve(len);
 1365|       |
 1366|   255k|        if ( v_view.size() == 0 )
  ------------------
  |  Branch (1366:14): [True: 36.2k, False: 219k]
  ------------------
 1367|  36.2k|        {
 1368|  36.2k|            data.push_back('0');
 1369|  36.2k|        }
 1370|   219k|        else
 1371|   219k|        {
 1372|   219k|            word_type r;
 1373|   219k|            basic_bigint<Allocator> R(get_allocator());
 1374|   219k|            basic_bigint<Allocator> LP10(max_unsigned_power_10, get_allocator()); 
 1375|       |
 1376|   219k|            do
 1377|   601k|            {
 1378|   601k|                v.divide( LP10, v, R, true );
 1379|   601k|                v_view = v.get_storage_view();
 1380|       |
 1381|   601k|                auto R_view = R.get_storage_view();
 1382|   601k|                r = (R_view.size() ? R_view[0] : 0);
  ------------------
  |  Branch (1382:22): [True: 601k, False: 555]
  ------------------
 1383|  8.15M|                for ( size_type j=0; j < imax_unsigned_power_10; j++ )
  ------------------
  |  Branch (1383:38): [True: 7.77M, False: 382k]
  ------------------
 1384|  7.77M|                {
 1385|  7.77M|                    data.push_back(char(r % 10u + '0'));
 1386|  7.77M|                    r /= 10u;
 1387|  7.77M|                    if ( r + v_view.size() == 0 )
  ------------------
  |  Branch (1387:26): [True: 219k, False: 7.55M]
  ------------------
 1388|   219k|                        break;
 1389|  7.77M|                }
 1390|   601k|            } 
 1391|   601k|            while ( v_view.size() > 0);
  ------------------
  |  Branch (1391:21): [True: 382k, False: 219k]
  ------------------
 1392|       |
 1393|   219k|            if (is_negative())
  ------------------
  |  Branch (1393:17): [True: 30.6k, False: 188k]
  ------------------
 1394|  30.6k|            {
 1395|  30.6k|                data.push_back('-');
 1396|  30.6k|            }
 1397|   219k|            std::reverse(data.begin(),data.end());
 1398|   219k|        }
 1399|   255k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE13get_allocatorEv:
  713|  2.47M|    {
  714|  2.47M|        return storage_.get_allocator();
  715|  2.47M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS3_:
  644|   219k|        : storage_(alloc)
  645|   219k|    {
  646|   219k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS4_:
  293|   221k|        : word_allocator_type(alloc)
  294|   221k|    {
  295|   221k|        ::new (&inlined_) inlined_storage();
  296|   221k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2Ev:
  113|   221k|            : is_allocated_(false),
  114|   221k|            is_negative_(false),
  115|   221k|            size_(0),
  116|   221k|            values_{0, 0}
  117|   221k|        {
  118|   221k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE6divideERKS4_RS4_S7_b:
 1675|   634k|    {
 1676|   634k|        basic_bigint<Allocator> denom(denom_, get_allocator());
 1677|   634k|        auto denom_view = denom.get_storage_view();
 1678|       |
 1679|   634k|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1679:13): [True: 0, False: 634k]
  ------------------
 1680|      0|        {
 1681|      0|            JSONCONS_THROW(std::runtime_error( "Zero divide." ));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1682|      0|        }
 1683|   634k|        bool quot_neg = is_negative() ^ denom.is_negative();
 1684|   634k|        bool rem_neg = is_negative();
 1685|   634k|        basic_bigint<Allocator> num(*this, get_allocator());
 1686|   634k|        num.set_negative(false);
 1687|   634k|        denom.set_negative(false);
 1688|   634k|        if ( num < denom )
  ------------------
  |  Branch (1688:14): [True: 221k, False: 412k]
  ------------------
 1689|   221k|        {
 1690|   221k|            quot = word_type(0);
 1691|   221k|            quot.set_negative(quot_neg);
 1692|   221k|            rem = num;
 1693|   221k|            rem.set_negative(rem_neg);
 1694|   221k|            return;
 1695|   221k|        }
 1696|       |
 1697|   412k|        auto num_view = num.get_storage_view();
 1698|   412k|        auto quot_view = quot.get_storage_view();
 1699|   412k|        auto this_view = get_storage_view();
 1700|       |
 1701|   412k|        if ( denom_view.size() == 1 && num_view.size() == 1 )
  ------------------
  |  Branch (1701:14): [True: 412k, False: 0]
  |  Branch (1701:40): [True: 29.5k, False: 383k]
  ------------------
 1702|  29.5k|        {
 1703|  29.5k|            quot = word_type( num_view[0]/denom_view[0] );
 1704|  29.5k|            rem = word_type( num_view[0]%denom_view[0] );
 1705|  29.5k|            quot.set_negative(quot_neg);
 1706|  29.5k|            rem.set_negative(rem_neg);
 1707|  29.5k|            return;
 1708|  29.5k|        }
 1709|   383k|        if (denom_view.size() == 1 && (denom_view[0] & l_mask) == 0 )
  ------------------
  |  Branch (1709:13): [True: 383k, False: 0]
  |  Branch (1709:39): [True: 0, False: 383k]
  ------------------
 1710|      0|        {
 1711|       |            // Denominator fits into a half word
 1712|      0|            word_type divisor = denom_view[0], dHi = 0, q1, r, q2, dividend;
 1713|      0|            quot.resize(this_view.size());
 1714|      0|            quot_view = quot.get_storage_view();
 1715|      0|            for (size_type i=this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1715:48): [True: 0, False: 0]
  ------------------
 1716|      0|            {
 1717|      0|                dividend = (dHi << word_type_half_bits) | (this_view[i] >> word_type_half_bits);
 1718|      0|                q1 = dividend/divisor;
 1719|      0|                r = dividend % divisor;
 1720|      0|                dividend = (r << word_type_half_bits) | (this_view[i] & r_mask);
 1721|      0|                q2 = dividend/divisor;
 1722|      0|                dHi = dividend % divisor;
 1723|      0|                quot_view[i] = (q1 << word_type_half_bits) | q2;
 1724|      0|            }
 1725|      0|            quot.reduce();
 1726|      0|            rem = dHi;
 1727|      0|            quot.set_negative(quot_neg);
 1728|      0|            rem.set_negative(rem_neg);
 1729|      0|            return;
 1730|      0|        }
 1731|   383k|        basic_bigint<Allocator> num0(num, get_allocator());
 1732|   383k|        basic_bigint<Allocator> denom0(denom, get_allocator());
 1733|   383k|        int x = 0;
 1734|   383k|        bool second_done = normalize(denom, num, x);
 1735|   383k|        denom_view = denom.get_storage_view();
 1736|   383k|        num_view = num.get_storage_view();
 1737|       |
 1738|   383k|        size_type l = denom_view.size() - 1;
 1739|   383k|        size_type n = num_view.size() - 1;
 1740|   383k|        quot.resize(n - l);
 1741|   383k|        quot_view = quot.get_storage_view();
 1742|   219M|        for (size_type i = quot_view.size(); i-- > 0; )
  ------------------
  |  Branch (1742:46): [True: 219M, False: 383k]
  ------------------
 1743|   219M|        {
 1744|   219M|            quot_view[i] = 0;
 1745|   219M|        }
 1746|   383k|        rem = num;
 1747|   383k|        auto rem_view = rem.get_storage_view();
 1748|   383k|        if ( rem_view[n] >= denom_view[l] )
  ------------------
  |  Branch (1748:14): [True: 2.50k, False: 380k]
  ------------------
 1749|  2.50k|        {
 1750|  2.50k|            rem.resize(rem_view.size() + 1);
 1751|  2.50k|            rem_view = rem.get_storage_view();
 1752|  2.50k|            n++;
 1753|  2.50k|            quot.resize(quot_view.size() + 1);
 1754|  2.50k|            quot_view = quot.get_storage_view();
 1755|  2.50k|        }
 1756|   383k|        word_type d = denom_view[l];
 1757|       |
 1758|   219M|        for ( size_type k = n; k > l; k-- )
  ------------------
  |  Branch (1758:32): [True: 219M, False: 383k]
  ------------------
 1759|   219M|        {
 1760|   219M|            word_type q = DDquotient(rem_view[k], rem_view[k-1], d);
 1761|   219M|            subtractmul( rem_view.data() + (k - l - 1), denom_view.data(), l + 1, q );
 1762|   219M|            quot_view[k - l - 1] = q;
 1763|   219M|        }
 1764|   383k|        quot.reduce();
 1765|   383k|        quot.set_negative(quot_neg);
 1766|   383k|        if (remDesired)
  ------------------
  |  Branch (1766:13): [True: 383k, False: 0]
  ------------------
 1767|   383k|        {
 1768|   383k|            unnormalize(rem, x, second_done);
 1769|   383k|            rem.set_negative(rem_neg);
 1770|   383k|        }
 1771|   383k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_RKS3_:
  676|  2.03M|        : storage_(other.storage_, alloc)
  677|  2.03M|    {
  678|  2.03M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_RKS4_:
  319|  2.03M|        : word_allocator_type(alloc)
  320|  2.03M|    {
  321|  2.03M|        if (!other.is_allocated())
  ------------------
  |  Branch (321:13): [True: 1.20M, False: 830k]
  ------------------
  322|  1.20M|        {
  323|  1.20M|            ::new (&inlined_) inlined_storage(other.inlined_);
  324|  1.20M|        }
  325|   830k|        else
  326|   830k|        {
  327|   830k|            ::new (&allocated_) allocated_storage(other.allocated_, alloc);
  328|   830k|        }
  329|  2.03M|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9normalizeERS4_S5_Ri:
 1872|   383k|    {
 1873|   383k|        auto denom_view = denom.get_storage_view();
 1874|   383k|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1874:13): [True: 0, False: 383k]
  ------------------
 1875|      0|        {
 1876|      0|            return false;
 1877|      0|        }
 1878|   383k|        size_type r = denom_view.size() - 1;
 1879|   383k|        word_type y = denom_view[r];
 1880|       |
 1881|   383k|        x = 0;
 1882|   474k|        while ( (y & l_bit) == 0 )
  ------------------
  |  Branch (1882:17): [True: 91.6k, False: 383k]
  ------------------
 1883|  91.6k|        {
 1884|  91.6k|            y <<= 1;
 1885|  91.6k|            x++;
 1886|  91.6k|        }
 1887|   383k|        denom <<= x;
 1888|   383k|        num <<= x;
 1889|       |
 1890|   383k|        denom_view = denom.get_storage_view();
 1891|   383k|        if ( r > 0 && denom_view[r] < denom_view[r-1] )
  ------------------
  |  Branch (1891:14): [True: 0, False: 383k]
  |  Branch (1891:23): [True: 0, False: 0]
  ------------------
 1892|      0|        {
 1893|      0|            denom *= max_word;
 1894|      0|            num *= max_word;
 1895|      0|            return true;
 1896|      0|        }
 1897|   383k|        return false;
 1898|   383k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEElSEm:
 1117|   766k|    {
 1118|   766k|        auto this_view = get_storage_view();
 1119|   766k|        size_type q = k / word_type_bits;
 1120|   766k|        if ( q ) // Increase storage_.size() by q:
  ------------------
  |  Branch (1120:14): [True: 0, False: 766k]
  ------------------
 1121|      0|        {
 1122|      0|            resize(this_view.size() + q);
 1123|      0|            this_view = get_storage_view();
 1124|      0|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1124:50): [True: 0, False: 0]
  ------------------
 1125|      0|                this_view[i] = ( i < q ? 0 : this_view[i - q]);
  ------------------
  |  Branch (1125:34): [True: 0, False: 0]
  ------------------
 1126|      0|            k %= word_type_bits;
 1127|      0|        }
 1128|   766k|        if ( k )  // 0 < k < word_type_bits:
  ------------------
  |  Branch (1128:14): [True: 61.0k, False: 705k]
  ------------------
 1129|  61.0k|        {
 1130|  61.0k|            size_type k1 = word_type_bits - k;
 1131|  61.0k|            word_type mask = (word_type(1) << k) - word_type(1);
 1132|  61.0k|            resize( this_view.size() + 1 );
 1133|  61.0k|            this_view = get_storage_view();
 1134|  22.7M|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1134:50): [True: 22.7M, False: 61.0k]
  ------------------
 1135|  22.7M|            {
 1136|  22.7M|                this_view[i] <<= k;
 1137|  22.7M|                if ( i > 0 )
  ------------------
  |  Branch (1137:22): [True: 22.6M, False: 61.0k]
  ------------------
 1138|  22.6M|                    this_view[i] |= (this_view[i-1] >> k1) & mask;
 1139|  22.7M|            }
 1140|  61.0k|        }
 1141|   766k|        reduce();
 1142|   766k|        return *this;
 1143|   766k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE10DDquotientEmmm:
 1799|   219M|    {
 1800|   219M|        word_type left, middle, right, qHi, qLo, x, dLo1,
 1801|   219M|                   dHi = d >> word_type_half_bits, dLo = d & r_mask;
 1802|   219M|        qHi = A/(dHi + 1);
 1803|       |        // This initial guess of qHi may be too small.
 1804|   219M|        middle = qHi * dLo;
 1805|   219M|        left = qHi * dHi;
 1806|   219M|        x = B - (middle << word_type_half_bits);
 1807|   219M|        A -= (middle >> word_type_half_bits) + left + (x > B);
 1808|   219M|        B = x;
 1809|   219M|        dLo1 = dLo << word_type_half_bits;
 1810|       |        // Increase qHi if necessary:
 1811|   321M|        while ( A > dHi || (A == dHi && B >= dLo1) )
  ------------------
  |  Branch (1811:17): [True: 101M, False: 219M]
  |  Branch (1811:29): [True: 223k, False: 219M]
  |  Branch (1811:41): [True: 223k, False: 18]
  ------------------
 1812|   102M|        {
 1813|   102M|            x = B - dLo1;
 1814|   102M|            A -= dHi + (x > B);
 1815|   102M|            B = x;
 1816|   102M|            qHi++;
 1817|   102M|        }
 1818|   219M|        qLo = ((A << word_type_half_bits) | (B >> word_type_half_bits))/(dHi + 1);
 1819|       |        // This initial guess of qLo may be too small.
 1820|   219M|        right = qLo * dLo;
 1821|   219M|        middle = qLo * dHi;
 1822|   219M|        x = B - right;
 1823|   219M|        A -= (x > B);
 1824|   219M|        B = x;
 1825|   219M|        x = B - (middle << word_type_half_bits);
 1826|   219M|            A -= (middle >> word_type_half_bits) + (x > B);
 1827|   219M|        B = x;
 1828|       |        // Increase qLo if necessary:
 1829|   321M|        while ( A || B >= d )
  ------------------
  |  Branch (1829:17): [True: 1.31M, False: 320M]
  |  Branch (1829:22): [True: 101M, False: 219M]
  ------------------
 1830|   102M|        {
 1831|   102M|            x = B - d;
 1832|   102M|            A -= (x > B);
 1833|   102M|            B = x;
 1834|   102M|            qLo++;
 1835|   102M|        }
 1836|   219M|        return (qHi << word_type_half_bits) + qLo;
 1837|   219M|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11subtractmulEPmS5_mRm:
 1841|   219M|    {
 1842|   219M|        word_type hi, lo, d, carry = 0;
 1843|   219M|        size_type i;
 1844|   439M|        for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1844:22): [True: 219M, False: 219M]
  ------------------
 1845|   219M|        {
 1846|   219M|            DDproduct( b[i], q, hi, lo );
 1847|   219M|            d = a[i];
 1848|   219M|            a[i] -= lo;
 1849|   219M|            if ( a[i] > d )
  ------------------
  |  Branch (1849:18): [True: 53.4M, False: 166M]
  ------------------
 1850|  53.4M|                carry++;
 1851|   219M|            d = a[i + 1];
 1852|   219M|            a[i + 1] -= hi + carry;
 1853|   219M|            carry = a[i + 1] > d;
 1854|   219M|        }
 1855|   219M|        if ( carry ) // q was too large
  ------------------
  |  Branch (1855:14): [True: 0, False: 219M]
  ------------------
 1856|      0|        {
 1857|      0|            q--;
 1858|      0|            carry = 0;
 1859|      0|            for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1859:26): [True: 0, False: 0]
  ------------------
 1860|      0|            {
 1861|      0|                d = a[i] + carry;
 1862|      0|                carry = d < carry;
 1863|      0|                a[i] = d + b[i];
 1864|      0|                if ( a[i] < d )
  ------------------
  |  Branch (1864:22): [True: 0, False: 0]
  ------------------
 1865|      0|                    carry = 1;
 1866|      0|            }
 1867|      0|            a[n] = 0;
 1868|      0|        }
 1869|   219M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4dataEv:
   79|   439M|        {
   80|   439M|            return data_;
   81|   439M|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11unnormalizeERS4_ib:
 1901|   383k|    {
 1902|   383k|        if (secondDone)
  ------------------
  |  Branch (1902:13): [True: 0, False: 383k]
  ------------------
 1903|      0|        {
 1904|      0|            rem /= max_word;
 1905|      0|        }
 1906|   383k|        if ( x > 0 )
  ------------------
  |  Branch (1906:14): [True: 30.5k, False: 352k]
  ------------------
 1907|  30.5k|        {
 1908|  30.5k|            rem >>= x;
 1909|  30.5k|        }
 1910|   352k|        else
 1911|   352k|        {
 1912|   352k|            rem.reduce();
 1913|   352k|        }
 1914|   383k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2Ev:
  641|  1.98k|    basic_bigint() = default;
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEErSEm:
 1146|  30.5k|    {
 1147|  30.5k|        auto this_view = get_storage_view();
 1148|  30.5k|        size_type q = k / word_type_bits;
 1149|  30.5k|        if ( q >= this_view.size())
  ------------------
  |  Branch (1149:14): [True: 0, False: 30.5k]
  ------------------
 1150|      0|        {
 1151|      0|            resize( 0 );
 1152|      0|            return *this;
 1153|      0|        }
 1154|  30.5k|        if (q > 0)
  ------------------
  |  Branch (1154:13): [True: 0, False: 30.5k]
  ------------------
 1155|      0|        {
 1156|      0|            memmove( this_view.data(), this_view.data()+q, size_type((this_view.size() - q)*sizeof(word_type)) );
 1157|      0|            resize( size_type(this_view.size() - q) );
 1158|      0|            k %= word_type_bits;
 1159|      0|            if ( k == 0 )
  ------------------
  |  Branch (1159:18): [True: 0, False: 0]
  ------------------
 1160|      0|            {
 1161|      0|                reduce();
 1162|      0|                return *this;
 1163|      0|            }
 1164|      0|        }
 1165|       |
 1166|  30.5k|        this_view = get_storage_view();
 1167|  30.5k|        size_type n = size_type(this_view.size() - 1);
 1168|  30.5k|        ssize_type k1 = word_type_bits - k;
 1169|  30.5k|        word_type mask = (word_type(1) << k) - 1;
 1170|  22.6M|        for (size_type i = 0; i <= n; i++)
  ------------------
  |  Branch (1170:31): [True: 22.6M, False: 30.5k]
  ------------------
 1171|  22.6M|        {
 1172|  22.6M|            this_view[i] >>= k;
 1173|  22.6M|            if ( i < n )
  ------------------
  |  Branch (1173:18): [True: 22.6M, False: 30.5k]
  ------------------
 1174|  22.6M|                this_view[i] |= ((this_view[i+1] & mask) << k1);
 1175|  22.6M|        }
 1176|  30.5k|        reduce();
 1177|  30.5k|        return *this;
 1178|  30.5k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEED2Ev:
  708|  3.38M|    {
  709|  3.38M|        storage_.destroy();
  710|  3.38M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7destroyEv:
  487|  3.38M|    {
  488|  3.38M|        if (is_allocated())
  ------------------
  |  Branch (488:13): [True: 1.04M, False: 2.34M]
  ------------------
  489|  1.04M|        {
  490|  1.04M|            allocated_.destroy(get_allocator());
  491|  1.04M|            allocated_.~allocated_storage();
  492|  1.04M|        }
  493|  2.34M|        else
  494|  2.34M|        {
  495|  2.34M|            inlined_.~inlined_storage();
  496|  2.34M|        }
  497|  3.38M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7destroyERKS4_:
  246|  1.04M|        {
  247|  1.04M|            if (data_ != nullptr)
  ------------------
  |  Branch (247:17): [True: 1.04M, False: 0]
  ------------------
  248|  1.04M|            {
  249|  1.04M|                real_allocator_type alloc(a);
  250|  1.04M|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  251|  1.04M|            }
  252|  1.04M|        }
_ZN8jsonconsmiENS_12basic_bigintINSt3__19allocatorImEEEERKS4_:
 1526|  31.6k|    {
 1527|  31.6k|        return x -= y;
 1528|  31.6k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IiEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  693|   298k|        : storage_(n, alloc)
  694|   298k|    {
  695|   298k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IiEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  360|   298k|        : word_allocator_type(alloc)
  361|   298k|    {
  362|   298k|        ::new (&inlined_) inlined_storage(n);
  363|   298k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IiEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  125|   298k|            : is_allocated_(false),
  126|   298k|            is_negative_(n < 0),
  127|   298k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (127:19): [True: 267k, False: 31.6k]
  ------------------
  128|   298k|        {
  129|   298k|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (129:26): [True: 31.6k, False: 267k]
  ------------------
  130|   298k|            values_[1] = 0;
  131|   298k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEaSERKS4_:
  842|   917k|    {
  843|   917k|        storage_ = y.storage_;
  844|   917k|        return *this;
  845|   917k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEaSERKS5_:
  366|   917k|    {
  367|   917k|        if (this != &other)
  ------------------
  |  Branch (367:13): [True: 917k, False: 0]
  ------------------
  368|   917k|        {
  369|   917k|            auto other_view = other.get_storage_view();
  370|   917k|            resize(other_view.size());
  371|   917k|            auto this_view = get_storage_view();
  372|   917k|            if (other_view.size() > 0)
  ------------------
  |  Branch (372:17): [True: 695k, False: 221k]
  ------------------
  373|   695k|            {
  374|   695k|                common_.is_negative_ = other.common_.is_negative_;
  375|   695k|                std::memcpy(this_view.data(), other_view.data(), size_type(other_view.size()*sizeof(word_type)));
  376|   695k|            }
  377|   917k|        }
  378|   917k|        return *this;
  379|   917k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4dataEv:
   79|   695k|        {
   80|   695k|            return data_;
   81|   695k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16write_string_hexIcNS1_11char_traitsIcEENS2_IcEEEEvRNS1_12basic_stringIT_T0_T1_EE:
 1410|  11.5k|    {
 1411|       |
 1412|       |
 1413|  11.5k|        basic_bigint<Allocator> v(*this);
 1414|  11.5k|        auto v_view = v.get_storage_view();
 1415|       |
 1416|  11.5k|        size_type len = (v_view.size() * basic_bigint<Allocator>::word_type_bits / 3) + 2;
 1417|  11.5k|        data.reserve(len);
 1418|       |
 1419|  11.5k|        if ( v_view.size() == 0 )
  ------------------
  |  Branch (1419:14): [True: 9.53k, False: 1.98k]
  ------------------
 1420|  9.53k|        {
 1421|  9.53k|            data.push_back('0');
 1422|  9.53k|        }
 1423|  1.98k|        else
 1424|  1.98k|        {
 1425|  1.98k|            word_type r;
 1426|  1.98k|            basic_bigint<Allocator> R;
 1427|  1.98k|            basic_bigint<Allocator> LP10 = max_unsigned_power_16; // LP10 = max_unsigned_power_16 = ::pow(16, imax_unsigned_power_16)
 1428|  1.98k|            do
 1429|  32.6k|            {
 1430|  32.6k|                v.divide( LP10, v, R, true );
 1431|  32.6k|                v_view = v.get_storage_view();
 1432|  32.6k|                auto R_view = R.get_storage_view();
 1433|  32.6k|                r = (R_view.size() ? R_view[0] : 0);
  ------------------
  |  Branch (1433:22): [True: 29.5k, False: 3.13k]
  ------------------
 1434|   498k|                for ( size_type j=0; j < imax_unsigned_power_16; j++ )
  ------------------
  |  Branch (1434:38): [True: 467k, False: 30.7k]
  ------------------
 1435|   467k|                {
 1436|   467k|                    uint8_t c = r % 16u;
 1437|   467k|                    data.push_back((c < 10u) ? ('0' + c) : ('A' - 10u + c));
  ------------------
  |  Branch (1437:36): [True: 354k, False: 112k]
  ------------------
 1438|   467k|                    r /= 16u;
 1439|   467k|                    if ( r + v_view.size() == 0 )
  ------------------
  |  Branch (1439:26): [True: 1.98k, False: 465k]
  ------------------
 1440|  1.98k|                        break;
 1441|   467k|                }
 1442|  32.6k|            } 
 1443|  32.6k|            while (v_view.size() > 0);
  ------------------
  |  Branch (1443:20): [True: 30.7k, False: 1.98k]
  ------------------
 1444|       |
 1445|  1.98k|            if (is_negative())
  ------------------
  |  Branch (1445:17): [True: 995, False: 985]
  ------------------
 1446|    995|            {
 1447|    995|                data.push_back('-');
 1448|    995|            }
 1449|  1.98k|            std::reverse(data.begin(),data.end());
 1450|  1.98k|        }
 1451|  11.5k|    }

_ZN8jsoncons6binary13big_to_nativeItNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  34.6k|    {
  183|  34.6k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 34.6k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  34.6k|        T val;
  188|  34.6k|        std::memcpy(&val,first,sizeof(T));
  189|  34.6k|        return byte_swap(val);
  190|  34.6k|    }
_ZN8jsoncons6binary9byte_swapItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|  1.78M|    {
   29|  1.78M|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|  1.78M|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  466|  1.78M|#      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|  1.78M|    }
_ZN8jsoncons6binary13big_to_nativeIjNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  7.71k|    {
  183|  7.71k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 7.71k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  7.71k|        T val;
  188|  7.71k|        std::memcpy(&val,first,sizeof(T));
  189|  7.71k|        return byte_swap(val);
  190|  7.71k|    }
_ZN8jsoncons6binary9byte_swapIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|  3.18M|    {
   40|  3.18M|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|  3.18M|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  462|  3.18M|#  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|  3.18M|    }
_ZN8jsoncons6binary13big_to_nativeImNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  8.42k|    {
  183|  8.42k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 8.42k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  8.42k|        T val;
  188|  8.42k|        std::memcpy(&val,first,sizeof(T));
  189|  8.42k|        return byte_swap(val);
  190|  8.42k|    }
_ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|   641k|    {
   52|   641k|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|   641k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|   641k|#  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|   641k|    }
_ZN8jsoncons6binary9byte_swapIsEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|   621k|    {
   29|   621k|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|   621k|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  466|   621k|#      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|   621k|    }
_ZN8jsoncons6binary9byte_swapIiEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|   762k|    {
   40|   762k|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|   762k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  462|   762k|#  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|   762k|    }
_ZN8jsoncons6binary9byte_swapIlEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|   601k|    {
   52|   601k|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|   601k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|   601k|#  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|   601k|    }
_ZN8jsoncons6binary9byte_swapIfEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   64|   456k|    {
   65|   456k|        uint32_t x;
   66|   456k|        std::memcpy(&x,&val,sizeof(uint32_t));
   67|   456k|        uint32_t y = byte_swap(x);
   68|   456k|        T val2;
   69|   456k|        std::memcpy(&val2,&y,sizeof(uint32_t));
   70|   456k|        return val2;
   71|   456k|    }
_ZN8jsoncons6binary9byte_swapIdEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   76|   179k|    {
   77|   179k|        uint64_t x;
   78|   179k|        std::memcpy(&x,&val,sizeof(uint64_t));
   79|   179k|        uint64_t y = byte_swap(x);
   80|   179k|        T val2;
   81|   179k|        std::memcpy(&val2,&y,sizeof(uint64_t));
   82|   179k|        return val2;
   83|   179k|    }
_ZN8jsoncons6binary13big_to_nativeIfNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  9.14k|    {
  183|  9.14k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 9.14k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  9.14k|        T val;
  188|  9.14k|        std::memcpy(&val,first,sizeof(T));
  189|  9.14k|        return byte_swap(val);
  190|  9.14k|    }
_ZN8jsoncons6binary13big_to_nativeIdNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  4.26k|    {
  183|  4.26k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 4.26k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  4.26k|        T val;
  188|  4.26k|        std::memcpy(&val,first,sizeof(T));
  189|  4.26k|        return byte_swap(val);
  190|  4.26k|    }

_ZN8jsoncons15bytes_to_base64IPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  188|  1.28k|    {
  189|  1.28k|        static constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  190|  1.28k|                                                   "abcdefghijklmnopqrstuvwxyz"
  191|  1.28k|                                                   "0123456789+/"
  192|  1.28k|                                                   "=";
  193|  1.28k|        return detail::bytes_to_base64_generic(first, last, alphabet, result);
  194|  1.28k|    }
_ZN8jsoncons6detail23bytes_to_base64_genericIPKhNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS4_9enable_ifIXsr3std7is_sameINS4_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESD_SD_PKcRT0_:
   44|  6.72M|    {
   45|  6.72M|        std::size_t count = 0;
   46|  6.72M|        unsigned char a3[3];
   47|  6.72M|        unsigned char a4[4];
   48|  6.72M|        unsigned char fill = alphabet[64];
   49|  6.72M|        int i = 0;
   50|  6.72M|        int j = 0;
   51|       |
   52|  31.4M|        while (first != last)
  ------------------
  |  Branch (52:16): [True: 24.6M, False: 6.72M]
  ------------------
   53|  24.6M|        {
   54|  24.6M|            a3[i++] = *first++;
   55|  24.6M|            if (i == 3)
  ------------------
  |  Branch (55:17): [True: 6.59M, False: 18.0M]
  ------------------
   56|  6.59M|            {
   57|  6.59M|                a4[0] = (a3[0] & 0xfc) >> 2;
   58|  6.59M|                a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   59|  6.59M|                a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   60|  6.59M|                a4[3] = a3[2] & 0x3f;
   61|       |
   62|  32.9M|                for (i = 0; i < 4; i++) 
  ------------------
  |  Branch (62:29): [True: 26.3M, False: 6.59M]
  ------------------
   63|  26.3M|                {
   64|  26.3M|                    result.push_back(alphabet[a4[i]]);
   65|  26.3M|                    ++count;
   66|  26.3M|                }
   67|  6.59M|                i = 0;
   68|  6.59M|            }
   69|  24.6M|        }
   70|       |
   71|  6.72M|        if (i > 0)
  ------------------
  |  Branch (71:13): [True: 2.53M, False: 4.19M]
  ------------------
   72|  2.53M|        {
   73|  5.25M|            for (j = i; j < 3; ++j) 
  ------------------
  |  Branch (73:25): [True: 2.72M, False: 2.53M]
  ------------------
   74|  2.72M|            {
   75|  2.72M|                a3[j] = 0;
   76|  2.72M|            }
   77|       |
   78|  2.53M|            a4[0] = (a3[0] & 0xfc) >> 2;
   79|  2.53M|            a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   80|  2.53M|            a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   81|       |
   82|  9.95M|            for (j = 0; j < i + 1; ++j) 
  ------------------
  |  Branch (82:25): [True: 7.42M, False: 2.53M]
  ------------------
   83|  7.42M|            {
   84|  7.42M|                result.push_back(alphabet[a4[j]]);
   85|  7.42M|                ++count;
   86|  7.42M|            }
   87|       |
   88|  2.53M|            if (fill != 0)
  ------------------
  |  Branch (88:17): [True: 775, False: 2.53M]
  ------------------
   89|    775|            {
   90|  2.32k|                while (i++ < 3) 
  ------------------
  |  Branch (90:24): [True: 1.54k, False: 775]
  ------------------
   91|  1.54k|                {
   92|  1.54k|                    result.push_back(fill);
   93|  1.54k|                    ++count;
   94|  1.54k|                }
   95|    775|            }
   96|  2.53M|        }
   97|       |
   98|  6.72M|        return count;
   99|  6.72M|    }
_ZNK8jsoncons16byte_string_view5beginEv:
  409|  9.99M|        {
  410|  9.99M|            return data_;
  411|  9.99M|        }
_ZNK8jsoncons16byte_string_view3endEv:
  413|  9.99M|        {
  414|  9.99M|            return data_ + size_;
  415|  9.99M|        }
_ZN8jsoncons15bytes_to_base16IPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  162|    690|    {
  163|    690|        static constexpr char characters[] = "0123456789ABCDEF";
  164|       |
  165|   789k|        for (auto it = first; it != last; ++it)
  ------------------
  |  Branch (165:31): [True: 788k, False: 690]
  ------------------
  166|   788k|        {
  167|   788k|            uint8_t c = *it;
  168|   788k|            result.push_back(characters[c >> 4]);
  169|   788k|            result.push_back(characters[c & 0xf]);
  170|   788k|        }
  171|    690|        return (last-first)*2;
  172|    690|    }
_ZN8jsoncons18bytes_to_base64urlIPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  177|  6.72M|    {
  178|  6.72M|        static constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  179|  6.72M|                                                      "abcdefghijklmnopqrstuvwxyz"
  180|  6.72M|                                                      "0123456789-_"
  181|  6.72M|                                                      "\0";
  182|  6.72M|        return detail::bytes_to_base64_generic(first, last, alphabet, result);
  183|  6.72M|    }
_ZNK8jsoncons16byte_string_view4dataEv:
  399|  8.88M|        {
  400|  8.88M|            return data_;
  401|  8.88M|        }
_ZNK8jsoncons16byte_string_view4sizeEv:
  403|  12.7M|        {
  404|  12.7M|            return size_;
  405|  12.7M|        }
_ZN8jsoncons16byte_string_viewC2EPKhm:
  362|  16.6M|            : data_(data), size_(length)
  363|  16.6M|        {
  364|  16.6M|        }
_ZN8jsoncons16byte_string_viewC2INSt3__16vectorIhNS2_9allocatorIhEEEEEERKT_NS2_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS7_EE5valueEiE4typeE:
  369|  88.9k|            : data_(reinterpret_cast<const uint8_t*>(cont.data())), size_(cont.size())
  370|  88.9k|        {
  371|  88.9k|        }
_ZN8jsoncons16byte_string_viewC2Ev:
  358|    625|        {
  359|    625|        }

_ZNK8jsoncons8identityclIRKhEEOT_S5_:
   19|  2.25M|    {
   20|  2.25M|        return std::forward<T>(val);
   21|  2.25M|    }
_ZNK8jsoncons8identityclIRKtEEOT_S5_:
   19|   782k|    {
   20|   782k|        return std::forward<T>(val);
   21|   782k|    }
_ZNK8jsoncons8identityclIRKjEEOT_S5_:
   19|  2.72M|    {
   20|  2.72M|        return std::forward<T>(val);
   21|  2.72M|    }
_ZNK8jsoncons8identityclIRKmEEOT_S5_:
   19|   454k|    {
   20|   454k|        return std::forward<T>(val);
   21|   454k|    }
_ZNK8jsoncons8identityclIRKaEEOT_S5_:
   19|  4.66M|    {
   20|  4.66M|        return std::forward<T>(val);
   21|  4.66M|    }
_ZNK8jsoncons8identityclIRKsEEOT_S5_:
   19|  1.05M|    {
   20|  1.05M|        return std::forward<T>(val);
   21|  1.05M|    }
_ZNK8jsoncons8identityclIRKiEEOT_S5_:
   19|   780k|    {
   20|   780k|        return std::forward<T>(val);
   21|   780k|    }
_ZNK8jsoncons8identityclIRKlEEOT_S5_:
   19|   601k|    {
   20|   601k|        return std::forward<T>(val);
   21|   601k|    }
_ZNK8jsoncons11decode_halfclEt:
   36|  12.4M|    {
   37|  12.4M|        return binary::decode_half(val);
   38|  12.4M|    }
_ZNK8jsoncons8identityclIRKfEEOT_S5_:
   19|   518k|    {
   20|   518k|        return std::forward<T>(val);
   21|   518k|    }
_ZNK8jsoncons8identityclIRKdEEOT_S5_:
   19|   221k|    {
   20|   221k|        return std::forward<T>(val);
   21|   221k|    }

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

_ZN8jsoncons16decstr_to_doubleEPKcmRd:
  866|   119k|{
  867|   119k|    const char* cur = s+length;
  868|   119k|    char *end = nullptr;
  869|   119k|    val = strtod(s, &end);
  870|   119k|    const char* str_end = end;
  871|   119k|    if (JSONCONS_UNLIKELY(end < cur))
  ------------------
  |  |   78|   119k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 119k]
  |  |  ------------------
  ------------------
  872|      0|    {
  873|      0|        if (*end == '.')
  ------------------
  |  Branch (873:13): [True: 0, False: 0]
  ------------------
  874|      0|        {
  875|      0|            std::string buf{s, length};
  876|      0|            char* dot_ptr = &buf[0] + (cur - end - 1);
  877|      0|            *dot_ptr = ',';
  878|      0|            end = nullptr;
  879|      0|            val = strtod(buf.c_str(), &end);
  880|      0|            str_end = s + (end - &buf[0]);
  881|      0|        }
  882|      0|        if (JSONCONS_UNLIKELY(str_end != cur))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  883|      0|        {
  884|      0|            return to_number_result<char>{str_end,std::errc::invalid_argument};
  885|      0|        }
  886|      0|    }
  887|   119k|    if (JSONCONS_UNLIKELY(val <= -HUGE_VAL || val >= HUGE_VAL))
  ------------------
  |  |   78|   238k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 119k]
  |  |  |  Branch (78:50): [True: 0, False: 119k]
  |  |  |  Branch (78:50): [True: 0, False: 119k]
  |  |  ------------------
  ------------------
  888|      0|    {
  889|      0|        return to_number_result<char>{str_end, std::errc::result_out_of_range};
  890|      0|    }
  891|   119k|    return to_number_result<char>{str_end};
  892|   119k|}
_ZN8jsoncons16to_number_resultIcEC2EPKc:
  137|   119k|        : ptr(ptr_), ec(std::errc{})
  138|   119k|    {
  139|   119k|    }

_ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_14unicode_resultIS4_EEE4typeEPKS4_m:
 1147|   532k|    {
 1148|   532k|        const uint8_t* it = reinterpret_cast<const uint8_t*>(data);
 1149|   532k|        const uint8_t* end = it + length;
 1150|       |
 1151|   532k|        unicode_errc  result{};
 1152|  3.46M|        while (it != end) 
  ------------------
  |  Branch (1152:16): [True: 2.93M, False: 532k]
  ------------------
 1153|  2.93M|        {
 1154|  2.93M|            if ((end - it) >= 8)
  ------------------
  |  Branch (1154:17): [True: 55.6k, False: 2.87M]
  ------------------
 1155|  55.6k|            {
 1156|   376k|                JSONCONS_REPEAT8({if (JSONCONS_LIKELY((*it & 0x80) == 0)) ++it; else goto non_ascii;})
  ------------------
  |  |  281|   111k|#define JSONCONS_REPEAT8(x)  { x x x x x x x x }
  |  |  ------------------
  |  |  |  Branch (281:32): [True: 54.0k, False: 1.58k]
  |  |  |  Branch (281:34): [True: 53.9k, False: 64]
  |  |  |  Branch (281:36): [True: 53.8k, False: 120]
  |  |  |  Branch (281:38): [True: 53.8k, False: 26]
  |  |  |  Branch (281:40): [True: 53.8k, False: 15]
  |  |  |  Branch (281:42): [True: 53.7k, False: 33]
  |  |  |  Branch (281:44): [True: 53.7k, False: 37]
  |  |  |  Branch (281:46): [True: 53.7k, False: 18]
  |  |  ------------------
  ------------------
 1157|  53.7k|                continue;
 1158|   376k|            }
 1159|  2.87M|    non_ascii:
 1160|  2.87M|            const std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[*it]) + 1;
 1161|  2.87M|            if (len > (std::size_t)(end - it))
  ------------------
  |  Branch (1161:17): [True: 19, False: 2.87M]
  ------------------
 1162|     19|            {
 1163|     19|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), unicode_errc::source_exhausted};
 1164|     19|            }
 1165|  2.87M|            if ((result=is_legal_utf8(it, len)) != unicode_errc())
  ------------------
  |  Branch (1165:17): [True: 144, False: 2.87M]
  ------------------
 1166|    144|            {
 1167|    144|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1168|    144|            }
 1169|  2.87M|            it += len;
 1170|  2.87M|        }
 1171|   532k|        return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1172|   532k|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8EPKhm:
  305|  2.87M|    {
  306|  2.87M|        const uint8_t* it = reinterpret_cast<const uint8_t*>(bytes);
  307|  2.87M|        const uint8_t* end = it+length;
  308|       |
  309|  2.87M|        uint8_t byte;
  310|  2.87M|        switch (length) {
  311|     22|        default:
  ------------------
  |  Branch (311:9): [True: 22, False: 2.87M]
  ------------------
  312|     22|            return unicode_errc::over_long_utf8_sequence;
  313|    878|        case 4:
  ------------------
  |  Branch (313:9): [True: 878, False: 2.87M]
  ------------------
  314|    878|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 9, False: 869]
  ------------------
  315|      9|                return unicode_errc::bad_continuation_byte;
  316|    869|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|    869|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  317|  2.53k|        case 3:
  ------------------
  |  Branch (317:9): [True: 1.66k, False: 2.87M]
  ------------------
  318|  2.53k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (318:17): [True: 7, False: 2.53k]
  ------------------
  319|      7|                return unicode_errc::bad_continuation_byte;
  320|  2.53k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|  2.53k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  321|  4.39k|        case 2:
  ------------------
  |  Branch (321:9): [True: 1.86k, False: 2.87M]
  ------------------
  322|  4.39k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (322:17): [True: 49, False: 4.34k]
  ------------------
  323|     49|                return unicode_errc::bad_continuation_byte;
  324|       |
  325|  4.34k|            switch (*it) 
  326|  4.34k|            {
  327|       |                // no fall-through in this inner switch
  328|    275|                case 0xE0: if (byte < 0xA0) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (328:17): [True: 275, False: 4.07k]
  |  Branch (328:32): [True: 5, False: 270]
  ------------------
  329|  1.37k|                case 0xED: if (byte > 0x9F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (329:17): [True: 1.37k, False: 2.97k]
  |  Branch (329:32): [True: 2, False: 1.36k]
  ------------------
  330|  1.36k|                case 0xF0: if (byte < 0x90) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (330:17): [True: 515, False: 3.83k]
  |  Branch (330:32): [True: 4, False: 511]
  ------------------
  331|    511|                case 0xF4: if (byte > 0x8F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (331:17): [True: 344, False: 4.00k]
  |  Branch (331:32): [True: 2, False: 342]
  ------------------
  332|  1.84k|                default:   if (byte < 0x80) return unicode_errc::source_illegal;
  ------------------
  |  Branch (332:17): [True: 1.84k, False: 2.50k]
  |  Branch (332:32): [True: 0, False: 1.84k]
  ------------------
  333|  4.34k|            }
  334|       |
  335|  4.33k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|  4.33k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  336|  2.87M|        case 1:
  ------------------
  |  Branch (336:9): [True: 2.87M, False: 4.43k]
  ------------------
  337|  2.87M|            if (*it >= 0x80 && *it < 0xC2)
  ------------------
  |  Branch (337:17): [True: 4.37k, False: 2.87M]
  |  Branch (337:32): [True: 44, False: 4.33k]
  ------------------
  338|     44|                return unicode_errc::source_illegal;
  339|  2.87M|            break;
  340|  2.87M|        }
  341|  2.87M|        if (*it > 0xF4) 
  ------------------
  |  Branch (341:13): [True: 0, False: 2.87M]
  ------------------
  342|      0|            return unicode_errc::source_illegal;
  343|       |
  344|  2.87M|        return unicode_errc();
  345|  2.87M|    }

_ZN8jsoncons12from_integerImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  14.7M|{
   43|  14.7M|    using char_type = typename Result::value_type;
   44|       |
   45|  14.7M|    char_type buf[255];
   46|  14.7M|    char_type *p = buf;
   47|  14.7M|    const char_type* last = buf+255;
   48|       |
   49|  14.7M|    bool is_negative = value < 0;
   50|       |
   51|  14.7M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 14.7M]
  ------------------
   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|  14.7M|    else
   60|  14.7M|    {
   61|       |
   62|  14.7M|        do
   63|  48.8M|        {
   64|  48.8M|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  48.8M|        }
   66|  48.8M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 34.1M, False: 14.7M]
  |  Branch (66:33): [True: 34.1M, False: 0]
  ------------------
   67|  14.7M|    }
   68|  14.7M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   49|  14.7M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 14.7M]
  |  |  ------------------
  |  |   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|  14.7M|    std::size_t count = (p - buf);
   71|  14.7M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 14.7M]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  63.5M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 48.8M, False: 14.7M]
  ------------------
   77|  48.8M|    {
   78|  48.8M|        result.push_back(*p);
   79|  48.8M|    }
   80|       |
   81|  14.7M|    return count;
   82|  14.7M|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  6.48M|{
   43|  6.48M|    using char_type = typename Result::value_type;
   44|       |
   45|  6.48M|    char_type buf[255];
   46|  6.48M|    char_type *p = buf;
   47|  6.48M|    const char_type* last = buf+255;
   48|       |
   49|  6.48M|    bool is_negative = value < 0;
   50|       |
   51|  6.48M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 2.66M, False: 3.82M]
  ------------------
   52|  2.66M|    {
   53|  2.66M|        do
   54|  9.57M|        {
   55|  9.57M|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|  9.57M|        }
   57|  9.57M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 6.91M, False: 2.66M]
  |  Branch (57:33): [True: 6.91M, False: 0]
  ------------------
   58|  2.66M|    }
   59|  3.82M|    else
   60|  3.82M|    {
   61|       |
   62|  3.82M|        do
   63|  14.4M|        {
   64|  14.4M|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  14.4M|        }
   66|  14.4M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 10.5M, False: 3.82M]
  |  Branch (66:33): [True: 10.5M, False: 0]
  ------------------
   67|  3.82M|    }
   68|  6.48M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   49|  6.48M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 6.48M]
  |  |  ------------------
  |  |   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|  6.48M|    std::size_t count = (p - buf);
   71|  6.48M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 2.66M, False: 3.82M]
  ------------------
   72|  2.66M|    {
   73|  2.66M|        result.push_back('-');
   74|  2.66M|        ++count;
   75|  2.66M|    }
   76|  30.4M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 23.9M, False: 6.48M]
  ------------------
   77|  23.9M|    {
   78|  23.9M|        result.push_back(*p);
   79|  23.9M|    }
   80|       |
   81|  6.48M|    return count;
   82|  6.48M|}
_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|  11.1M|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|  11.1M|    {
  489|  11.1M|#if !defined(JSONCONS_NO_LOCALECONV)
  490|  11.1M|        struct lconv *lc = localeconv();
  491|  11.1M|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 11.1M, False: 0]
  |  Branch (491:30): [True: 11.1M, False: 0]
  ------------------
  492|  11.1M|        {
  493|  11.1M|            decimal_point_ = lc->decimal_point[0];
  494|  11.1M|        }
  495|  11.1M|#endif
  496|  11.1M|    }
_ZN8jsoncons12write_doubleclINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEmdRT_:
  503|  11.1M|    {
  504|  11.1M|        std::size_t count = 0;
  505|       |
  506|  11.1M|        char number_buffer[200];
  507|  11.1M|        int length = 0;
  508|       |
  509|  11.1M|        switch (float_format_)
  510|  11.1M|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 11.1M]
  ------------------
  512|      0|            {
  513|      0|                if (precision_ > 0)
  ------------------
  |  Branch (513:21): [True: 0, False: 0]
  ------------------
  514|      0|                {
  515|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*f", precision_, val);
  516|      0|                    if (length < 0)
  ------------------
  |  Branch (516:25): [True: 0, False: 0]
  ------------------
  517|      0|                    {
  518|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  519|      0|                    }
  520|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  521|      0|                }
  522|      0|                else
  523|      0|                {
  524|      0|                    if (!dtoa_fixed(val, decimal_point_, result))
  ------------------
  |  Branch (524:25): [True: 0, False: 0]
  ------------------
  525|      0|                    {
  526|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  527|      0|                    }
  528|      0|                }
  529|      0|            }
  530|      0|            break;
  531|      0|        case float_chars_format::scientific:
  ------------------
  |  Branch (531:9): [True: 0, False: 11.1M]
  ------------------
  532|      0|            {
  533|      0|                if (precision_ > 0)
  ------------------
  |  Branch (533:21): [True: 0, False: 0]
  ------------------
  534|      0|                {
  535|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*e", precision_, val);
  536|      0|                    if (length < 0)
  ------------------
  |  Branch (536:25): [True: 0, False: 0]
  ------------------
  537|      0|                    {
  538|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  539|      0|                    }
  540|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  541|      0|                }
  542|      0|                else
  543|      0|                {
  544|      0|                    if (!dtoa_scientific(val, decimal_point_, result))
  ------------------
  |  Branch (544:25): [True: 0, False: 0]
  ------------------
  545|      0|                    {
  546|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  547|      0|                    }
  548|      0|                }
  549|      0|            }
  550|      0|            break;
  551|  11.1M|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 11.1M, False: 0]
  ------------------
  552|  11.1M|            {
  553|  11.1M|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 11.1M]
  ------------------
  554|      0|                {
  555|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*g", precision_, val);
  556|      0|                    if (length < 0)
  ------------------
  |  Branch (556:25): [True: 0, False: 0]
  ------------------
  557|      0|                    {
  558|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  559|      0|                    }
  560|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  561|      0|                }
  562|  11.1M|                else
  563|  11.1M|                {
  564|  11.1M|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 11.1M]
  ------------------
  565|      0|                    {
  566|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  567|      0|                    }
  568|  11.1M|                }             
  569|  11.1M|                break;
  570|  11.1M|            }
  571|  11.1M|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 11.1M]
  ------------------
  572|      0|                JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  573|      0|                break;
  574|  11.1M|        }
  575|  11.1M|        return count;
  576|  11.1M|    }
_ZN8jsoncons11dump_bufferINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKcmcRT_:
  243|   119k|{
  244|   119k|    const char *sbeg = buffer;
  245|   119k|    const char *send = sbeg + length;
  246|       |
  247|   119k|    if (sbeg != send)
  ------------------
  |  Branch (247:9): [True: 119k, False: 0]
  ------------------
  248|   119k|    {
  249|   119k|        bool needs_dot = true;
  250|  2.71M|        for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (250:36): [True: 2.59M, False: 119k]
  ------------------
  251|  2.59M|        {
  252|  2.59M|            switch (*q)
  253|  2.59M|            {
  254|   107k|            case '-':
  ------------------
  |  Branch (254:13): [True: 107k, False: 2.48M]
  ------------------
  255|   668k|            case '0':
  ------------------
  |  Branch (255:13): [True: 560k, False: 2.03M]
  ------------------
  256|   955k|            case '1':
  ------------------
  |  Branch (256:13): [True: 286k, False: 2.30M]
  ------------------
  257|  1.15M|            case '2':
  ------------------
  |  Branch (257:13): [True: 197k, False: 2.39M]
  ------------------
  258|  1.35M|            case '3':
  ------------------
  |  Branch (258:13): [True: 201k, False: 2.39M]
  ------------------
  259|  1.48M|            case '4':
  ------------------
  |  Branch (259:13): [True: 134k, False: 2.45M]
  ------------------
  260|  1.59M|            case '5':
  ------------------
  |  Branch (260:13): [True: 109k, False: 2.48M]
  ------------------
  261|  1.93M|            case '6':
  ------------------
  |  Branch (261:13): [True: 334k, False: 2.25M]
  ------------------
  262|  2.08M|            case '7':
  ------------------
  |  Branch (262:13): [True: 155k, False: 2.43M]
  ------------------
  263|  2.40M|            case '8':
  ------------------
  |  Branch (263:13): [True: 322k, False: 2.27M]
  ------------------
  264|  2.46M|            case '9':
  ------------------
  |  Branch (264:13): [True: 51.6k, False: 2.54M]
  ------------------
  265|  2.46M|            case '+':
  ------------------
  |  Branch (265:13): [True: 1.24k, False: 2.59M]
  ------------------
  266|  2.46M|                result.push_back(*q);
  267|  2.46M|                break;
  268|  12.8k|            case 'e':
  ------------------
  |  Branch (268:13): [True: 12.8k, False: 2.58M]
  ------------------
  269|  12.8k|            case 'E':
  ------------------
  |  Branch (269:13): [True: 0, False: 2.59M]
  ------------------
  270|  12.8k|                result.push_back('e');
  271|  12.8k|                needs_dot = false;
  272|  12.8k|                break;
  273|   118k|            default:
  ------------------
  |  Branch (273:13): [True: 118k, False: 2.47M]
  ------------------
  274|   118k|                if (*q == decimal_point)
  ------------------
  |  Branch (274:21): [True: 116k, False: 1.61k]
  ------------------
  275|   116k|                {
  276|   116k|                    needs_dot = false;
  277|   116k|                    result.push_back('.');
  278|   116k|                }
  279|   118k|                break;
  280|  2.59M|            }
  281|  2.59M|        }
  282|   119k|        if (needs_dot)
  ------------------
  |  Branch (282:13): [True: 2.16k, False: 116k]
  ------------------
  283|  2.16k|        {
  284|  2.16k|            result.push_back('.');
  285|  2.16k|            result.push_back('0');
  286|  2.16k|        }
  287|   119k|    }
  288|   119k|}
_ZN8jsoncons15prettify_stringINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKciiiiRT_:
  171|  10.6M|{
  172|  10.6M|    int nb_digits = length;
  173|  10.6M|    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|  10.6M|    int kk = nb_digits + k;
  179|       |
  180|  10.6M|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 2.84M, False: 7.77M]
  |  Branch (180:28): [True: 1.57M, False: 1.26M]
  ------------------
  181|  1.57M|    {
  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|  7.09M|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 5.51M, False: 1.57M]
  ------------------
  186|  5.51M|        {
  187|  5.51M|            result.push_back(buffer[i]);
  188|  5.51M|        }
  189|  1.75M|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 180k, False: 1.57M]
  ------------------
  190|   180k|        {
  191|   180k|            result.push_back('0');
  192|   180k|        }
  193|  1.57M|        result.push_back('.');
  194|  1.57M|        result.push_back('0');
  195|  1.57M|    } 
  196|  9.04M|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 4.56M, False: 4.47M]
  |  Branch (196:24): [True: 3.29M, False: 1.26M]
  ------------------
  197|  3.29M|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|  11.1M|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 7.80M, False: 3.29M]
  ------------------
  200|  7.80M|        {
  201|  7.80M|            result.push_back(buffer[i]);
  202|  7.80M|        }
  203|  3.29M|        result.push_back('.');
  204|  11.5M|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 8.28M, False: 3.29M]
  ------------------
  205|  8.28M|        {
  206|  8.28M|            result.push_back(buffer[i]);
  207|  8.28M|        }
  208|  3.29M|    } 
  209|  5.74M|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 3.76M, False: 1.98M]
  |  Branch (209:30): [True: 2.49M, False: 1.26M]
  ------------------
  210|  2.49M|    {
  211|  2.49M|        offset = 2 - kk;
  212|       |
  213|  2.49M|        result.push_back('0');
  214|  2.49M|        result.push_back('.');
  215|  6.32M|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 3.83M, False: 2.49M]
  ------------------
  216|  3.83M|            result.push_back('0');
  217|  35.6M|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 33.1M, False: 2.49M]
  ------------------
  218|  33.1M|        {
  219|  33.1M|            result.push_back(buffer[i]);
  220|  33.1M|        }
  221|  2.49M|    } 
  222|  3.25M|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 514, False: 3.25M]
  ------------------
  223|    514|    {
  224|    514|        result.push_back(buffer[0]);
  225|    514|        result.push_back('e');
  226|    514|        fill_exponent(kk - 1, result);
  227|    514|    } 
  228|  3.25M|    else
  229|  3.25M|    {
  230|  3.25M|        result.push_back(buffer[0]);
  231|  3.25M|        result.push_back('.');
  232|  52.8M|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 49.5M, False: 3.25M]
  ------------------
  233|  49.5M|        {
  234|  49.5M|            result.push_back(buffer[i]);
  235|  49.5M|        }
  236|  3.25M|        result.push_back('e');
  237|  3.25M|        fill_exponent(kk - 1, result);
  238|  3.25M|    }
  239|  10.6M|}
_ZN8jsoncons13fill_exponentINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEviRT_:
  136|  3.25M|{
  137|  3.25M|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 1.98M, False: 1.26M]
  ------------------
  138|  1.98M|    {
  139|  1.98M|        result.push_back('-');
  140|  1.98M|        K = -K;
  141|  1.98M|    }
  142|  1.26M|    else
  143|  1.26M|    {
  144|  1.26M|        result.push_back('+'); // compatibility with sprintf
  145|  1.26M|    }
  146|       |
  147|  3.25M|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 1.78M, False: 1.47M]
  ------------------
  148|  1.78M|    {
  149|  1.78M|        result.push_back('0'); // compatibility with sprintf
  150|  1.78M|        result.push_back((char)('0' + K));
  151|  1.78M|    }
  152|  1.47M|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 255k, False: 1.21M]
  ------------------
  153|   255k|    {
  154|   255k|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|   255k|        result.push_back((char)('0' + K));
  156|   255k|    }
  157|  1.21M|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 1.21M, False: 0]
  ------------------
  158|  1.21M|    {
  159|  1.21M|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|  1.21M|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|  1.21M|        result.push_back((char)('0' + K));
  162|  1.21M|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|  3.25M|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_:
  475|  11.1M|{
  476|  11.1M|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|  11.1M|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb1EEE:
  366|  11.1M|{
  367|  11.1M|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 447k, False: 10.7M]
  ------------------
  368|   447k|    {
  369|   447k|        result.push_back('0');
  370|   447k|        result.push_back('.');
  371|   447k|        result.push_back('0');
  372|   447k|        return true;
  373|   447k|    }
  374|       |
  375|  10.7M|    int length = 0;
  376|  10.7M|    int k;
  377|       |
  378|  10.7M|    char buffer[100];
  379|       |
  380|  10.7M|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 5.14M, False: 5.59M]
  ------------------
  381|  10.7M|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 10.6M, False: 119k]
  ------------------
  382|  10.6M|    {
  383|  10.6M|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 5.04M, False: 5.57M]
  ------------------
  384|  5.04M|        {
  385|  5.04M|            result.push_back('-');
  386|  5.04M|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|  10.6M|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|  10.6M|        return true;
  391|  10.6M|    }
  392|   119k|    else
  393|   119k|    {
  394|   119k|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|   119k|    }
  396|  10.7M|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb0EEE:
  329|   119k|{
  330|   119k|    if (val == 0)
  ------------------
  |  Branch (330:9): [True: 0, False: 119k]
  ------------------
  331|      0|    {
  332|      0|        result.push_back('0');
  333|      0|        result.push_back('.');
  334|      0|        result.push_back('0');
  335|      0|        return true;
  336|      0|    }
  337|       |
  338|   119k|    char buffer[100];
  339|   119k|    int precision = std::numeric_limits<double>::digits10;
  340|   119k|    int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  341|   119k|    if (length < 0)
  ------------------
  |  Branch (341:9): [True: 0, False: 119k]
  ------------------
  342|      0|    {
  343|      0|        return false;
  344|      0|    }
  345|   119k|    double x{0};
  346|   119k|    auto res = decstr_to_double(buffer, length, x);
  347|   119k|    if (res.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (347:9): [True: 0, False: 119k]
  ------------------
  348|      0|    {
  349|      0|        return false;
  350|      0|    }
  351|   119k|    if (x != val)
  ------------------
  |  Branch (351:9): [True: 118k, False: 592]
  ------------------
  352|   118k|    {
  353|   118k|        const int precision2 = std::numeric_limits<double>::max_digits10;
  354|   118k|        length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  355|   118k|        if (length < 0)
  ------------------
  |  Branch (355:13): [True: 0, False: 118k]
  ------------------
  356|      0|        {
  357|      0|            return false;
  358|      0|        }
  359|   118k|    }
  360|   119k|    dump_buffer(buffer, length, decimal_point, result);
  361|   119k|    return true;
  362|   119k|}
_ZN8jsoncons15prettify_stringINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKciiiiRT_:
  171|   696k|{
  172|   696k|    int nb_digits = length;
  173|   696k|    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|   696k|    int kk = nb_digits + k;
  179|       |
  180|   696k|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 181k, False: 514k]
  |  Branch (180:28): [True: 6.36k, False: 174k]
  ------------------
  181|  6.36k|    {
  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|  32.8k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 26.4k, False: 6.36k]
  ------------------
  186|  26.4k|        {
  187|  26.4k|            result.push_back(buffer[i]);
  188|  26.4k|        }
  189|  14.2k|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 7.85k, False: 6.36k]
  ------------------
  190|  7.85k|        {
  191|  7.85k|            result.push_back('0');
  192|  7.85k|        }
  193|  6.36k|        result.push_back('.');
  194|  6.36k|        result.push_back('0');
  195|  6.36k|    } 
  196|   689k|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 680k, False: 9.17k]
  |  Branch (196:24): [True: 505k, False: 175k]
  ------------------
  197|   505k|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|  1.01M|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 507k, False: 505k]
  ------------------
  200|   507k|        {
  201|   507k|            result.push_back(buffer[i]);
  202|   507k|        }
  203|   505k|        result.push_back('.');
  204|  1.01M|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 506k, False: 505k]
  ------------------
  205|   506k|        {
  206|   506k|            result.push_back(buffer[i]);
  207|   506k|        }
  208|   505k|    } 
  209|   184k|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 182k, False: 1.60k]
  |  Branch (209:30): [True: 7.57k, False: 175k]
  ------------------
  210|  7.57k|    {
  211|  7.57k|        offset = 2 - kk;
  212|       |
  213|  7.57k|        result.push_back('0');
  214|  7.57k|        result.push_back('.');
  215|  28.7k|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 21.1k, False: 7.57k]
  ------------------
  216|  21.1k|            result.push_back('0');
  217|  22.4k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 14.9k, False: 7.57k]
  ------------------
  218|  14.9k|        {
  219|  14.9k|            result.push_back(buffer[i]);
  220|  14.9k|        }
  221|  7.57k|    } 
  222|   176k|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 1.25k, False: 175k]
  ------------------
  223|  1.25k|    {
  224|  1.25k|        result.push_back(buffer[0]);
  225|  1.25k|        result.push_back('e');
  226|  1.25k|        fill_exponent(kk - 1, result);
  227|  1.25k|    } 
  228|   175k|    else
  229|   175k|    {
  230|   175k|        result.push_back(buffer[0]);
  231|   175k|        result.push_back('.');
  232|   701k|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 525k, False: 175k]
  ------------------
  233|   525k|        {
  234|   525k|            result.push_back(buffer[i]);
  235|   525k|        }
  236|   175k|        result.push_back('e');
  237|   175k|        fill_exponent(kk - 1, result);
  238|   175k|    }
  239|   696k|}
_ZN8jsoncons13fill_exponentINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEviRT_:
  136|   176k|{
  137|   176k|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 1.60k, False: 175k]
  ------------------
  138|  1.60k|    {
  139|  1.60k|        result.push_back('-');
  140|  1.60k|        K = -K;
  141|  1.60k|    }
  142|   175k|    else
  143|   175k|    {
  144|   175k|        result.push_back('+'); // compatibility with sprintf
  145|   175k|    }
  146|       |
  147|   176k|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 732, False: 176k]
  ------------------
  148|    732|    {
  149|    732|        result.push_back('0'); // compatibility with sprintf
  150|    732|        result.push_back((char)('0' + K));
  151|    732|    }
  152|   176k|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 175k, False: 717]
  ------------------
  153|   175k|    {
  154|   175k|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|   175k|        result.push_back((char)('0' + K));
  156|   175k|    }
  157|    717|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 283, False: 434]
  ------------------
  158|    283|    {
  159|    283|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|    283|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|    283|        result.push_back((char)('0' + K));
  162|    283|    }
  163|    434|    else
  164|    434|    {
  165|    434|        jsoncons::from_integer(K, result);
  166|    434|    }
  167|   176k|}
_ZN8jsoncons12from_integerIiNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|    434|{
   43|    434|    using char_type = typename Result::value_type;
   44|       |
   45|    434|    char_type buf[255];
   46|    434|    char_type *p = buf;
   47|    434|    const char_type* last = buf+255;
   48|       |
   49|    434|    bool is_negative = value < 0;
   50|       |
   51|    434|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 434]
  ------------------
   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|    434|    else
   60|    434|    {
   61|       |
   62|    434|        do
   63|  2.79k|        {
   64|  2.79k|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  2.79k|        }
   66|  2.79k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 2.36k, False: 434]
  |  Branch (66:33): [True: 2.36k, False: 0]
  ------------------
   67|    434|    }
   68|    434|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   49|    434|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 434]
  |  |  ------------------
  |  |   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|    434|    std::size_t count = (p - buf);
   71|    434|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 434]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  3.23k|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 2.79k, False: 434]
  ------------------
   77|  2.79k|    {
   78|  2.79k|        result.push_back(*p);
   79|  2.79k|    }
   80|       |
   81|    434|    return count;
   82|    434|}
_ZN8jsoncons14integer_to_hexImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   89|   324k|{
   90|   324k|    using char_type = typename Result::value_type;
   91|       |
   92|   324k|    char_type buf[255];
   93|   324k|    char_type *p = buf;
   94|   324k|    const char_type* last = buf+255;
   95|       |
   96|   324k|    bool is_negative = value < 0;
   97|       |
   98|   324k|    if (value < 0)
  ------------------
  |  Branch (98:9): [True: 0, False: 324k]
  ------------------
   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|   324k|    else
  107|   324k|    {
  108|       |
  109|   324k|        do
  110|   353k|        {
  111|   353k|            *p++ = to_hex_character(value % 16);
  112|   353k|        }
  113|   353k|        while ((value /= 16) && (p < last));
  ------------------
  |  Branch (113:16): [True: 29.3k, False: 324k]
  |  Branch (113:33): [True: 29.3k, False: 0]
  ------------------
  114|   324k|    }
  115|   324k|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   49|   324k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 324k]
  |  |  ------------------
  |  |   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|   324k|    std::size_t count = (p - buf);
  118|   324k|    if (is_negative)
  ------------------
  |  Branch (118:9): [True: 0, False: 324k]
  ------------------
  119|      0|    {
  120|      0|        result.push_back('-');
  121|      0|        ++count;
  122|      0|    }
  123|   677k|    while (--p >= buf)
  ------------------
  |  Branch (123:12): [True: 353k, False: 324k]
  ------------------
  124|   353k|    {
  125|   353k|        result.push_back(*p);
  126|   353k|    }
  127|       |
  128|   324k|    return count;
  129|   324k|}
_ZN8jsoncons16to_hex_characterEh:
   33|   353k|{
   34|   353k|    return (char)((c < 10) ? ('0' + c) : ('A' - 10 + c));
  ------------------
  |  Branch (34:19): [True: 350k, False: 2.93k]
  ------------------
   35|   353k|}

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

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

_ZN8jsoncons4cbor19cbor_decode_optionsC1Ev:
   42|  8.86k|    cbor_decode_options() = default;
_ZN8jsoncons4cbor19cbor_options_commonC2Ev:
   25|  8.86k|    cbor_options_common() = default;
_ZN8jsoncons4cbor19cbor_options_commonD2Ev:
   27|  8.86k|    virtual ~cbor_options_common() = default;
_ZNK8jsoncons4cbor19cbor_options_common17max_nesting_depthEv:
   33|  8.86k|    {
   34|  8.86k|        return max_nesting_depth_;
   35|  8.86k|    }

_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEED2Ev:
  236|  8.86k|    ~basic_cbor_parser() = default;
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringD2Ev:
  135|  12.1M|        ~mapped_string() = default;
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RKNS0_19cbor_decode_optionsERKS7_:
  219|  8.86k|       : alloc_(alloc),
  220|  8.86k|         source_(std::forward<Sourceable>(source)),
  221|  8.86k|         max_nesting_depth_(options.max_nesting_depth()),
  222|  8.86k|         text_buffer_(alloc),
  223|  8.86k|         bytes_buffer_(alloc),
  224|  8.86k|         state_stack_(alloc),
  225|  8.86k|         stringref_map_stack_(alloc),
  226|  8.86k|         extents_(alloc)
  227|  8.86k|    {
  228|  8.86k|        state_stack_.emplace_back(parse_mode::root,0);
  229|  8.86k|    }
_ZN8jsoncons4cbor11parse_stateC2ENS0_10parse_modeEmb:
   51|  8.23M|        : mode(mode), length(length), pop_stringref_map_stack(pop_stringref_map_stack)
   52|  8.23M|    {
   53|  8.23M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5resetEv:
  244|  8.86k|    {
  245|  8.86k|        more_ = true;
  246|  8.86k|        done_ = false;
  247|  8.86k|        text_buffer_.clear();
  248|  8.86k|        bytes_buffer_.clear();
  249|  8.86k|        raw_tag_ = 0;
  250|  8.86k|        state_stack_.clear();
  251|  8.86k|        state_stack_.emplace_back(parse_mode::root,0);
  252|  8.86k|        stringref_map_stack_.clear();
  253|  8.86k|        nesting_depth_ = 0;
  254|  8.86k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  347|  8.86k|    {
  348|  67.0M|        while (!done_ && more_)
  ------------------
  |  Branch (348:16): [True: 67.0M, False: 1.71k]
  |  Branch (348:26): [True: 67.0M, False: 0]
  ------------------
  349|  67.0M|        {
  350|  67.0M|            switch (state_stack_.back().mode)
  ------------------
  |  Branch (350:21): [True: 67.0M, False: 0]
  ------------------
  351|  67.0M|            {
  352|     20|                case parse_mode::multi_dim:
  ------------------
  |  Branch (352:17): [True: 20, False: 67.0M]
  ------------------
  353|     20|                {
  354|     20|                    JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   49|     20|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 20]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  355|     20|                    typed_array_stack_.pop_back();
  356|     20|                    state_stack_.pop_back();
  357|     20|                    break;
  358|     20|                }
  359|  26.5M|                case parse_mode::typed_array:
  ------------------
  |  Branch (359:17): [True: 26.5M, False: 40.4M]
  ------------------
  360|  26.5M|                {
  361|  26.5M|                    JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   49|  26.5M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 26.5M]
  |  |  ------------------
  |  |   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|  26.5M|                    read_typed_array_item(visitor, ec);
  363|  26.5M|                    auto iter = typed_array_stack_.back();
  364|  26.5M|                    if (iter->done())
  ------------------
  |  Branch (364:25): [True: 98.3k, False: 26.4M]
  ------------------
  365|  98.3k|                    {
  366|  98.3k|                        if (!is_multi_dim())
  ------------------
  |  Branch (366:29): [True: 98.3k, False: 0]
  ------------------
  367|  98.3k|                        {
  368|  98.3k|                            typed_array_stack_.pop_back();
  369|  98.3k|                        }
  370|  98.3k|                        state_stack_.pop_back();
  371|  98.3k|                    }
  372|  26.5M|                    break;
  373|  26.5M|                }
  374|  2.90M|                case parse_mode::array:
  ------------------
  |  Branch (374:17): [True: 2.90M, False: 64.1M]
  ------------------
  375|  2.90M|                {
  376|  2.90M|                    if (is_multi_dim())
  ------------------
  |  Branch (376:25): [True: 60.1k, False: 2.84M]
  ------------------
  377|  60.1k|                    {
  378|  60.1k|                        JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   49|  60.1k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 60.1k]
  |  |  ------------------
  |  |   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|  60.1k|                        auto iter = typed_array_stack_.back();
  380|  60.1k|                        if (!iter->done())
  ------------------
  |  Branch (380:29): [True: 60.1k, False: 17]
  ------------------
  381|  60.1k|                        {
  382|  60.1k|                            iter->next(visitor, *this, ec);
  383|  60.1k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  60.1k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 13, False: 60.1k]
  |  |  ------------------
  ------------------
  384|     13|                            {
  385|     13|                                return;
  386|     13|                            }
  387|  60.1k|                        }
  388|     17|                        else
  389|     17|                        {
  390|     17|                            if (iter->count() != state_stack_.back().length)
  ------------------
  |  Branch (390:33): [True: 6, False: 11]
  ------------------
  391|      6|                            {
  392|       |                                //std::cout << state_stack_.back().index << "!=" << state_stack_.back().length << "\n";
  393|      6|                                ec = cbor_errc::bad_mdarray;
  394|      6|                                return;
  395|      6|                            }
  396|     11|                            end_classical_array_storage(ec);
  397|     11|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     11|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 11]
  |  |  ------------------
  ------------------
  398|      0|                            {
  399|      0|                                return;
  400|      0|                            }
  401|     11|                        }
  402|  60.1k|                    }
  403|  2.84M|                    else
  404|  2.84M|                    {
  405|  2.84M|                        if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (405:29): [True: 2.21M, False: 628k]
  ------------------
  406|  2.21M|                        {
  407|  2.21M|                            ++state_stack_.back().index;
  408|  2.21M|                            read_item(visitor, ec);
  409|  2.21M|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.21M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.05k, False: 2.21M]
  |  |  ------------------
  ------------------
  410|  1.05k|                            {
  411|  1.05k|                                return;
  412|  1.05k|                            }
  413|  2.21M|                        }
  414|   628k|                        else
  415|   628k|                        {
  416|   628k|                            end_array(visitor, ec);
  417|   628k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   628k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 628k]
  |  |  ------------------
  ------------------
  418|      0|                            {
  419|      0|                                return;
  420|      0|                            }
  421|   628k|                        }
  422|  2.84M|                    }
  423|  2.90M|                    break;
  424|  2.90M|                }
  425|  10.7M|                case parse_mode::indefinite_array:
  ------------------
  |  Branch (425:17): [True: 10.7M, False: 56.3M]
  ------------------
  426|  10.7M|                {
  427|  10.7M|                    if (is_multi_dim()) 
  ------------------
  |  Branch (427:25): [True: 214, False: 10.7M]
  ------------------
  428|    214|                    {
  429|    214|                        JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   49|    214|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 214]
  |  |  ------------------
  |  |   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|    214|                        auto iter = typed_array_stack_.back();
  431|    214|                        if (!iter->done())
  ------------------
  |  Branch (431:29): [True: 199, False: 15]
  ------------------
  432|    199|                        {
  433|    199|                            iter->next(visitor, *this, ec);
  434|    199|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    199|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 6, False: 193]
  |  |  ------------------
  ------------------
  435|      6|                            {
  436|      6|                                return;
  437|      6|                            }
  438|    199|                        }
  439|     15|                        else
  440|     15|                        {
  441|     15|                            auto c = source_.peek();
  442|     15|                            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|     15|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 14]
  |  |  ------------------
  ------------------
  443|      1|                            {
  444|      1|                                ec = cbor_errc::unexpected_eof;
  445|      1|                                more_ = false;
  446|      1|                                return;
  447|      1|                            }
  448|     14|                            if (c.value == 0xff)
  ------------------
  |  Branch (448:33): [True: 9, False: 5]
  ------------------
  449|      9|                            {
  450|      9|                                source_.ignore(1);
  451|      9|                            }
  452|      5|                            else
  453|      5|                            {
  454|      5|                                ec = cbor_errc::bad_mdarray;
  455|      5|                                return;
  456|      5|                            }
  457|      9|                            end_classical_array_storage(ec);
  458|      9|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      9|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 9]
  |  |  ------------------
  ------------------
  459|      0|                            {
  460|      0|                                return;
  461|      0|                            }
  462|      9|                        }
  463|    214|                    }
  464|  10.7M|                    else
  465|  10.7M|                    {
  466|  10.7M|                        auto c = source_.peek();
  467|  10.7M|                        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  10.7M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 622, False: 10.7M]
  |  |  ------------------
  ------------------
  468|    622|                        {
  469|    622|                            ec = cbor_errc::unexpected_eof;
  470|    622|                            more_ = false;
  471|    622|                            return;
  472|    622|                        }
  473|  10.7M|                        if (c.value == 0xff)
  ------------------
  |  Branch (473:29): [True: 878k, False: 9.83M]
  ------------------
  474|   878k|                        {
  475|   878k|                            source_.ignore(1);
  476|   878k|                            end_array(visitor, ec);
  477|   878k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   878k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 878k]
  |  |  ------------------
  ------------------
  478|      0|                            {
  479|      0|                                return;
  480|      0|                            }
  481|   878k|                        }
  482|  9.83M|                        else
  483|  9.83M|                        {
  484|  9.83M|                            read_item(visitor, ec);
  485|  9.83M|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  9.83M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 271, False: 9.83M]
  |  |  ------------------
  ------------------
  486|    271|                            {
  487|    271|                                return;
  488|    271|                            }
  489|  9.83M|                        }
  490|  10.7M|                    }
  491|  10.7M|                    break;
  492|  10.7M|                }
  493|  10.7M|                case parse_mode::map_key:
  ------------------
  |  Branch (493:17): [True: 8.16M, False: 58.8M]
  ------------------
  494|  8.16M|                {
  495|  8.16M|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (495:25): [True: 1.69M, False: 6.47M]
  ------------------
  496|  1.69M|                    {
  497|  1.69M|                        ++state_stack_.back().index;
  498|  1.69M|                        state_stack_.back().mode = parse_mode::map_value;
  499|  1.69M|                        read_item(visitor, ec);
  500|  1.69M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.69M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 981, False: 1.69M]
  |  |  ------------------
  ------------------
  501|    981|                        {
  502|    981|                            return;
  503|    981|                        }
  504|  1.69M|                    }
  505|  6.47M|                    else
  506|  6.47M|                    {
  507|  6.47M|                        end_object(visitor, ec);
  508|  6.47M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  6.47M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 6.47M]
  |  |  ------------------
  ------------------
  509|      0|                        {
  510|      0|                            return;
  511|      0|                        }
  512|  6.47M|                    }
  513|  8.16M|                    break;
  514|  8.16M|                }
  515|  8.16M|                case parse_mode::map_value:
  ------------------
  |  Branch (515:17): [True: 1.67M, False: 65.3M]
  ------------------
  516|  1.67M|                {
  517|  1.67M|                    state_stack_.back().mode = parse_mode::map_key;
  518|  1.67M|                    read_item(visitor, ec);
  519|  1.67M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.67M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.17k, False: 1.67M]
  |  |  ------------------
  ------------------
  520|  1.17k|                    {
  521|  1.17k|                        return;
  522|  1.17k|                    }
  523|  1.67M|                    break;
  524|  1.67M|                }
  525|  8.52M|                case parse_mode::indefinite_map_key:
  ------------------
  |  Branch (525:17): [True: 8.52M, False: 58.5M]
  ------------------
  526|  8.52M|                {
  527|  8.52M|                    auto c = source_.peek();
  528|  8.52M|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  8.52M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 440, False: 8.52M]
  |  |  ------------------
  ------------------
  529|    440|                    {
  530|    440|                        ec = cbor_errc::unexpected_eof;
  531|    440|                        more_ = false;
  532|    440|                        return;
  533|    440|                    }
  534|  8.52M|                    if (c.value == 0xff)
  ------------------
  |  Branch (534:25): [True: 36.1k, False: 8.48M]
  ------------------
  535|  36.1k|                    {
  536|  36.1k|                        source_.ignore(1);
  537|  36.1k|                        end_object(visitor, ec);
  538|  36.1k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  36.1k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 36.1k]
  |  |  ------------------
  ------------------
  539|      0|                        {
  540|      0|                            return;
  541|      0|                        }
  542|  36.1k|                    }
  543|  8.48M|                    else
  544|  8.48M|                    {
  545|  8.48M|                        state_stack_.back().mode = parse_mode::indefinite_map_value;
  546|  8.48M|                        read_item(visitor, ec);
  547|  8.48M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  8.48M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 308, False: 8.48M]
  |  |  ------------------
  ------------------
  548|    308|                        {
  549|    308|                            return;
  550|    308|                        }
  551|  8.48M|                    }
  552|  8.52M|                    break;
  553|  8.52M|                }
  554|  8.52M|                case parse_mode::indefinite_map_value:
  ------------------
  |  Branch (554:17): [True: 8.47M, False: 58.5M]
  ------------------
  555|  8.47M|                {
  556|  8.47M|                    state_stack_.back().mode = parse_mode::indefinite_map_key;
  557|  8.47M|                    read_item(visitor, ec);
  558|  8.47M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  8.47M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 787, False: 8.47M]
  |  |  ------------------
  ------------------
  559|    787|                    {
  560|    787|                        return;
  561|    787|                    }
  562|  8.47M|                    break;
  563|  8.47M|                }
  564|  8.47M|                case parse_mode::root:
  ------------------
  |  Branch (564:17): [True: 8.86k, False: 67.0M]
  ------------------
  565|  8.86k|                {
  566|  8.86k|                    state_stack_.back().mode = parse_mode::accept;
  567|  8.86k|                    read_item(visitor, ec);
  568|  8.86k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  8.86k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.48k, False: 7.38k]
  |  |  ------------------
  ------------------
  569|  1.48k|                    {
  570|  1.48k|                        return;
  571|  1.48k|                    }
  572|  7.38k|                    break;
  573|  8.86k|                }
  574|  7.38k|                case parse_mode::accept:
  ------------------
  |  Branch (574:17): [True: 1.71k, False: 67.0M]
  ------------------
  575|  1.71k|                {
  576|  1.71k|                    JSONCONS_ASSERT(state_stack_.size() == 1);
  ------------------
  |  |   49|  1.71k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 1.71k]
  |  |  ------------------
  |  |   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|  1.71k|                    state_stack_.clear();
  578|  1.71k|                    more_ = false;
  579|  1.71k|                    done_ = true;
  580|  1.71k|                    visitor.flush();
  581|  1.71k|                    break;
  582|  1.71k|                }
  583|  67.0M|            }
  584|  67.0M|        }
  585|  8.86k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_typed_array_itemERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  588|  26.5M|    {
  589|  26.5M|        JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   49|  26.5M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 26.5M]
  |  |  ------------------
  |  |   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|  26.5M|        auto iter = typed_array_stack_.back();
  591|  26.5M|        if (!iter->done())
  ------------------
  |  Branch (591:13): [True: 26.5M, False: 0]
  ------------------
  592|  26.5M|        {
  593|  26.5M|            iter->next(visitor, *this, ec);
  594|  26.5M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  26.5M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 26.5M]
  |  |  ------------------
  ------------------
  595|      0|            {
  596|      0|                return;
  597|      0|            }
  598|  26.5M|            more_ = !cursor_mode_;
  599|  26.5M|        }
  600|  26.5M|    }
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12is_multi_dimEv:
  262|  13.7M|    {
  263|  13.7M|        return state_stack_.size() >=2 && state_stack_[state_stack_.size()-2].mode == parse_mode::multi_dim;
  ------------------
  |  Branch (263:16): [True: 13.7M, False: 0]
  |  Branch (263:43): [True: 60.4k, False: 13.6M]
  ------------------
  264|  13.7M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE27end_classical_array_storageERNS3_10error_codeE:
 1035|     20|    {
 1036|     20|        --nesting_depth_;
 1037|       |
 1038|     20|        more_ = !cursor_mode_;
 1039|     20|        if (level() == mark_level_)
  ------------------
  |  Branch (1039:13): [True: 0, False: 20]
  ------------------
 1040|      0|        {
 1041|      0|            more_ = false;
 1042|      0|        }
 1043|     20|        if (state_stack_.back().pop_stringref_map_stack)
  ------------------
  |  Branch (1043:13): [True: 0, False: 20]
  ------------------
 1044|      0|        {
 1045|      0|            stringref_map_stack_.pop_back();
 1046|      0|        }
 1047|     20|        state_stack_.pop_back();
 1048|     20|    }
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5levelEv:
  302|  8.01M|    {
  303|  8.01M|        return static_cast<int>(state_stack_.size());
  304|  8.01M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_itemERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  603|  32.4M|    {
  604|  32.4M|        read_tags(ec);
  605|  32.4M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  32.4M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3.08k, False: 32.4M]
  |  |  ------------------
  ------------------
  606|  3.08k|        {
  607|  3.08k|            return;
  608|  3.08k|        }
  609|  32.4M|        auto c = source_.peek();
  610|  32.4M|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  32.4M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 32.4M]
  |  |  ------------------
  ------------------
  611|      0|        {
  612|      0|            ec = cbor_errc::unexpected_eof;
  613|      0|            more_ = false;
  614|      0|            return;
  615|      0|        }
  616|  32.4M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
  617|  32.4M|        uint8_t info = get_additional_information_value(c.value);
  618|       |
  619|  32.4M|        switch (major_type)
  620|  32.4M|        {
  621|  9.92M|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (621:13): [True: 9.92M, False: 22.4M]
  ------------------
  622|  9.92M|            {
  623|  9.92M|                uint64_t val = read_uint64(ec);
  624|  9.92M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  9.92M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 111, False: 9.92M]
  |  |  ------------------
  ------------------
  625|    111|                {
  626|    111|                    return;
  627|    111|                }
  628|  9.92M|                if (!stringref_map_stack_.empty() && other_tags_[stringref_tag])
  ------------------
  |  Branch (628:21): [True: 3.96M, False: 5.96M]
  |  Branch (628:21): [True: 89.3k, False: 9.83M]
  |  Branch (628:54): [True: 89.3k, False: 3.87M]
  ------------------
  629|  89.3k|                {
  630|  89.3k|                    other_tags_[stringref_tag] = false;
  631|  89.3k|                    if (val >= stringref_map_stack_.back().size())
  ------------------
  |  Branch (631:25): [True: 52, False: 89.2k]
  ------------------
  632|     52|                    {
  633|     52|                        ec = cbor_errc::stringref_too_large;
  634|     52|                        more_ = false;
  635|     52|                        return;
  636|     52|                    }
  637|  89.2k|                    auto index = static_cast<typename stringref_map::size_type>(val);
  638|  89.2k|                    if (index != val)
  ------------------
  |  Branch (638:25): [True: 0, False: 89.2k]
  ------------------
  639|      0|                    {
  640|      0|                        ec = cbor_errc::number_too_large;
  641|      0|                        more_ = false;
  642|      0|                        return;
  643|      0|                    }
  644|  89.2k|                    auto& str = stringref_map_stack_.back().at(index);
  645|  89.2k|                    switch (str.type)
  646|  89.2k|                    {
  647|    339|                        case jsoncons::cbor::detail::cbor_major_type::text_string:
  ------------------
  |  Branch (647:25): [True: 339, False: 88.9k]
  ------------------
  648|    339|                        {
  649|    339|                            handle_string(visitor, jsoncons::string_view(str.str.data(),str.str.length()),ec);
  650|    339|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    339|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 339]
  |  |  ------------------
  ------------------
  651|      0|                            {
  652|      0|                                return;
  653|      0|                            }
  654|    339|                            break;
  655|    339|                        }
  656|  88.9k|                        case jsoncons::cbor::detail::cbor_major_type::byte_string:
  ------------------
  |  Branch (656:25): [True: 88.9k, False: 339]
  ------------------
  657|  88.9k|                        {
  658|  88.9k|                            read_byte_string_from_buffer read(byte_string_view(str.bytes));
  659|  88.9k|                            read_byte_string(read, visitor, ec);
  660|  88.9k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  88.9k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 88.9k]
  |  |  ------------------
  ------------------
  661|      0|                            {
  662|      0|                                return;
  663|      0|                            }
  664|  88.9k|                            break;
  665|  88.9k|                        }
  666|  88.9k|                        default:
  ------------------
  |  Branch (666:25): [True: 0, False: 89.2k]
  ------------------
  667|      0|                            JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
  668|      0|                            break;
  669|  89.2k|                    }
  670|  89.2k|                }
  671|  9.83M|                else
  672|  9.83M|                {
  673|  9.83M|                    semantic_tag tag = semantic_tag::none;
  674|  9.83M|                    if (other_tags_[item_tag])
  ------------------
  |  Branch (674:25): [True: 35.1k, False: 9.80M]
  ------------------
  675|  35.1k|                    {
  676|  35.1k|                        if (raw_tag_ == 1)
  ------------------
  |  Branch (676:29): [True: 446, False: 34.6k]
  ------------------
  677|    446|                        {
  678|    446|                            tag = semantic_tag::epoch_second;
  679|    446|                        }
  680|  35.1k|                        other_tags_[item_tag] = false;
  681|  35.1k|                    }
  682|  9.83M|                    visitor.uint64_value(val, tag, *this, ec);
  683|  9.83M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  9.83M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 9.83M]
  |  |  ------------------
  ------------------
  684|      0|                    {
  685|      0|                        return;
  686|      0|                    }
  687|  9.83M|                    more_ = !cursor_mode_;
  688|  9.83M|                }
  689|  9.92M|                break;
  690|  9.92M|            }
  691|  9.92M|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (691:13): [True: 1.82M, False: 30.5M]
  ------------------
  692|  1.82M|            {
  693|  1.82M|                int64_t val = read_int64(ec);
  694|  1.82M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.82M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 26, False: 1.82M]
  |  |  ------------------
  ------------------
  695|     26|                {
  696|     26|                    return;
  697|     26|                }
  698|  1.82M|                semantic_tag tag = semantic_tag::none;
  699|  1.82M|                if (other_tags_[item_tag])
  ------------------
  |  Branch (699:21): [True: 19.6k, False: 1.80M]
  ------------------
  700|  19.6k|                {
  701|  19.6k|                    if (raw_tag_ == 1)
  ------------------
  |  Branch (701:25): [True: 129, False: 19.5k]
  ------------------
  702|    129|                    {
  703|    129|                        tag = semantic_tag::epoch_second;
  704|    129|                    }
  705|  19.6k|                    other_tags_[item_tag] = false;
  706|  19.6k|                }
  707|  1.82M|                visitor.int64_value(val, tag, *this, ec);
  708|  1.82M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.82M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.82M]
  |  |  ------------------
  ------------------
  709|      0|                {
  710|      0|                    return;
  711|      0|                }
  712|  1.82M|                more_ = !cursor_mode_;
  713|  1.82M|                break;
  714|  1.82M|            }
  715|  7.85M|            case jsoncons::cbor::detail::cbor_major_type::byte_string:
  ------------------
  |  Branch (715:13): [True: 7.85M, False: 24.5M]
  ------------------
  716|  7.85M|            {
  717|  7.85M|                read_byte_string_from_source read(this);
  718|  7.85M|                read_byte_string(read, visitor, ec);
  719|  7.85M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  7.85M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 770, False: 7.85M]
  |  |  ------------------
  ------------------
  720|    770|                {
  721|    770|                    return;
  722|    770|                }
  723|  7.85M|                break;
  724|  7.85M|            }
  725|  7.85M|            case jsoncons::cbor::detail::cbor_major_type::text_string:
  ------------------
  |  Branch (725:13): [True: 532k, False: 31.8M]
  ------------------
  726|   532k|            {
  727|   532k|                auto sv = read_text_string_view(ec);
  728|   532k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   532k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 539, False: 532k]
  |  |  ------------------
  ------------------
  729|    539|                {
  730|    539|                    return;
  731|    539|                }
  732|   532k|                auto result = unicode_traits::validate(sv.data(),sv.size());
  733|   532k|                if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (733:21): [True: 153, False: 532k]
  ------------------
  734|    153|                {
  735|    153|                    ec = cbor_errc::invalid_utf8_text_string;
  736|    153|                    more_ = false;
  737|    153|                    return;
  738|    153|                }
  739|   532k|                handle_string(visitor, sv, ec);
  740|   532k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   532k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 532k]
  |  |  ------------------
  ------------------
  741|      0|                {
  742|      0|                    return;
  743|      0|                }
  744|   532k|                break;
  745|   532k|            }
  746|   532k|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (746:13): [True: 0, False: 32.4M]
  ------------------
  747|      0|            {
  748|      0|                JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
  749|      0|                break;
  750|   532k|            }
  751|  3.13M|            case jsoncons::cbor::detail::cbor_major_type::simple:
  ------------------
  |  Branch (751:13): [True: 3.13M, False: 29.2M]
  ------------------
  752|  3.13M|            {
  753|  3.13M|                switch (info)
  754|  3.13M|                {
  755|   142k|                    case 0x14:
  ------------------
  |  Branch (755:21): [True: 142k, False: 2.99M]
  ------------------
  756|   142k|                        visitor.bool_value(false, semantic_tag::none, *this, ec);
  757|   142k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   142k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 142k]
  |  |  ------------------
  ------------------
  758|      0|                        {
  759|      0|                            return;
  760|      0|                        }
  761|   142k|                        more_ = !cursor_mode_;
  762|   142k|                        source_.ignore(1);
  763|   142k|                        break;
  764|  1.48M|                    case 0x15:
  ------------------
  |  Branch (764:21): [True: 1.48M, False: 1.64M]
  ------------------
  765|  1.48M|                        visitor.bool_value(true, semantic_tag::none, *this, ec);
  766|  1.48M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.48M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.48M]
  |  |  ------------------
  ------------------
  767|      0|                        {
  768|      0|                            return;
  769|      0|                        }
  770|  1.48M|                        more_ = !cursor_mode_;
  771|  1.48M|                        source_.ignore(1);
  772|  1.48M|                        break;
  773|  1.44M|                    case 0x16:
  ------------------
  |  Branch (773:21): [True: 1.44M, False: 1.68M]
  ------------------
  774|  1.44M|                        visitor.null_value(semantic_tag::none, *this, ec);
  775|  1.44M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.44M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.44M]
  |  |  ------------------
  ------------------
  776|      0|                        {
  777|      0|                            return;
  778|      0|                        }
  779|  1.44M|                        more_ = !cursor_mode_;
  780|  1.44M|                        source_.ignore(1);
  781|  1.44M|                        break;
  782|  30.4k|                    case 0x17:
  ------------------
  |  Branch (782:21): [True: 30.4k, False: 3.10M]
  ------------------
  783|  30.4k|                        visitor.null_value(semantic_tag::undefined, *this, ec);
  784|  30.4k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  30.4k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 30.4k]
  |  |  ------------------
  ------------------
  785|      0|                        {
  786|      0|                            return;
  787|      0|                        }
  788|  30.4k|                        more_ = !cursor_mode_;
  789|  30.4k|                        source_.ignore(1);
  790|  30.4k|                        break;
  791|  10.7k|                    case 0x19: // Half-Precision Float (two-byte IEEE 754)
  ------------------
  |  Branch (791:21): [True: 10.7k, False: 3.12M]
  ------------------
  792|  10.7k|                    {
  793|  10.7k|                        uint64_t val = read_uint64(ec);
  794|  10.7k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  10.7k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 175, False: 10.5k]
  |  |  ------------------
  ------------------
  795|    175|                        {
  796|    175|                            return;
  797|    175|                        }
  798|  10.5k|                        visitor.half_value(static_cast<uint16_t>(val), semantic_tag::none, *this, ec);
  799|  10.5k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  10.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 10.5k]
  |  |  ------------------
  ------------------
  800|      0|                        {
  801|      0|                            return;
  802|      0|                        }
  803|  10.5k|                        more_ = !cursor_mode_;
  804|  10.5k|                        break;
  805|  10.5k|                    }
  806|  9.17k|                    case 0x1a: // Single-Precision Float (four-byte IEEE 754)
  ------------------
  |  Branch (806:21): [True: 9.17k, False: 3.12M]
  ------------------
  807|  13.4k|                    case 0x1b: // Double-Precision Float (eight-byte IEEE 754)
  ------------------
  |  Branch (807:21): [True: 4.28k, False: 3.12M]
  ------------------
  808|  13.4k|                    {
  809|  13.4k|                        double val = read_double(ec);
  810|  13.4k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  13.4k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 50, False: 13.4k]
  |  |  ------------------
  ------------------
  811|     50|                        {
  812|     50|                            return;
  813|     50|                        }
  814|  13.4k|                        semantic_tag tag = semantic_tag::none;
  815|  13.4k|                        if (other_tags_[item_tag])
  ------------------
  |  Branch (815:29): [True: 836, False: 12.5k]
  ------------------
  816|    836|                        {
  817|    836|                            if (raw_tag_ == 1)
  ------------------
  |  Branch (817:33): [True: 209, False: 627]
  ------------------
  818|    209|                            {
  819|    209|                                tag = semantic_tag::epoch_second;
  820|    209|                            }
  821|    836|                            other_tags_[item_tag] = false;
  822|    836|                        }
  823|  13.4k|                        visitor.double_value(val, tag, *this, ec);
  824|  13.4k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  13.4k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 13.4k]
  |  |  ------------------
  ------------------
  825|      0|                        {
  826|      0|                            return;
  827|      0|                        }
  828|  13.4k|                        more_ = !cursor_mode_;
  829|  13.4k|                        break;
  830|  13.4k|                    }
  831|    277|                    default:
  ------------------
  |  Branch (831:21): [True: 277, False: 3.13M]
  ------------------
  832|    277|                    {
  833|    277|                        ec = cbor_errc::unknown_type;
  834|    277|                        more_ = false;
  835|    277|                        return;
  836|  13.4k|                    }
  837|  3.13M|                }
  838|  3.13M|                break;
  839|  3.13M|            }
  840|  3.13M|            case jsoncons::cbor::detail::cbor_major_type::array:
  ------------------
  |  Branch (840:13): [True: 2.56M, False: 29.8M]
  ------------------
  841|  2.56M|            {
  842|  2.56M|                if (other_tags_[item_tag])
  ------------------
  |  Branch (842:21): [True: 1.04M, False: 1.51M]
  ------------------
  843|  1.04M|                {
  844|  1.04M|                    switch (raw_tag_)
  845|  1.04M|                    {
  846|   696k|                        case 0x04:
  ------------------
  |  Branch (846:25): [True: 696k, False: 350k]
  ------------------
  847|   696k|                            text_buffer_.clear();
  848|   696k|                            read_decimal_fraction(text_buffer_, ec);
  849|   696k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   696k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 305, False: 696k]
  |  |  ------------------
  ------------------
  850|    305|                            {
  851|    305|                                return;
  852|    305|                            }
  853|   696k|                            visitor.string_value(text_buffer_, semantic_tag::bigdec, *this, ec);
  854|   696k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   696k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 696k]
  |  |  ------------------
  ------------------
  855|      0|                            {
  856|      0|                                return;
  857|      0|                            }
  858|   696k|                            more_ = !cursor_mode_;
  859|   696k|                            break;
  860|   312k|                        case 0x05:
  ------------------
  |  Branch (860:25): [True: 312k, False: 734k]
  ------------------
  861|   312k|                            text_buffer_.clear();
  862|   312k|                            read_bigfloat(text_buffer_, ec);
  863|   312k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   312k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 249, False: 311k]
  |  |  ------------------
  ------------------
  864|    249|                            {
  865|    249|                                return;
  866|    249|                            }
  867|   311k|                            visitor.string_value(text_buffer_, semantic_tag::bigfloat, *this, ec);
  868|   311k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   311k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 311k]
  |  |  ------------------
  ------------------
  869|      0|                            {
  870|      0|                                return;
  871|      0|                            }
  872|   311k|                            more_ = !cursor_mode_;
  873|   311k|                            break;
  874|    546|                        case 40: // row-major storage
  ------------------
  |  Branch (874:25): [True: 546, False: 1.04M]
  ------------------
  875|    546|                            order_ = mdarray_order::row_major;
  876|    546|                            read_mdarray_header(visitor, ec);
  877|    546|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    546|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 92, False: 454]
  |  |  ------------------
  ------------------
  878|     92|                            {
  879|     92|                                return;
  880|     92|                            }
  881|    454|                            break;
  882|    454|                        case 1040: // column-major storage
  ------------------
  |  Branch (882:25): [True: 2, False: 1.04M]
  ------------------
  883|      2|                            order_ = mdarray_order::column_major;
  884|      2|                            read_mdarray_header(visitor, ec);
  885|      2|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  886|      2|                            {
  887|      2|                                return;
  888|      2|                            }
  889|      0|                            break;
  890|  37.9k|                        default:
  ------------------
  |  Branch (890:25): [True: 37.9k, False: 1.00M]
  ------------------
  891|  37.9k|                            begin_array(visitor, info, ec);
  892|  37.9k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  37.9k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 30, False: 37.9k]
  |  |  ------------------
  ------------------
  893|     30|                            {
  894|     30|                                return;
  895|     30|                            }
  896|  37.9k|                            break;
  897|  1.04M|                    }
  898|  1.04M|                    other_tags_[item_tag] = false;
  899|  1.04M|                }
  900|  1.51M|                else
  901|  1.51M|                {
  902|  1.51M|                    begin_array(visitor, info, ec);
  903|  1.51M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.51M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 83, False: 1.51M]
  |  |  ------------------
  ------------------
  904|     83|                    {
  905|     83|                        return;
  906|     83|                    }
  907|  1.51M|                }
  908|  2.56M|                break;
  909|  2.56M|            }
  910|  6.56M|            case jsoncons::cbor::detail::cbor_major_type::map:
  ------------------
  |  Branch (910:13): [True: 6.56M, False: 25.8M]
  ------------------
  911|  6.56M|            {
  912|  6.56M|                begin_object(visitor, info, ec);
  913|  6.56M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  6.56M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 73, False: 6.56M]
  |  |  ------------------
  ------------------
  914|     73|                {
  915|     73|                    return;
  916|     73|                }
  917|  6.56M|                break;
  918|  6.56M|            }
  919|  6.56M|            default:
  ------------------
  |  Branch (919:13): [True: 0, False: 32.4M]
  ------------------
  920|      0|                break;
  921|  32.4M|        }
  922|  32.4M|        other_tags_[item_tag] = false;
  923|  32.4M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_tagsERNS3_10error_codeE:
 1949|  32.4M|    {
 1950|  32.4M|        auto c = source_.peek();
 1951|  32.4M|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  32.4M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2.68k, False: 32.4M]
  |  |  ------------------
  ------------------
 1952|  2.68k|        {
 1953|  2.68k|            ec = cbor_errc::unexpected_eof;
 1954|  2.68k|            more_ = false;
 1955|  2.68k|            return;
 1956|  2.68k|        }
 1957|  32.4M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1958|       |
 1959|  35.7M|        while (major_type == jsoncons::cbor::detail::cbor_major_type::semantic_tag)
  ------------------
  |  Branch (1959:16): [True: 3.31M, False: 32.4M]
  ------------------
 1960|  3.31M|        {
 1961|  3.31M|            uint64_t val = read_uint64(ec);
 1962|  3.31M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.31M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 213, False: 3.31M]
  |  |  ------------------
  ------------------
 1963|    213|            {
 1964|    213|                return;
 1965|    213|            }
 1966|  3.31M|            switch(val)
 1967|  3.31M|            {
 1968|  97.0k|                case 25: // stringref
  ------------------
  |  Branch (1968:17): [True: 97.0k, False: 3.21M]
  ------------------
 1969|  97.0k|                    other_tags_[stringref_tag] = true;
 1970|  97.0k|                    break;
 1971|  7.05k|                case 256: // stringref-namespace
  ------------------
  |  Branch (1971:17): [True: 7.05k, False: 3.30M]
  ------------------
 1972|  7.05k|                    other_tags_[stringref_namespace_tag] = true;
 1973|  7.05k|                    break;
 1974|  3.20M|                default:
  ------------------
  |  Branch (1974:17): [True: 3.20M, False: 104k]
  ------------------
 1975|  3.20M|                    other_tags_[item_tag] = true;
 1976|  3.20M|                    raw_tag_ = val;
 1977|  3.20M|                    break;
 1978|  3.31M|            }
 1979|  3.31M|            c = source_.peek();
 1980|  3.31M|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  3.31M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 193, False: 3.31M]
  |  |  ------------------
  ------------------
 1981|    193|            {
 1982|    193|                ec = cbor_errc::unexpected_eof;
 1983|    193|                more_ = false;
 1984|    193|                return;
 1985|    193|            }
 1986|  3.31M|            major_type = get_major_type(c.value);
 1987|  3.31M|        }
 1988|  32.4M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE14get_major_typeEh:
 1935|  82.7M|    {
 1936|  82.7M|        static constexpr uint8_t major_type_shift = 0x05;
 1937|  82.7M|        uint8_t value = type >> major_type_shift;
 1938|  82.7M|        return static_cast<jsoncons::cbor::detail::cbor_major_type>(value);
 1939|  82.7M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE32get_additional_information_valueEh:
 1942|  77.1M|    {
 1943|  77.1M|        static constexpr uint8_t additional_information_mask = (1U << 5) - 1;
 1944|  77.1M|        uint8_t value = type & additional_information_mask;
 1945|  77.1M|        return value;
 1946|  77.1M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11read_uint64ERNS3_10error_codeE:
 1381|  32.1M|    {
 1382|  32.1M|        uint64_t val = 0;
 1383|       |
 1384|  32.1M|        uint8_t initial_b;
 1385|  32.1M|        if (source_.read(&initial_b, 1) == 0)
  ------------------
  |  Branch (1385:13): [True: 5, False: 32.1M]
  ------------------
 1386|      5|        {
 1387|      5|            ec = cbor_errc::unexpected_eof;
 1388|      5|            more_ = false;
 1389|      5|            return 0;
 1390|      5|        }
 1391|  32.1M|        uint8_t info = get_additional_information_value(initial_b);
 1392|  32.1M|        switch (info)
 1393|  32.1M|        {
 1394|  23.3M|            case JSONCONS_EXT_CBOR_0x00_0x17: // Integer 0x00..0x17 (0..23)
  ------------------
  |  |   18|  23.3M|    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: 340k, False: 31.7M]
  |  |  |  Branch (18:20): [True: 1.19M, False: 30.9M]
  |  |  |  Branch (18:30): [True: 52.9k, False: 32.0M]
  |  |  |  Branch (18:40): [True: 1.69M, False: 30.4M]
  |  |  |  Branch (18:50): [True: 4.54M, False: 27.5M]
  |  |  |  Branch (18:60): [True: 6.72k, False: 32.1M]
  |  |  |  Branch (18:70): [True: 905k, False: 31.2M]
  |  |  |  Branch (18:80): [True: 17.8k, False: 32.1M]
  |  |  |  Branch (18:90): [True: 53.8k, False: 32.0M]
  |  |  |  Branch (18:100): [True: 6.02k, False: 32.1M]
  |  |  |  Branch (18:110): [True: 25.9k, False: 32.1M]
  |  |  |  Branch (18:120): [True: 19.2k, False: 32.1M]
  |  |  |  Branch (18:130): [True: 171k, False: 31.9M]
  |  |  |  Branch (18:140): [True: 5.52k, False: 32.1M]
  |  |  |  Branch (18:150): [True: 8.61k, False: 32.1M]
  |  |  |  Branch (18:160): [True: 28.3k, False: 32.1M]
  |  |  |  Branch (18:170): [True: 1.12M, False: 31.0M]
  |  |  |  Branch (18:180): [True: 9.61k, False: 32.1M]
  |  |  |  Branch (18:190): [True: 8.45k, False: 32.1M]
  |  |  |  Branch (18:200): [True: 5.95k, False: 32.1M]
  |  |  |  Branch (18:210): [True: 49.2k, False: 32.0M]
  |  |  |  Branch (18:220): [True: 13.8k, False: 32.1M]
  |  |  ------------------
  ------------------
  |  Branch (1394:13): [True: 13.0M, False: 19.0M]
  ------------------
 1395|  23.3M|            {
 1396|  23.3M|                val = info;
 1397|  23.3M|                break;
 1398|   460M|            }
 1399|       |
 1400|   241k|            case 0x18: // Unsigned integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1400:13): [True: 241k, False: 31.8M]
  ------------------
 1401|   241k|            {
 1402|   241k|                uint8_t b;
 1403|   241k|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1403:21): [True: 135, False: 241k]
  ------------------
 1404|    135|                {
 1405|    135|                    ec = cbor_errc::unexpected_eof;
 1406|    135|                    more_ = false;
 1407|    135|                    return val;
 1408|    135|                }
 1409|   241k|                val = b;
 1410|   241k|                break;
 1411|   241k|            }
 1412|       |
 1413|  32.9k|            case 0x19: // Unsigned integer (two-byte uint16_t follows)
  ------------------
  |  Branch (1413:13): [True: 32.9k, False: 32.1M]
  ------------------
 1414|  32.9k|            {
 1415|  32.9k|                uint8_t buf[sizeof(uint16_t)];
 1416|  32.9k|                if (source_.read(buf, sizeof(uint16_t)) != sizeof(uint16_t))
  ------------------
  |  Branch (1416:21): [True: 252, False: 32.6k]
  ------------------
 1417|    252|                {
 1418|    252|                    ec = cbor_errc::unexpected_eof;
 1419|    252|                    more_ = false;
 1420|    252|                    return val;
 1421|    252|                }
 1422|  32.6k|                val = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1423|  32.6k|                break;
 1424|  32.9k|            }
 1425|       |
 1426|  3.21k|            case 0x1a: // Unsigned integer (four-byte uint32_t follows)
  ------------------
  |  Branch (1426:13): [True: 3.21k, False: 32.1M]
  ------------------
 1427|  3.21k|            {
 1428|  3.21k|                uint8_t buf[sizeof(uint32_t)];
 1429|  3.21k|                if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (1429:21): [True: 81, False: 3.13k]
  ------------------
 1430|     81|                {
 1431|     81|                    ec = cbor_errc::unexpected_eof;
 1432|     81|                    more_ = false;
 1433|     81|                    return val;
 1434|     81|                }
 1435|  3.13k|                val = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1436|  3.13k|                break;
 1437|  3.21k|            }
 1438|       |
 1439|  4.78k|            case 0x1b: // Unsigned integer (eight-byte uint64_t follows)
  ------------------
  |  Branch (1439:13): [True: 4.78k, False: 32.1M]
  ------------------
 1440|  4.78k|            {
 1441|  4.78k|                uint8_t buf[sizeof(uint64_t)];
 1442|  4.78k|                if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (1442:21): [True: 728, False: 4.06k]
  ------------------
 1443|    728|                {
 1444|    728|                    ec = cbor_errc::unexpected_eof;
 1445|    728|                    more_ = false;
 1446|    728|                    return val;
 1447|    728|                }
 1448|  4.06k|                val = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1449|  4.06k|                break;
 1450|  4.78k|            }
 1451|  8.47M|            default:
  ------------------
  |  Branch (1451:13): [True: 8.47M, False: 23.6M]
  ------------------
 1452|  8.47M|                break;
 1453|  32.1M|        }
 1454|  32.1M|        return val;
 1455|  32.1M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13handle_stringERNS_21basic_generic_visitorIcEERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERNS3_10error_codeE:
 1991|   532k|    {
 1992|   532k|        semantic_tag tag = semantic_tag::none;
 1993|   532k|        if (other_tags_[item_tag])
  ------------------
  |  Branch (1993:13): [True: 6.07k, False: 526k]
  ------------------
 1994|  6.07k|        {
 1995|  6.07k|            switch (raw_tag_)
 1996|  6.07k|            {
 1997|    730|                case 0:
  ------------------
  |  Branch (1997:17): [True: 730, False: 5.34k]
  ------------------
 1998|    730|                    tag = semantic_tag::datetime;
 1999|    730|                    break;
 2000|    540|                case 32:
  ------------------
  |  Branch (2000:17): [True: 540, False: 5.53k]
  ------------------
 2001|    540|                    tag = semantic_tag::uri;
 2002|    540|                    break;
 2003|    240|                case 33:
  ------------------
  |  Branch (2003:17): [True: 240, False: 5.83k]
  ------------------
 2004|    240|                    tag = semantic_tag::base64url;
 2005|    240|                    break;
 2006|    981|                case 34:
  ------------------
  |  Branch (2006:17): [True: 981, False: 5.09k]
  ------------------
 2007|    981|                    tag = semantic_tag::base64;
 2008|    981|                    break;
 2009|  3.58k|                default:
  ------------------
  |  Branch (2009:17): [True: 3.58k, False: 2.49k]
  ------------------
 2010|  3.58k|                    break;
 2011|  6.07k|            }
 2012|  6.07k|            other_tags_[item_tag] = false;
 2013|  6.07k|        }
 2014|   532k|        visitor.string_value(v, tag, *this, ec);
 2015|   532k|        more_ = !cursor_mode_;
 2016|   532k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_bufferC2ERKNS_16byte_string_viewE:
  174|  88.9k|            : bytes(b)
  175|  88.9k|        {
  176|  88.9k|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringINS8_28read_byte_string_from_bufferEEEvT_RNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 2033|  88.9k|    {
 2034|  88.9k|        if (other_tags_[item_tag])
  ------------------
  |  Branch (2034:13): [True: 83.9k, False: 4.97k]
  ------------------
 2035|  83.9k|        {
 2036|  83.9k|            switch (raw_tag_)
 2037|  83.9k|            {
 2038|  13.1k|                case 0x2:
  ------------------
  |  Branch (2038:17): [True: 13.1k, False: 70.7k]
  ------------------
 2039|  13.1k|                {
 2040|  13.1k|                    auto bytes = read.view(ec);
 2041|  13.1k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  13.1k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 13.1k]
  |  |  ------------------
  ------------------
 2042|      0|                    {
 2043|      0|                        more_ = false;
 2044|      0|                        return;
 2045|      0|                    }
 2046|  13.1k|                    bigint n = bigint::from_bytes_be(1, bytes.data(), bytes.size());
 2047|  13.1k|                    text_buffer_.clear();
 2048|  13.1k|                    n.write_string(text_buffer_);
 2049|  13.1k|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2050|  13.1k|                    more_ = !cursor_mode_;
 2051|  13.1k|                    break;
 2052|  13.1k|                }
 2053|  27.3k|                case 0x3:
  ------------------
  |  Branch (2053:17): [True: 27.3k, False: 56.6k]
  ------------------
 2054|  27.3k|                {
 2055|  27.3k|                    auto bytes = read.view(ec);
 2056|  27.3k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  27.3k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 27.3k]
  |  |  ------------------
  ------------------
 2057|      0|                    {
 2058|      0|                        more_ = false;
 2059|      0|                        return;
 2060|      0|                    }
 2061|  27.3k|                    bigint n = bigint::from_bytes_be(1, bytes.data(), bytes.size());
 2062|  27.3k|                    n = -1 - n;
 2063|  27.3k|                    text_buffer_.clear();
 2064|  27.3k|                    n.write_string(text_buffer_);
 2065|  27.3k|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2066|  27.3k|                    more_ = !cursor_mode_;
 2067|  27.3k|                    break;
 2068|  27.3k|                }
 2069|    220|                case 0x15:
  ------------------
  |  Branch (2069:17): [True: 220, False: 83.7k]
  ------------------
 2070|    455|                case 0x16:
  ------------------
  |  Branch (2070:17): [True: 235, False: 83.7k]
  ------------------
 2071|    866|                case 0x17:
  ------------------
  |  Branch (2071:17): [True: 411, False: 83.5k]
  ------------------
 2072|    866|                {
 2073|    866|                    auto bytes = read.view(ec);
 2074|    866|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    866|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 866]
  |  |  ------------------
  ------------------
 2075|      0|                    {
 2076|      0|                        more_ = false;
 2077|      0|                        return;
 2078|      0|                    }
 2079|    866|                    const semantic_tag tag = raw_tag_ == 0x15 ? semantic_tag::base64url
  ------------------
  |  Branch (2079:46): [True: 220, False: 646]
  ------------------
 2080|    866|                        : raw_tag_ == 0x16 ? semantic_tag::base64
  ------------------
  |  Branch (2080:27): [True: 235, False: 411]
  ------------------
 2081|    646|                        : semantic_tag::base16;
 2082|    866|                    visitor.byte_string_value(bytes, tag, *this, ec);
 2083|    866|                    more_ = !cursor_mode_;
 2084|    866|                    break;
 2085|    866|                }
 2086|    297|                case 0x40:
  ------------------
  |  Branch (2086:17): [True: 297, False: 83.6k]
  ------------------
 2087|    297|                {
 2088|    297|                    array_tag_ = typed_array_tags::uint8;
 2089|    297|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2090|    297|                    read(array_buffer, ec);
 2091|    297|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    297|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 297]
  |  |  ------------------
  ------------------
 2092|      0|                    {
 2093|      0|                        more_ = false;
 2094|      0|                        return;
 2095|      0|                    }
 2096|    297|                    auto ta = typed_array_cast<const uint8_t>(array_buffer);
 2097|    297|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2097:25): [True: 297, False: 0]
  |  Branch (2097:42): [True: 0, False: 297]
  ------------------
 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|    297|                    else
 2111|    297|                    {
 2112|    297|                        auto iter = std::make_shared<oned_typed_array_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2113|    297|                            typed_array_tags::uint8, semantic_tag::none, alloc_);
 2114|    297|                        typed_array_stack_.push_back(iter);
 2115|    297|                        iter->next(visitor, *this, ec);
 2116|    297|                    }
 2117|    297|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2118|    297|                    more_ = !cursor_mode_;
 2119|    297|                    break;
 2120|    297|                }
 2121|  1.01k|                case 0x44:
  ------------------
  |  Branch (2121:17): [True: 1.01k, False: 82.9k]
  ------------------
 2122|  1.01k|                {
 2123|  1.01k|                    array_tag_ = typed_array_tags::uint8;
 2124|  1.01k|                    typed_array_tag_ = semantic_tag::clamped;
 2125|  1.01k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2126|  1.01k|                    read(array_buffer, ec);
 2127|  1.01k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.01k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.01k]
  |  |  ------------------
  ------------------
 2128|      0|                    {
 2129|      0|                        more_ = false;
 2130|      0|                        return;
 2131|      0|                    }
 2132|  1.01k|                    auto ta = typed_array_cast<const uint8_t>(array_buffer);
 2133|  1.01k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2133:25): [True: 1.01k, False: 0]
  |  Branch (2133:42): [True: 0, False: 1.01k]
  ------------------
 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|  1.01k|                    else
 2147|  1.01k|                    {
 2148|  1.01k|                        auto iter = std::make_shared<oned_typed_array_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2149|  1.01k|                            typed_array_tags::uint8, semantic_tag::clamped, alloc_);
 2150|  1.01k|                        typed_array_stack_.push_back(iter);
 2151|  1.01k|                        iter->next(visitor, *this, ec);
 2152|  1.01k|                    }
 2153|  1.01k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2154|  1.01k|                    more_ = !cursor_mode_;
 2155|  1.01k|                    break;
 2156|  1.01k|                }
 2157|  1.76k|                case 0x41:
  ------------------
  |  Branch (2157:17): [True: 1.76k, False: 82.2k]
  ------------------
 2158|  4.93k|                case 0x45:
  ------------------
  |  Branch (2158:17): [True: 3.17k, False: 80.8k]
  ------------------
 2159|  4.93k|                {
 2160|  4.93k|                    array_tag_ = typed_array_tags::uint16;
 2161|  4.93k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2162|  4.93k|                    read(array_buffer, ec);
 2163|  4.93k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.93k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4.93k]
  |  |  ------------------
  ------------------
 2164|      0|                    {
 2165|      0|                        more_ = false;
 2166|      0|                        return;
 2167|      0|                    }
 2168|  4.93k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2169|  4.93k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2170|  4.93k|                    auto ta = typed_array_cast<uint16_t>(array_buffer);
 2171|  4.93k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2171:25): [True: 1.76k, False: 3.17k]
  ------------------
 2172|  1.76k|                    {
 2173|   516k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2173:49): [True: 514k, False: 1.76k]
  ------------------
 2174|   514k|                        {
 2175|   514k|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2176|   514k|                        }
 2177|  1.76k|                    }
 2178|  4.93k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2178:25): [True: 4.93k, False: 0]
  |  Branch (2178:42): [True: 0, False: 4.93k]
  ------------------
 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|  4.93k|                    else
 2192|  4.93k|                    {
 2193|  4.93k|                        auto iter = std::make_shared<oned_typed_array_iterator<uint16_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2194|  4.93k|                            typed_array_tags::uint16, semantic_tag::none, alloc_);
 2195|  4.93k|                        typed_array_stack_.push_back(iter);
 2196|  4.93k|                        iter->next(visitor, *this, ec);
 2197|  4.93k|                    }
 2198|  4.93k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2199|  4.93k|                    more_ = !cursor_mode_;
 2200|  4.93k|                    break;
 2201|  4.93k|                }
 2202|    802|                case 0x42:
  ------------------
  |  Branch (2202:17): [True: 802, False: 83.1k]
  ------------------
 2203|  1.12k|                case 0x46:
  ------------------
  |  Branch (2203:17): [True: 319, False: 83.6k]
  ------------------
 2204|  1.12k|                {
 2205|  1.12k|                    array_tag_ = typed_array_tags::uint32;
 2206|  1.12k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2207|  1.12k|                    read(array_buffer, ec);
 2208|  1.12k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.12k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.12k]
  |  |  ------------------
  ------------------
 2209|      0|                    {
 2210|      0|                        more_ = false;
 2211|      0|                        return;
 2212|      0|                    }
 2213|  1.12k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2214|  1.12k|                    jsoncons::endian e = get_typed_array_endianness(tag);
 2215|  1.12k|                    auto ta = typed_array_cast<uint32_t>(array_buffer);
 2216|  1.12k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2216:25): [True: 802, False: 319]
  ------------------
 2217|    802|                    {
 2218|  2.01M|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2218:49): [True: 2.01M, False: 802]
  ------------------
 2219|  2.01M|                        {
 2220|  2.01M|                            ta[i] = binary::byte_swap<uint32_t>(ta[i]);
 2221|  2.01M|                        }
 2222|    802|                    }
 2223|  1.12k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2223:25): [True: 1.12k, False: 0]
  |  Branch (2223:42): [True: 0, False: 1.12k]
  ------------------
 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|  1.12k|                    else
 2237|  1.12k|                    {
 2238|  1.12k|                        auto iter = std::make_shared<oned_typed_array_iterator<uint32_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2239|  1.12k|                            typed_array_tags::uint32, semantic_tag::none, alloc_);
 2240|  1.12k|                        typed_array_stack_.push_back(iter);
 2241|  1.12k|                        iter->next(visitor, *this, ec);
 2242|  1.12k|                    }
 2243|  1.12k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2244|  1.12k|                    more_ = !cursor_mode_;
 2245|  1.12k|                    break;
 2246|  1.12k|                }
 2247|  1.20k|                case 0x43:
  ------------------
  |  Branch (2247:17): [True: 1.20k, False: 82.7k]
  ------------------
 2248|  12.9k|                case 0x47:
  ------------------
  |  Branch (2248:17): [True: 11.7k, False: 72.2k]
  ------------------
 2249|  12.9k|                {
 2250|  12.9k|                    array_tag_ = typed_array_tags::uint64;
 2251|  12.9k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2252|  12.9k|                    read(array_buffer, ec);
 2253|  12.9k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  12.9k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 12.9k]
  |  |  ------------------
  ------------------
 2254|      0|                    {
 2255|      0|                        more_ = false;
 2256|      0|                        return;
 2257|      0|                    }
 2258|  12.9k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2259|  12.9k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2260|  12.9k|                    auto ta = typed_array_cast<uint64_t>(array_buffer);
 2261|  12.9k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2261:25): [True: 1.20k, False: 11.7k]
  ------------------
 2262|  1.20k|                    {
 2263|   303k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2263:49): [True: 302k, False: 1.20k]
  ------------------
 2264|   302k|                        {
 2265|   302k|                            ta[i] = binary::byte_swap<uint64_t>(ta[i]);
 2266|   302k|                        }
 2267|  1.20k|                    }
 2268|  12.9k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2268:25): [True: 12.9k, False: 0]
  |  Branch (2268:42): [True: 0, False: 12.9k]
  ------------------
 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|  12.9k|                    else
 2282|  12.9k|                    {
 2283|  12.9k|                        auto iter = std::make_shared<oned_typed_array_iterator<uint64_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2284|  12.9k|                            typed_array_tags::uint64, semantic_tag::none, alloc_);
 2285|  12.9k|                        typed_array_stack_.push_back(iter);
 2286|  12.9k|                        iter->next(visitor, *this, ec);
 2287|  12.9k|                    }
 2288|  12.9k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2289|  12.9k|                    more_ = !cursor_mode_;
 2290|  12.9k|                    break;
 2291|  12.9k|                }
 2292|    411|                case 0x48:
  ------------------
  |  Branch (2292:17): [True: 411, False: 83.5k]
  ------------------
 2293|    411|                {
 2294|    411|                    array_tag_ = typed_array_tags::int8;
 2295|    411|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2296|    411|                    read(array_buffer, ec);
 2297|    411|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    411|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 411]
  |  |  ------------------
  ------------------
 2298|      0|                    {
 2299|      0|                        more_ = false;
 2300|      0|                        return;
 2301|      0|                    }
 2302|    411|                    auto ta = typed_array_cast<int8_t>(array_buffer);
 2303|    411|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2303:25): [True: 411, False: 0]
  |  Branch (2303:42): [True: 0, False: 411]
  ------------------
 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|    411|                    else
 2317|    411|                    {
 2318|    411|                        auto iter = std::make_shared<oned_typed_array_iterator<int8_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2319|    411|                            typed_array_tags::int8, semantic_tag::none, alloc_);
 2320|    411|                        typed_array_stack_.push_back(iter);
 2321|    411|                        iter->next(visitor, *this, ec);
 2322|    411|                    }
 2323|    411|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2324|    411|                    more_ = !cursor_mode_;
 2325|    411|                    break;
 2326|    411|                }
 2327|  2.11k|                case 0x49:
  ------------------
  |  Branch (2327:17): [True: 2.11k, False: 81.8k]
  ------------------
 2328|  2.68k|                case 0x4d:
  ------------------
  |  Branch (2328:17): [True: 566, False: 83.4k]
  ------------------
 2329|  2.68k|                {
 2330|  2.68k|                    array_tag_ = typed_array_tags::int16;
 2331|  2.68k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2332|  2.68k|                    read(array_buffer, ec);
 2333|  2.68k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.68k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.68k]
  |  |  ------------------
  ------------------
 2334|      0|                    {
 2335|      0|                        more_ = false;
 2336|      0|                        return;
 2337|      0|                    }
 2338|  2.68k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2339|  2.68k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2340|  2.68k|                    auto ta = typed_array_cast<int16_t>(array_buffer);
 2341|  2.68k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2341:25): [True: 2.11k, False: 566]
  ------------------
 2342|  2.11k|                    {
 2343|   462k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2343:49): [True: 460k, False: 2.11k]
  ------------------
 2344|   460k|                        {
 2345|   460k|                            ta[i] = binary::byte_swap<int16_t>(ta[i]);
 2346|   460k|                        }
 2347|  2.11k|                    }
 2348|  2.68k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2348:25): [True: 2.68k, False: 0]
  |  Branch (2348:42): [True: 0, False: 2.68k]
  ------------------
 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|  2.68k|                    else
 2362|  2.68k|                    {
 2363|  2.68k|                        auto iter = std::make_shared<oned_typed_array_iterator<int16_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2364|  2.68k|                            typed_array_tags::int16, semantic_tag::none, alloc_);
 2365|  2.68k|                        typed_array_stack_.push_back(iter);
 2366|  2.68k|                        iter->next(visitor, *this, ec);
 2367|  2.68k|                    }
 2368|  2.68k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2369|  2.68k|                    more_ = !cursor_mode_;
 2370|  2.68k|                    break;
 2371|  2.68k|                }
 2372|  1.23k|                case 0x4a:
  ------------------
  |  Branch (2372:17): [True: 1.23k, False: 82.7k]
  ------------------
 2373|  2.04k|                case 0x4e:
  ------------------
  |  Branch (2373:17): [True: 811, False: 83.1k]
  ------------------
 2374|  2.04k|                {
 2375|  2.04k|                    array_tag_ = typed_array_tags::int32;
 2376|  2.04k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2377|  2.04k|                    read(array_buffer, ec);
 2378|  2.04k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.04k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.04k]
  |  |  ------------------
  ------------------
 2379|      0|                    {
 2380|      0|                        more_ = false;
 2381|      0|                        return;
 2382|      0|                    }
 2383|  2.04k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2384|  2.04k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2385|  2.04k|                    auto ta = typed_array_cast<int32_t>(array_buffer);
 2386|  2.04k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2386:25): [True: 1.23k, False: 811]
  ------------------
 2387|  1.23k|                    {
 2388|   725k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2388:49): [True: 724k, False: 1.23k]
  ------------------
 2389|   724k|                        {
 2390|   724k|                            ta[i] = binary::byte_swap<int32_t>(ta[i]);
 2391|   724k|                        }
 2392|  1.23k|                    }
 2393|  2.04k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2393:25): [True: 2.04k, False: 0]
  |  Branch (2393:42): [True: 0, False: 2.04k]
  ------------------
 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|  2.04k|                    else
 2407|  2.04k|                    {
 2408|  2.04k|                        auto iter = std::make_shared<oned_typed_array_iterator<int32_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2409|  2.04k|                            typed_array_tags::int32, semantic_tag::none, alloc_);
 2410|  2.04k|                        typed_array_stack_.push_back(iter);
 2411|  2.04k|                        iter->next(visitor, *this, ec);
 2412|  2.04k|                    }
 2413|  2.04k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2414|  2.04k|                    more_ = !cursor_mode_;
 2415|  2.04k|                    break;
 2416|  2.04k|                }
 2417|    915|                case 0x4b:
  ------------------
  |  Branch (2417:17): [True: 915, False: 83.0k]
  ------------------
 2418|  1.20k|                case 0x4f:
  ------------------
  |  Branch (2418:17): [True: 292, False: 83.6k]
  ------------------
 2419|  1.20k|                {
 2420|  1.20k|                    array_tag_ = typed_array_tags::int64;
 2421|  1.20k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2422|  1.20k|                    read(array_buffer, ec);
 2423|  1.20k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.20k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.20k]
  |  |  ------------------
  ------------------
 2424|      0|                    {
 2425|      0|                        more_ = false;
 2426|      0|                        return;
 2427|      0|                    }
 2428|  1.20k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2429|  1.20k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2430|  1.20k|                    auto ta = typed_array_cast<int64_t>(array_buffer);
 2431|  1.20k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2431:25): [True: 915, False: 292]
  ------------------
 2432|    915|                    {
 2433|   520k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2433:49): [True: 519k, False: 915]
  ------------------
 2434|   519k|                        {
 2435|   519k|                            ta[i] = binary::byte_swap<int64_t>(ta[i]);
 2436|   519k|                        }
 2437|    915|                    }
 2438|  1.20k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2438:25): [True: 1.20k, False: 0]
  |  Branch (2438:42): [True: 0, False: 1.20k]
  ------------------
 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|  1.20k|                    else
 2452|  1.20k|                    {
 2453|  1.20k|                        auto iter = std::make_shared<oned_typed_array_iterator<int64_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2454|  1.20k|                            typed_array_tags::int64, semantic_tag::none, alloc_);
 2455|  1.20k|                        typed_array_stack_.push_back(iter);
 2456|  1.20k|                        iter->next(visitor, *this, ec);
 2457|  1.20k|                    }
 2458|  1.20k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2459|  1.20k|                    more_ = !cursor_mode_;
 2460|  1.20k|                    break;
 2461|  1.20k|                }
 2462|    721|                case 0x50:
  ------------------
  |  Branch (2462:17): [True: 721, False: 83.2k]
  ------------------
 2463|  10.0k|                case 0x54:
  ------------------
  |  Branch (2463:17): [True: 9.36k, False: 74.6k]
  ------------------
 2464|  10.0k|                {
 2465|  10.0k|                    array_tag_ = typed_array_tags::half_float;
 2466|  10.0k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2467|  10.0k|                    read(array_buffer, ec);
 2468|  10.0k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  10.0k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 10.0k]
  |  |  ------------------
  ------------------
 2469|      0|                    {
 2470|      0|                        more_ = false;
 2471|      0|                        return;
 2472|      0|                    }
 2473|  10.0k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2474|  10.0k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2475|  10.0k|                    auto ta = typed_array_cast<uint16_t>(array_buffer);
 2476|  10.0k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2476:25): [True: 721, False: 9.36k]
  ------------------
 2477|    721|                    {
 2478|  1.11M|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2478:49): [True: 1.11M, False: 721]
  ------------------
 2479|  1.11M|                        {
 2480|  1.11M|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2481|  1.11M|                        }
 2482|    721|                    }
 2483|  10.0k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2483:25): [True: 10.0k, False: 0]
  |  Branch (2483:42): [True: 0, False: 10.0k]
  ------------------
 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|  10.0k|                    else
 2497|  10.0k|                    {
 2498|  10.0k|                        auto iter = std::make_shared<oned_typed_array_iterator<uint16_t,decode_half,Allocator>>(std::move(array_buffer),
 2499|  10.0k|                            typed_array_tags::half_float, semantic_tag::none, alloc_);
 2500|  10.0k|                        typed_array_stack_.push_back(iter);
 2501|  10.0k|                        iter->next(visitor, *this, ec);
 2502|  10.0k|                    }
 2503|  10.0k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2504|  10.0k|                    more_ = !cursor_mode_;
 2505|  10.0k|                    break;
 2506|  10.0k|                }
 2507|  2.40k|                case 0x51:
  ------------------
  |  Branch (2507:17): [True: 2.40k, False: 81.5k]
  ------------------
 2508|  3.07k|                case 0x55:
  ------------------
  |  Branch (2508:17): [True: 665, False: 83.3k]
  ------------------
 2509|  3.07k|                {
 2510|  3.07k|                    array_tag_ = typed_array_tags::float32;
 2511|  3.07k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2512|  3.07k|                    read(array_buffer, ec);
 2513|  3.07k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.07k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.07k]
  |  |  ------------------
  ------------------
 2514|      0|                    {
 2515|      0|                        more_ = false;
 2516|      0|                        return;
 2517|      0|                    }
 2518|  3.07k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2519|  3.07k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2520|  3.07k|                    auto ta = typed_array_cast<float>(array_buffer);
 2521|  3.07k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2521:25): [True: 2.40k, False: 665]
  ------------------
 2522|  2.40k|                    {
 2523|   303k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2523:49): [True: 301k, False: 2.40k]
  ------------------
 2524|   301k|                        {
 2525|   301k|                            ta[i] = binary::byte_swap<float>(ta[i]);
 2526|   301k|                        }
 2527|  2.40k|                    }
 2528|  3.07k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2528:25): [True: 3.07k, False: 0]
  |  Branch (2528:42): [True: 0, False: 3.07k]
  ------------------
 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|  3.07k|                    else
 2542|  3.07k|                    {
 2543|  3.07k|                        auto iter = std::make_shared<oned_typed_array_iterator<float,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2544|  3.07k|                            typed_array_tags::float32, semantic_tag::none, alloc_);
 2545|  3.07k|                        typed_array_stack_.push_back(iter);
 2546|  3.07k|                        iter->next(visitor, *this, ec);
 2547|  3.07k|                    }
 2548|  3.07k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2549|  3.07k|                    more_ = !cursor_mode_;
 2550|  3.07k|                    break;
 2551|  3.07k|                }
 2552|    696|                case 0x52:
  ------------------
  |  Branch (2552:17): [True: 696, False: 83.2k]
  ------------------
 2553|  1.09k|                case 0x56:
  ------------------
  |  Branch (2553:17): [True: 397, False: 83.5k]
  ------------------
 2554|  1.09k|                {
 2555|  1.09k|                    array_tag_ = typed_array_tags::float64;
 2556|  1.09k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2557|  1.09k|                    read(array_buffer, ec);
 2558|  1.09k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.09k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.09k]
  |  |  ------------------
  ------------------
 2559|      0|                    {
 2560|      0|                        more_ = false;
 2561|      0|                        return;
 2562|      0|                    }
 2563|  1.09k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2564|  1.09k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2565|  1.09k|                    auto ta = typed_array_cast<double>(array_buffer);
 2566|  1.09k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2566:25): [True: 696, False: 397]
  ------------------
 2567|    696|                    {
 2568|   151k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2568:49): [True: 150k, False: 696]
  ------------------
 2569|   150k|                        {
 2570|   150k|                            ta[i] = binary::byte_swap<double>(ta[i]);
 2571|   150k|                        }
 2572|    696|                    }
 2573|  1.09k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2573:25): [True: 1.09k, False: 0]
  |  Branch (2573:42): [True: 0, False: 1.09k]
  ------------------
 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|  1.09k|                    else
 2587|  1.09k|                    {
 2588|  1.09k|                        auto iter = std::make_shared<oned_typed_array_iterator<double,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2589|  1.09k|                            typed_array_tags::float64, semantic_tag::none, alloc_);
 2590|  1.09k|                        typed_array_stack_.push_back(iter);
 2591|  1.09k|                        iter->next(visitor, *this, ec);
 2592|  1.09k|                    }
 2593|  1.09k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2594|  1.09k|                    more_ = !cursor_mode_;
 2595|  1.09k|                    break;
 2596|  1.09k|                }
 2597|  1.64k|                default:
  ------------------
  |  Branch (2597:17): [True: 1.64k, False: 82.3k]
  ------------------
 2598|  1.64k|                {
 2599|  1.64k|                    auto bytes = read.view(ec);
 2600|  1.64k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.64k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.64k]
  |  |  ------------------
  ------------------
 2601|      0|                    {
 2602|      0|                        more_ = false;
 2603|      0|                        return;
 2604|      0|                    }
 2605|  1.64k|                    visitor.byte_string_value(bytes, raw_tag_, *this, ec);
 2606|  1.64k|                    more_ = !cursor_mode_;
 2607|  1.64k|                    break;
 2608|  1.64k|                }
 2609|  83.9k|            }
 2610|  83.9k|            other_tags_[item_tag] = false;
 2611|  83.9k|        }
 2612|  4.97k|        else
 2613|  4.97k|        {
 2614|  4.97k|            auto bytes = read.view(ec);
 2615|  4.97k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.97k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4.97k]
  |  |  ------------------
  ------------------
 2616|      0|            {
 2617|      0|                return;
 2618|      0|            }
 2619|  4.97k|            visitor.byte_string_value(bytes, semantic_tag::none, *this, ec);
 2620|  4.97k|            more_ = !cursor_mode_;
 2621|  4.97k|        }
 2622|  88.9k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_buffer4viewERNS3_10error_codeE:
  189|  48.0k|        {
  190|  48.0k|            return bytes;
  191|  48.0k|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_bufferclINS3_6vectorIhS5_EEEEvRT_RNS3_10error_codeE:
  179|  40.9k|        {
  180|  40.9k|            c.clear();
  181|  40.9k|            c.reserve(bytes.size());
  182|  40.9k|            for (auto b : bytes)
  ------------------
  |  Branch (182:25): [True: 55.5M, False: 40.9k]
  ------------------
  183|  55.5M|            {
  184|  55.5M|                c.push_back(b);
  185|  55.5M|            }
  186|  40.9k|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE26get_typed_array_endiannessEh:
 2019|  87.1k|    {
 2020|  87.1k|        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: 44.7k, False: 42.3k]
  ------------------
 2021|  87.1k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10read_int64ERNS3_10error_codeE:
 1458|  3.16M|    {
 1459|  3.16M|        int64_t val = 0;
 1460|       |
 1461|  3.16M|        auto ch = source_.peek();
 1462|  3.16M|        if (ch.eof)
  ------------------
  |  Branch (1462:13): [True: 0, False: 3.16M]
  ------------------
 1463|      0|        {
 1464|      0|            ec = cbor_errc::unexpected_eof;
 1465|      0|            more_ = false;
 1466|      0|            return val;
 1467|      0|        }
 1468|       |
 1469|  3.16M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(ch.value);
 1470|  3.16M|        uint8_t info = get_additional_information_value(ch.value);
 1471|  3.16M|        switch (major_type)
 1472|  3.16M|        {
 1473|  3.16M|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1473:13): [True: 3.16M, False: 0]
  ------------------
 1474|  3.16M|                source_.ignore(1);
 1475|  3.16M|                switch (info)
  ------------------
  |  Branch (1475:25): [True: 2.59M, False: 575k]
  ------------------
 1476|  3.16M|                {
 1477|  2.51M|                    case JSONCONS_EXT_CBOR_0x00_0x17: // 0x00..0x17 (0..23)
  ------------------
  |  |   18|  2.51M|    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: 8.00k, False: 3.16M]
  |  |  |  Branch (18:20): [True: 1.24k, False: 3.16M]
  |  |  |  Branch (18:30): [True: 1.42k, False: 3.16M]
  |  |  |  Branch (18:40): [True: 11.8k, False: 3.15M]
  |  |  |  Branch (18:50): [True: 5.29k, False: 3.16M]
  |  |  |  Branch (18:60): [True: 13.1k, False: 3.15M]
  |  |  |  Branch (18:70): [True: 334k, False: 2.83M]
  |  |  |  Branch (18:80): [True: 881k, False: 2.28M]
  |  |  |  Branch (18:90): [True: 28.8k, False: 3.13M]
  |  |  |  Branch (18:100): [True: 6.09k, False: 3.16M]
  |  |  |  Branch (18:110): [True: 1.17k, False: 3.16M]
  |  |  |  Branch (18:120): [True: 2.02k, False: 3.16M]
  |  |  |  Branch (18:130): [True: 540k, False: 2.62M]
  |  |  |  Branch (18:140): [True: 52.8k, False: 3.11M]
  |  |  |  Branch (18:150): [True: 17.0k, False: 3.15M]
  |  |  |  Branch (18:160): [True: 18.3k, False: 3.14M]
  |  |  |  Branch (18:170): [True: 10.7k, False: 3.15M]
  |  |  |  Branch (18:180): [True: 7.17k, False: 3.16M]
  |  |  |  Branch (18:190): [True: 3.13k, False: 3.16M]
  |  |  |  Branch (18:200): [True: 5.21k, False: 3.16M]
  |  |  |  Branch (18:210): [True: 2.74k, False: 3.16M]
  |  |  |  Branch (18:220): [True: 25.0k, False: 3.14M]
  |  |  ------------------
  ------------------
  |  Branch (1477:21): [True: 529k, False: 2.63M]
  ------------------
 1478|  2.51M|                    {
 1479|  2.51M|                        val = static_cast<int8_t>(- 1 - info);
 1480|  2.51M|                        break;
 1481|  37.8M|                    }
 1482|  69.4k|                    case 0x18: // Negative integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1482:21): [True: 69.4k, False: 3.09M]
  ------------------
 1483|  69.4k|                        {
 1484|  69.4k|                            uint8_t b;
 1485|  69.4k|                            if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1485:33): [True: 7, False: 69.4k]
  ------------------
 1486|      7|                            {
 1487|      7|                                ec = cbor_errc::unexpected_eof;
 1488|      7|                                more_ = false;
 1489|      7|                                return val;
 1490|      7|                            }
 1491|  69.4k|                            val = static_cast<int64_t>(-1) - static_cast<int64_t>(b);
 1492|  69.4k|                            break;
 1493|  69.4k|                        }
 1494|       |
 1495|  2.04k|                    case 0x19: // Negative integer -1-n (two-byte uint16_t follows)
  ------------------
  |  Branch (1495:21): [True: 2.04k, False: 3.16M]
  ------------------
 1496|  2.04k|                        {
 1497|  2.04k|                            uint8_t buf[sizeof(uint16_t)];
 1498|  2.04k|                            if (source_.read(buf, sizeof(uint16_t)) != sizeof(uint16_t))
  ------------------
  |  Branch (1498:33): [True: 7, False: 2.03k]
  ------------------
 1499|      7|                            {
 1500|      7|                                ec = cbor_errc::unexpected_eof;
 1501|      7|                                more_ = false;
 1502|      7|                                return val;
 1503|      7|                            }
 1504|  2.03k|                            auto x = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1505|  2.03k|                            val = static_cast<int64_t>(-1)- x;
 1506|  2.03k|                            break;
 1507|  2.04k|                        }
 1508|       |
 1509|  4.58k|                    case 0x1a: // Negative integer -1-n (four-byte uint32_t follows)
  ------------------
  |  Branch (1509:21): [True: 4.58k, False: 3.16M]
  ------------------
 1510|  4.58k|                        {
 1511|  4.58k|                            uint8_t buf[sizeof(uint32_t)];
 1512|  4.58k|                            if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (1512:33): [True: 8, False: 4.57k]
  ------------------
 1513|      8|                            {
 1514|      8|                                ec = cbor_errc::unexpected_eof;
 1515|      8|                                more_ = false;
 1516|      8|                                return val;
 1517|      8|                            }
 1518|  4.57k|                            auto x = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1519|  4.57k|                            val = static_cast<int64_t>(-1)- x;
 1520|  4.57k|                            break;
 1521|  4.58k|                        }
 1522|       |
 1523|  4.37k|                    case 0x1b: // Negative integer -1-n (eight-byte uint64_t follows)
  ------------------
  |  Branch (1523:21): [True: 4.37k, False: 3.16M]
  ------------------
 1524|  4.37k|                        {
 1525|  4.37k|                            uint8_t buf[sizeof(uint64_t)];
 1526|  4.37k|                            if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (1526:33): [True: 11, False: 4.36k]
  ------------------
 1527|     11|                            {
 1528|     11|                                ec = cbor_errc::unexpected_eof;
 1529|     11|                                more_ = false;
 1530|     11|                                return val;
 1531|     11|                            }
 1532|  4.36k|                            auto x = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1533|  4.36k|                            val = static_cast<int64_t>(-1)- static_cast<int64_t>(x);
 1534|  4.36k|                            break;
 1535|  4.37k|                        }
 1536|  3.16M|                }
 1537|  3.16M|                break;
 1538|       |
 1539|  3.16M|                case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1539:17): [True: 0, False: 3.16M]
  ------------------
 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: 3.16M]
  ------------------
 1559|      0|                break;
 1560|  3.16M|        }
 1561|       |
 1562|  3.16M|        return val;
 1563|  3.16M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_sourceC2EPS8_:
  199|  7.85M|            : source(source)
  200|  7.85M|        {
  201|  7.85M|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringINS8_28read_byte_string_from_sourceEEEvT_RNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 2033|  7.85M|    {
 2034|  7.85M|        if (other_tags_[item_tag])
  ------------------
  |  Branch (2034:13): [True: 160k, False: 7.69M]
  ------------------
 2035|   160k|        {
 2036|   160k|            switch (raw_tag_)
 2037|   160k|            {
 2038|  33.1k|                case 0x2:
  ------------------
  |  Branch (2038:17): [True: 33.1k, False: 127k]
  ------------------
 2039|  33.1k|                {
 2040|  33.1k|                    auto bytes = read.view(ec);
 2041|  33.1k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  33.1k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 14, False: 33.1k]
  |  |  ------------------
  ------------------
 2042|     14|                    {
 2043|     14|                        more_ = false;
 2044|     14|                        return;
 2045|     14|                    }
 2046|  33.1k|                    bigint n = bigint::from_bytes_be(1, bytes.data(), bytes.size());
 2047|  33.1k|                    text_buffer_.clear();
 2048|  33.1k|                    n.write_string(text_buffer_);
 2049|  33.1k|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2050|  33.1k|                    more_ = !cursor_mode_;
 2051|  33.1k|                    break;
 2052|  33.1k|                }
 2053|  2.50k|                case 0x3:
  ------------------
  |  Branch (2053:17): [True: 2.50k, False: 158k]
  ------------------
 2054|  2.50k|                {
 2055|  2.50k|                    auto bytes = read.view(ec);
 2056|  2.50k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.50k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 11, False: 2.49k]
  |  |  ------------------
  ------------------
 2057|     11|                    {
 2058|     11|                        more_ = false;
 2059|     11|                        return;
 2060|     11|                    }
 2061|  2.49k|                    bigint n = bigint::from_bytes_be(1, bytes.data(), bytes.size());
 2062|  2.49k|                    n = -1 - n;
 2063|  2.49k|                    text_buffer_.clear();
 2064|  2.49k|                    n.write_string(text_buffer_);
 2065|  2.49k|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2066|  2.49k|                    more_ = !cursor_mode_;
 2067|  2.49k|                    break;
 2068|  2.50k|                }
 2069|    843|                case 0x15:
  ------------------
  |  Branch (2069:17): [True: 843, False: 159k]
  ------------------
 2070|  2.10k|                case 0x16:
  ------------------
  |  Branch (2070:17): [True: 1.26k, False: 159k]
  ------------------
 2071|  2.48k|                case 0x17:
  ------------------
  |  Branch (2071:17): [True: 384, False: 160k]
  ------------------
 2072|  2.48k|                {
 2073|  2.48k|                    auto bytes = read.view(ec);
 2074|  2.48k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.48k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 9, False: 2.48k]
  |  |  ------------------
  ------------------
 2075|      9|                    {
 2076|      9|                        more_ = false;
 2077|      9|                        return;
 2078|      9|                    }
 2079|  2.48k|                    const semantic_tag tag = raw_tag_ == 0x15 ? semantic_tag::base64url
  ------------------
  |  Branch (2079:46): [True: 841, False: 1.63k]
  ------------------
 2080|  2.48k|                        : raw_tag_ == 0x16 ? semantic_tag::base64
  ------------------
  |  Branch (2080:27): [True: 1.25k, False: 382]
  ------------------
 2081|  1.63k|                        : semantic_tag::base16;
 2082|  2.48k|                    visitor.byte_string_value(bytes, tag, *this, ec);
 2083|  2.48k|                    more_ = !cursor_mode_;
 2084|  2.48k|                    break;
 2085|  2.48k|                }
 2086|  4.92k|                case 0x40:
  ------------------
  |  Branch (2086:17): [True: 4.92k, False: 155k]
  ------------------
 2087|  4.92k|                {
 2088|  4.92k|                    array_tag_ = typed_array_tags::uint8;
 2089|  4.92k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2090|  4.92k|                    read(array_buffer, ec);
 2091|  4.92k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.92k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 4.91k]
  |  |  ------------------
  ------------------
 2092|      4|                    {
 2093|      4|                        more_ = false;
 2094|      4|                        return;
 2095|      4|                    }
 2096|  4.91k|                    auto ta = typed_array_cast<const uint8_t>(array_buffer);
 2097|  4.91k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2097:25): [True: 4.91k, False: 0]
  |  Branch (2097:42): [True: 0, False: 4.91k]
  ------------------
 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|  4.91k|                    else
 2111|  4.91k|                    {
 2112|  4.91k|                        auto iter = std::make_shared<oned_typed_array_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2113|  4.91k|                            typed_array_tags::uint8, semantic_tag::none, alloc_);
 2114|  4.91k|                        typed_array_stack_.push_back(iter);
 2115|  4.91k|                        iter->next(visitor, *this, ec);
 2116|  4.91k|                    }
 2117|  4.91k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2118|  4.91k|                    more_ = !cursor_mode_;
 2119|  4.91k|                    break;
 2120|  4.91k|                }
 2121|  1.06k|                case 0x44:
  ------------------
  |  Branch (2121:17): [True: 1.06k, False: 159k]
  ------------------
 2122|  1.06k|                {
 2123|  1.06k|                    array_tag_ = typed_array_tags::uint8;
 2124|  1.06k|                    typed_array_tag_ = semantic_tag::clamped;
 2125|  1.06k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2126|  1.06k|                    read(array_buffer, ec);
 2127|  1.06k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.06k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 14, False: 1.05k]
  |  |  ------------------
  ------------------
 2128|     14|                    {
 2129|     14|                        more_ = false;
 2130|     14|                        return;
 2131|     14|                    }
 2132|  1.05k|                    auto ta = typed_array_cast<const uint8_t>(array_buffer);
 2133|  1.05k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2133:25): [True: 1.05k, False: 0]
  |  Branch (2133:42): [True: 0, False: 1.05k]
  ------------------
 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|  1.05k|                    else
 2147|  1.05k|                    {
 2148|  1.05k|                        auto iter = std::make_shared<oned_typed_array_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2149|  1.05k|                            typed_array_tags::uint8, semantic_tag::clamped, alloc_);
 2150|  1.05k|                        typed_array_stack_.push_back(iter);
 2151|  1.05k|                        iter->next(visitor, *this, ec);
 2152|  1.05k|                    }
 2153|  1.05k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2154|  1.05k|                    more_ = !cursor_mode_;
 2155|  1.05k|                    break;
 2156|  1.05k|                }
 2157|  2.06k|                case 0x41:
  ------------------
  |  Branch (2157:17): [True: 2.06k, False: 158k]
  ------------------
 2158|  3.05k|                case 0x45:
  ------------------
  |  Branch (2158:17): [True: 993, False: 159k]
  ------------------
 2159|  3.05k|                {
 2160|  3.05k|                    array_tag_ = typed_array_tags::uint16;
 2161|  3.05k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2162|  3.05k|                    read(array_buffer, ec);
 2163|  3.05k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.05k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 8, False: 3.04k]
  |  |  ------------------
  ------------------
 2164|      8|                    {
 2165|      8|                        more_ = false;
 2166|      8|                        return;
 2167|      8|                    }
 2168|  3.04k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2169|  3.04k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2170|  3.04k|                    auto ta = typed_array_cast<uint16_t>(array_buffer);
 2171|  3.04k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2171:25): [True: 2.05k, False: 993]
  ------------------
 2172|  2.05k|                    {
 2173|  7.74k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2173:49): [True: 5.69k, False: 2.05k]
  ------------------
 2174|  5.69k|                        {
 2175|  5.69k|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2176|  5.69k|                        }
 2177|  2.05k|                    }
 2178|  3.04k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2178:25): [True: 3.04k, False: 0]
  |  Branch (2178:42): [True: 0, False: 3.04k]
  ------------------
 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|  3.04k|                    else
 2192|  3.04k|                    {
 2193|  3.04k|                        auto iter = std::make_shared<oned_typed_array_iterator<uint16_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2194|  3.04k|                            typed_array_tags::uint16, semantic_tag::none, alloc_);
 2195|  3.04k|                        typed_array_stack_.push_back(iter);
 2196|  3.04k|                        iter->next(visitor, *this, ec);
 2197|  3.04k|                    }
 2198|  3.04k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2199|  3.04k|                    more_ = !cursor_mode_;
 2200|  3.04k|                    break;
 2201|  3.04k|                }
 2202|  4.02k|                case 0x42:
  ------------------
  |  Branch (2202:17): [True: 4.02k, False: 156k]
  ------------------
 2203|  4.45k|                case 0x46:
  ------------------
  |  Branch (2203:17): [True: 432, False: 160k]
  ------------------
 2204|  4.45k|                {
 2205|  4.45k|                    array_tag_ = typed_array_tags::uint32;
 2206|  4.45k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2207|  4.45k|                    read(array_buffer, ec);
 2208|  4.45k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.45k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 11, False: 4.44k]
  |  |  ------------------
  ------------------
 2209|     11|                    {
 2210|     11|                        more_ = false;
 2211|     11|                        return;
 2212|     11|                    }
 2213|  4.44k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2214|  4.44k|                    jsoncons::endian e = get_typed_array_endianness(tag);
 2215|  4.44k|                    auto ta = typed_array_cast<uint32_t>(array_buffer);
 2216|  4.44k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2216:25): [True: 4.01k, False: 432]
  ------------------
 2217|  4.01k|                    {
 2218|   713k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2218:49): [True: 709k, False: 4.01k]
  ------------------
 2219|   709k|                        {
 2220|   709k|                            ta[i] = binary::byte_swap<uint32_t>(ta[i]);
 2221|   709k|                        }
 2222|  4.01k|                    }
 2223|  4.44k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2223:25): [True: 4.44k, False: 0]
  |  Branch (2223:42): [True: 0, False: 4.44k]
  ------------------
 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|  4.44k|                    else
 2237|  4.44k|                    {
 2238|  4.44k|                        auto iter = std::make_shared<oned_typed_array_iterator<uint32_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2239|  4.44k|                            typed_array_tags::uint32, semantic_tag::none, alloc_);
 2240|  4.44k|                        typed_array_stack_.push_back(iter);
 2241|  4.44k|                        iter->next(visitor, *this, ec);
 2242|  4.44k|                    }
 2243|  4.44k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2244|  4.44k|                    more_ = !cursor_mode_;
 2245|  4.44k|                    break;
 2246|  4.44k|                }
 2247|  4.85k|                case 0x43:
  ------------------
  |  Branch (2247:17): [True: 4.85k, False: 155k]
  ------------------
 2248|  5.32k|                case 0x47:
  ------------------
  |  Branch (2248:17): [True: 469, False: 160k]
  ------------------
 2249|  5.32k|                {
 2250|  5.32k|                    array_tag_ = typed_array_tags::uint64;
 2251|  5.32k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2252|  5.32k|                    read(array_buffer, ec);
 2253|  5.32k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  5.32k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 5, False: 5.31k]
  |  |  ------------------
  ------------------
 2254|      5|                    {
 2255|      5|                        more_ = false;
 2256|      5|                        return;
 2257|      5|                    }
 2258|  5.31k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2259|  5.31k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2260|  5.31k|                    auto ta = typed_array_cast<uint64_t>(array_buffer);
 2261|  5.31k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2261:25): [True: 4.85k, False: 468]
  ------------------
 2262|  4.85k|                    {
 2263|   155k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2263:49): [True: 150k, False: 4.85k]
  ------------------
 2264|   150k|                        {
 2265|   150k|                            ta[i] = binary::byte_swap<uint64_t>(ta[i]);
 2266|   150k|                        }
 2267|  4.85k|                    }
 2268|  5.31k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2268:25): [True: 5.31k, False: 0]
  |  Branch (2268:42): [True: 0, False: 5.31k]
  ------------------
 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|  5.31k|                    else
 2282|  5.31k|                    {
 2283|  5.31k|                        auto iter = std::make_shared<oned_typed_array_iterator<uint64_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2284|  5.31k|                            typed_array_tags::uint64, semantic_tag::none, alloc_);
 2285|  5.31k|                        typed_array_stack_.push_back(iter);
 2286|  5.31k|                        iter->next(visitor, *this, ec);
 2287|  5.31k|                    }
 2288|  5.31k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2289|  5.31k|                    more_ = !cursor_mode_;
 2290|  5.31k|                    break;
 2291|  5.31k|                }
 2292|  3.53k|                case 0x48:
  ------------------
  |  Branch (2292:17): [True: 3.53k, False: 157k]
  ------------------
 2293|  3.53k|                {
 2294|  3.53k|                    array_tag_ = typed_array_tags::int8;
 2295|  3.53k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2296|  3.53k|                    read(array_buffer, ec);
 2297|  3.53k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.53k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 13, False: 3.52k]
  |  |  ------------------
  ------------------
 2298|     13|                    {
 2299|     13|                        more_ = false;
 2300|     13|                        return;
 2301|     13|                    }
 2302|  3.52k|                    auto ta = typed_array_cast<int8_t>(array_buffer);
 2303|  3.52k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2303:25): [True: 3.52k, False: 0]
  |  Branch (2303:42): [True: 0, False: 3.52k]
  ------------------
 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|  3.52k|                    else
 2317|  3.52k|                    {
 2318|  3.52k|                        auto iter = std::make_shared<oned_typed_array_iterator<int8_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2319|  3.52k|                            typed_array_tags::int8, semantic_tag::none, alloc_);
 2320|  3.52k|                        typed_array_stack_.push_back(iter);
 2321|  3.52k|                        iter->next(visitor, *this, ec);
 2322|  3.52k|                    }
 2323|  3.52k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2324|  3.52k|                    more_ = !cursor_mode_;
 2325|  3.52k|                    break;
 2326|  3.52k|                }
 2327|  6.41k|                case 0x49:
  ------------------
  |  Branch (2327:17): [True: 6.41k, False: 154k]
  ------------------
 2328|  6.91k|                case 0x4d:
  ------------------
  |  Branch (2328:17): [True: 502, False: 160k]
  ------------------
 2329|  6.91k|                {
 2330|  6.91k|                    array_tag_ = typed_array_tags::int16;
 2331|  6.91k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2332|  6.91k|                    read(array_buffer, ec);
 2333|  6.91k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  6.91k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 16, False: 6.89k]
  |  |  ------------------
  ------------------
 2334|     16|                    {
 2335|     16|                        more_ = false;
 2336|     16|                        return;
 2337|     16|                    }
 2338|  6.89k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2339|  6.89k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2340|  6.89k|                    auto ta = typed_array_cast<int16_t>(array_buffer);
 2341|  6.89k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2341:25): [True: 6.39k, False: 499]
  ------------------
 2342|  6.39k|                    {
 2343|   167k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2343:49): [True: 161k, False: 6.39k]
  ------------------
 2344|   161k|                        {
 2345|   161k|                            ta[i] = binary::byte_swap<int16_t>(ta[i]);
 2346|   161k|                        }
 2347|  6.39k|                    }
 2348|  6.89k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2348:25): [True: 6.89k, False: 0]
  |  Branch (2348:42): [True: 0, False: 6.89k]
  ------------------
 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|  6.89k|                    else
 2362|  6.89k|                    {
 2363|  6.89k|                        auto iter = std::make_shared<oned_typed_array_iterator<int16_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2364|  6.89k|                            typed_array_tags::int16, semantic_tag::none, alloc_);
 2365|  6.89k|                        typed_array_stack_.push_back(iter);
 2366|  6.89k|                        iter->next(visitor, *this, ec);
 2367|  6.89k|                    }
 2368|  6.89k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2369|  6.89k|                    more_ = !cursor_mode_;
 2370|  6.89k|                    break;
 2371|  6.89k|                }
 2372|  5.98k|                case 0x4a:
  ------------------
  |  Branch (2372:17): [True: 5.98k, False: 154k]
  ------------------
 2373|  6.25k|                case 0x4e:
  ------------------
  |  Branch (2373:17): [True: 269, False: 160k]
  ------------------
 2374|  6.25k|                {
 2375|  6.25k|                    array_tag_ = typed_array_tags::int32;
 2376|  6.25k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2377|  6.25k|                    read(array_buffer, ec);
 2378|  6.25k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  6.25k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 21, False: 6.22k]
  |  |  ------------------
  ------------------
 2379|     21|                    {
 2380|     21|                        more_ = false;
 2381|     21|                        return;
 2382|     21|                    }
 2383|  6.22k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2384|  6.22k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2385|  6.22k|                    auto ta = typed_array_cast<int32_t>(array_buffer);
 2386|  6.22k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2386:25): [True: 5.96k, False: 265]
  ------------------
 2387|  5.96k|                    {
 2388|  44.1k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2388:49): [True: 38.2k, False: 5.96k]
  ------------------
 2389|  38.2k|                        {
 2390|  38.2k|                            ta[i] = binary::byte_swap<int32_t>(ta[i]);
 2391|  38.2k|                        }
 2392|  5.96k|                    }
 2393|  6.22k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2393:25): [True: 6.22k, False: 0]
  |  Branch (2393:42): [True: 0, False: 6.22k]
  ------------------
 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|  6.22k|                    else
 2407|  6.22k|                    {
 2408|  6.22k|                        auto iter = std::make_shared<oned_typed_array_iterator<int32_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2409|  6.22k|                            typed_array_tags::int32, semantic_tag::none, alloc_);
 2410|  6.22k|                        typed_array_stack_.push_back(iter);
 2411|  6.22k|                        iter->next(visitor, *this, ec);
 2412|  6.22k|                    }
 2413|  6.22k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2414|  6.22k|                    more_ = !cursor_mode_;
 2415|  6.22k|                    break;
 2416|  6.22k|                }
 2417|  2.30k|                case 0x4b:
  ------------------
  |  Branch (2417:17): [True: 2.30k, False: 158k]
  ------------------
 2418|  2.67k|                case 0x4f:
  ------------------
  |  Branch (2418:17): [True: 370, False: 160k]
  ------------------
 2419|  2.67k|                {
 2420|  2.67k|                    array_tag_ = typed_array_tags::int64;
 2421|  2.67k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2422|  2.67k|                    read(array_buffer, ec);
 2423|  2.67k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.67k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 2.67k]
  |  |  ------------------
  ------------------
 2424|      7|                    {
 2425|      7|                        more_ = false;
 2426|      7|                        return;
 2427|      7|                    }
 2428|  2.67k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2429|  2.67k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2430|  2.67k|                    auto ta = typed_array_cast<int64_t>(array_buffer);
 2431|  2.67k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2431:25): [True: 2.30k, False: 369]
  ------------------
 2432|  2.30k|                    {
 2433|  84.1k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2433:49): [True: 81.8k, False: 2.30k]
  ------------------
 2434|  81.8k|                        {
 2435|  81.8k|                            ta[i] = binary::byte_swap<int64_t>(ta[i]);
 2436|  81.8k|                        }
 2437|  2.30k|                    }
 2438|  2.67k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2438:25): [True: 2.67k, False: 0]
  |  Branch (2438:42): [True: 0, False: 2.67k]
  ------------------
 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.67k|                    else
 2452|  2.67k|                    {
 2453|  2.67k|                        auto iter = std::make_shared<oned_typed_array_iterator<int64_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2454|  2.67k|                            typed_array_tags::int64, semantic_tag::none, alloc_);
 2455|  2.67k|                        typed_array_stack_.push_back(iter);
 2456|  2.67k|                        iter->next(visitor, *this, ec);
 2457|  2.67k|                    }
 2458|  2.67k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2459|  2.67k|                    more_ = !cursor_mode_;
 2460|  2.67k|                    break;
 2461|  2.67k|                }
 2462|  4.45k|                case 0x50:
  ------------------
  |  Branch (2462:17): [True: 4.45k, False: 156k]
  ------------------
 2463|  5.30k|                case 0x54:
  ------------------
  |  Branch (2463:17): [True: 851, False: 159k]
  ------------------
 2464|  5.30k|                {
 2465|  5.30k|                    array_tag_ = typed_array_tags::half_float;
 2466|  5.30k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2467|  5.30k|                    read(array_buffer, ec);
 2468|  5.30k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  5.30k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 13, False: 5.29k]
  |  |  ------------------
  ------------------
 2469|     13|                    {
 2470|     13|                        more_ = false;
 2471|     13|                        return;
 2472|     13|                    }
 2473|  5.29k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2474|  5.29k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2475|  5.29k|                    auto ta = typed_array_cast<uint16_t>(array_buffer);
 2476|  5.29k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2476:25): [True: 4.44k, False: 848]
  ------------------
 2477|  4.44k|                    {
 2478|   114k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2478:49): [True: 110k, False: 4.44k]
  ------------------
 2479|   110k|                        {
 2480|   110k|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2481|   110k|                        }
 2482|  4.44k|                    }
 2483|  5.29k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2483:25): [True: 5.29k, False: 0]
  |  Branch (2483:42): [True: 0, False: 5.29k]
  ------------------
 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|  5.29k|                    else
 2497|  5.29k|                    {
 2498|  5.29k|                        auto iter = std::make_shared<oned_typed_array_iterator<uint16_t,decode_half,Allocator>>(std::move(array_buffer),
 2499|  5.29k|                            typed_array_tags::half_float, semantic_tag::none, alloc_);
 2500|  5.29k|                        typed_array_stack_.push_back(iter);
 2501|  5.29k|                        iter->next(visitor, *this, ec);
 2502|  5.29k|                    }
 2503|  5.29k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2504|  5.29k|                    more_ = !cursor_mode_;
 2505|  5.29k|                    break;
 2506|  5.29k|                }
 2507|    947|                case 0x51:
  ------------------
  |  Branch (2507:17): [True: 947, False: 159k]
  ------------------
 2508|  9.65k|                case 0x55:
  ------------------
  |  Branch (2508:17): [True: 8.70k, False: 151k]
  ------------------
 2509|  9.65k|                {
 2510|  9.65k|                    array_tag_ = typed_array_tags::float32;
 2511|  9.65k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2512|  9.65k|                    read(array_buffer, ec);
 2513|  9.65k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  9.65k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 9.64k]
  |  |  ------------------
  ------------------
 2514|      7|                    {
 2515|      7|                        more_ = false;
 2516|      7|                        return;
 2517|      7|                    }
 2518|  9.64k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2519|  9.64k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2520|  9.64k|                    auto ta = typed_array_cast<float>(array_buffer);
 2521|  9.64k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2521:25): [True: 941, False: 8.70k]
  ------------------
 2522|    941|                    {
 2523|   146k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2523:49): [True: 145k, False: 941]
  ------------------
 2524|   145k|                        {
 2525|   145k|                            ta[i] = binary::byte_swap<float>(ta[i]);
 2526|   145k|                        }
 2527|    941|                    }
 2528|  9.64k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2528:25): [True: 9.64k, False: 0]
  |  Branch (2528:42): [True: 0, False: 9.64k]
  ------------------
 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|  9.64k|                    else
 2542|  9.64k|                    {
 2543|  9.64k|                        auto iter = std::make_shared<oned_typed_array_iterator<float,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2544|  9.64k|                            typed_array_tags::float32, semantic_tag::none, alloc_);
 2545|  9.64k|                        typed_array_stack_.push_back(iter);
 2546|  9.64k|                        iter->next(visitor, *this, ec);
 2547|  9.64k|                    }
 2548|  9.64k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2549|  9.64k|                    more_ = !cursor_mode_;
 2550|  9.64k|                    break;
 2551|  9.64k|                }
 2552|  1.98k|                case 0x52:
  ------------------
  |  Branch (2552:17): [True: 1.98k, False: 158k]
  ------------------
 2553|  4.42k|                case 0x56:
  ------------------
  |  Branch (2553:17): [True: 2.44k, False: 158k]
  ------------------
 2554|  4.42k|                {
 2555|  4.42k|                    array_tag_ = typed_array_tags::float64;
 2556|  4.42k|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2557|  4.42k|                    read(array_buffer, ec);
 2558|  4.42k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.42k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 27, False: 4.40k]
  |  |  ------------------
  ------------------
 2559|     27|                    {
 2560|     27|                        more_ = false;
 2561|     27|                        return;
 2562|     27|                    }
 2563|  4.40k|                    const uint8_t tag = (uint8_t)raw_tag_;
 2564|  4.40k|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2565|  4.40k|                    auto ta = typed_array_cast<double>(array_buffer);
 2566|  4.40k|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2566:25): [True: 1.95k, False: 2.44k]
  ------------------
 2567|  1.95k|                    {
 2568|  26.9k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2568:49): [True: 24.9k, False: 1.95k]
  ------------------
 2569|  24.9k|                        {
 2570|  24.9k|                            ta[i] = binary::byte_swap<double>(ta[i]);
 2571|  24.9k|                        }
 2572|  1.95k|                    }
 2573|  4.40k|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2573:25): [True: 4.40k, False: 0]
  |  Branch (2573:42): [True: 0, False: 4.40k]
  ------------------
 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|  4.40k|                    else
 2587|  4.40k|                    {
 2588|  4.40k|                        auto iter = std::make_shared<oned_typed_array_iterator<double,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2589|  4.40k|                            typed_array_tags::float64, semantic_tag::none, alloc_);
 2590|  4.40k|                        typed_array_stack_.push_back(iter);
 2591|  4.40k|                        iter->next(visitor, *this, ec);
 2592|  4.40k|                    }
 2593|  4.40k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2594|  4.40k|                    more_ = !cursor_mode_;
 2595|  4.40k|                    break;
 2596|  4.40k|                }
 2597|  64.8k|                default:
  ------------------
  |  Branch (2597:17): [True: 64.8k, False: 95.7k]
  ------------------
 2598|  64.8k|                {
 2599|  64.8k|                    auto bytes = read.view(ec);
 2600|  64.8k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  64.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 26, False: 64.8k]
  |  |  ------------------
  ------------------
 2601|     26|                    {
 2602|     26|                        more_ = false;
 2603|     26|                        return;
 2604|     26|                    }
 2605|  64.8k|                    visitor.byte_string_value(bytes, raw_tag_, *this, ec);
 2606|  64.8k|                    more_ = !cursor_mode_;
 2607|  64.8k|                    break;
 2608|  64.8k|                }
 2609|   160k|            }
 2610|   160k|            other_tags_[item_tag] = false;
 2611|   160k|        }
 2612|  7.69M|        else
 2613|  7.69M|        {
 2614|  7.69M|            auto bytes = read.view(ec);
 2615|  7.69M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  7.69M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 565, False: 7.69M]
  |  |  ------------------
  ------------------
 2616|    565|            {
 2617|    565|                return;
 2618|    565|            }
 2619|  7.69M|            visitor.byte_string_value(bytes, semantic_tag::none, *this, ec);
 2620|  7.69M|            more_ = !cursor_mode_;
 2621|  7.69M|        }
 2622|  7.85M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_source4viewERNS3_10error_codeE:
  209|  7.79M|        {
  210|  7.79M|            return source->read_byte_string_view(ec);
  211|  7.79M|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_byte_string_viewERNS3_10error_codeE:
 1208|  7.79M|    {
 1209|  7.79M|        auto c = source_.peek();
 1210|  7.79M|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  7.79M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 7.79M]
  |  |  ------------------
  ------------------
 1211|      0|        {
 1212|      0|            ec = cbor_errc::unexpected_eof;
 1213|      0|            more_ = false;
 1214|      0|            return byte_string_view();
 1215|      0|        }
 1216|  7.79M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1217|  7.79M|        uint8_t info = get_additional_information_value(c.value);
 1218|       |
 1219|  7.79M|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::byte_string);
  ------------------
  |  |   49|  7.79M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 7.79M]
  |  |  ------------------
  |  |   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|  7.79M|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1221:13): [True: 699, False: 7.79M]
  ------------------
 1222|    699|        {
 1223|    699|            bytes_buffer_.clear();
 1224|    699|            source_.ignore(1);
 1225|    699|            iterate_string_chunks(bytes_buffer_, major_type, ec);
 1226|    699|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    699|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 167, False: 532]
  |  |  ------------------
  ------------------
 1227|    167|            {
 1228|    167|                return byte_string_view();
 1229|    167|            }
 1230|    532|            return byte_string_view(bytes_buffer_.data(), bytes_buffer_.size());
 1231|    699|        }
 1232|       |
 1233|  7.79M|        std::size_t length = read_size(ec);
 1234|  7.79M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  7.79M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 95, False: 7.79M]
  |  |  ------------------
  ------------------
 1235|     95|        {
 1236|     95|            return byte_string_view();
 1237|     95|        }
 1238|  7.79M|        auto data = source_.read_span(length, bytes_buffer_);
 1239|  7.79M|        if (data.size() != length)
  ------------------
  |  Branch (1239:13): [True: 363, False: 7.79M]
  ------------------
 1240|    363|        {
 1241|    363|            ec = cbor_errc::unexpected_eof;
 1242|    363|            more_ = false;
 1243|    363|            return byte_string_view();
 1244|    363|        }
 1245|       |        
 1246|  7.79M|        byte_string_view bytes(data.data(), data.size());
 1247|  7.79M|        if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1247:13): [True: 3.79M, False: 4.00M]
  ------------------
 1248|  3.79M|            bytes.size() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1248:13): [True: 3.21M, False: 576k]
  ------------------
 1249|  3.21M|        {
 1250|  3.21M|            stringref_map_stack_.back().emplace_back(mapped_string(bytes, alloc_));
 1251|  3.21M|        }
 1252|  7.79M|        return bytes;
 1253|  7.79M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21iterate_string_chunksINS3_6vectorIhS5_EEEEvRT_NS0_6detail15cbor_major_typeERNS3_10error_codeE:
 1316|    765|    {
 1317|    765|        bool done = false;
 1318|   115k|        while (!done)
  ------------------
  |  Branch (1318:16): [True: 114k, False: 578]
  ------------------
 1319|   114k|        {
 1320|   114k|            auto c = source_.peek();
 1321|   114k|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   114k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 26, False: 114k]
  |  |  ------------------
  ------------------
 1322|     26|            {
 1323|     26|                ec = cbor_errc::unexpected_eof;
 1324|     26|                more_ = false;
 1325|     26|                return;
 1326|     26|            }
 1327|   114k|            if (c.value == 0xff)
  ------------------
  |  Branch (1327:17): [True: 578, False: 114k]
  ------------------
 1328|    578|            {
 1329|    578|                done = true;
 1330|    578|                source_.ignore(1);
 1331|    578|                continue;
 1332|    578|            }
 1333|       |
 1334|   114k|            jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1335|   114k|            if (major_type != type)
  ------------------
  |  Branch (1335:17): [True: 27, False: 114k]
  ------------------
 1336|     27|            {
 1337|     27|                ec = cbor_errc::illegal_chunked_string;
 1338|     27|                more_ = false;
 1339|     27|                return;
 1340|     27|            }
 1341|   114k|            uint8_t info = get_additional_information_value(c.value);
 1342|   114k|            if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1342:17): [True: 8, False: 114k]
  ------------------
 1343|      8|            {
 1344|      8|                ec = cbor_errc::illegal_chunked_string;
 1345|      8|                more_ = false;
 1346|      8|                return;
 1347|      8|            }
 1348|       |
 1349|   114k|            std::size_t length = read_size(ec);
 1350|   114k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   114k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 46, False: 114k]
  |  |  ------------------
  ------------------
 1351|     46|            {
 1352|     46|                return;
 1353|     46|            }
 1354|   114k|            const std::size_t offset = v.size();
 1355|   114k|            if (source_reader<Source>::read(source_, v, length) != length)
  ------------------
  |  Branch (1355:17): [True: 80, False: 113k]
  ------------------
 1356|     80|            {
 1357|     80|                ec = cbor_errc::unexpected_eof;
 1358|     80|            }
 1359|   114k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   114k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 80, False: 113k]
  |  |  ------------------
  ------------------
 1360|     80|            {
 1361|     80|                return;
 1362|     80|            }
 1363|   113k|            if (type == jsoncons::cbor::detail::cbor_major_type::text_string)
  ------------------
  |  Branch (1363:17): [True: 0, False: 113k]
  ------------------
 1364|      0|            {
 1365|       |                // RFC 8949 3.2.3: each chunk of an indefinite-length text
 1366|       |                // string must itself be well-formed UTF-8, so a code point
 1367|       |                // may not be split across chunks.
 1368|      0|                auto result = unicode_traits::validate(
 1369|      0|                    reinterpret_cast<const char*>(v.data()) + offset, length);
 1370|      0|                if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (1370:21): [True: 0, False: 0]
  ------------------
 1371|      0|                {
 1372|      0|                    ec = cbor_errc::invalid_utf8_text_string;
 1373|      0|                    more_ = false;
 1374|      0|                    return;
 1375|      0|                }
 1376|      0|            }
 1377|   113k|        }
 1378|    765|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_sizeERNS3_10error_codeE:
 1256|  18.6M|    {
 1257|  18.6M|        uint64_t u = read_uint64(ec);
 1258|  18.6M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  18.6M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 587, False: 18.6M]
  |  |  ------------------
  ------------------
 1259|    587|        {
 1260|    587|            return 0;
 1261|    587|        }
 1262|  18.6M|        std::size_t len = static_cast<std::size_t>(u);
 1263|  18.6M|        if (len != u)
  ------------------
  |  Branch (1263:13): [True: 0, False: 18.6M]
  ------------------
 1264|      0|        {
 1265|      0|            ec = cbor_errc::number_too_large;
 1266|      0|            more_ = false;
 1267|      0|        }
 1268|  18.6M|        return len;
 1269|  18.6M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringC2EOS9_:
  120|  8.54M|        mapped_string(mapped_string&&) = default;
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringC2ERKNS_16byte_string_viewERKS7_:
  109|  3.21M|            : type(jsoncons::cbor::detail::cbor_major_type::byte_string), str(alloc), bytes(bytes.begin(),bytes.end(),alloc)
  110|  3.21M|        {
  111|  3.21M|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_sourceclINS3_6vectorIhS5_EEEEvRT_RNS3_10error_codeE:
  204|  57.5k|        {
  205|  57.5k|            source->read_byte_string(cont,ec);
  206|  57.5k|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringERNS3_6vectorIhS5_EERNS3_10error_codeE:
 1272|   516k|    {
 1273|   516k|        v.clear();
 1274|   516k|        auto c = source_.peek();
 1275|   516k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   516k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 516k]
  |  |  ------------------
  ------------------
 1276|      0|        {
 1277|      0|            ec = cbor_errc::unexpected_eof;
 1278|      0|            return;
 1279|      0|        }
 1280|   516k|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1281|   516k|        uint8_t info = get_additional_information_value(c.value);
 1282|       |
 1283|   516k|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::byte_string);
  ------------------
  |  |   49|   516k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 516k]
  |  |  ------------------
  |  |   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|   516k|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1285:13): [True: 66, False: 516k]
  ------------------
 1286|     66|        {
 1287|     66|            source_.ignore(1);
 1288|     66|            iterate_string_chunks(v, major_type, ec);
 1289|     66|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     66|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 20, False: 46]
  |  |  ------------------
  ------------------
 1290|     20|            {
 1291|     20|                return;
 1292|     20|            }
 1293|     66|        }
 1294|   516k|        else 
 1295|   516k|        {
 1296|   516k|            std::size_t length = read_size(ec);
 1297|   516k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   516k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 15, False: 516k]
  |  |  ------------------
  ------------------
 1298|     15|            {
 1299|     15|                return;
 1300|     15|            }
 1301|   516k|            if (source_reader<Source>::read(source_, v, length) != length)
  ------------------
  |  Branch (1301:17): [True: 136, False: 516k]
  ------------------
 1302|    136|            {
 1303|    136|                ec = cbor_errc::unexpected_eof;
 1304|    136|                return;
 1305|    136|            }
 1306|   516k|            if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1306:17): [True: 220k, False: 295k]
  ------------------
 1307|   220k|                v.size() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1307:17): [True: 5.23k, False: 215k]
  ------------------
 1308|  5.23k|            {
 1309|  5.23k|                stringref_map_stack_.back().emplace_back(mapped_string(v, alloc_));
 1310|  5.23k|            }
 1311|   516k|        }
 1312|   516k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringC2ERKNS3_6vectorIhS5_EERKS7_:
  103|  5.23k|            : type(jsoncons::cbor::detail::cbor_major_type::byte_string), str(alloc), bytes(bytes,alloc)
  104|  5.23k|        {
  105|  5.23k|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_text_string_viewERNS3_10error_codeE:
 1119|   532k|    {
 1120|   532k|        auto c = source_.peek();
 1121|   532k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   532k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 532k]
  |  |  ------------------
  ------------------
 1122|      0|        {
 1123|      0|            ec = cbor_errc::unexpected_eof;
 1124|      0|            more_ = false;
 1125|      0|            return string_view_type();
 1126|      0|        }
 1127|   532k|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1128|   532k|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::text_string);
  ------------------
  |  |   49|   532k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 532k]
  |  |  ------------------
  |  |   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|   532k|        uint8_t info = get_additional_information_value(c.value);
 1130|       |
 1131|   532k|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1131:13): [True: 866, False: 531k]
  ------------------
 1132|    866|        {
 1133|    866|            text_buffer_.clear();
 1134|    866|            source_.ignore(1);
 1135|    866|            iterate_string_chunks(text_buffer_, major_type, ec);
 1136|    866|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    866|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 152, False: 714]
  |  |  ------------------
  ------------------
 1137|    152|            {
 1138|    152|                return string_view_type();
 1139|    152|            }
 1140|    714|            return string_view_type(text_buffer_.data(), text_buffer_.size());
 1141|    866|        }
 1142|       |
 1143|   531k|        std::size_t length = read_size(ec);
 1144|   531k|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   531k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 111, False: 531k]
  |  |  ------------------
  ------------------
 1145|    111|        {
 1146|    111|            return string_view_type();
 1147|    111|        }
 1148|   531k|        auto data = source_.read_span(length, text_buffer_);
 1149|   531k|        if (data.size() != length)
  ------------------
  |  Branch (1149:13): [True: 276, False: 531k]
  ------------------
 1150|    276|        {
 1151|    276|            ec = cbor_errc::unexpected_eof;
 1152|    276|            more_ = false;
 1153|    276|            return string_view_type();
 1154|    276|        }
 1155|   531k|        string_view_type sv(reinterpret_cast<const char_type*>(data.data()), data.size());
 1156|   531k|        if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1156:13): [True: 451k, False: 79.7k]
  ------------------
 1157|   451k|            sv.length() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1157:13): [True: 402k, False: 49.2k]
  ------------------
 1158|   402k|        {
 1159|   402k|            stringref_map_stack_.back().emplace_back(mapped_string(sv,alloc_));
 1160|   402k|        }
 1161|   531k|        return sv;
 1162|   531k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21iterate_string_chunksINS3_12basic_stringIcNS3_11char_traitsIcEES7_EEEEvRT_NS0_6detail15cbor_major_typeERNS3_10error_codeE:
 1316|    866|    {
 1317|    866|        bool done = false;
 1318|  2.00k|        while (!done)
  ------------------
  |  Branch (1318:16): [True: 1.28k, False: 714]
  ------------------
 1319|  1.28k|        {
 1320|  1.28k|            auto c = source_.peek();
 1321|  1.28k|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.28k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 17, False: 1.27k]
  |  |  ------------------
  ------------------
 1322|     17|            {
 1323|     17|                ec = cbor_errc::unexpected_eof;
 1324|     17|                more_ = false;
 1325|     17|                return;
 1326|     17|            }
 1327|  1.27k|            if (c.value == 0xff)
  ------------------
  |  Branch (1327:17): [True: 714, False: 556]
  ------------------
 1328|    714|            {
 1329|    714|                done = true;
 1330|    714|                source_.ignore(1);
 1331|    714|                continue;
 1332|    714|            }
 1333|       |
 1334|    556|            jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1335|    556|            if (major_type != type)
  ------------------
  |  Branch (1335:17): [True: 20, False: 536]
  ------------------
 1336|     20|            {
 1337|     20|                ec = cbor_errc::illegal_chunked_string;
 1338|     20|                more_ = false;
 1339|     20|                return;
 1340|     20|            }
 1341|    536|            uint8_t info = get_additional_information_value(c.value);
 1342|    536|            if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1342:17): [True: 14, False: 522]
  ------------------
 1343|     14|            {
 1344|     14|                ec = cbor_errc::illegal_chunked_string;
 1345|     14|                more_ = false;
 1346|     14|                return;
 1347|     14|            }
 1348|       |
 1349|    522|            std::size_t length = read_size(ec);
 1350|    522|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    522|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 12, False: 510]
  |  |  ------------------
  ------------------
 1351|     12|            {
 1352|     12|                return;
 1353|     12|            }
 1354|    510|            const std::size_t offset = v.size();
 1355|    510|            if (source_reader<Source>::read(source_, v, length) != length)
  ------------------
  |  Branch (1355:17): [True: 79, False: 431]
  ------------------
 1356|     79|            {
 1357|     79|                ec = cbor_errc::unexpected_eof;
 1358|     79|            }
 1359|    510|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    510|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 79, False: 431]
  |  |  ------------------
  ------------------
 1360|     79|            {
 1361|     79|                return;
 1362|     79|            }
 1363|    431|            if (type == jsoncons::cbor::detail::cbor_major_type::text_string)
  ------------------
  |  Branch (1363:17): [True: 431, False: 0]
  ------------------
 1364|    431|            {
 1365|       |                // RFC 8949 3.2.3: each chunk of an indefinite-length text
 1366|       |                // string must itself be well-formed UTF-8, so a code point
 1367|       |                // may not be split across chunks.
 1368|    431|                auto result = unicode_traits::validate(
 1369|    431|                    reinterpret_cast<const char*>(v.data()) + offset, length);
 1370|    431|                if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (1370:21): [True: 10, False: 421]
  ------------------
 1371|     10|                {
 1372|     10|                    ec = cbor_errc::invalid_utf8_text_string;
 1373|     10|                    more_ = false;
 1374|     10|                    return;
 1375|     10|                }
 1376|    431|            }
 1377|    431|        }
 1378|    866|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringC2ERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKS7_:
   92|   402k|            : type(jsoncons::cbor::detail::cbor_major_type::text_string), str(sv.data(), sv.size(), alloc), bytes(alloc)
   93|   402k|        {
   94|   402k|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11read_doubleERNS3_10error_codeE:
 1566|  13.4k|    {
 1567|  13.4k|        double val = 0;
 1568|       |
 1569|  13.4k|        uint8_t b;
 1570|  13.4k|        if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1570:13): [True: 0, False: 13.4k]
  ------------------
 1571|      0|        {
 1572|      0|            ec = cbor_errc::unexpected_eof;
 1573|      0|            more_ = false;
 1574|      0|            return 0;
 1575|      0|        }
 1576|  13.4k|        uint8_t info = get_additional_information_value(b);
 1577|  13.4k|        switch (info)
 1578|  13.4k|        {
 1579|  9.17k|        case 0x1a: // Single-Precision Float (four-byte IEEE 754)
  ------------------
  |  Branch (1579:9): [True: 9.17k, False: 4.28k]
  ------------------
 1580|  9.17k|            {
 1581|  9.17k|                uint8_t buf[sizeof(float)];
 1582|  9.17k|                if (source_.read(buf, sizeof(float)) !=sizeof(float)) 
  ------------------
  |  Branch (1582:21): [True: 25, False: 9.14k]
  ------------------
 1583|     25|                {
 1584|     25|                    ec = cbor_errc::unexpected_eof;
 1585|     25|                    more_ = false;
 1586|     25|                    return 0;
 1587|     25|                }
 1588|  9.14k|                val = binary::big_to_native<float>(buf, sizeof(buf));
 1589|  9.14k|                break;
 1590|  9.17k|            }
 1591|       |
 1592|  4.28k|        case 0x1b: //  Double-Precision Float (eight-byte IEEE 754)
  ------------------
  |  Branch (1592:9): [True: 4.28k, False: 9.17k]
  ------------------
 1593|  4.28k|            {
 1594|  4.28k|                uint8_t buf[sizeof(double)];
 1595|  4.28k|                if (source_.read(buf, sizeof(double)) != sizeof(double))
  ------------------
  |  Branch (1595:21): [True: 25, False: 4.26k]
  ------------------
 1596|     25|                {
 1597|     25|                    ec = cbor_errc::unexpected_eof;
 1598|     25|                    more_ = false;
 1599|     25|                    return 0;
 1600|     25|                }
 1601|  4.26k|                val = binary::big_to_native<double>(buf, sizeof(buf));
 1602|  4.26k|                break;
 1603|  4.28k|            }
 1604|      0|            default:
  ------------------
  |  Branch (1604:13): [True: 0, False: 13.4k]
  ------------------
 1605|      0|                break;
 1606|  13.4k|        }
 1607|       |        
 1608|  13.4k|        return val;
 1609|  13.4k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_decimal_fractionERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 1612|   696k|    {
 1613|   696k|        std::size_t size = read_size(ec);
 1614|   696k|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   696k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 46, False: 696k]
  |  |  ------------------
  ------------------
 1615|     46|        {
 1616|     46|            return;
 1617|     46|        }
 1618|   696k|        if (size != 2)
  ------------------
  |  Branch (1618:13): [True: 37, False: 696k]
  ------------------
 1619|     37|        {
 1620|     37|            ec = cbor_errc::invalid_decimal_fraction;
 1621|     37|            more_ = false;
 1622|     37|            return;
 1623|     37|        }
 1624|       |
 1625|   696k|        auto c = source_.peek();
 1626|   696k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   696k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 21, False: 696k]
  |  |  ------------------
  ------------------
 1627|     21|        {
 1628|     21|            ec = cbor_errc::unexpected_eof;
 1629|     21|            more_ = false;
 1630|     21|            return;
 1631|     21|        }
 1632|   696k|        int32_t exponent = 0;
 1633|   696k|        switch (get_major_type(c.value))
 1634|   696k|        {
 1635|   176k|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1635:13): [True: 176k, False: 519k]
  ------------------
 1636|   176k|            {
 1637|   176k|                auto u = read_uint64(ec);
 1638|   176k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   176k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 176k]
  |  |  ------------------
  ------------------
 1639|      2|                {
 1640|      2|                    return;
 1641|      2|                }
 1642|   176k|                if (u > static_cast<uint64_t>((std::numeric_limits<int>::max)()))
  ------------------
  |  Branch (1642:21): [True: 8, False: 176k]
  ------------------
 1643|      8|                {
 1644|      8|                    ec = cbor_errc::invalid_decimal_fraction;
 1645|      8|                    more_ = false;
 1646|      8|                    return;
 1647|      8|                }
 1648|   176k|                exponent = static_cast<int>(u);
 1649|   176k|                break;
 1650|   176k|            }
 1651|   519k|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1651:13): [True: 519k, False: 176k]
  ------------------
 1652|   519k|            {
 1653|   519k|                auto u = read_int64(ec);
 1654|   519k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   519k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 519k]
  |  |  ------------------
  ------------------
 1655|      3|                {
 1656|      3|                    return;
 1657|      3|                }
 1658|   519k|                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: 51, False: 519k]
  |  Branch (1658:84): [True: 0, False: 519k]
  ------------------
 1659|     51|                {
 1660|     51|                    ec = cbor_errc::invalid_decimal_fraction;
 1661|     51|                    more_ = false;
 1662|     51|                    return;
 1663|     51|                }
 1664|   519k|                exponent = static_cast<int>(u);
 1665|   519k|                break;
 1666|   519k|            }
 1667|     15|            default:
  ------------------
  |  Branch (1667:13): [True: 15, False: 696k]
  ------------------
 1668|     15|            {
 1669|     15|                ec = cbor_errc::invalid_decimal_fraction;
 1670|     15|                more_ = false;
 1671|     15|                return;
 1672|   519k|            }
 1673|   696k|        }
 1674|       |
 1675|   696k|        string_type str(alloc_);
 1676|       |
 1677|   696k|        c = source_.peek();
 1678|   696k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   696k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 20, False: 696k]
  |  |  ------------------
  ------------------
 1679|     20|        {
 1680|     20|            ec = cbor_errc::unexpected_eof;
 1681|     20|            more_ = false;
 1682|     20|            return;
 1683|     20|        }
 1684|       |
 1685|   696k|        switch (get_major_type(c.value))
 1686|   696k|        {
 1687|  5.70k|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1687:13): [True: 5.70k, False: 690k]
  ------------------
 1688|  5.70k|            {
 1689|  5.70k|                uint64_t val = read_uint64(ec);
 1690|  5.70k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  5.70k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 45, False: 5.65k]
  |  |  ------------------
  ------------------
 1691|     45|                {
 1692|     45|                    return;
 1693|     45|                }
 1694|  5.65k|                jsoncons::from_integer(val, str);
 1695|  5.65k|                break;
 1696|  5.70k|            }
 1697|   510k|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1697:13): [True: 510k, False: 185k]
  ------------------
 1698|   510k|            {
 1699|   510k|                int64_t val = read_int64(ec);
 1700|   510k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   510k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 510k]
  |  |  ------------------
  ------------------
 1701|      1|                {
 1702|      1|                    return;
 1703|      1|                }
 1704|   510k|                jsoncons::from_integer(val, str);
 1705|   510k|                break;
 1706|   510k|            }
 1707|   179k|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (1707:13): [True: 179k, False: 516k]
  ------------------
 1708|   179k|            {
 1709|   179k|                uint8_t b;
 1710|   179k|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1710:21): [True: 0, False: 179k]
  ------------------
 1711|      0|                {
 1712|      0|                    ec = cbor_errc::unexpected_eof;
 1713|      0|                    more_ = false;
 1714|      0|                    return;
 1715|      0|                }
 1716|   179k|                uint8_t tag = get_additional_information_value(b);
 1717|   179k|                c = source_.peek();
 1718|   179k|                if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   179k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 8, False: 179k]
  |  |  ------------------
  ------------------
 1719|      8|                {
 1720|      8|                    ec = cbor_errc::unexpected_eof;
 1721|      8|                    more_ = false;
 1722|      8|                    return;
 1723|      8|                }
 1724|       |
 1725|   179k|                if (get_major_type(c.value) == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (1725:21): [True: 179k, False: 20]
  ------------------
 1726|   179k|                {
 1727|   179k|                    bytes_buffer_.clear();
 1728|   179k|                    read_byte_string(bytes_buffer_, ec);
 1729|   179k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   179k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 6, False: 179k]
  |  |  ------------------
  ------------------
 1730|      6|                    {
 1731|      6|                        more_ = false;
 1732|      6|                        return;
 1733|      6|                    }
 1734|   179k|                    if (tag == 2)
  ------------------
  |  Branch (1734:25): [True: 178k, False: 802]
  ------------------
 1735|   178k|                    {
 1736|   178k|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1737|   178k|                        n.write_string(str);
 1738|   178k|                    }
 1739|    802|                    else if (tag == 3)
  ------------------
  |  Branch (1739:30): [True: 794, False: 8]
  ------------------
 1740|    794|                    {
 1741|    794|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1742|    794|                        n = -1 - n;
 1743|    794|                        n.write_string(str);
 1744|    794|                    }
 1745|   179k|                }
 1746|   179k|                break;
 1747|   179k|            }
 1748|   179k|            default:
  ------------------
  |  Branch (1748:13): [True: 14, False: 696k]
  ------------------
 1749|     14|            {
 1750|     14|                ec = cbor_errc::invalid_decimal_fraction;
 1751|     14|                more_ = false;
 1752|     14|                return;
 1753|   179k|            }
 1754|   696k|        }
 1755|       |
 1756|   696k|        if (str.size() > static_cast<std::size_t>((std::numeric_limits<int>::max)()))
  ------------------
  |  Branch (1756:13): [True: 0, False: 696k]
  ------------------
 1757|      0|        {
 1758|      0|            ec = cbor_errc::invalid_decimal_fraction;
 1759|      0|            more_ = false;
 1760|      0|            return;
 1761|      0|        }
 1762|   696k|        int length = static_cast<int>(str.size());
 1763|   696k|        if (length > 0)
  ------------------
  |  Branch (1763:13): [True: 696k, False: 28]
  ------------------
 1764|   696k|        {
 1765|   696k|            if (str[0] == '-')
  ------------------
  |  Branch (1765:17): [True: 511k, False: 184k]
  ------------------
 1766|   511k|            {
 1767|   511k|                result.push_back('-');
 1768|   511k|                jsoncons::prettify_string(str.data()+1, length-1, exponent, -4, 17, result);
 1769|   511k|            }
 1770|   184k|            else
 1771|   184k|            {
 1772|   184k|                jsoncons::prettify_string(str.data(), length, exponent, -4, 17, result);
 1773|   184k|            }
 1774|   696k|        }
 1775|     28|        else
 1776|     28|        {
 1777|     28|            ec = cbor_errc::invalid_decimal_fraction;
 1778|     28|            more_ = false;
 1779|     28|            return;
 1780|     28|        }
 1781|   696k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13read_bigfloatERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 1784|   312k|    {
 1785|   312k|        std::size_t size = read_size(ec);
 1786|   312k|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   312k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 69, False: 312k]
  |  |  ------------------
  ------------------
 1787|     69|        {
 1788|     69|            return;
 1789|     69|        }
 1790|   312k|        if (size != 2)
  ------------------
  |  Branch (1790:13): [True: 22, False: 312k]
  ------------------
 1791|     22|        {
 1792|     22|            ec = cbor_errc::invalid_bigfloat;
 1793|     22|            more_ = false;
 1794|     22|            return;
 1795|     22|        }
 1796|       |
 1797|   312k|        auto c = source_.peek();
 1798|   312k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   312k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 12, False: 312k]
  |  |  ------------------
  ------------------
 1799|     12|        {
 1800|     12|            ec = cbor_errc::unexpected_eof;
 1801|     12|            more_ = false;
 1802|     12|            return;
 1803|     12|        }
 1804|   312k|        int64_t exponent = 0;
 1805|   312k|        switch (get_major_type(c.value))
 1806|   312k|        {
 1807|  5.52k|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1807:13): [True: 5.52k, False: 306k]
  ------------------
 1808|  5.52k|            {
 1809|  5.52k|                exponent = read_uint64(ec);
 1810|  5.52k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  5.52k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 5.52k]
  |  |  ------------------
  ------------------
 1811|      2|                {
 1812|      2|                    return;
 1813|      2|                }
 1814|  5.52k|                break;
 1815|  5.52k|            }
 1816|   306k|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1816:13): [True: 306k, False: 5.54k]
  ------------------
 1817|   306k|            {
 1818|   306k|                exponent = read_int64(ec);
 1819|   306k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   306k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 306k]
  |  |  ------------------
  ------------------
 1820|      2|                {
 1821|      2|                    return;
 1822|      2|                }
 1823|   306k|                break;
 1824|   306k|            }
 1825|   306k|            default:
  ------------------
  |  Branch (1825:13): [True: 15, False: 312k]
  ------------------
 1826|     15|            {
 1827|     15|                ec = cbor_errc::invalid_bigfloat;
 1828|     15|                more_ = false;
 1829|     15|                return;
 1830|   306k|            }
 1831|   312k|        }
 1832|       |
 1833|   312k|        c = source_.peek();
 1834|   312k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   312k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 23, False: 311k]
  |  |  ------------------
  ------------------
 1835|     23|        {
 1836|     23|            ec = cbor_errc::unexpected_eof;
 1837|     23|            more_ = false;
 1838|     23|            return;
 1839|     23|        }
 1840|   311k|        switch (get_major_type(c.value))
 1841|   311k|        {
 1842|  8.46k|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1842:13): [True: 8.46k, False: 303k]
  ------------------
 1843|  8.46k|            {
 1844|  8.46k|                uint64_t val = read_uint64(ec);
 1845|  8.46k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  8.46k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 66, False: 8.40k]
  |  |  ------------------
  ------------------
 1846|     66|                {
 1847|     66|                    return;
 1848|     66|                }
 1849|  8.40k|                str.push_back('0');
 1850|  8.40k|                str.push_back('x');
 1851|  8.40k|                jsoncons::integer_to_hex(val, str);
 1852|  8.40k|                break;
 1853|  8.46k|            }
 1854|  3.75k|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1854:13): [True: 3.75k, False: 308k]
  ------------------
 1855|  3.75k|            {
 1856|  3.75k|                int64_t val = read_int64(ec);
 1857|  3.75k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.75k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 3.75k]
  |  |  ------------------
  ------------------
 1858|      1|                {
 1859|      1|                    return;
 1860|      1|                }
 1861|  3.75k|                str.push_back('-');
 1862|  3.75k|                str.push_back('0');
 1863|  3.75k|                str.push_back('x');
 1864|  3.75k|                jsoncons::integer_to_hex(static_cast<uint64_t>(-1 - val) + 1u, str);
 1865|  3.75k|                break;
 1866|  3.75k|            }
 1867|   299k|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (1867:13): [True: 299k, False: 12.2k]
  ------------------
 1868|   299k|            {
 1869|   299k|                uint8_t b;
 1870|   299k|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1870:21): [True: 0, False: 299k]
  ------------------
 1871|      0|                {
 1872|      0|                    ec = cbor_errc::unexpected_eof;
 1873|      0|                    more_ = false;
 1874|      0|                    return;
 1875|      0|                }
 1876|   299k|                uint8_t tag = get_additional_information_value(b);
 1877|       |
 1878|   299k|                c = source_.peek();
 1879|   299k|                if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   299k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 299k]
  |  |  ------------------
  ------------------
 1880|      7|                {
 1881|      7|                    ec = cbor_errc::unexpected_eof;
 1882|      7|                    more_ = false;
 1883|      7|                    return;
 1884|      7|                }
 1885|       |
 1886|   299k|                if (get_major_type(c.value) == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (1886:21): [True: 279k, False: 20.0k]
  ------------------
 1887|   279k|                {
 1888|   279k|                    bytes_buffer_.clear(); 
 1889|   279k|                    read_byte_string(bytes_buffer_, ec);
 1890|   279k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   279k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 19, False: 279k]
  |  |  ------------------
  ------------------
 1891|     19|                    {
 1892|     19|                        more_ = false;
 1893|     19|                        return;
 1894|     19|                    }
 1895|   279k|                    if (tag == 2)
  ------------------
  |  Branch (1895:25): [True: 10.5k, False: 269k]
  ------------------
 1896|  10.5k|                    {
 1897|  10.5k|                        str.push_back('0');
 1898|  10.5k|                        str.push_back('x');
 1899|  10.5k|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1900|  10.5k|                        n.write_string_hex(str);
 1901|  10.5k|                    }
 1902|   269k|                    else if (tag == 3)
  ------------------
  |  Branch (1902:30): [True: 995, False: 268k]
  ------------------
 1903|    995|                    {
 1904|    995|                        str.push_back('-');
 1905|    995|                        str.push_back('0');
 1906|    995|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1907|    995|                        n = -1 - n;
 1908|    995|                        n.write_string_hex(str);
 1909|    995|                        str[2] = 'x'; // overwrite minus
 1910|    995|                    }
 1911|   279k|                }
 1912|   299k|                break;
 1913|   299k|            }
 1914|   299k|            default:
  ------------------
  |  Branch (1914:13): [True: 11, False: 311k]
  ------------------
 1915|     11|            {
 1916|     11|                ec = cbor_errc::invalid_bigfloat;
 1917|     11|                more_ = false;
 1918|     11|                return;
 1919|   299k|            }
 1920|   311k|        }
 1921|       |
 1922|   311k|        str.push_back('p');
 1923|   311k|        if (exponent >=0)
  ------------------
  |  Branch (1923:13): [True: 5.54k, False: 306k]
  ------------------
 1924|  5.54k|        {
 1925|  5.54k|            jsoncons::integer_to_hex(static_cast<uint64_t>(exponent), str);
 1926|  5.54k|        }
 1927|   306k|        else
 1928|   306k|        {
 1929|   306k|            str.push_back('-');
 1930|   306k|            jsoncons::integer_to_hex(static_cast<uint64_t>(-1 - exponent) + 1u, str);
 1931|   306k|        }
 1932|   311k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE19read_mdarray_headerERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 2625|    548|    {
 2626|    548|        uint8_t b;
 2627|    548|        if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (2627:13): [True: 0, False: 548]
  ------------------
 2628|      0|        {
 2629|      0|            ec = cbor_errc::unexpected_eof;
 2630|      0|            more_ = false;
 2631|      0|            return;
 2632|      0|        }
 2633|    548|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(b);
 2634|    548|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::array);
  ------------------
  |  |   49|    548|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 548]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 2635|    548|        uint8_t info = get_additional_information_value(b);
 2636|       |       
 2637|    548|        read_extents(ec);   
 2638|    548|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    548|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 89, False: 459]
  |  |  ------------------
  ------------------
 2639|     89|        {
 2640|     89|            return;
 2641|     89|        }
 2642|       |
 2643|    459|        read_tags(ec);
 2644|    459|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    459|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 458]
  |  |  ------------------
  ------------------
 2645|      1|        {
 2646|      1|            return;
 2647|      1|        }
 2648|    458|        auto c = source_.peek();
 2649|    458|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|    458|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 458]
  |  |  ------------------
  ------------------
 2650|      0|        {
 2651|      0|            ec = cbor_errc::unexpected_eof;
 2652|      0|            more_ = false;
 2653|      0|            return;
 2654|      0|        }
 2655|    458|        major_type = get_major_type(c.value);
 2656|    458|        info = get_additional_information_value(c.value);
 2657|    458|        state_stack_.emplace_back(parse_mode::multi_dim, 0);
 2658|    458|        ++state_stack_.back().index;
 2659|       |
 2660|    458|        if (major_type == jsoncons::cbor::detail::cbor_major_type::array && order_ == mdarray_order::row_major) 
  ------------------
  |  Branch (2660:13): [True: 455, False: 3]
  |  Branch (2660:77): [True: 455, False: 0]
  ------------------
 2661|    455|        {
 2662|    455|            begin_classical_array_storage(info, ec);
 2663|    455|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    455|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 454]
  |  |  ------------------
  ------------------
 2664|      1|            {
 2665|      1|                return;
 2666|      1|            }
 2667|    454|            auto iter = std::make_shared<cbor_mdarray_row_major_iterator<Source,Allocator>>(extents_, this, cursor_mode_, alloc_);
 2668|    454|            typed_array_stack_.push_back(iter);
 2669|    454|            if (!iter->done())
  ------------------
  |  Branch (2669:17): [True: 454, False: 0]
  ------------------
 2670|    454|            {
 2671|    454|                iter->next(visitor, *this, ec);
 2672|    454|            }
 2673|    454|        }
 2674|      3|        else if (major_type == jsoncons::cbor::detail::cbor_major_type::array && order_ == mdarray_order::column_major) 
  ------------------
  |  Branch (2674:18): [True: 0, False: 3]
  |  Branch (2674:82): [True: 0, False: 0]
  ------------------
 2675|      0|        {
 2676|      0|            begin_classical_array_storage(info, ec);
 2677|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2678|      0|            {
 2679|      0|                return;
 2680|      0|            }
 2681|      0|            auto iter = std::make_shared<cbor_mdarray_column_major_iterator<Source,Allocator>>(extents_, this, cursor_mode_, alloc_);
 2682|      0|            typed_array_stack_.push_back(iter);
 2683|      0|            if (!iter->done())
  ------------------
  |  Branch (2683:17): [True: 0, False: 0]
  ------------------
 2684|      0|            {
 2685|      0|                iter->next(visitor, *this, ec);
 2686|      0|            }
 2687|      0|        }
 2688|      3|        else if (major_type == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (2688:18): [True: 2, False: 1]
  ------------------
 2689|      2|        {
 2690|      2|            std::size_t typed_array_count = typed_array_stack_.size();
 2691|      2|            read_byte_string_from_source read(this);
 2692|      2|            read_byte_string(read, visitor, ec);
 2693|      2|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 1]
  |  |  ------------------
  ------------------
 2694|      1|            {
 2695|      1|                return;
 2696|      1|            }
 2697|      1|            if (typed_array_stack_.size() == typed_array_count)
  ------------------
  |  Branch (2697:17): [True: 1, False: 0]
  ------------------
 2698|      1|            {
 2699|       |                // Byte string storage must be a typed array
 2700|      1|                ec = cbor_errc::bad_mdarray;
 2701|      1|                return;
 2702|      1|            }
 2703|      1|        }
 2704|      1|        else
 2705|      1|        {
 2706|      1|            ec = cbor_errc::bad_mdarray;
 2707|      1|            return;
 2708|      1|        }
 2709|       |        // cursor case
 2710|    458|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12read_extentsERNS3_10error_codeE:
 2713|    548|    {
 2714|    548|        extents_.clear();
 2715|       |
 2716|    548|        auto b = source_.peek();
 2717|    548|        if (JSONCONS_UNLIKELY(b.eof))
  ------------------
  |  |   78|    548|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 545]
  |  |  ------------------
  ------------------
 2718|      3|        {
 2719|      3|            ec = cbor_errc::unexpected_eof;
 2720|      3|            more_ = false;
 2721|      3|            return;
 2722|      3|        }
 2723|    545|        if (get_major_type(b.value) != jsoncons::cbor::detail::cbor_major_type::array)
  ------------------
  |  Branch (2723:13): [True: 35, False: 510]
  ------------------
 2724|     35|        {
 2725|     35|            ec = cbor_errc::bad_extents;
 2726|     35|            more_ = false;
 2727|     35|            return;
 2728|     35|        }
 2729|    510|        uint8_t info = get_additional_information_value(b.value);
 2730|       |
 2731|    510|        switch (info)
 2732|    510|        {
 2733|     23|            case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (2733:13): [True: 23, False: 487]
  ------------------
 2734|     23|            {
 2735|     23|                source_.ignore(1);
 2736|     23|                bool done = false;
 2737|  1.45M|                while (!done)
  ------------------
  |  Branch (2737:24): [True: 1.45M, False: 6]
  ------------------
 2738|  1.45M|                {
 2739|  1.45M|                    auto c = source_.peek();
 2740|  1.45M|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.45M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 15, False: 1.45M]
  |  |  ------------------
  ------------------
 2741|     15|                    {
 2742|     15|                        ec = cbor_errc::unexpected_eof;
 2743|     15|                        more_ = false;
 2744|     15|                        return;
 2745|     15|                    }
 2746|  1.45M|                    if (c.value == 0xff)
  ------------------
  |  Branch (2746:25): [True: 6, False: 1.45M]
  ------------------
 2747|      6|                    {
 2748|      6|                        source_.ignore(1);
 2749|      6|                        done = true;
 2750|      6|                    }
 2751|  1.45M|                    else
 2752|  1.45M|                    {
 2753|  1.45M|                        std::size_t extent = read_size(ec);
 2754|  1.45M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.45M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 1.45M]
  |  |  ------------------
  ------------------
 2755|      2|                        {
 2756|      2|                            more_ = false;
 2757|      2|                            return;
 2758|      2|                        }
 2759|  1.45M|                        extents_.push_back(extent);
 2760|  1.45M|                    }
 2761|  1.45M|                }
 2762|      6|                break;
 2763|     23|            }
 2764|    487|            default:
  ------------------
  |  Branch (2764:13): [True: 487, False: 23]
  ------------------
 2765|    487|            {
 2766|    487|                std::size_t size = read_size(ec);
 2767|    487|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    487|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 480]
  |  |  ------------------
  ------------------
 2768|      7|                {
 2769|      7|                    more_ = false;
 2770|      7|                    return;
 2771|      7|                }
 2772|  89.9k|                for (std::size_t i = 0; more_ && i < size; ++i)
  ------------------
  |  Branch (2772:41): [True: 89.9k, False: 0]
  |  Branch (2772:50): [True: 89.5k, False: 473]
  ------------------
 2773|  89.5k|                {
 2774|  89.5k|                    std::size_t extent = read_size(ec);
 2775|  89.5k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  89.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 89.4k]
  |  |  ------------------
  ------------------
 2776|      7|                    {
 2777|      7|                        more_ = false;
 2778|      7|                        return;
 2779|      7|                    }
 2780|  89.4k|                    extents_.push_back(extent);
 2781|  89.4k|                }
 2782|    473|                break;
 2783|    480|            }
 2784|    510|        }
 2785|    479|        auto r = calculate_mdarray_size(extents_);
 2786|    479|        if (!r || *r == 0)
  ------------------
  |  Branch (2786:13): [True: 17, False: 462]
  |  Branch (2786:19): [True: 3, False: 459]
  ------------------
 2787|     20|        {
 2788|     20|            ec = cbor_errc::bad_extents;
 2789|     20|            more_ = false;
 2790|     20|            return;
 2791|     20|        }
 2792|    459|        mdarray_size_ = *r;
 2793|    459|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE29begin_classical_array_storageEhRNS3_10error_codeE:
  997|    455|    {
  998|    455|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|    455|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 454]
  |  |  ------------------
  ------------------
  999|      1|        {
 1000|      1|            ec = cbor_errc::max_nesting_depth_exceeded;
 1001|      1|            more_ = false;
 1002|      1|            return;
 1003|      1|        }
 1004|    454|        bool pop_stringref_map_stack = false;
 1005|    454|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (1005:13): [True: 52, False: 402]
  ------------------
 1006|     52|        {
 1007|     52|            stringref_map_stack_.emplace_back();
 1008|     52|            other_tags_[stringref_namespace_tag] = false;
 1009|     52|            pop_stringref_map_stack = true;
 1010|     52|        }
 1011|    454|        switch (info)
 1012|    454|        {
 1013|     28|            case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (1013:13): [True: 28, False: 426]
  ------------------
 1014|     28|            {
 1015|     28|                state_stack_.emplace_back(parse_mode::indefinite_array, 0, pop_stringref_map_stack);
 1016|     28|                more_ = !cursor_mode_;
 1017|     28|                source_.ignore(1);
 1018|     28|                break;
 1019|      0|            }
 1020|    426|            default: // definite length
  ------------------
  |  Branch (1020:13): [True: 426, False: 28]
  ------------------
 1021|    426|            {
 1022|    426|                std::size_t len = read_size(ec);
 1023|    426|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    426|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 426]
  |  |  ------------------
  ------------------
 1024|      0|                {
 1025|      0|                    return;
 1026|      0|                }
 1027|    426|                state_stack_.emplace_back(parse_mode::array, len, pop_stringref_map_stack);
 1028|    426|                more_ = !cursor_mode_;
 1029|    426|                break;
 1030|    426|            }
 1031|    454|        }
 1032|    454|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayERNS_21basic_generic_visitorIcEEhRNS3_10error_codeE:
  927|  1.55M|    {
  928|  1.55M|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|  1.55M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 5, False: 1.55M]
  |  |  ------------------
  ------------------
  929|      5|        {
  930|      5|            ec = cbor_errc::max_nesting_depth_exceeded;
  931|      5|            more_ = false;
  932|      5|            return;
  933|      5|        } 
  934|  1.55M|        semantic_tag tag = semantic_tag::none;
  935|  1.55M|        bool pop_stringref_map_stack = false;
  936|  1.55M|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (936:13): [True: 3.29k, False: 1.55M]
  ------------------
  937|  3.29k|        {
  938|  3.29k|            stringref_map_stack_.emplace_back();
  939|  3.29k|            other_tags_[stringref_namespace_tag] = false;
  940|  3.29k|            pop_stringref_map_stack = true;
  941|  3.29k|        }
  942|  1.55M|        switch (info)
  943|  1.55M|        {
  944|   895k|            case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (944:13): [True: 895k, False: 662k]
  ------------------
  945|   895k|            {
  946|   895k|                state_stack_.emplace_back(parse_mode::indefinite_array,0,pop_stringref_map_stack);
  947|   895k|                visitor.begin_array(tag, *this, ec);
  948|   895k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   895k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 895k]
  |  |  ------------------
  ------------------
  949|      0|                {
  950|      0|                    return;
  951|      0|                }
  952|   895k|                more_ = !cursor_mode_;
  953|   895k|                source_.ignore(1);
  954|   895k|                break;
  955|   895k|            }
  956|   662k|            default: // definite length
  ------------------
  |  Branch (956:13): [True: 662k, False: 895k]
  ------------------
  957|   662k|            {
  958|   662k|                std::size_t len = read_size(ec);
  959|   662k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   662k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 108, False: 662k]
  |  |  ------------------
  ------------------
  960|    108|                {
  961|    108|                    return;
  962|    108|                }
  963|   662k|                state_stack_.emplace_back(parse_mode::array,len,pop_stringref_map_stack);
  964|   662k|                visitor.begin_array(len, tag, *this, ec);
  965|   662k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   662k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 662k]
  |  |  ------------------
  ------------------
  966|      0|                {
  967|      0|                    return;
  968|      0|                }
  969|   662k|                more_ = !cursor_mode_;
  970|   662k|                break;
  971|   662k|            }
  972|  1.55M|        }
  973|  1.55M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12begin_objectERNS_21basic_generic_visitorIcEEhRNS3_10error_codeE:
 1051|  6.56M|    {
 1052|  6.56M|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|  6.56M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 6.56M]
  |  |  ------------------
  ------------------
 1053|      4|        {
 1054|      4|            ec = cbor_errc::max_nesting_depth_exceeded;
 1055|      4|            more_ = false;
 1056|      4|            return;
 1057|      4|        } 
 1058|  6.56M|        bool pop_stringref_map_stack = false;
 1059|  6.56M|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (1059:13): [True: 3.50k, False: 6.56M]
  ------------------
 1060|  3.50k|        {
 1061|  3.50k|            stringref_map_stack_.emplace_back();
 1062|  3.50k|            other_tags_[stringref_namespace_tag] = false;
 1063|  3.50k|            pop_stringref_map_stack = true;
 1064|  3.50k|        }
 1065|  6.56M|        switch (info)
 1066|  6.56M|        {
 1067|  55.6k|            case jsoncons::cbor::detail::additional_info::indefinite_length: 
  ------------------
  |  Branch (1067:13): [True: 55.6k, False: 6.50M]
  ------------------
 1068|  55.6k|            {
 1069|  55.6k|                state_stack_.emplace_back(parse_mode::indefinite_map_key,0,pop_stringref_map_stack);
 1070|  55.6k|                visitor.begin_object(semantic_tag::none, *this, ec);
 1071|  55.6k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  55.6k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 55.6k]
  |  |  ------------------
  ------------------
 1072|      0|                {
 1073|      0|                    return;
 1074|      0|                }
 1075|  55.6k|                more_ = !cursor_mode_;
 1076|  55.6k|                source_.ignore(1);
 1077|  55.6k|                break;
 1078|  55.6k|            }
 1079|  6.50M|            default: // definite_length
  ------------------
  |  Branch (1079:13): [True: 6.50M, False: 55.6k]
  ------------------
 1080|  6.50M|            {
 1081|  6.50M|                std::size_t len = read_size(ec);
 1082|  6.50M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  6.50M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 69, False: 6.50M]
  |  |  ------------------
  ------------------
 1083|     69|                {
 1084|     69|                    return;
 1085|     69|                }
 1086|  6.50M|                state_stack_.emplace_back(parse_mode::map_key,len,pop_stringref_map_stack);
 1087|  6.50M|                visitor.begin_object(len, semantic_tag::none, *this, ec);
 1088|  6.50M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  6.50M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 6.50M]
  |  |  ------------------
  ------------------
 1089|      0|                {
 1090|      0|                    return;
 1091|      0|                }
 1092|  6.50M|                more_ = !cursor_mode_;
 1093|  6.50M|                break;
 1094|  6.50M|            }
 1095|  6.56M|        }
 1096|  6.56M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9end_arrayERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  976|  1.50M|    {
  977|  1.50M|        --nesting_depth_;
  978|       |
  979|  1.50M|        visitor.end_array(*this, ec);
  980|  1.50M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.50M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.50M]
  |  |  ------------------
  ------------------
  981|      0|        {
  982|      0|            return;
  983|      0|        }
  984|  1.50M|        more_ = !cursor_mode_;
  985|  1.50M|        if (level() == mark_level_)
  ------------------
  |  Branch (985:13): [True: 0, False: 1.50M]
  ------------------
  986|      0|        {
  987|      0|            more_ = false;
  988|      0|        }
  989|  1.50M|        if (state_stack_.back().pop_stringref_map_stack)
  ------------------
  |  Branch (989:13): [True: 1.54k, False: 1.50M]
  ------------------
  990|  1.54k|        {
  991|  1.54k|            stringref_map_stack_.pop_back();
  992|  1.54k|        }
  993|  1.50M|        state_stack_.pop_back();
  994|  1.50M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10end_objectERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 1099|  6.51M|    {
 1100|  6.51M|        --nesting_depth_;
 1101|  6.51M|        visitor.end_object(*this, ec);
 1102|  6.51M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  6.51M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 6.51M]
  |  |  ------------------
  ------------------
 1103|      0|        {
 1104|      0|            return;
 1105|      0|        }
 1106|  6.51M|        more_ = !cursor_mode_;
 1107|  6.51M|        if (level() == mark_level_)
  ------------------
  |  Branch (1107:13): [True: 0, False: 6.51M]
  ------------------
 1108|      0|        {
 1109|      0|            more_ = false;
 1110|      0|        }
 1111|  6.51M|        if (state_stack_.back().pop_stringref_map_stack)
  ------------------
  |  Branch (1111:13): [True: 413, False: 6.51M]
  ------------------
 1112|    413|        {
 1113|    413|            stringref_map_stack_.pop_back();
 1114|    413|        }
 1115|  6.51M|        state_stack_.pop_back();
 1116|  6.51M|    }

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

_ZN8jsoncons4cbor20typed_array_iteratorD2Ev:
   43|  98.8k|    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|  2.25M|    {
   73|  2.25M|        visitor.uint64_value(val, tag, context, ec);
   74|  2.25M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|  7.28k|        : data_(std::move(data), alloc), 
  107|  7.28k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  7.28k|          array_tag_(array_tag), 
  109|  7.28k|          extent_(span_.size()), 
  110|  7.28k|          tag_(tag), 
  111|  7.28k|          func_(Func{})
  112|  7.28k|    {
  113|  7.28k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|  4.51M|    {
  142|  4.51M|        return done_;
  143|  4.51M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|  2.26M|    {
  148|  2.26M|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|  2.26M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7.28k, False: 2.25M]
  |  |  ------------------
  ------------------
  149|  7.28k|        {
  150|  7.28k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  7.28k|            first_ = false;
  152|  7.28k|        }
  153|  2.25M|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|  2.25M|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 2.25M, False: 7.28k]
  |  |  ------------------
  ------------------
  154|  2.25M|        {
  155|  2.25M|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|  2.25M|            ++index_;
  157|  2.25M|        }
  158|  7.28k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 7.28k, False: 0]
  ------------------
  159|  7.28k|        {
  160|  7.28k|            visitor.end_array(context, ec);
  161|  7.28k|            done_ = true;
  162|  7.28k|        }
  163|  2.26M|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueItEENSt3__19enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   72|   782k|    {
   73|   782k|        visitor.uint64_value(val, tag, context, ec);
   74|   782k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|  7.98k|        : data_(std::move(data), alloc), 
  107|  7.98k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  7.98k|          array_tag_(array_tag), 
  109|  7.98k|          extent_(span_.size()), 
  110|  7.98k|          tag_(tag), 
  111|  7.98k|          func_(Func{})
  112|  7.98k|    {
  113|  7.98k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|  1.58M|    {
  142|  1.58M|        return done_;
  143|  1.58M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|   798k|    {
  148|   798k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|   798k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7.98k, False: 790k]
  |  |  ------------------
  ------------------
  149|  7.98k|        {
  150|  7.98k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  7.98k|            first_ = false;
  152|  7.98k|        }
  153|   790k|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|   790k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 782k, False: 7.98k]
  |  |  ------------------
  ------------------
  154|   782k|        {
  155|   782k|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|   782k|            ++index_;
  157|   782k|        }
  158|  7.98k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 7.98k, False: 0]
  ------------------
  159|  7.98k|        {
  160|  7.98k|            visitor.end_array(context, ec);
  161|  7.98k|            done_ = true;
  162|  7.98k|        }
  163|   798k|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIjEENSt3__19enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   72|  2.72M|    {
   73|  2.72M|        visitor.uint64_value(val, tag, context, ec);
   74|  2.72M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIjNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|  5.56k|        : data_(std::move(data), alloc), 
  107|  5.56k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  5.56k|          array_tag_(array_tag), 
  109|  5.56k|          extent_(span_.size()), 
  110|  5.56k|          tag_(tag), 
  111|  5.56k|          func_(Func{})
  112|  5.56k|    {
  113|  5.56k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIjNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|  5.46M|    {
  142|  5.46M|        return done_;
  143|  5.46M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIjNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|  2.73M|    {
  148|  2.73M|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|  2.73M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 5.56k, False: 2.73M]
  |  |  ------------------
  ------------------
  149|  5.56k|        {
  150|  5.56k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  5.56k|            first_ = false;
  152|  5.56k|        }
  153|  2.73M|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|  2.73M|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 2.72M, False: 5.56k]
  |  |  ------------------
  ------------------
  154|  2.72M|        {
  155|  2.72M|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|  2.72M|            ++index_;
  157|  2.72M|        }
  158|  5.56k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 5.56k, False: 0]
  ------------------
  159|  5.56k|        {
  160|  5.56k|            visitor.end_array(context, ec);
  161|  5.56k|            done_ = true;
  162|  5.56k|        }
  163|  2.73M|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueImEENSt3__19enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   72|   454k|    {
   73|   454k|        visitor.uint64_value(val, tag, context, ec);
   74|   454k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|  18.2k|        : data_(std::move(data), alloc), 
  107|  18.2k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  18.2k|          array_tag_(array_tag), 
  109|  18.2k|          extent_(span_.size()), 
  110|  18.2k|          tag_(tag), 
  111|  18.2k|          func_(Func{})
  112|  18.2k|    {
  113|  18.2k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|   945k|    {
  142|   945k|        return done_;
  143|   945k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|   490k|    {
  148|   490k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|   490k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 18.2k, False: 472k]
  |  |  ------------------
  ------------------
  149|  18.2k|        {
  150|  18.2k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  18.2k|            first_ = false;
  152|  18.2k|        }
  153|   472k|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|   472k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 454k, False: 18.2k]
  |  |  ------------------
  ------------------
  154|   454k|        {
  155|   454k|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|   454k|            ++index_;
  157|   454k|        }
  158|  18.2k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 18.2k, False: 0]
  ------------------
  159|  18.2k|        {
  160|  18.2k|            visitor.end_array(context, ec);
  161|  18.2k|            done_ = true;
  162|  18.2k|        }
  163|   490k|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIaEENSt3__19enable_ifIXsr10ext_traits17is_signed_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   64|  4.66M|    {
   65|  4.66M|        visitor.int64_value(val, tag, context, ec);
   66|  4.66M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIaNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|  3.93k|        : data_(std::move(data), alloc), 
  107|  3.93k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  3.93k|          array_tag_(array_tag), 
  109|  3.93k|          extent_(span_.size()), 
  110|  3.93k|          tag_(tag), 
  111|  3.93k|          func_(Func{})
  112|  3.93k|    {
  113|  3.93k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIaNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|  9.34M|    {
  142|  9.34M|        return done_;
  143|  9.34M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIaNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|  4.67M|    {
  148|  4.67M|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|  4.67M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3.93k, False: 4.67M]
  |  |  ------------------
  ------------------
  149|  3.93k|        {
  150|  3.93k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  3.93k|            first_ = false;
  152|  3.93k|        }
  153|  4.67M|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|  4.67M|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 4.66M, False: 3.93k]
  |  |  ------------------
  ------------------
  154|  4.66M|        {
  155|  4.66M|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|  4.66M|            ++index_;
  157|  4.66M|        }
  158|  3.93k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 3.93k, False: 0]
  ------------------
  159|  3.93k|        {
  160|  3.93k|            visitor.end_array(context, ec);
  161|  3.93k|            done_ = true;
  162|  3.93k|        }
  163|  4.67M|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIsEENSt3__19enable_ifIXsr10ext_traits17is_signed_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   64|  1.05M|    {
   65|  1.05M|        visitor.int64_value(val, tag, context, ec);
   66|  1.05M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIsNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|  9.58k|        : data_(std::move(data), alloc), 
  107|  9.58k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  9.58k|          array_tag_(array_tag), 
  109|  9.58k|          extent_(span_.size()), 
  110|  9.58k|          tag_(tag), 
  111|  9.58k|          func_(Func{})
  112|  9.58k|    {
  113|  9.58k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIsNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|  2.11M|    {
  142|  2.11M|        return done_;
  143|  2.11M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIsNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|  1.06M|    {
  148|  1.06M|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|  1.06M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 9.58k, False: 1.05M]
  |  |  ------------------
  ------------------
  149|  9.58k|        {
  150|  9.58k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  9.58k|            first_ = false;
  152|  9.58k|        }
  153|  1.05M|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|  1.05M|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 1.05M, False: 9.58k]
  |  |  ------------------
  ------------------
  154|  1.05M|        {
  155|  1.05M|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|  1.05M|            ++index_;
  157|  1.05M|        }
  158|  9.58k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 9.58k, False: 0]
  ------------------
  159|  9.58k|        {
  160|  9.58k|            visitor.end_array(context, ec);
  161|  9.58k|            done_ = true;
  162|  9.58k|        }
  163|  1.06M|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIiEENSt3__19enable_ifIXsr10ext_traits17is_signed_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   64|   780k|    {
   65|   780k|        visitor.int64_value(val, tag, context, ec);
   66|   780k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIiNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|  8.27k|        : data_(std::move(data), alloc), 
  107|  8.27k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  8.27k|          array_tag_(array_tag), 
  109|  8.27k|          extent_(span_.size()), 
  110|  8.27k|          tag_(tag), 
  111|  8.27k|          func_(Func{})
  112|  8.27k|    {
  113|  8.27k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIiNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|  1.57M|    {
  142|  1.57M|        return done_;
  143|  1.57M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIiNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|   796k|    {
  148|   796k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|   796k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 8.27k, False: 788k]
  |  |  ------------------
  ------------------
  149|  8.27k|        {
  150|  8.27k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  8.27k|            first_ = false;
  152|  8.27k|        }
  153|   788k|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|   788k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 780k, False: 8.27k]
  |  |  ------------------
  ------------------
  154|   780k|        {
  155|   780k|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|   780k|            ++index_;
  157|   780k|        }
  158|  8.27k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 8.27k, False: 0]
  ------------------
  159|  8.27k|        {
  160|  8.27k|            visitor.end_array(context, ec);
  161|  8.27k|            done_ = true;
  162|  8.27k|        }
  163|   796k|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIlEENSt3__19enable_ifIXsr10ext_traits17is_signed_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   64|   601k|    {
   65|   601k|        visitor.int64_value(val, tag, context, ec);
   66|   601k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|  3.87k|        : data_(std::move(data), alloc), 
  107|  3.87k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  3.87k|          array_tag_(array_tag), 
  109|  3.87k|          extent_(span_.size()), 
  110|  3.87k|          tag_(tag), 
  111|  3.87k|          func_(Func{})
  112|  3.87k|    {
  113|  3.87k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|  1.21M|    {
  142|  1.21M|        return done_;
  143|  1.21M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|   609k|    {
  148|   609k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|   609k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3.87k, False: 605k]
  |  |  ------------------
  ------------------
  149|  3.87k|        {
  150|  3.87k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  3.87k|            first_ = false;
  152|  3.87k|        }
  153|   605k|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|   605k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 601k, False: 3.87k]
  |  |  ------------------
  ------------------
  154|   601k|        {
  155|   601k|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|   601k|            ++index_;
  157|   601k|        }
  158|  3.87k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 3.87k, False: 0]
  ------------------
  159|  3.87k|        {
  160|  3.87k|            visitor.end_array(context, ec);
  161|  3.87k|            done_ = true;
  162|  3.87k|        }
  163|   609k|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIdEENSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   80|  12.6M|    {
   81|  12.6M|        visitor.double_value(val, tag, context, ec);
   82|  12.6M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_11decode_halfENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|  15.3k|        : data_(std::move(data), alloc), 
  107|  15.3k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  15.3k|          array_tag_(array_tag), 
  109|  15.3k|          extent_(span_.size()), 
  110|  15.3k|          tag_(tag), 
  111|  15.3k|          func_(Func{})
  112|  15.3k|    {
  113|  15.3k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorItNS_11decode_halfENSt3__19allocatorIcEEE4doneEv:
  141|  24.8M|    {
  142|  24.8M|        return done_;
  143|  24.8M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_11decode_halfENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|  12.4M|    {
  148|  12.4M|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|  12.4M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 15.3k, False: 12.4M]
  |  |  ------------------
  ------------------
  149|  15.3k|        {
  150|  15.3k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  15.3k|            first_ = false;
  152|  15.3k|        }
  153|  12.4M|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|  12.4M|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 12.4M, False: 15.3k]
  |  |  ------------------
  ------------------
  154|  12.4M|        {
  155|  12.4M|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|  12.4M|            ++index_;
  157|  12.4M|        }
  158|  15.3k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 15.3k, False: 0]
  ------------------
  159|  15.3k|        {
  160|  15.3k|            visitor.end_array(context, ec);
  161|  15.3k|            done_ = true;
  162|  15.3k|        }
  163|  12.4M|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIfEENSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   80|   518k|    {
   81|   518k|        visitor.double_value(val, tag, context, ec);
   82|   518k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|  12.7k|        : data_(std::move(data), alloc), 
  107|  12.7k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  12.7k|          array_tag_(array_tag), 
  109|  12.7k|          extent_(span_.size()), 
  110|  12.7k|          tag_(tag), 
  111|  12.7k|          func_(Func{})
  112|  12.7k|    {
  113|  12.7k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|  1.06M|    {
  142|  1.06M|        return done_;
  143|  1.06M|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|   543k|    {
  148|   543k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|   543k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 12.7k, False: 531k]
  |  |  ------------------
  ------------------
  149|  12.7k|        {
  150|  12.7k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  12.7k|            first_ = false;
  152|  12.7k|        }
  153|   531k|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|   531k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 518k, False: 12.7k]
  |  |  ------------------
  ------------------
  154|   518k|        {
  155|   518k|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|   518k|            ++index_;
  157|   518k|        }
  158|  12.7k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 12.7k, False: 0]
  ------------------
  159|  12.7k|        {
  160|  12.7k|            visitor.end_array(context, ec);
  161|  12.7k|            done_ = true;
  162|  12.7k|        }
  163|   543k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIdNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|  5.49k|        : data_(std::move(data), alloc), 
  107|  5.49k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  5.49k|          array_tag_(array_tag), 
  109|  5.49k|          extent_(span_.size()), 
  110|  5.49k|          tag_(tag), 
  111|  5.49k|          func_(Func{})
  112|  5.49k|    {
  113|  5.49k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIdNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|   453k|    {
  142|   453k|        return done_;
  143|   453k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIdNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|   232k|    {
  148|   232k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|   232k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 5.49k, False: 226k]
  |  |  ------------------
  ------------------
  149|  5.49k|        {
  150|  5.49k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  5.49k|            first_ = false;
  152|  5.49k|        }
  153|   226k|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   77|   226k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 221k, False: 5.49k]
  |  |  ------------------
  ------------------
  154|   221k|        {
  155|   221k|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|   221k|            ++index_;
  157|   221k|        }
  158|  5.49k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 5.49k, False: 0]
  ------------------
  159|  5.49k|        {
  160|  5.49k|            visitor.end_array(context, ec);
  161|  5.49k|            done_ = true;
  162|  5.49k|        }
  163|   232k|    }
_ZN8jsoncons4cbor31cbor_mdarray_row_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2ERKNS3_6vectorImNS4_ImEEEEPNS0_17basic_cbor_parserIS6_S7_EEbRKS7_:
  337|    454|        : extents_(extents, alloc), dimensions_(extents.size(), mdarray_dimension{}, alloc),
  338|    454|          parser_(parser), cursor_mode_(cursor_mode)
  339|    454|    {
  340|    454|        std::vector<std::size_t> strides(extents.size(), 0);
  341|    454|        std::size_t stride = 1;
  342|    454|        const size_t num_extents = extents.size();
  343|  1.57k|        for (size_t i = 0; i < num_extents; ++i)
  ------------------
  |  Branch (343:28): [True: 1.12k, False: 454]
  ------------------
  344|  1.12k|        {
  345|  1.12k|            strides[num_extents - i - 1] = stride;
  346|  1.12k|            stride *= extents[num_extents - i - 1];
  347|  1.12k|        }
  348|  1.57k|        for (std::size_t i = 0; i < strides.size(); ++i)
  ------------------
  |  Branch (348:33): [True: 1.12k, False: 454]
  ------------------
  349|  1.12k|        {
  350|  1.12k|            dimensions_[i].extent = extents[i];
  351|  1.12k|            dimensions_[i].stride = strides[i];
  352|  1.12k|            dimensions_[i].index = 0;
  353|  1.12k|            dimensions_[i].end = strides[i] * extents[i];
  354|  1.12k|        }
  355|    454|    }
_ZNK8jsoncons4cbor31cbor_mdarray_row_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5countEv:
  383|     17|    {
  384|     17|        return count_;
  385|     17|    }
_ZNK8jsoncons4cbor31cbor_mdarray_row_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4doneEv:
  378|  60.8k|    {
  379|  60.8k|        return done_;
  380|  60.8k|    }
_ZN8jsoncons4cbor31cbor_mdarray_row_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  389|  60.8k|    {
  390|  60.8k|        JSONCONS_ASSERT(!dimensions_.empty());
  ------------------
  |  |   49|  60.8k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 60.8k]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  391|       |
  392|  60.8k|        if (dim_ == 0)
  ------------------
  |  Branch (392:13): [True: 1.05k, False: 59.7k]
  ------------------
  393|  1.05k|        {
  394|  1.05k|            if (first_)
  ------------------
  |  Branch (394:17): [True: 454, False: 603]
  ------------------
  395|    454|            {
  396|    454|                visitor.begin_array(dimensions_[dim_].extent, tag_, context, ec);
  397|    454|                first_ = false;
  398|    454|                return;
  399|    454|            }
  400|    603|            if (dimensions_[dim_].index == dimensions_[dim_].end)
  ------------------
  |  Branch (400:17): [True: 32, False: 571]
  ------------------
  401|     32|            {
  402|     32|                visitor.end_array(context, ec);
  403|     32|                done_ = true;
  404|     32|                return;
  405|     32|            }
  406|    603|        }
  407|  60.3k|        if (dim_+1 < dimensions_.size() && dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (407:13): [True: 24.8k, False: 35.5k]
  |  Branch (407:44): [True: 21.4k, False: 3.42k]
  ------------------
  408|  21.4k|        {
  409|  21.4k|            if (!cursor_mode_)
  ------------------
  |  Branch (409:17): [True: 21.4k, False: 0]
  ------------------
  410|  21.4k|            {
  411|  21.4k|                visitor.begin_array(dimensions_[dim_].extent, semantic_tag::none, context, ec);
  412|  21.4k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  21.4k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 21.4k]
  |  |  ------------------
  ------------------
  413|      0|                {
  414|      0|                    return;
  415|      0|                }
  416|  21.4k|            }
  417|  21.4k|            ++dim_;
  418|  21.4k|            return;
  419|  21.4k|        }
  420|  38.9k|        if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (420:13): [True: 18.1k, False: 20.7k]
  ------------------
  421|  18.1k|        {
  422|  18.1k|            parser_->read_item(visitor, ec);
  423|  18.1k|            dimensions_[dim_].index += dimensions_[dim_].stride;
  424|  18.1k|            ++count_;
  425|  18.1k|            return;
  426|  18.1k|        }
  427|  20.7k|        if (dimensions_[dim_].index + dimensions_[dim_].stride >= dimensions_[dim_].end)
  ------------------
  |  Branch (427:13): [True: 20.7k, False: 0]
  ------------------
  428|  20.7k|        {
  429|  20.7k|            if (!cursor_mode_)
  ------------------
  |  Branch (429:17): [True: 20.7k, False: 0]
  ------------------
  430|  20.7k|            {
  431|  20.7k|                visitor.end_array(context, ec);
  432|  20.7k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  20.7k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 20.7k]
  |  |  ------------------
  ------------------
  433|      0|                {
  434|      0|                    return;
  435|      0|                }
  436|  20.7k|            }
  437|  20.7k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  20.7k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 20.7k]
  |  |  ------------------
  ------------------
  438|      0|            {
  439|      0|                return;
  440|      0|            }
  441|  20.7k|            if (dim_ > 0)
  ------------------
  |  Branch (441:17): [True: 20.7k, False: 0]
  ------------------
  442|  20.7k|            {
  443|  20.7k|                --dim_;
  444|  20.7k|                dimensions_[dim_].index += dimensions_[dim_].stride;
  445|  20.7k|                if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (445:21): [True: 17.3k, False: 3.44k]
  ------------------
  446|  17.3k|                {
  447|  38.0k|                    for (std::size_t i = dim_+1; i < dimensions_.size(); ++i)
  ------------------
  |  Branch (447:50): [True: 20.7k, False: 17.3k]
  ------------------
  448|  20.7k|                    {
  449|  20.7k|                        dimensions_[i].index = dimensions_[i-1].index;
  450|  20.7k|                        dimensions_[i].end = dimensions_[i].index + dimensions_[i].stride*dimensions_[i].extent;
  451|  20.7k|                    }
  452|  17.3k|                }
  453|  20.7k|            }
  454|  20.7k|        }
  455|  20.7k|    }