LLVMFuzzerTestOneInput:
   12|  6.81k|{
   13|  6.81k|    std::string s(reinterpret_cast<const char*>(data), size);
   14|  6.81k|    std::istringstream is(s);
   15|       |
   16|  6.81k|    std::error_code ec;
   17|  6.81k|    cbor_stream_cursor cursor(is, ec);
   18|  10.9k|    while (!cursor.done() && !ec)
  ------------------
  |  Branch (18:12): [True: 7.23k, False: 3.71k]
  |  Branch (18:30): [True: 4.13k, False: 3.09k]
  ------------------
   19|  4.13k|    {
   20|  4.13k|        const auto& event = cursor.current();
   21|  4.13k|        std::string s2 = event.get<std::string>(ec);
   22|  4.13k|        if (!ec)
  ------------------
  |  Branch (22:13): [True: 3.71k, False: 419]
  ------------------
   23|  3.71k|        {
   24|  3.71k|            cursor.next(ec);
   25|  3.71k|        }
   26|  4.13k|    }
   27|       |
   28|  6.81k|    return 0;
   29|  6.81k|}

_ZN8jsoncons15make_error_codeENS_9conv_errcE:
  180|    419|{
  181|    419|    return std::error_code(static_cast<int>(result),conv_error_category());
  182|    419|}
_ZN8jsoncons19conv_error_categoryEv:
  173|    419|{
  174|    419|  static detail::conv_error_category_impl instance;
  175|    419|  return instance;
  176|    419|}

_ZN8jsoncons21basic_generic_visitorIcEC2Ev:
   52|  6.81k|    basic_generic_visitor() = default;
_ZN8jsoncons21basic_generic_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  294|    381|    {
  295|    381|        visit_begin_array(length, tag, context, ec);
  296|    381|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    381|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  297|    381|    }
_ZN8jsoncons21basic_generic_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  363|    175|    {
  364|    175|        visit_uint64(value, tag, context, ec);
  365|    175|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    175|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  366|    175|    }
_ZN8jsoncons21basic_generic_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  372|    253|    {
  373|    253|        visit_int64(value, tag, context, ec);
  374|    253|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    253|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  375|    253|    }
_ZN8jsoncons21basic_generic_visitorIcE10half_valueEtNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  381|    131|    {
  382|    131|        visit_half(value, tag, context, ec);
  383|    131|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    131|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  384|    131|    }
_ZN8jsoncons21basic_generic_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  390|    700|    {
  391|    700|        visit_double(value, tag, context, ec);
  392|    700|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    700|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  393|    700|    }
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  267|      2|    {
  268|      2|        visit_begin_object(tag, context, ec);
  269|      2|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  270|      2|    }
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr6nonstd18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  343|     79|    {
  344|     79|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  345|     79|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     79|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  346|     79|    }
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr6nonstd18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  354|      3|    {
  355|      3|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), raw_tag, context, ec);
  356|      3|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  357|      3|    }
_ZN8jsoncons21basic_generic_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  323|      2|    {
  324|      2|        visit_bool(value, tag, context, ec);
  325|      2|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  326|      2|    }
_ZN8jsoncons21basic_generic_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  314|      4|    {
  315|      4|        visit_null(tag, context, ec);
  316|      4|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      4|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  317|      4|    }
_ZN8jsoncons21basic_generic_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  332|  2.37k|    {
  333|  2.37k|        visit_string(value, tag, context, ec);
  334|  2.37k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  2.37k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  335|  2.37k|    }
_ZN8jsoncons21basic_generic_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  288|     15|    {
  289|     15|        visit_begin_array(tag, context, ec);
  290|     15|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     15|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  291|     15|    }
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  276|     21|    {
  277|     21|        visit_begin_object(length, tag, context, ec);
  278|     21|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     21|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  279|     21|    }
_ZN8jsoncons21basic_generic_visitorIcE5flushEv:
   57|  3.71k|    {
   58|  3.71k|        visit_flush();
   59|  3.71k|    }

_ZN8jsoncons19typed_array_visitorD2Ev:
   33|  6.81k|        virtual ~typed_array_visitor() = default;

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

_ZN8jsoncons6nonstd8expectedImNSt3__14errcEEC2ImEENS2_9enable_ifIXsr3std24is_default_constructibleIT_EE5valueEiE4typeE:
   41|      5|        : expected(T{})
   42|      5|    {
   43|      5|    }
_ZN8jsoncons6nonstd8expectedImNSt3__14errcEEC2EOm:
   52|    222|        : has_value_(true)
   53|    222|    {
   54|    222|        construct(std::move(value));
   55|    222|    }
_ZN8jsoncons6nonstd8expectedImNSt3__14errcEE9constructEOm:
  274|    222|    {
  275|    222|        ::new (&value_) T(std::move(value));
  276|    222|        has_value_ = true;
  277|    222|    }
_ZN8jsoncons6nonstd8expectedImNSt3__14errcEEC2IJS3_EEENS0_10unexpect_tEDpOT_:
   66|     33|        : has_value_(false)
   67|     33|    {
   68|     33|        ::new (&error_) E(std::forward<Args>(args)...);
   69|     33|    }
_ZNK8jsoncons6nonstd8expectedImNSt3__14errcEEcvbEv:
  146|    255|    {
  147|    255|        return has_value_;
  148|    255|    }
_ZNR8jsoncons6nonstd8expectedImNSt3__14errcEEdeEv:
  231|    438|    {
  232|    438|        return this->value_;
  233|    438|    }
_ZN8jsoncons6nonstd8expectedImNSt3__14errcEED2Ev:
  100|    255|    {
  101|    255|        destroy();
  102|    255|    }
_ZN8jsoncons6nonstd8expectedImNSt3__14errcEE7destroyEv:
  280|    255|    {
  281|    255|        if (has_value_) 
  ------------------
  |  Branch (281:13): [True: 222, False: 33]
  ------------------
  282|    222|        {
  283|    222|            value_.~T();
  284|    222|            has_value_ = false;
  285|    222|        }
  286|     33|        else
  287|     33|        {
  288|     33|            error_.~E();
  289|     33|        }
  290|    255|    }

_ZN8jsoncons6nonstd24make_obj_using_allocatorINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES7_JRKPKcRKmEEENS2_9enable_ifIXaaaantsr6nonstd11is_std_pairIT_EE5valuesr3std14uses_allocatorISG_T0_EE5valuesr3std16is_constructibleISG_DpT1_SH_EE5valueESG_E4typeERKSH_DpOSI_:
   16|  2.37k|{
   17|  2.37k|    return T(std::forward<Args>(args)..., alloc);
   18|  2.37k|}
_ZN8jsoncons6nonstd24make_obj_using_allocatorINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES7_JEEENS2_9enable_ifIXaaaantsr6nonstd11is_std_pairIT_EE5valuesr3std14uses_allocatorISA_T0_EE5valuesr3std16is_constructibleISA_DpT1_SB_EE5valueESA_E4typeERKSB_DpOSC_:
   16|  1.33k|{
   17|  1.33k|    return T(std::forward<Args>(args)..., alloc);
   18|  1.33k|}
_ZN8jsoncons6nonstd24make_obj_using_allocatorINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES7_JRKPKcEEENS2_9enable_ifIXaaaantsr6nonstd11is_std_pairIT_EE5valuesr3std14uses_allocatorISE_T0_EE5valuesr3std16is_constructibleISE_DpT1_SF_EE5valueESE_E4typeERKSF_DpOSG_:
   16|      6|{
   17|      6|    return T(std::forward<Args>(args)..., alloc);
   18|      6|}

_ZN8jsoncons6nonstd16to_plain_pointerImEEPT_S3_:
  241|   205k|    {       
  242|   205k|        return (ptr);
  243|   205k|    }  

_ZNK8jsoncons6nonstd4spanIKhLm18446744073709551615EE4sizeEv:
  116|  2.54k|        {
  117|  2.54k|            return size_;
  118|  2.54k|        }
_ZNK8jsoncons6nonstd4spanIKtLm18446744073709551615EE4sizeEv:
  116|     76|        {
  117|     76|            return size_;
  118|     76|        }
_ZNK8jsoncons6nonstd4spanIKjLm18446744073709551615EE4sizeEv:
  116|     56|        {
  117|     56|            return size_;
  118|     56|        }
_ZNK8jsoncons6nonstd4spanIKmLm18446744073709551615EE4sizeEv:
  116|  4.31k|        {
  117|  4.31k|            return size_;
  118|  4.31k|        }
_ZNK8jsoncons6nonstd4spanIKaLm18446744073709551615EE4sizeEv:
  116|      2|        {
  117|      2|            return size_;
  118|      2|        }
_ZNK8jsoncons6nonstd4spanIKsLm18446744073709551615EE4sizeEv:
  116|     50|        {
  117|     50|            return size_;
  118|     50|        }
_ZNK8jsoncons6nonstd4spanIKiLm18446744073709551615EE4sizeEv:
  116|     56|        {
  117|     56|            return size_;
  118|     56|        }
_ZNK8jsoncons6nonstd4spanIKlLm18446744073709551615EE4sizeEv:
  116|     52|        {
  117|     52|            return size_;
  118|     52|        }
_ZNK8jsoncons6nonstd4spanIKfLm18446744073709551615EE4sizeEv:
  116|     40|        {
  117|     40|            return size_;
  118|     40|        }
_ZNK8jsoncons6nonstd4spanIKdLm18446744073709551615EE4sizeEv:
  116|     34|        {
  117|     34|            return size_;
  118|     34|        }
_ZNK8jsoncons6nonstd4spanIhLm18446744073709551615EE4dataEv:
  111|    412|        {
  112|    412|            return data_;
  113|    412|        }
_ZNK8jsoncons6nonstd4spanIhLm18446744073709551615EE4sizeEv:
  116|    412|        {
  117|    412|            return size_;
  118|    412|        }
_ZN8jsoncons6nonstd4spanIKhLm18446744073709551615EEC2EPS2_m:
   61|  1.57k|            : data_(data), size_(size)
   62|  1.57k|        {
   63|  1.57k|        }
_ZN8jsoncons6nonstd4spanIhLm18446744073709551615EEC2INSt3__16vectorIhNS4_9allocatorIhEEEEEERT_PNS4_9enable_ifIXaaaaaantsr7is_spanIS9_EE5valuentsr6nonstd12is_std_arrayIS9_EE5valuesr6nonstd21is_compatible_elementIS9_hEE5valuesr6nonstd17has_data_and_sizeIS9_EE5valueEvE4typeE:
   68|    412|            : data_(c.data()), size_(c.size())
   69|    412|        {
   70|    412|        }
_ZN8jsoncons6nonstd4spanIKhLm18446744073709551615EEC2IhLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|      3|            : data_(s.data()), size_(s.size())
  103|      3|        {
  104|      3|        }
_ZN8jsoncons6nonstd4spanItLm18446744073709551615EEC2EPtm:
   61|     76|            : data_(data), size_(size)
   62|     76|        {
   63|     76|        }
_ZNK8jsoncons6nonstd4spanItLm18446744073709551615EE4sizeEv:
  116|  71.1k|        {
  117|  71.1k|            return size_;
  118|  71.1k|        }
_ZNK8jsoncons6nonstd4spanItLm18446744073709551615EEixEm:
  126|   142k|         {
  127|   142k|             return data_[index];
  128|   142k|         }
_ZN8jsoncons6nonstd4spanIKtLm18446744073709551615EEC2ItLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|     38|            : data_(s.data()), size_(s.size())
  103|     38|        {
  104|     38|        }
_ZNK8jsoncons6nonstd4spanItLm18446744073709551615EE4dataEv:
  111|     38|        {
  112|     38|            return data_;
  113|     38|        }
_ZN8jsoncons6nonstd4spanIjLm18446744073709551615EEC2EPjm:
   61|     56|            : data_(data), size_(size)
   62|     56|        {
   63|     56|        }
_ZNK8jsoncons6nonstd4spanIjLm18446744073709551615EE4sizeEv:
  116|  36.2k|        {
  117|  36.2k|            return size_;
  118|  36.2k|        }
_ZNK8jsoncons6nonstd4spanIjLm18446744073709551615EEixEm:
  126|  72.2k|         {
  127|  72.2k|             return data_[index];
  128|  72.2k|         }
_ZN8jsoncons6nonstd4spanIKjLm18446744073709551615EEC2IjLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|     28|            : data_(s.data()), size_(s.size())
  103|     28|        {
  104|     28|        }
_ZNK8jsoncons6nonstd4spanIjLm18446744073709551615EE4dataEv:
  111|     28|        {
  112|     28|            return data_;
  113|     28|        }
_ZN8jsoncons6nonstd4spanImLm18446744073709551615EEC2EPmm:
   61|     40|            : data_(data), size_(size)
   62|     40|        {
   63|     40|        }
_ZNK8jsoncons6nonstd4spanImLm18446744073709551615EE4sizeEv:
  116|  9.56k|        {
  117|  9.56k|            return size_;
  118|  9.56k|        }
_ZNK8jsoncons6nonstd4spanImLm18446744073709551615EEixEm:
  126|  19.0k|         {
  127|  19.0k|             return data_[index];
  128|  19.0k|         }
_ZN8jsoncons6nonstd4spanIKmLm18446744073709551615EEC2ImLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|     20|            : data_(s.data()), size_(s.size())
  103|     20|        {
  104|     20|        }
_ZNK8jsoncons6nonstd4spanImLm18446744073709551615EE4dataEv:
  111|     20|        {
  112|     20|            return data_;
  113|     20|        }
_ZNK8jsoncons6nonstd4spanIKmLm18446744073709551615EEixEm:
  126|  12.3k|         {
  127|  12.3k|             return data_[index];
  128|  12.3k|         }
_ZN8jsoncons6nonstd4spanIaLm18446744073709551615EEC2EPam:
   61|      2|            : data_(data), size_(size)
   62|      2|        {
   63|      2|        }
_ZNK8jsoncons6nonstd4spanIaLm18446744073709551615EE4sizeEv:
  116|      2|        {
  117|      2|            return size_;
  118|      2|        }
_ZN8jsoncons6nonstd4spanIKaLm18446744073709551615EEC2IaLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|      1|            : data_(s.data()), size_(s.size())
  103|      1|        {
  104|      1|        }
_ZNK8jsoncons6nonstd4spanIaLm18446744073709551615EE4dataEv:
  111|      1|        {
  112|      1|            return data_;
  113|      1|        }
_ZN8jsoncons6nonstd4spanIsLm18446744073709551615EEC2EPsm:
   61|     50|            : data_(data), size_(size)
   62|     50|        {
   63|     50|        }
_ZNK8jsoncons6nonstd4spanIsLm18446744073709551615EE4sizeEv:
  116|   118k|        {
  117|   118k|            return size_;
  118|   118k|        }
_ZNK8jsoncons6nonstd4spanIsLm18446744073709551615EEixEm:
  126|   237k|         {
  127|   237k|             return data_[index];
  128|   237k|         }
_ZN8jsoncons6nonstd4spanIKsLm18446744073709551615EEC2IsLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|     25|            : data_(s.data()), size_(s.size())
  103|     25|        {
  104|     25|        }
_ZNK8jsoncons6nonstd4spanIsLm18446744073709551615EE4dataEv:
  111|     25|        {
  112|     25|            return data_;
  113|     25|        }
_ZN8jsoncons6nonstd4spanIiLm18446744073709551615EEC2EPim:
   61|     56|            : data_(data), size_(size)
   62|     56|        {
   63|     56|        }
_ZNK8jsoncons6nonstd4spanIiLm18446744073709551615EE4sizeEv:
  116|  84.0k|        {
  117|  84.0k|            return size_;
  118|  84.0k|        }
_ZNK8jsoncons6nonstd4spanIiLm18446744073709551615EEixEm:
  126|   167k|         {
  127|   167k|             return data_[index];
  128|   167k|         }
_ZN8jsoncons6nonstd4spanIKiLm18446744073709551615EEC2IiLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|     28|            : data_(s.data()), size_(s.size())
  103|     28|        {
  104|     28|        }
_ZNK8jsoncons6nonstd4spanIiLm18446744073709551615EE4dataEv:
  111|     28|        {
  112|     28|            return data_;
  113|     28|        }
_ZN8jsoncons6nonstd4spanIlLm18446744073709551615EEC2EPlm:
   61|     52|            : data_(data), size_(size)
   62|     52|        {
   63|     52|        }
_ZNK8jsoncons6nonstd4spanIlLm18446744073709551615EE4sizeEv:
  116|    974|        {
  117|    974|            return size_;
  118|    974|        }
_ZNK8jsoncons6nonstd4spanIlLm18446744073709551615EEixEm:
  126|  1.79k|         {
  127|  1.79k|             return data_[index];
  128|  1.79k|         }
_ZN8jsoncons6nonstd4spanIKlLm18446744073709551615EEC2IlLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|     26|            : data_(s.data()), size_(s.size())
  103|     26|        {
  104|     26|        }
_ZNK8jsoncons6nonstd4spanIlLm18446744073709551615EE4dataEv:
  111|     26|        {
  112|     26|            return data_;
  113|     26|        }
_ZN8jsoncons6nonstd4spanIfLm18446744073709551615EEC2EPfm:
   61|     40|            : data_(data), size_(size)
   62|     40|        {
   63|     40|        }
_ZNK8jsoncons6nonstd4spanIfLm18446744073709551615EE4sizeEv:
  116|  10.7k|        {
  117|  10.7k|            return size_;
  118|  10.7k|        }
_ZNK8jsoncons6nonstd4spanIfLm18446744073709551615EEixEm:
  126|  21.3k|         {
  127|  21.3k|             return data_[index];
  128|  21.3k|         }
_ZN8jsoncons6nonstd4spanIKfLm18446744073709551615EEC2IfLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|     20|            : data_(s.data()), size_(s.size())
  103|     20|        {
  104|     20|        }
_ZNK8jsoncons6nonstd4spanIfLm18446744073709551615EE4dataEv:
  111|     20|        {
  112|     20|            return data_;
  113|     20|        }
_ZN8jsoncons6nonstd4spanIdLm18446744073709551615EEC2EPdm:
   61|     34|            : data_(data), size_(size)
   62|     34|        {
   63|     34|        }
_ZNK8jsoncons6nonstd4spanIdLm18446744073709551615EE4sizeEv:
  116|  8.43k|        {
  117|  8.43k|            return size_;
  118|  8.43k|        }
_ZNK8jsoncons6nonstd4spanIdLm18446744073709551615EEixEm:
  126|  16.7k|         {
  127|  16.7k|             return data_[index];
  128|  16.7k|         }
_ZN8jsoncons6nonstd4spanIKdLm18446744073709551615EEC2IdLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|     17|            : data_(s.data()), size_(s.size())
  103|     17|        {
  104|     17|        }
_ZNK8jsoncons6nonstd4spanIdLm18446744073709551615EE4dataEv:
  111|     17|        {
  112|     17|            return data_;
  113|     17|        }
_ZN8jsoncons6nonstd4spanIKhLm18446744073709551615EEC2Ev:
   58|     16|        {
   59|     16|        }
_ZNK8jsoncons6nonstd4spanIKhLm18446744073709551615EE4dataEv:
  111|    950|        {
  112|    950|            return data_;
  113|    950|        }
_ZNK8jsoncons6nonstd4spanIKmLm18446744073709551615EE5emptyEv:
  121|    255|        { 
  122|    255|            return size_ == 0; 
  123|    255|        }
_ZN8jsoncons6nonstd4spanIKmLm18446744073709551615EEC2INSt3__16vectorImNS5_9allocatorImEEEEEERT_PNS5_9enable_ifIXaaaaaantsr7is_spanISA_EE5valuentsr6nonstd12is_std_arrayISA_EE5valuesr6nonstd21is_compatible_elementISA_S2_EE5valuesr6nonstd17has_data_and_sizeISA_EE5valueEvE4typeE:
   68|    255|            : data_(c.data()), size_(c.size())
   69|    255|        {
   70|    255|        }

_ZN8jsoncons6nonstd4u128C2Em:
   29|  1.72G|    constexpr u128(uint64_t lo) : hi(0), lo(lo) {}
_ZNK8jsoncons6nonstd4u128mlERKS1_:
  103|   861M|    u128 operator*(const u128& rhs) const {
  104|       |        // Split components into 32-bit chunks to avoid 64-bit overflow during multiplication
  105|   861M|        uint64_t a3 = hi >> 32;
  106|   861M|        uint64_t a2 = hi & 0xFFFFFFFFFFFFFFULL; // lower 32 bits of hi
  107|   861M|        uint64_t a1 = lo >> 32;
  108|   861M|        uint64_t a0 = lo & 0xFFFFFFFFULL;
  109|       |
  110|   861M|        uint64_t b3 = rhs.hi >> 32;
  111|   861M|        uint64_t b2 = rhs.hi & 0xFFFFFFFFFFFFFFULL;
  112|   861M|        uint64_t b1 = rhs.lo >> 32;
  113|   861M|        uint64_t b0 = rhs.lo & 0xFFFFFFFFULL;
  114|       |
  115|       |        // Long multiplication matrix
  116|       |        // We only care about terms that fit in the final 128 bits.
  117|       |        // Chunks exceeding indices that add up to 3 (e.g., a2*b2, a3*b1) drop out of range.
  118|       |
  119|   861M|        uint64_t c0 = a0 * b0;
  120|   861M|        uint64_t c1 = a0 * b1 + a1 * b0;
  121|   861M|        uint64_t c2 = a0 * b2 + a1 * b1 + a2 * b0;
  122|   861M|        uint64_t c3 = a0 * b3 + a1 * b2 + a2 * b1 + a3 * b0;
  123|       |
  124|       |        // Carry propagation
  125|   861M|        c1 += (c0 >> 32);
  126|   861M|        c2 += (c1 >> 32);
  127|   861M|        c3 += (c2 >> 32);
  128|       |
  129|       |        // Reconstruct hi and lo 64-bit values
  130|   861M|        uint64_t new_low = (c0 & 0xFFFFFFFFULL) | (c1 << 32);
  131|   861M|        uint64_t new_high = (c2 & 0xFFFFFFFFULL) | (c3 << 32);
  132|       |
  133|   861M|        return {new_high, new_low};
  134|   861M|    }
_ZN8jsoncons6nonstd4u128C2Emm:
   30|  2.58G|    constexpr u128(uint64_t hi, uint64_t lo) : hi(hi), lo(lo) {}
_ZNK8jsoncons6nonstd4u128plERKS1_:
   41|   861M|    u128 operator+(const u128& rhs) const {
   42|   861M|        uint64_t new_low = lo + rhs.lo;
   43|       |        // Carry occurs if the result wrapped around and is less than one of the inputs
   44|   861M|        uint64_t carry = (new_low < lo) ? 1 : 0;
  ------------------
  |  Branch (44:26): [True: 0, False: 861M]
  ------------------
   45|   861M|        uint64_t new_high = hi + rhs.hi + carry;
   46|   861M|        return {new_high, new_low};
   47|   861M|    }
_ZNK8jsoncons6nonstd4u128cvmEv:
  146|   861M|    explicit operator uint64_t() const {
  147|   861M|        return lo;
  148|   861M|    }
_ZNK8jsoncons6nonstd4u128rsEj:
   87|   861M|    u128 operator>>(unsigned int shift) const {
   88|   861M|        if (shift == 0) return *this;
  ------------------
  |  Branch (88:13): [True: 0, False: 861M]
  ------------------
   89|   861M|        if (shift >= 128) return {0, 0};
  ------------------
  |  Branch (89:13): [True: 0, False: 861M]
  ------------------
   90|       |
   91|   861M|        if (shift >= 64) {
  ------------------
  |  Branch (91:13): [True: 861M, False: 0]
  ------------------
   92|   861M|            return {0, hi >> (shift - 64)};
   93|   861M|        }
   94|      0|        else {
   95|      0|            return {
   96|      0|                hi >> shift,
   97|      0|                (lo >> shift) | (hi << (64 - shift))
   98|      0|            };
   99|      0|        }
  100|   861M|    }
_ZNK8jsoncons6nonstd4u128cvbEv:
   32|   785k|    explicit operator bool() const {
   33|   785k|        return hi != 0 || lo != 0;
  ------------------
  |  Branch (33:16): [True: 0, False: 785k]
  |  Branch (33:27): [True: 97.5k, False: 688k]
  ------------------
   34|   785k|    }

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

_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev:
  193|  6.81k|    {
  194|  6.81k|        if (chunk_)
  ------------------
  |  Branch (194:13): [True: 6.81k, False: 0]
  ------------------
  195|  6.81k|        {
  196|  6.81k|            std::allocator_traits<char_allocator_type>::deallocate(alloc_, chunk_, chunk_size_);
  197|  6.81k|        }
  198|  6.81k|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm:
  377|  5.89M|    {
  378|  5.89M|        std::size_t len = 0;
  379|  5.89M|        if (remaining_ > 0)
  ------------------
  |  Branch (379:13): [True: 5.89M, False: 591]
  ------------------
  380|  5.89M|        {
  381|  5.89M|            len = (std::min)(remaining_, length);
  382|  5.89M|            std::memcpy(p, data_end_, len*sizeof(value_type));
  383|  5.89M|            data_end_ += len;
  384|  5.89M|            remaining_ -= len;
  385|  5.89M|            position_ += len;
  386|  5.89M|        }
  387|  5.89M|        if (length - len == 0)
  ------------------
  |  Branch (387:13): [True: 5.89M, False: 2.16k]
  ------------------
  388|  5.89M|        {
  389|  5.89M|            return len;
  390|  5.89M|        }
  391|  2.16k|        else if (length - len < chunk_size_)
  ------------------
  |  Branch (391:18): [True: 2.16k, False: 0]
  ------------------
  392|  2.16k|        {
  393|  2.16k|            data_end_ = chunk_;
  394|  2.16k|            remaining_ = fill_buffer(chunk_, chunk_size_);
  395|  2.16k|            if (remaining_ > 0)
  ------------------
  |  Branch (395:17): [True: 1.53k, False: 626]
  ------------------
  396|  1.53k|            {
  397|  1.53k|                std::size_t len2 = (std::min)(remaining_, length-len);
  398|  1.53k|                std::memcpy(p+len, data_end_, len2*sizeof(value_type));
  399|  1.53k|                data_end_ += len2;
  400|  1.53k|                remaining_ -= len2;
  401|  1.53k|                position_ += len2;
  402|  1.53k|                len += len2;
  403|  1.53k|            }
  404|  2.16k|            return len;
  405|  2.16k|        }
  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|  5.89M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEPhm:
  442|  10.6k|    {
  443|  10.6k|        if (stream_ptr_->eof())
  ------------------
  |  Branch (443:13): [True: 1.30k, False: 9.35k]
  ------------------
  444|  1.30k|        {
  445|  1.30k|            return 0;
  446|  1.30k|        }
  447|       |
  448|  9.35k|        JSONCONS_TRY
  ------------------
  |  |   37|  9.35k|    #define JSONCONS_TRY try
  ------------------
  449|  9.35k|        {
  450|  9.35k|            std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(chunk), chunk_size);
  451|  9.35k|            std::size_t length = static_cast<std::size_t>(count);
  452|       |
  453|  9.35k|            if (length < chunk_size)
  ------------------
  |  Branch (453:17): [True: 6.77k, False: 2.57k]
  ------------------
  454|  6.77k|            {
  455|  6.77k|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  456|  6.77k|            }
  457|  9.35k|            return length;
  458|  9.35k|        }
  459|  9.35k|        JSONCONS_CATCH(const std::exception&)     
  460|  9.35k|        {
  461|      0|            stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  462|      0|            return 0;
  463|      0|        }
  464|  9.35k|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_6vectorIhS4_EEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr6nonstd7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSD_m:
  746|  1.15M|    {
  747|  1.15M|        std::size_t unread = length;
  748|       |
  749|  2.31M|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (749:16): [True: 1.15M, False: 1.15M]
  |  Branch (749:30): [True: 1.15M, False: 653]
  ------------------
  750|  1.15M|        {
  751|  1.15M|            if (source.remaining() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (751:17): [True: 375, False: 1.15M]
  |  Branch (751:44): [True: 293, False: 82]
  ------------------
  752|    293|            {
  753|    293|                std::size_t n = source.chunk_size();
  754|    293|                std::size_t offset = buffer.size();
  755|    293|                buffer.resize(offset+n);
  756|    293|                std::size_t actual = source.read_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  757|    293|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|    293|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 28, False: 265]
  |  |  ------------------
  ------------------
  758|     28|                {
  759|     28|                    buffer.resize(offset+actual);
  760|     28|                }
  761|    293|                unread -= actual;
  762|    293|            }
  763|  1.15M|            else
  764|  1.15M|            {
  765|  1.15M|                std::size_t n = (std::min)(source.chunk_size(), unread);
  766|  1.15M|                std::size_t offset = buffer.size();
  767|  1.15M|                buffer.resize(offset+n);
  768|  1.15M|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  769|  1.15M|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|  1.15M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 246, False: 1.15M]
  |  |  ------------------
  ------------------
  770|    246|                {
  771|    246|                    buffer.resize(offset + actual);
  772|    246|                }
  773|  1.15M|                unread -= actual;
  774|  1.15M|            }
  775|  1.15M|        }
  776|  1.15M|        return length - unread;
  777|  1.15M|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv:
  271|  3.27M|    {
  272|  3.27M|        return remaining_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:16): [True: 1.89k, False: 3.27M]
  |  Branch (272:35): [True: 1.10k, False: 792]
  ------------------
  273|  3.27M|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9remainingEv:
  346|  3.27M|    {
  347|  3.27M|        return remaining_;
  348|  3.27M|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE10chunk_sizeEv:
  261|  3.27M|    {
  262|  3.27M|        return chunk_size_;
  263|  3.27M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11read_bufferEPhm:
  435|    557|    {
  436|    557|        auto len = fill_buffer(chunk, chunk_size);
  437|    557|        position_ += len;
  438|    557|        return len;
  439|    557|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_6vectorIhS3_EEEENS_6nonstd4spanIKhLm18446744073709551615EEEmOT_:
  352|  1.12k|    {
  353|  1.12k|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   79|  1.12k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 10, False: 1.11k]
  |  |  ------------------
  ------------------
  354|     10|        {
  355|     10|            return span<const value_type>{};
  356|     10|        }
  357|  1.11k|        if (remaining_ == 0 && length <= chunk_size_)
  ------------------
  |  Branch (357:13): [True: 186, False: 929]
  |  Branch (357:32): [True: 28, False: 158]
  ------------------
  358|     28|        {
  359|     28|            remaining_ = fill_buffer(chunk_, chunk_size_);
  360|     28|            data_end_ = chunk_;
  361|     28|        }
  362|  1.11k|        if (length > remaining_)
  ------------------
  |  Branch (362:13): [True: 344, False: 771]
  ------------------
  363|    344|        {
  364|    344|            buffer.clear();
  365|    344|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  366|    344|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  367|    344|        }
  368|       |
  369|    771|        const value_type* data = data_end_;
  370|    771|        data_end_ += length;
  371|    771|        remaining_ -= length;
  372|    771|        position_ += length;
  373|    771|        return span<const value_type>(data, length);
  374|  1.11k|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_12basic_stringIcNS2_11char_traitsIcEENS3_IcEEEEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr6nonstd7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSG_m:
  746|  2.12M|    {
  747|  2.12M|        std::size_t unread = length;
  748|       |
  749|  4.24M|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (749:16): [True: 2.11M, False: 2.12M]
  |  Branch (749:30): [True: 2.11M, False: 454]
  ------------------
  750|  2.11M|        {
  751|  2.11M|            if (source.remaining() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (751:17): [True: 417, False: 2.11M]
  |  Branch (751:44): [True: 264, False: 153]
  ------------------
  752|    264|            {
  753|    264|                std::size_t n = source.chunk_size();
  754|    264|                std::size_t offset = buffer.size();
  755|    264|                buffer.resize(offset+n);
  756|    264|                std::size_t actual = source.read_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  757|    264|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|    264|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 31, False: 233]
  |  |  ------------------
  ------------------
  758|     31|                {
  759|     31|                    buffer.resize(offset+actual);
  760|     31|                }
  761|    264|                unread -= actual;
  762|    264|            }
  763|  2.11M|            else
  764|  2.11M|            {
  765|  2.11M|                std::size_t n = (std::min)(source.chunk_size(), unread);
  766|  2.11M|                std::size_t offset = buffer.size();
  767|  2.11M|                buffer.resize(offset+n);
  768|  2.11M|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  769|  2.11M|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|  2.11M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 161, False: 2.11M]
  |  |  ------------------
  ------------------
  770|    161|                {
  771|    161|                    buffer.resize(offset + actual);
  772|    161|                }
  773|  2.11M|                unread -= actual;
  774|  2.11M|            }
  775|  2.11M|        }
  776|  2.12M|        return length - unread;
  777|  2.12M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_12basic_stringIcNS1_11char_traitsIcEENS2_IcEEEEEENS_6nonstd4spanIKhLm18446744073709551615EEEmOT_:
  352|    465|    {
  353|    465|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   79|    465|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 6, False: 459]
  |  |  ------------------
  ------------------
  354|      6|        {
  355|      6|            return span<const value_type>{};
  356|      6|        }
  357|    459|        if (remaining_ == 0 && length <= chunk_size_)
  ------------------
  |  Branch (357:13): [True: 164, False: 295]
  |  Branch (357:32): [True: 18, False: 146]
  ------------------
  358|     18|        {
  359|     18|            remaining_ = fill_buffer(chunk_, chunk_size_);
  360|     18|            data_end_ = chunk_;
  361|     18|        }
  362|    459|        if (length > remaining_)
  ------------------
  |  Branch (362:13): [True: 300, False: 159]
  ------------------
  363|    300|        {
  364|    300|            buffer.clear();
  365|    300|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  366|    300|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  367|    300|        }
  368|       |
  369|    159|        const value_type* data = data_end_;
  370|    159|        data_end_ += length;
  371|    159|        remaining_ -= length;
  372|    159|        position_ += length;
  373|    159|        return span<const value_type>(data, length);
  374|    459|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4peekEv:
  312|  7.38M|    {
  313|  7.38M|        if (remaining_ == 0)
  ------------------
  |  Branch (313:13): [True: 7.89k, False: 7.37M]
  ------------------
  314|  7.89k|        {
  315|  7.89k|            data_end_ = chunk_;
  316|  7.89k|            remaining_ = fill_buffer(chunk_, chunk_size_);
  317|  7.89k|        }
  318|  7.38M|        if (remaining_ > 0)
  ------------------
  |  Branch (318:13): [True: 7.38M, False: 655]
  ------------------
  319|  7.38M|        {
  320|  7.38M|            value_type c = *data_end_;
  321|  7.38M|            return char_result<value_type>{c, false};
  322|  7.38M|        }
  323|    655|        else
  324|    655|        {
  325|    655|            return char_result<value_type>{0, true};
  326|    655|        }
  327|  7.38M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE6ignoreEm:
  286|  7.37M|    {
  287|  7.37M|        std::size_t len = 0;
  288|  7.37M|        if (remaining_ > 0)
  ------------------
  |  Branch (288:13): [True: 7.37M, False: 0]
  ------------------
  289|  7.37M|        {
  290|  7.37M|            len = (std::min)(remaining_, length);
  291|  7.37M|            position_ += len;
  292|  7.37M|            data_end_ += len;
  293|  7.37M|            remaining_ -= len;
  294|  7.37M|        }
  295|  7.37M|        while (len < length)
  ------------------
  |  Branch (295:16): [True: 0, False: 7.37M]
  ------------------
  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|  7.37M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  176|  6.81k|        : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  177|  6.81k|          chunk_size_(default_max_chunk_size)
  178|  6.81k|    {
  179|  6.81k|        chunk_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, chunk_size_);
  180|  6.81k|        data_end_ = chunk_;
  181|  6.81k|    }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   57|  6.81k|      : std::basic_istream<CharT>(&nb_)
   58|  6.81k|    {
   59|  6.81k|    }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   43|  6.81k|        null_buffer() = default;

_ZN8jsoncons17basic_staj_cursorIcED2Ev:
  558|  6.81k|    virtual ~basic_staj_cursor() = default;
_ZNK8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE5eventEv:
   73|  4.13k|    {
   74|  4.13k|        return event_;
   75|  4.13k|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEEC2ERKS3_:
   67|  6.81k|        : event_(staj_events::null_value), structure_stack_(temp_alloc)
   68|  6.81k|    {
   69|  6.81k|        structure_stack_.emplace_back(json_structure_kind::root_kind);
   70|  6.81k|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE14json_structureC2ENS4_19json_structure_kindE:
   53|  7.23k|            : structure_kind(type)
   54|  7.23k|        {
   55|  7.23k|        }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  174|    381|    {
  175|    381|        auto& structure = structure_stack_.back();
  176|    381|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (176:13): [True: 0, False: 381]
  ------------------
  177|      0|        {
  178|      0|            structure.is_key = !structure_stack_.back().is_key;
  179|      0|        }
  180|    381|        if (structure.is_key)
  ------------------
  |  Branch (180:13): [True: 0, False: 381]
  ------------------
  181|      0|        {
  182|      0|            event_ = staj_event_type(staj_events::begin_array, length, tag, staj_events::key_flag);
  183|      0|        }
  184|    381|        else
  185|    381|        {
  186|    381|            event_ = staj_event_type(staj_events::begin_array, length, tag);
  187|    381|        }
  188|    381|        structure_stack_.emplace_back(json_structure_kind::array_kind);
  189|    381|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    381|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  190|    381|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  295|    175|    {
  296|    175|        auto& structure = structure_stack_.back();
  297|    175|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (297:13): [True: 0, False: 175]
  ------------------
  298|      0|        {
  299|      0|            structure.is_key = !structure.is_key;
  300|      0|        }
  301|    175|        if (structure.is_key)
  ------------------
  |  Branch (301:13): [True: 0, False: 175]
  ------------------
  302|      0|        {
  303|      0|            event_ = staj_event_type(value, tag, staj_events::key_flag);
  304|      0|        }
  305|    175|        else
  306|    175|        {
  307|    175|            event_ = staj_event_type(value, tag);
  308|    175|        }
  309|    175|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    175|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  310|    175|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  274|    253|    {
  275|    253|        auto& structure = structure_stack_.back();
  276|    253|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (276:13): [True: 0, False: 253]
  ------------------
  277|      0|        {
  278|      0|            structure.is_key = !structure.is_key;
  279|      0|        }
  280|    253|        if (structure.is_key)
  ------------------
  |  Branch (280:13): [True: 0, False: 253]
  ------------------
  281|      0|        {
  282|      0|            event_ = staj_event_type(value, tag, staj_events::key_flag);
  283|      0|        }
  284|    253|        else
  285|    253|        {
  286|    253|            event_ = staj_event_type(value, tag);
  287|    253|        }
  288|    253|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    253|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  289|    253|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  337|    700|    {
  338|    700|        auto& structure = structure_stack_.back();
  339|    700|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (339:13): [True: 0, False: 700]
  ------------------
  340|      0|        {
  341|      0|            structure.is_key = !structure.is_key;
  342|      0|        }
  343|    700|        if (structure.is_key)
  ------------------
  |  Branch (343:13): [True: 0, False: 700]
  ------------------
  344|      0|        {
  345|      0|            event_ = staj_event_type(value, tag, staj_events::key_flag);
  346|      0|        }
  347|    700|        else
  348|    700|        {
  349|    700|            event_ = staj_event_type(value, tag);
  350|    700|        }
  351|    700|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    700|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  352|    700|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE11visit_flushEv:
   94|  3.71k|    {
   95|  3.71k|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  117|      2|    {
  118|      2|        auto& structure = structure_stack_.back();
  119|      2|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (119:13): [True: 0, False: 2]
  ------------------
  120|      0|        {
  121|      0|            structure_stack_.back().is_key = !structure_stack_.back().is_key;
  122|      0|        }
  123|      2|        if (structure.is_key)
  ------------------
  |  Branch (123:13): [True: 0, False: 2]
  ------------------
  124|      0|        {
  125|      0|            event_ = staj_event_type(staj_events::begin_object, tag, staj_events::key_flag);
  126|      0|        }
  127|      2|        else 
  128|      2|        {
  129|      2|            event_ = staj_event_type(staj_events::begin_object, tag);
  130|      2|        }
  131|      2|        structure_stack_.emplace_back(json_structure_kind::object_kind);
  132|      2|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  133|      2|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
   98|     21|    {
   99|     21|        auto& structure = structure_stack_.back();
  100|     21|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (100:13): [True: 0, False: 21]
  ------------------
  101|      0|        {
  102|      0|            structure_stack_.back().is_key = !structure_stack_.back().is_key;
  103|      0|        }
  104|     21|        if (structure.is_key)
  ------------------
  |  Branch (104:13): [True: 0, False: 21]
  ------------------
  105|      0|        {
  106|      0|            event_ = staj_event_type(staj_events::begin_object, length, tag, staj_events::key_flag);
  107|      0|        }
  108|     21|        else 
  109|     21|        {
  110|     21|            event_ = staj_event_type(staj_events::begin_object, length, tag);
  111|     21|        }
  112|     21|        structure_stack_.emplace_back(json_structure_kind::object_kind);
  113|     21|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     21|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  114|     21|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  154|     15|    {
  155|     15|        auto& structure = structure_stack_.back();
  156|     15|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (156:13): [True: 0, False: 15]
  ------------------
  157|      0|        {
  158|      0|            structure.is_key = !structure_stack_.back().is_key;
  159|      0|        }
  160|     15|        if (structure.is_key)
  ------------------
  |  Branch (160:13): [True: 0, False: 15]
  ------------------
  161|      0|        {
  162|      0|            event_ = staj_event_type(staj_events::begin_array, tag, staj_events::key_flag);
  163|      0|        }
  164|     15|        else
  165|     15|        {
  166|     15|            event_ = staj_event_type(staj_events::begin_array, tag);
  167|     15|        }
  168|     15|        structure_stack_.emplace_back(json_structure_kind::array_kind);
  169|     15|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     15|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  170|     15|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  373|      4|    {
  374|      4|        auto& structure = structure_stack_.back();
  375|      4|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (375:13): [True: 0, False: 4]
  ------------------
  376|      0|        {
  377|      0|            structure.is_key = !structure.is_key;
  378|      0|        }
  379|      4|        if (structure.is_key)
  ------------------
  |  Branch (379:13): [True: 0, False: 4]
  ------------------
  380|      0|        {
  381|      0|            event_ = staj_event_type(staj_events::null_value, tag, staj_events::key_flag);
  382|      0|        }
  383|      4|        else
  384|      4|        {
  385|      4|            event_ = staj_event_type(staj_events::null_value, tag);
  386|      4|        }
  387|      4|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      4|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  388|      4|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  355|      2|    {
  356|      2|        auto& structure = structure_stack_.back();
  357|      2|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (357:13): [True: 0, False: 2]
  ------------------
  358|      0|        {
  359|      0|            structure.is_key = !structure.is_key;
  360|      0|        }
  361|      2|        if (structure.is_key)
  ------------------
  |  Branch (361:13): [True: 0, False: 2]
  ------------------
  362|      0|        {
  363|      0|            event_ = staj_event_type(value, tag, staj_events::key_flag);
  364|      0|        }
  365|      2|        else
  366|      2|        {
  367|      2|            event_ = staj_event_type(value, tag);
  368|      2|        }
  369|      2|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  370|      2|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE12visit_stringERKNS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  211|  2.37k|    {
  212|  2.37k|        auto& structure = structure_stack_.back();
  213|  2.37k|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (213:13): [True: 0, False: 2.37k]
  ------------------
  214|      0|        {
  215|      0|            structure.is_key = !structure.is_key;
  216|      0|        }
  217|  2.37k|        if (structure.is_key)
  ------------------
  |  Branch (217:13): [True: 0, False: 2.37k]
  ------------------
  218|      0|        {
  219|      0|            event_ = staj_event_type(sv, staj_events::string_value, tag, staj_events::key_flag);
  220|      0|        }
  221|  2.37k|        else
  222|  2.37k|        {
  223|  2.37k|            event_ = staj_event_type(sv, staj_events::string_value, tag);
  224|  2.37k|        }
  225|  2.37k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  2.37k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  226|  2.37k|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  232|     79|    {
  233|     79|        auto& structure = structure_stack_.back();
  234|     79|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (234:13): [True: 0, False: 79]
  ------------------
  235|      0|        {
  236|      0|            structure.is_key = !structure.is_key;
  237|      0|        }
  238|     79|        if (structure.is_key)
  ------------------
  |  Branch (238:13): [True: 0, False: 79]
  ------------------
  239|      0|        {
  240|      0|            event_ = staj_event_type(value, staj_events::byte_string_value, tag, staj_events::key_flag);
  241|      0|        }
  242|     79|        else
  243|     79|        {
  244|     79|            event_ = staj_event_type(value, staj_events::byte_string_value, tag);
  245|     79|        }
  246|     79|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     79|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  247|     79|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS1_10error_codeE:
  253|      3|    {
  254|      3|        auto& structure = structure_stack_.back();
  255|      3|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (255:13): [True: 0, False: 3]
  ------------------
  256|      0|        {
  257|      0|            structure.is_key = !structure.is_key;
  258|      0|        }
  259|      3|        if (structure.is_key)
  ------------------
  |  Branch (259:13): [True: 0, False: 3]
  ------------------
  260|      0|        {
  261|      0|            event_ = staj_event_type(value, staj_events::byte_string_value, raw_tag, staj_events::key_flag);
  262|      0|        }
  263|      3|        else
  264|      3|        {
  265|      3|            event_ = staj_event_type(value, staj_events::byte_string_value, raw_tag);
  266|      3|        }
  267|      3|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      3|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  268|      3|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE10visit_halfEtNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  316|    131|    {
  317|    131|        auto& structure = structure_stack_.back();
  318|    131|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (318:13): [True: 0, False: 131]
  ------------------
  319|      0|        {
  320|      0|            structure.is_key = !structure.is_key;
  321|      0|        }
  322|    131|        if (structure.is_key)
  ------------------
  |  Branch (322:13): [True: 0, False: 131]
  ------------------
  323|      0|        {
  324|      0|            event_ = staj_event_type(half_arg, value, tag, staj_events::key_flag);
  325|      0|        }
  326|    131|        else
  327|    131|        {
  328|    131|            event_ = staj_event_type(half_arg, value, tag);
  329|    131|        }
  330|    131|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    131|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  331|    131|    }

_ZN8jsonconsanENS_11staj_eventsES0_:
   67|  4.13k|{ return (staj_events)((uint64_t)lhs & (uint64_t)rhs); }
_ZNK8jsoncons16basic_staj_eventIcE11storage_tagEv:
  213|  4.13k|    {
  214|  4.13k|        static constexpr staj_events mask = ~staj_events::key_flag;
  215|  4.13k|        return event_flags_ & mask;
  216|  4.13k|    }
_ZNK8jsoncons16basic_staj_eventIcE3tagEv:
  497|     78|    semantic_tag tag() const noexcept { return tag_; }
_ZN8jsoncons16basic_staj_eventIcEC2ENS_11staj_eventsENS_12semantic_tagES2_:
  223|  6.83k|        : event_flags_(event_type | key_flag), tag_(tag), value_()
  224|  6.83k|    {
  225|  6.83k|    }
_ZN8jsonconsorENS_11staj_eventsES0_:
   62|  10.9k|{ return (staj_events)((uint64_t)lhs | (uint64_t)rhs); }
_ZN8jsoncons16basic_staj_eventIcEC2ENS_11staj_eventsEmNS_12semantic_tagES2_:
  230|    402|        : event_flags_(event_type | key_flag), tag_(tag), value_(), length_(length)
  231|    402|    {
  232|    402|    }
_ZN8jsoncons16basic_staj_eventIcEC2EmNS_12semantic_tagENS_11staj_eventsE:
  250|    175|        : event_flags_(staj_events::uint64_value | key_flag), tag_(tag)
  251|    175|    {
  252|    175|        value_.uint64_value_ = value;
  253|    175|    }
_ZN8jsoncons16basic_staj_eventIcEC2ElNS_12semantic_tagENS_11staj_eventsE:
  243|    253|        : event_flags_(staj_events::int64_value | key_flag), tag_(tag)
  244|    253|    {
  245|    253|        value_.int64_value_ = value;
  246|    253|    }
_ZN8jsoncons16basic_staj_eventIcEC2EdNS_12semantic_tagENS_11staj_eventsE:
  264|    700|        : event_flags_(staj_events::double_value | key_flag), tag_(tag)
  265|    700|    {
  266|    700|        value_.double_value_ = value;
  267|    700|    }
_ZN8jsoncons16basic_staj_eventIcEC2EbNS_12semantic_tagENS_11staj_eventsE:
  236|      2|        : event_flags_(staj_events::bool_value | key_flag), tag_(tag)
  237|      2|    {
  238|      2|        value_.bool_value_ = value;
  239|      2|    }
_ZN8jsoncons16basic_staj_eventIcEC2ERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_11staj_eventsENS_12semantic_tagES9_:
  273|  2.37k|        : event_flags_(event_type | key_flag), tag_(tag), length_(s.length())
  274|  2.37k|    {
  275|  2.37k|        value_.string_data_ = s.data();
  276|  2.37k|    }
_ZN8jsoncons16basic_staj_eventIcEC2ERKNS_16byte_string_viewENS_11staj_eventsENS_12semantic_tagES5_:
  282|     79|        : event_flags_(event_type | key_flag), tag_(tag), length_(s.size())
  283|     79|    {
  284|     79|        value_.byte_string_data_ = s.data();
  285|     79|    }
_ZN8jsoncons16basic_staj_eventIcEC2ERKNS_16byte_string_viewENS_11staj_eventsEmS5_:
  291|      3|        : event_flags_(event_type | key_flag), tag_(semantic_tag::ext), raw_tag_(raw_tag), length_(s.size())
  292|      3|    {
  293|      3|        value_.byte_string_data_ = s.data();
  294|      3|    }
_ZN8jsoncons16basic_staj_eventIcEC2ENS_10half_arg_tEtNS_12semantic_tagENS_11staj_eventsE:
  257|    131|        : event_flags_(staj_events::half_value | key_flag), tag_(tag)
  258|    131|    {
  259|    131|        value_.half_value_ = value;
  260|    131|    }
_ZNK8jsoncons16basic_staj_eventIcE3getINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEET_RNS3_10error_codeE:
  317|  4.13k|    {
  318|  4.13k|        return get_<T>(std::allocator<char>{}, ec);
  319|  4.13k|    }
_ZNK8jsoncons16basic_staj_eventIcE4get_INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES8_cEENS3_9enable_ifIXaasr6nonstd9is_stringIT_EE5valuesr3std7is_sameINSB_10value_typeET1_EE5valueESB_E4typeET0_RNS3_10error_codeE:
  324|  4.13k|    {
  325|  4.13k|        constexpr const char_type* true_literal = JSONCONS_CSTRING_CONSTANT(char_type,"true"); 
  ------------------
  |  |  307|  4.13k|#define JSONCONS_CSTRING_CONSTANT(CharT, Str) jsoncons::cstring_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  305|  4.13k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  302|  4.13k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  326|  4.13k|        constexpr const char_type* false_literal = JSONCONS_CSTRING_CONSTANT(char_type,"false"); 
  ------------------
  |  |  307|  4.13k|#define JSONCONS_CSTRING_CONSTANT(CharT, Str) jsoncons::cstring_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  305|  4.13k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  302|  4.13k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  327|  4.13k|        constexpr const char_type* null_literal = JSONCONS_CSTRING_CONSTANT(char_type,"null"); 
  ------------------
  |  |  307|  4.13k|#define JSONCONS_CSTRING_CONSTANT(CharT, Str) jsoncons::cstring_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  305|  4.13k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  302|  4.13k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  328|       |
  329|  4.13k|        switch (storage_tag())
  330|  4.13k|        {
  331|  2.37k|            case staj_events::string_value:
  ------------------
  |  Branch (331:13): [True: 2.37k, False: 1.76k]
  ------------------
  332|  2.37k|            {
  333|  2.37k|                return jsoncons::make_obj_using_allocator<T>(alloc, value_.string_data_, length_);
  334|      0|            }
  335|     78|            case staj_events::byte_string_value:
  ------------------
  |  Branch (335:13): [True: 78, False: 4.05k]
  ------------------
  336|     78|            {
  337|     78|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  338|     78|                bytes_to_string(value_.byte_string_data_, value_.byte_string_data_+length_, tag(), s);
  339|     78|                return s;
  340|      0|            }
  341|    175|            case staj_events::uint64_value:
  ------------------
  |  Branch (341:13): [True: 175, False: 3.95k]
  ------------------
  342|    175|            {
  343|    175|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  344|    175|                jsoncons::from_integer(value_.uint64_value_, s);
  345|    175|                return s;
  346|      0|            }
  347|    253|            case staj_events::int64_value:
  ------------------
  |  Branch (347:13): [True: 253, False: 3.88k]
  ------------------
  348|    253|            {
  349|    253|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  350|    253|                jsoncons::from_integer(value_.int64_value_, s);
  351|    253|                return s;
  352|      0|            }
  353|    131|            case staj_events::half_value:
  ------------------
  |  Branch (353:13): [True: 131, False: 4.00k]
  ------------------
  354|    131|            {
  355|    131|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  356|    131|                jsoncons::write_double f{float_chars_format::general,0};
  357|    131|                double x = binary::decode_half(value_.half_value_);
  358|    131|                f(x, s);
  359|    131|                return s;
  360|      0|            }
  361|    700|            case staj_events::double_value:
  ------------------
  |  Branch (361:13): [True: 700, False: 3.43k]
  ------------------
  362|    700|            {
  363|    700|                auto s = jsoncons::make_obj_using_allocator<T>(alloc);
  364|    700|                jsoncons::write_double f{float_chars_format::general,0};
  365|    700|                f(value_.double_value_, s);
  366|    700|                return s;
  367|      0|            }
  368|      2|            case staj_events::bool_value:
  ------------------
  |  Branch (368:13): [True: 2, False: 4.13k]
  ------------------
  369|      2|            {
  370|      2|                return jsoncons::make_obj_using_allocator<T>(alloc, value_.bool_value_ ? true_literal : false_literal);
  ------------------
  |  Branch (370:69): [True: 1, False: 1]
  ------------------
  371|      0|            }
  372|      4|            case staj_events::null_value:
  ------------------
  |  Branch (372:13): [True: 4, False: 4.13k]
  ------------------
  373|      4|            {
  374|      4|                return jsoncons::make_obj_using_allocator<T>(alloc, null_literal);
  375|      0|            }
  376|    419|            default:
  ------------------
  |  Branch (376:13): [True: 419, False: 3.71k]
  ------------------
  377|    419|            {
  378|    419|                ec = conv_errc::not_string;
  379|    419|                return T{};
  380|      0|            }
  381|  4.13k|        }
  382|  4.13k|    }

_ZN8jsoncons16typed_array_castIKhEENS_6nonstd4spanIT_Lm18446744073709551615EEENS3_IhLm18446744073709551615EEE:
  141|      3|{
  142|      3|    return jsoncons::span<const uint8_t>{reinterpret_cast<const uint8_t*>(bytes.data()), bytes.size()};
  143|      3|}
_ZN8jsoncons16typed_array_castIhEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   81|      3|{
   82|      3|    return bytes;
   83|      3|}
_ZN8jsoncons16typed_array_castItEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   87|     76|{
   88|     76|    return jsoncons::span<uint16_t>{reinterpret_cast<uint16_t*>(bytes.data()), bytes.size()/sizeof(uint16_t)};
   89|     76|}
_ZN8jsoncons16typed_array_castIjEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   93|     56|{
   94|     56|    return jsoncons::span<uint32_t>{reinterpret_cast<uint32_t*>(bytes.data()), bytes.size()/sizeof(uint32_t)};
   95|     56|}
_ZN8jsoncons16typed_array_castImEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   99|     40|{
  100|     40|    return jsoncons::span<uint64_t>{reinterpret_cast<uint64_t*>(bytes.data()), bytes.size()/sizeof(uint64_t)};
  101|     40|}
_ZN8jsoncons16typed_array_castIaEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  105|      2|{
  106|      2|    return jsoncons::span<int8_t>{reinterpret_cast<int8_t*>(bytes.data()), bytes.size()};
  107|      2|}
_ZN8jsoncons16typed_array_castIsEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  111|     50|{
  112|     50|    return jsoncons::span<int16_t>{reinterpret_cast<int16_t*>(bytes.data()), bytes.size()/sizeof(int16_t)};
  113|     50|}
_ZN8jsoncons16typed_array_castIiEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  117|     56|{
  118|     56|    return jsoncons::span<int32_t>{reinterpret_cast<int32_t*>(bytes.data()), bytes.size()/sizeof(int32_t)};
  119|     56|}
_ZN8jsoncons16typed_array_castIlEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  123|     52|{
  124|     52|    return jsoncons::span<int64_t>{reinterpret_cast<int64_t*>(bytes.data()), bytes.size()/sizeof(int64_t)};
  125|     52|}
_ZN8jsoncons16typed_array_castIfEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  129|     40|{
  130|     40|    return jsoncons::span<float>{reinterpret_cast<float*>(bytes.data()), bytes.size()/sizeof(float)};
  131|     40|}
_ZN8jsoncons16typed_array_castIdEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  135|     34|{
  136|     34|    return jsoncons::span<double>{reinterpret_cast<double*>(bytes.data()), bytes.size()/sizeof(double)};
  137|     34|}
_ZN8jsoncons22calculate_mdarray_sizeENS_6nonstd4spanIKmLm18446744073709551615EEE:
  247|    255|{
  248|    255|    using result_type = jsoncons::expected<std::size_t,std::errc>;
  249|       |
  250|    255|    if (extents.empty())
  ------------------
  |  Branch (250:9): [True: 5, False: 250]
  ------------------
  251|      5|    {
  252|      5|        return result_type(0);
  253|      5|    }
  254|    250|    std::size_t n = extents[0];
  255|  4.27k|    for (std::size_t i = 1; i < extents.size(); ++i)
  ------------------
  |  Branch (255:29): [True: 4.05k, False: 217]
  ------------------
  256|  4.05k|    {
  257|  4.05k|        if (extents[i] == 0 || JSONCONS_UNLIKELY(n > (std::numeric_limits<std::size_t>::max)()/extents[i]))
  ------------------
  |  |   79|  4.04k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 16, False: 4.02k]
  |  |  ------------------
  ------------------
  |  Branch (257:13): [True: 17, False: 4.04k]
  ------------------
  258|     33|        {
  259|     33|            return result_type(jsoncons::unexpect, std::errc::value_too_large);
  260|     33|        }
  261|  4.02k|        n *= extents[i];
  262|  4.02k|    }
  263|    217|    return n;
  264|    250|}

_ZN8jsoncons12basic_bigdecINSt3__19allocatorImEEEC2EONS_12basic_bigintIS3_EEl:
   42|    617|        : unscaled_{unscaled}, scale_{scale}
   43|    617|    {
   44|    617|    }
_ZN8jsoncons16append_to_bufferINSt3__19allocatorImEEcNS2_IcEEEEvRKNS_12basic_bigdecIT_EERNS1_12basic_stringIT0_NS1_11char_traitsISB_EET1_EE:
  398|    617|{
  399|    617|    if (value.scale() == 0)
  ------------------
  |  Branch (399:9): [True: 68, False: 549]
  ------------------
  400|     68|    {
  401|     68|        append_to_buffer(value.unscaled(), buf);
  402|     68|        return;
  403|     68|    }
  404|    549|    if (value.unscaled().is_negative())
  ------------------
  |  Branch (404:9): [True: 272, False: 277]
  ------------------
  405|    272|    {
  406|    272|        buf.push_back('-');
  407|    272|    }
  408|    549|    std::basic_string<CharT> coeff;
  409|    549|    append_to_buffer(value.unscaled().is_negative() ? -value.unscaled() : value.unscaled(), coeff);
  ------------------
  |  Branch (409:22): [True: 272, False: 277]
  ------------------
  410|    549|    std::size_t coeffLen = coeff.size();
  411|    549|    if ((value.scale() >= 0) && (value.scale() <= static_cast<int64_t>(coeffLen) + 5)) 
  ------------------
  |  Branch (411:9): [True: 380, False: 169]
  |  Branch (411:33): [True: 218, False: 162]
  ------------------
  412|    218|    { 
  413|    218|        int64_t pad = value.scale() - coeffLen;         // padding zeros
  414|    218|        if (pad >= 0) {                                 // 0.xxx form
  ------------------
  |  Branch (414:13): [True: 33, False: 185]
  ------------------
  415|     33|            buf.push_back('0');
  416|     33|            buf.push_back('.');
  417|    115|            for (; pad>0; pad--) {
  ------------------
  |  Branch (417:20): [True: 82, False: 33]
  ------------------
  418|     82|                buf.push_back('0');
  419|     82|            }
  420|     33|            buf.append(coeff.data(), coeffLen);
  421|     33|        } 
  422|    185|        else 
  423|    185|        {
  424|    185|            buf.append(coeff.data(), -pad);
  425|    185|            buf.push_back('.');
  426|    185|            buf.append(coeff.data() -pad, value.scale());
  427|    185|        }
  428|    218|    }
  429|    331|    else
  430|    331|    {
  431|    331|        buf.push_back(coeff[0]);   // first character
  432|    331|        if (coeffLen > 1) 
  ------------------
  |  Branch (432:13): [True: 158, False: 173]
  ------------------
  433|    158|        {
  434|    158|            buf.push_back('.');
  435|    158|            buf.append(coeff.data() + 1, coeffLen - 1);
  436|    158|        }
  437|    331|        int64_t digits = static_cast<int64_t>(coeffLen) - 1;
  438|    331|        if (value.scale() != digits) 
  ------------------
  |  Branch (438:13): [True: 331, False: 0]
  ------------------
  439|    331|        {             
  440|    331|            buf.push_back('e');
  441|    331|            if (value.scale() < digits)
  ------------------
  |  Branch (441:17): [True: 169, False: 162]
  ------------------
  442|    169|            {
  443|    169|                from_integer(static_cast<uint64_t>(digits) - static_cast<uint64_t>(value.scale()), buf);
  444|    169|            }
  445|    162|            else
  446|    162|            {
  447|    162|                from_integer(digits - value.scale(), buf);
  448|    162|            }
  449|    331|        }
  450|    331|    }
  451|    549|}
_ZNK8jsoncons12basic_bigdecINSt3__19allocatorImEEE5scaleEv:
   78|  2.94k|    {
   79|  2.94k|        return scale_;
   80|  2.94k|    }
_ZNK8jsoncons12basic_bigdecINSt3__19allocatorImEEE8unscaledEv:
   73|  1.71k|    {
   74|  1.71k|        return unscaled_;
   75|  1.71k|    }

_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE13from_bytes_beEiPKhm:
  824|  1.32k|    {
  825|  1.32k|        static const double radix_log2 = std::log2(next_power_of_two(256));
  826|       |        // Estimate how big the result will be, so we can pre-allocate it.
  827|  1.32k|        double bits = radix_log2 * n;
  828|  1.32k|        double big_digits = std::ceil(bits / 64.0);
  829|       |        //std::cout << "ESTIMATED: " << big_digits << "\n";
  830|       |
  831|  1.32k|        basic_bigint<Allocator> v = 0;
  832|  1.32k|        v.reserve(static_cast<size_type>(big_digits));
  833|       |
  834|   789k|        for (size_type i = 0; i < n; i++)
  ------------------
  |  Branch (834:31): [True: 787k, False: 1.32k]
  ------------------
  835|   787k|        {
  836|   787k|            v *= 256;
  837|   787k|            v += (word_type)(bytes[i]);
  838|   787k|        }
  839|       |        //std::cout << "ACTUAL: " << v.size() << "\n";
  840|       |
  841|  1.32k|        if (signum < 0)
  ------------------
  |  Branch (841:13): [True: 0, False: 1.32k]
  ------------------
  842|      0|        {
  843|      0|            v.set_negative(true);
  844|      0|        }
  845|       |
  846|  1.32k|        return v;
  847|  1.32k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE17next_power_of_twoEm:
 2043|      1|    static word_type next_power_of_two(word_type n) {
 2044|      1|        n = n - 1;
 2045|      1|        n |= n >> 1u;
 2046|      1|        n |= n >> 2u;
 2047|      1|        n |= n >> 4u;
 2048|      1|        n |= n >> 8u;
 2049|      1|        n |= n >> 16u;
 2050|      1|        n |= n >> 32u;
 2051|      1|        return n + 1;
 2052|      1|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE7reserveEm:
  855|  1.32k|    {
  856|  1.32k|        storage_.reserve(n);
  857|  1.32k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7reserveEm:
  455|  1.16M|    {
  456|  1.16M|       if (capacity() < n)
  ------------------
  |  Branch (456:12): [True: 2.44k, False: 1.15M]
  ------------------
  457|  2.44k|       {
  458|  2.44k|           if (!is_allocated())
  ------------------
  |  Branch (458:16): [True: 2.44k, False: 2]
  ------------------
  459|  2.44k|           {
  460|  2.44k|               size_type size = inlined_.size_;
  461|  2.44k|               size_type is_neg = inlined_.is_negative_;
  462|  2.44k|               word_type values[inlined_capacity] = {inlined_.values_[0], inlined_.values_[1]};
  463|       |
  464|  2.44k|               ::new (&allocated_) allocated_storage();
  465|  2.44k|               allocated_.reserve(n, get_allocator());
  466|  2.44k|               allocated_.size_ = size;
  467|  2.44k|               allocated_.is_negative_ = is_neg;
  468|  2.44k|               if (n >= 1)
  ------------------
  |  Branch (468:20): [True: 2.44k, False: 0]
  ------------------
  469|  2.44k|               {
  470|  2.44k|                   allocated_.data_[0] = values[0];
  471|  2.44k|               }
  472|  2.44k|               if (n >= 2)
  ------------------
  |  Branch (472:20): [True: 2.44k, False: 0]
  ------------------
  473|  2.44k|               {
  474|  2.44k|                   allocated_.data_[1] = values[1];
  475|  2.44k|               }
  476|  2.44k|           }
  477|      2|           else
  478|      2|           {
  479|      2|               allocated_.reserve(n, get_allocator());
  480|      2|           }
  481|  2.44k|       }
  482|  1.16M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE8capacityEv:
  508|  1.16M|    {
  509|  1.16M|        return is_allocated() ? allocated_.capacity_ : inlined_capacity;
  ------------------
  |  Branch (509:16): [True: 1.11M, False: 47.1k]
  ------------------
  510|  1.16M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12is_allocatedEv:
  503|  3.05M|    {
  504|  3.05M|        return common_.is_allocated_;
  505|  3.05M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2Ev:
  206|  2.44k|            : is_allocated_(true),
  207|  2.44k|            is_negative_(false)
  208|  2.44k|        {
  209|  2.44k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7reserveEmRKS4_:
  258|  2.44k|        {
  259|  2.44k|            JSONCONS_ASSERT(n < max_size);
  ------------------
  |  |   54|  2.44k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 2.44k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  260|  2.44k|            size_type capacity_new = round_up(n);
  261|       |
  262|  2.44k|            real_allocator_type alloc(a);
  263|  2.44k|            word_type* data_new = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_new);
  264|  2.44k|            if (size_ > 0)
  ------------------
  |  Branch (264:17): [True: 2, False: 2.44k]
  ------------------
  265|      2|            {
  266|      2|                std::memcpy(data_new, data_, size_type(size_ * sizeof(word_type)));
  267|      2|            }
  268|  2.44k|            if (data_ != nullptr)
  ------------------
  |  Branch (268:17): [True: 2, False: 2.44k]
  ------------------
  269|      2|            {
  270|      2|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  271|      2|            }
  272|  2.44k|            capacity_ = capacity_new;
  273|  2.44k|            data_ = data_new;
  274|  2.44k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage8round_upEm:
  278|  2.44k|        {
  279|  2.44k|            size_type remainder = i % mem_unit;
  280|  2.44k|            size_type off = mem_unit - remainder;
  281|  2.44k|            bool testoff = i < max_size - off;
  282|  2.44k|            JSONCONS_ASSERT(testoff);
  ------------------
  |  |   54|  2.44k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 2.44k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  283|       |
  284|  2.44k|            return i + off;
  285|  2.44k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE13get_allocatorEv:
  485|   629k|    {
  486|   629k|        return static_cast<const word_allocator_type&>(*this);
  487|   629k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLIiEENS1_9enable_ifIXsr6nonstd17is_signed_integerIT_EE5valueERS4_E4typeES7_:
 1020|   787k|    {
 1021|   787k|        *this *= word_type(y < 0 ? -y : y);
  ------------------
  |  Branch (1021:28): [True: 0, False: 787k]
  ------------------
 1022|   787k|        if ( y < 0 )
  ------------------
  |  Branch (1022:14): [True: 0, False: 787k]
  ------------------
 1023|      0|            set_negative(!is_negative());
 1024|   787k|        return *this;
 1025|   787k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLImEENS1_9enable_ifIXsr6nonstd19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
 1030|   787k|    {
 1031|   787k|        auto words = get_words();
 1032|   787k|        size_type len = words.size();
 1033|   787k|        if (len == 0 || m == 0)
  ------------------
  |  Branch (1033:13): [True: 1.83k, False: 785k]
  |  Branch (1033:25): [True: 0, False: 785k]
  ------------------
 1034|  1.83k|        {
 1035|  1.83k|            resize(0);
 1036|  1.83k|            return *this;
 1037|  1.83k|        }
 1038|       |
 1039|   785k|        dword_type carry = 0;
 1040|   785k|        size_t i = 0;
 1041|   862M|        for (; i < len; ++i) {
  ------------------
  |  Branch (1041:16): [True: 861M, False: 785k]
  ------------------
 1042|   861M|            dword_type x = dword_type(words[i]) * m + carry;
 1043|   861M|            words[i] = static_cast<word_type>(x);
 1044|   861M|            carry = x >> 64;
 1045|   861M|        }
 1046|       |
 1047|   785k|        if (carry)
  ------------------
  |  Branch (1047:13): [True: 97.5k, False: 688k]
  ------------------
 1048|  97.5k|        {
 1049|  97.5k|            resize(len+1);
 1050|  97.5k|            words = get_words();
 1051|  97.5k|            words[i] = static_cast<word_type>(carry);
 1052|  97.5k|        }
 1053|       |
 1054|       |        /*
 1055|       |        word_type dig = words[0];
 1056|       |        word_type carry = 0;
 1057|       |
 1058|       |        resize(words.size() + 1);
 1059|       |        words = get_words();
 1060|       |
 1061|       |        size_type i = 0;
 1062|       |        for (; i < len; i++ )
 1063|       |        {
 1064|       |            word_type hi;
 1065|       |            word_type lo;
 1066|       |            DDproduct( dig, y, hi, lo );
 1067|       |            words[i] = lo + carry;
 1068|       |            dig = words[i+1];
 1069|       |            carry = hi + (words[i] < lo);
 1070|       |        }
 1071|       |        words[i] = carry;
 1072|       |        reduce(); 
 1073|       |        */ 
 1074|   785k|        return *this;
 1075|   787k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE9get_wordsEv:
  697|  3.90M|    {
  698|  3.90M|        return storage_.get_words();
  699|  3.90M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE9get_wordsEv:
  523|  5.20M|    {
  524|  5.20M|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (524:16): [True: 4.52M, False: 679k]
  ------------------
  525|  4.52M|            storage_view<word_type>{allocated_.data_, allocated_.size_} :
  526|  5.20M|            storage_view<word_type>{inlined_.values_, inlined_.size_};
  527|  5.20M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEC2EPmm:
   67|  5.20M|            : data_(data), size_(size)
   68|  5.20M|        {
   69|  5.20M|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4sizeEv:
   87|  5.47M|        {
   88|  5.47M|            return size_;
   89|  5.47M|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6resizeEm:
  850|  1.05M|    {
  851|  1.05M|        storage_.resize(new_length);
  852|  1.05M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6resizeEm:
  537|  1.15M|    {
  538|  1.15M|        size_type old_length = common_.size_;
  539|  1.15M|        reserve(new_length);
  540|  1.15M|        common_.size_ = new_length;
  541|       |
  542|  1.15M|        if (old_length < new_length)
  ------------------
  |  Branch (542:13): [True: 1.05M, False: 107k]
  ------------------
  543|  1.05M|        {
  544|  1.05M|            if (is_allocated())
  ------------------
  |  Branch (544:17): [True: 1.01M, False: 40.3k]
  ------------------
  545|  1.01M|            {
  546|  1.01M|                std::memset(allocated_.data_+old_length, 0, size_type((new_length-old_length)*sizeof(word_type)));
  547|  1.01M|            }
  548|  40.3k|            else
  549|  40.3k|            {
  550|  40.3k|                JSONCONS_ASSERT(new_length <= inlined_capacity);
  ------------------
  |  |   54|  40.3k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 40.3k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  551|  83.5k|                for (size_type i = old_length; i < inlined_capacity; ++i)
  ------------------
  |  Branch (551:48): [True: 43.2k, False: 40.3k]
  ------------------
  552|  43.2k|                {
  553|  43.2k|                    inlined_.values_[i] = 0;
  554|  43.2k|                }
  555|  40.3k|            }
  556|  1.05M|        }
  557|  1.15M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEixEm:
   72|  2.37G|        {
   73|  2.37G|            return data_[i];
   74|  2.37G|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11is_negativeEv:
  707|  1.41M|    {
  708|  1.41M|        return storage_.is_negative();
  709|  1.41M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE11is_negativeEv:
  513|  1.41M|    {
  514|  1.41M|        return common_.is_negative_;
  515|  1.41M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLImEENS1_9enable_ifIXaasr6nonstd19is_unsigned_integerIT_EE5valuelestS7_Lm8EERS4_E4typeES7_:
  921|   787k|    {
  922|   787k|        if ( is_negative())
  ------------------
  |  Branch (922:14): [True: 0, False: 787k]
  ------------------
  923|      0|            return *this -= -basic_bigint<Allocator>(y);
  924|       |
  925|   787k|        word_type d;
  926|   787k|        word_type carry = 0;
  927|       |
  928|   787k|        auto words = get_words();
  929|   787k|        resize(words.size() + 1);
  930|       |
  931|   787k|        words = get_words();
  932|   787k|        const size_type this_size = words.size();
  933|   787k|        size_type y_size = 1;
  934|       |
  935|   787k|        d = words[0] + carry;
  936|   787k|        carry = d < carry;
  937|   787k|        words[0] = d + y;
  938|   787k|        if (words[0] < d)
  ------------------
  |  Branch (938:13): [True: 0, False: 787k]
  ------------------
  939|      0|            carry = 1;
  940|       |
  941|   787k|        for (size_type i = y_size; i < this_size && carry != 0; ++i)
  ------------------
  |  Branch (941:36): [True: 785k, False: 1.83k]
  |  Branch (941:53): [True: 0, False: 785k]
  ------------------
  942|      0|        {
  943|      0|            d = words[i] + carry;
  944|      0|            carry = d < carry;
  945|      0|            words[i] = d;
  946|      0|        }
  947|   787k|        reduce();
  948|   787k|        return *this;
  949|   787k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ImEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  672|  5.03k|        : storage_(n, alloc)
  673|  5.03k|    {
  674|  5.03k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ImEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  363|  5.03k|        : word_allocator_type(alloc)
  364|  5.03k|    {
  365|  5.03k|        ::new (&inlined_) inlined_storage(n);
  366|  5.03k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ImEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  141|  5.03k|            : is_allocated_(false),
  142|  5.03k|            is_negative_(false),
  143|  5.03k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (143:19): [True: 1.93k, False: 3.10k]
  ------------------
  144|  5.03k|        {
  145|  5.03k|            values_[0] = n;
  146|  5.03k|            values_[1] = 0;
  147|  5.03k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEEngEv:
  867|  1.32k|    {
  868|  1.32k|        basic_bigint<Allocator> v(*this);
  869|  1.32k|        v.set_negative(!v.is_negative());
  870|  1.32k|        return v;
  871|  1.32k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_:
  650|  6.53k|        : storage_(other.storage_)
  651|  6.53k|    {
  652|  6.53k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_:
  302|  6.53k|        : word_allocator_type(other.get_allocator())
  303|  6.53k|    {
  304|       |#if defined(__GNUC__) && JSONCONS_GCC_AVAILABLE(12,0,0)
  305|       |# pragma GCC diagnostic push
  306|       |# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
  307|       |#endif
  308|  6.53k|        if (!other.is_allocated())
  ------------------
  |  Branch (308:13): [True: 3.67k, False: 2.86k]
  ------------------
  309|  3.67k|        {
  310|  3.67k|            ::new (&inlined_) inlined_storage(other.inlined_);
  311|  3.67k|        }
  312|  2.86k|        else
  313|  2.86k|        {
  314|  2.86k|            ::new (&allocated_) allocated_storage(other.allocated_, get_allocator());
  315|  2.86k|        }
  316|       |#if defined(__GNUC__) && JSONCONS_GCC_AVAILABLE(12,0,0)
  317|       |# pragma GCC diagnostic pop
  318|       |#endif
  319|  6.53k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ERKS6_:
  181|   208k|            : is_allocated_(false),
  182|   208k|            is_negative_(stor.is_negative_),
  183|   208k|            size_(stor.size_)
  184|   208k|        {
  185|   208k|            values_[0] = stor.values_[0];
  186|   208k|            values_[1] = stor.values_[1];
  187|   208k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2ERKS6_RKS4_:
  212|   205k|            : is_allocated_(true),
  213|   205k|              is_negative_(stor.is_negative_),
  214|   205k|              size_(stor.size_),
  215|   205k|              capacity_(stor.capacity_)
  216|   205k|        {
  217|   205k|            real_allocator_type alloc(a);
  218|       |
  219|   205k|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_);
  220|   205k|            JSONCONS_TRY
  ------------------
  |  |   37|   205k|    #define JSONCONS_TRY try
  ------------------
  221|   205k|            {
  222|   205k|                std::allocator_traits<real_allocator_type>::construct(alloc, nonstd::to_plain_pointer(data_));
  223|   205k|            }
  224|   205k|            JSONCONS_CATCH(...)
  225|   205k|            {
  226|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  227|      0|                data_ = nullptr;
  228|      0|                JSONCONS_RETHROW;
  ------------------
  |  |   36|      0|    #define JSONCONS_RETHROW throw
  ------------------
  229|      0|            }
  230|   205k|            JSONCONS_ASSERT(stor.data_ != nullptr);
  ------------------
  |  |   54|   205k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 205k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  231|   205k|            std::memcpy(data_, stor.data_, size_type(stor.size_ * sizeof(word_type)));
  232|   205k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmIERKS4_:
  986|  1.04k|    {
  987|  1.04k|        auto y_words = y.get_words();
  988|       |
  989|  1.04k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (989:14): [True: 1.04k, False: 0]
  ------------------
  990|  1.04k|            return *this += -y;
  991|      0|        if ( (!is_negative() && y > *this) || (is_negative() && y < *this) )
  ------------------
  |  Branch (991:15): [True: 0, False: 0]
  |  Branch (991:33): [True: 0, False: 0]
  |  Branch (991:48): [True: 0, False: 0]
  |  Branch (991:65): [True: 0, False: 0]
  ------------------
  992|      0|            return *this = -(y - *this);
  993|      0|        word_type borrow = 0;
  994|      0|        word_type d;
  995|      0|        auto words = get_words();
  996|      0|        const size_type this_size = words.size();
  997|      0|        const size_type y_size = y_words.size();
  998|       |
  999|      0|        for (size_type i = 0; i < y_size; i++ )
  ------------------
  |  Branch (999:31): [True: 0, False: 0]
  ------------------
 1000|      0|        {
 1001|      0|            d = words[i] - borrow;
 1002|      0|            borrow = d > words[i];
 1003|      0|            words[i] = d - y_words[i];
 1004|      0|            if ( words[i] > d )
  ------------------
  |  Branch (1004:18): [True: 0, False: 0]
  ------------------
 1005|      0|                borrow = 1;
 1006|      0|        }
 1007|      0|        for (size_type i = y_size; i < this_size && borrow != 0; i++ )
  ------------------
  |  Branch (1007:36): [True: 0, False: 0]
  |  Branch (1007:53): [True: 0, False: 0]
  ------------------
 1008|      0|        {
 1009|      0|            d = words[i] - borrow;
 1010|      0|            borrow = d > words[i];
 1011|      0|            words[i] = d;
 1012|      0|        }
 1013|      0|        reduce();
 1014|      0|        return *this;
 1015|      0|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9get_wordsEv:
  702|   310k|    {
  703|   310k|        return storage_.get_words();
  704|   310k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE9get_wordsEv:
  530|   417k|    {
  531|   417k|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (531:16): [True: 307k, False: 110k]
  ------------------
  532|   307k|            storage_view<const word_type>{allocated_.data_, allocated_.size_} :
  533|   417k|            storage_view<const word_type>{inlined_.values_, inlined_.size_};
  534|   417k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEC2EPS7_m:
   67|   417k|            : data_(data), size_(size)
   68|   417k|        {
   69|   417k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLERKS4_:
  952|  1.04k|    {
  953|  1.04k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (953:14): [True: 0, False: 1.04k]
  ------------------
  954|      0|            return *this -= -y;
  955|       |
  956|  1.04k|        auto y_words = y.get_words();
  957|       |        
  958|  1.04k|        word_type d;
  959|  1.04k|        word_type carry = 0;
  960|       |
  961|  1.04k|        auto words = get_words();
  962|  1.04k|        resize( (std::max)(y_words.size(), words.size()) + 1 );
  963|  1.04k|        words = get_words();
  964|       |
  965|  1.04k|        const size_t this_size = words.size();
  966|  1.04k|        const size_t y_size = y_words.size();
  967|  91.2k|        for (size_type i = 0; i < y_size; i++ )
  ------------------
  |  Branch (967:31): [True: 90.2k, False: 1.04k]
  ------------------
  968|  90.2k|        {
  969|  90.2k|            d = words[i] + carry;
  970|  90.2k|            carry = d < carry;
  971|  90.2k|            words[i] = d + y_words[i];
  972|  90.2k|            if (words[i] < d)
  ------------------
  |  Branch (972:17): [True: 405, False: 89.8k]
  ------------------
  973|    405|                carry = 1;
  974|  90.2k|        }
  975|  1.06k|        for (size_type i = y_size; i < this_size && carry != 0; i++ )
  ------------------
  |  Branch (975:36): [True: 1.04k, False: 11]
  |  Branch (975:53): [True: 11, False: 1.03k]
  ------------------
  976|     11|        {
  977|     11|            d = words[i] + carry;
  978|     11|            carry = d < carry;
  979|     11|            words[i] = d;
  980|     11|        }
  981|  1.04k|        reduce();
  982|  1.04k|        return *this;
  983|  1.04k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7compareERKS4_:
 1702|   102k|    {
 1703|   102k|        auto words = get_words();
 1704|   102k|        auto y_words = y.get_words();
 1705|       |
 1706|   102k|        const size_type y_size = y_words.size();
 1707|   102k|        if ( words.size() == 0 && y_size == 0 )
  ------------------
  |  Branch (1707:14): [True: 0, False: 102k]
  |  Branch (1707:35): [True: 0, False: 0]
  ------------------
 1708|      0|            return 0;
 1709|   102k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (1709:14): [True: 0, False: 102k]
  ------------------
 1710|      0|            return y.is_negative() - is_negative();
 1711|   102k|        int code = 0;
 1712|   102k|        if ( words.size() < y_size)
  ------------------
  |  Branch (1712:14): [True: 0, False: 102k]
  ------------------
 1713|      0|            code = -1;
 1714|   102k|        else if ( words.size() > y_size)
  ------------------
  |  Branch (1714:19): [True: 100k, False: 2.29k]
  ------------------
 1715|   100k|            code = +1;
 1716|  2.29k|        else
 1717|  2.29k|        {
 1718|  2.30k|            for (size_type i = words.size(); i-- > 0; )
  ------------------
  |  Branch (1718:46): [True: 2.29k, False: 5]
  ------------------
 1719|  2.29k|            {
 1720|  2.29k|                if (words[i] > y_words[i])
  ------------------
  |  Branch (1720:21): [True: 462, False: 1.83k]
  ------------------
 1721|    462|                {
 1722|    462|                    code = 1;
 1723|    462|                    break;
 1724|    462|                }
 1725|  1.83k|                else if (words[i] < y_words[i])
  ------------------
  |  Branch (1725:26): [True: 1.82k, False: 5]
  ------------------
 1726|  1.82k|                {
 1727|  1.82k|                    code = -1;
 1728|  1.82k|                    break;
 1729|  1.82k|                }
 1730|  2.29k|            }
 1731|  2.29k|        }
 1732|   102k|        return is_negative() ? -code : code;
  ------------------
  |  Branch (1732:16): [True: 0, False: 102k]
  ------------------
 1733|   102k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEES6_:
 1537|   102k|    {
 1538|   102k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1538:15): [True: 1.82k, False: 101k]
  ------------------
 1539|   102k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4sizeEv:
   87|   735k|        {
   88|   735k|            return size_;
   89|   735k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEixEm:
   72|  98.4k|        {
   73|  98.4k|            return data_[i];
   74|  98.4k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6reduceEv:
 2039|  1.19M|    {
 2040|  1.19M|        storage_.reduce();
 2041|  1.19M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6reduceEv:
  432|  1.19M|    {
  433|  1.19M|        if (common_.size_ > 0)
  ------------------
  |  Branch (433:13): [True: 1.19M, False: 0]
  ------------------
  434|  1.19M|        {
  435|  1.19M|            auto words = get_words();
  436|  1.19M|            word_type* p = words.end() - 1;
  437|  1.19M|            word_type* first = words.begin();
  438|   112M|            while ( p >= first )
  ------------------
  |  Branch (438:21): [True: 112M, False: 1.49k]
  ------------------
  439|   112M|            {
  440|   112M|                if ( *p )
  ------------------
  |  Branch (440:22): [True: 1.19M, False: 111M]
  ------------------
  441|  1.19M|                {
  442|  1.19M|                    break;
  443|  1.19M|                }
  444|   111M|                --common_.size_;
  445|   111M|                --p;
  446|   111M|            }
  447|  1.19M|        }
  448|  1.19M|        if (common_.size_ == 0)
  ------------------
  |  Branch (448:13): [True: 1.49k, False: 1.19M]
  ------------------
  449|  1.49k|        {
  450|  1.49k|            common_.is_negative_ = false;
  451|  1.49k|        }
  452|  1.19M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE3endEv:
   96|  1.19M|        {
   97|  1.19M|            return data_ + size_;
   98|  1.19M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE5beginEv:
   91|  1.19M|        {
   92|  1.19M|            return data_;
   93|  1.19M|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE12set_negativeEb:
  728|   413k|    {
  729|   413k|        storage_.set_negative(value);
  730|   413k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12set_negativeEb:
  518|   413k|    {
  519|   413k|        common_.is_negative_ = value;
  520|   413k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16append_to_bufferIcNS1_11char_traitsIcEENS2_IcEEEEvRNS1_12basic_stringIT_T0_T1_EE:
 1414|    861|    {
 1415|    861|        if (is_zero())
  ------------------
  |  Branch (1415:13): [True: 4, False: 857]
  ------------------
 1416|      4|        {
 1417|      4|            buf.push_back('0');
 1418|      4|            return;
 1419|      4|        }
 1420|    857|        if (is_negative())
  ------------------
  |  Branch (1420:13): [True: 533, False: 324]
  ------------------
 1421|    533|        {
 1422|    533|            buf.push_back('-');
 1423|    533|        }
 1424|    857|        std::size_t pos = buf.size();
 1425|    857|        basic_bigint<Allocator> v(*this);
 1426|    857|        auto v_words = v.get_words();
 1427|       |
 1428|    857|        size_type len = (v_words.size() * word_bits / 3) + 2;
 1429|    857|        buf.reserve(len);
 1430|       |
 1431|    857|        if ( v_words.size() == 0 )
  ------------------
  |  Branch (1431:14): [True: 0, False: 857]
  ------------------
 1432|      0|        {
 1433|      0|            buf.push_back('0');
 1434|      0|        }
 1435|    857|        else
 1436|    857|        {
 1437|    857|            word_type r;
 1438|    857|            basic_bigint<Allocator> R(get_allocator());
 1439|    857|            basic_bigint<Allocator> LP10(max_unsigned_power_10, get_allocator()); 
 1440|       |
 1441|    857|            do
 1442|  32.8k|            {
 1443|  32.8k|                v.divide( LP10, v, R, true );
 1444|  32.8k|                v_words = v.get_words();
 1445|       |
 1446|  32.8k|                auto R_words = R.get_words();
 1447|  32.8k|                r = (R_words.size() ? R_words[0] : 0);
  ------------------
  |  Branch (1447:22): [True: 32.8k, False: 4]
  ------------------
 1448|   645k|                for ( size_type j=0; j < imax_unsigned_power_10; j++ )
  ------------------
  |  Branch (1448:38): [True: 613k, False: 32.0k]
  ------------------
 1449|   613k|                {
 1450|   613k|                    buf.push_back(char(r % 10u + '0'));
 1451|   613k|                    r /= 10u;
 1452|   613k|                    if ( r + v_words.size() == 0 )
  ------------------
  |  Branch (1452:26): [True: 857, False: 612k]
  ------------------
 1453|    857|                        break;
 1454|   613k|                }
 1455|  32.8k|            } 
 1456|  32.8k|            while ( v_words.size() > 0);
  ------------------
  |  Branch (1456:21): [True: 32.0k, False: 857]
  ------------------
 1457|       |
 1458|    857|            std::reverse(buf.begin()+pos,buf.end());
 1459|    857|        }
 1460|    857|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7is_zeroEv:
 2160|  1.47k|    bool is_zero() const {
 2161|  1.47k|        return get_words().size() == 0;
 2162|  1.47k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE13get_allocatorEv:
  692|   409k|    {
  693|   409k|        return storage_.get_allocator();
  694|   409k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS3_:
  623|  1.34k|        : storage_(alloc)
  624|  1.34k|    {
  625|  1.34k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS4_:
  296|  2.47k|        : word_allocator_type(alloc)
  297|  2.47k|    {
  298|  2.47k|        ::new (&inlined_) inlined_storage();
  299|  2.47k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2Ev:
  116|  2.47k|            : is_allocated_(false),
  117|  2.47k|            is_negative_(false),
  118|  2.47k|            size_(0),
  119|  2.47k|            values_{0, 0}
  120|  2.47k|        {
  121|  2.47k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE6divideERKS4_RS4_S7_b:
 1796|   102k|    {
 1797|   102k|        basic_bigint<Allocator> denom(denom_, get_allocator());
 1798|   102k|        auto denom_words = denom.get_words();
 1799|       |
 1800|   102k|        if (denom_words.size() == 0)
  ------------------
  |  Branch (1800:13): [True: 0, False: 102k]
  ------------------
 1801|      0|        {
 1802|      0|            JSONCONS_THROW(std::runtime_error( "Zero divide." ));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1803|      0|        }
 1804|   102k|        bool quot_neg = is_negative() ^ denom.is_negative();
 1805|   102k|        bool rem_neg = is_negative();
 1806|   102k|        basic_bigint<Allocator> num(*this, get_allocator());
 1807|   102k|        num.set_negative(false);
 1808|   102k|        denom.set_negative(false);
 1809|   102k|        if ( num < denom )
  ------------------
  |  Branch (1809:14): [True: 1.82k, False: 101k]
  ------------------
 1810|  1.82k|        {
 1811|  1.82k|            quot = word_type(0);
 1812|  1.82k|            quot.set_negative(quot_neg);
 1813|  1.82k|            rem = num;
 1814|  1.82k|            rem.set_negative(rem_neg);
 1815|  1.82k|            return;
 1816|  1.82k|        }
 1817|       |
 1818|   101k|        auto num_words = num.get_words();
 1819|   101k|        auto quot_words = quot.get_words();
 1820|   101k|        auto words = get_words();
 1821|       |
 1822|   101k|        if ( denom_words.size() == 1 && num_words.size() == 1 )
  ------------------
  |  Branch (1822:14): [True: 101k, False: 0]
  |  Branch (1822:41): [True: 467, False: 100k]
  ------------------
 1823|    467|        {
 1824|    467|            quot = word_type( num_words[0]/denom_words[0] );
 1825|    467|            rem = word_type( num_words[0]%denom_words[0] );
 1826|    467|            quot.set_negative(quot_neg);
 1827|    467|            rem.set_negative(rem_neg);
 1828|    467|            return;
 1829|    467|        }
 1830|   100k|        if (denom_words.size() == 1 && (denom_words[0] & l_mask) == 0 )
  ------------------
  |  Branch (1830:13): [True: 100k, False: 0]
  |  Branch (1830:40): [True: 0, False: 100k]
  ------------------
 1831|      0|        {
 1832|       |            // Denominator fits into a half word
 1833|      0|            word_type divisor = denom_words[0], dHi = 0, q1, r, q2, dividend;
 1834|      0|            quot.resize(words.size());
 1835|      0|            quot_words = quot.get_words();
 1836|      0|            for (size_type i=words.size(); i-- > 0; )
  ------------------
  |  Branch (1836:44): [True: 0, False: 0]
  ------------------
 1837|      0|            {
 1838|      0|                dividend = (dHi << word_half_bits) | (words[i] >> word_half_bits);
 1839|      0|                q1 = dividend/divisor;
 1840|      0|                r = dividend % divisor;
 1841|      0|                dividend = (r << word_half_bits) | (words[i] & r_mask);
 1842|      0|                q2 = dividend/divisor;
 1843|      0|                dHi = dividend % divisor;
 1844|      0|                quot_words[i] = (q1 << word_half_bits) | q2;
 1845|      0|            }
 1846|      0|            quot.reduce();
 1847|      0|            rem = dHi;
 1848|      0|            quot.set_negative(quot_neg);
 1849|      0|            rem.set_negative(rem_neg);
 1850|      0|            return;
 1851|      0|        }
 1852|   100k|        basic_bigint<Allocator> num0(num, get_allocator());
 1853|   100k|        basic_bigint<Allocator> denom0(denom, get_allocator());
 1854|   100k|        int x = 0;
 1855|   100k|        bool second_done = normalize(denom, num, x);
 1856|   100k|        denom_words = denom.get_words();
 1857|   100k|        num_words = num.get_words();
 1858|       |
 1859|   100k|        size_type l = denom_words.size() - 1;
 1860|   100k|        size_type n = num_words.size() - 1;
 1861|   100k|        quot.resize(n - l);
 1862|   100k|        quot_words = quot.get_words();
 1863|   110M|        for (size_type i = quot_words.size(); i-- > 0; )
  ------------------
  |  Branch (1863:47): [True: 110M, False: 100k]
  ------------------
 1864|   110M|        {
 1865|   110M|            quot_words[i] = 0;
 1866|   110M|        }
 1867|   100k|        rem = num;
 1868|   100k|        auto rem_words = rem.get_words();
 1869|   100k|        if ( rem_words[n] >= denom_words[l] )
  ------------------
  |  Branch (1869:14): [True: 1.45k, False: 99.2k]
  ------------------
 1870|  1.45k|        {
 1871|  1.45k|            rem.resize(rem_words.size() + 1);
 1872|  1.45k|            rem_words = rem.get_words();
 1873|  1.45k|            n++;
 1874|  1.45k|            quot.resize(quot_words.size() + 1);
 1875|  1.45k|            quot_words = quot.get_words();
 1876|  1.45k|        }
 1877|   100k|        word_type d = denom_words[l];
 1878|       |
 1879|   110M|        for ( size_type k = n; k > l; k-- )
  ------------------
  |  Branch (1879:32): [True: 110M, False: 100k]
  ------------------
 1880|   110M|        {
 1881|   110M|            word_type q = DDquotient(rem_words[k], rem_words[k-1], d);
 1882|   110M|            subtractmul( rem_words.data() + (k - l - 1), denom_words.data(), l + 1, q );
 1883|   110M|            quot_words[k - l - 1] = q;
 1884|   110M|        }
 1885|   100k|        quot.reduce();
 1886|   100k|        quot.set_negative(quot_neg);
 1887|   100k|        if (remDesired)
  ------------------
  |  Branch (1887:13): [True: 100k, False: 0]
  ------------------
 1888|   100k|        {
 1889|   100k|            unnormalize(rem, x, second_done);
 1890|   100k|            rem.set_negative(rem_neg);
 1891|   100k|        }
 1892|   100k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_RKS3_:
  655|   407k|        : storage_(other.storage_, alloc)
  656|   407k|    {
  657|   407k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_RKS4_:
  322|   407k|        : word_allocator_type(alloc)
  323|   407k|    {
  324|   407k|        if (!other.is_allocated())
  ------------------
  |  Branch (324:13): [True: 204k, False: 202k]
  ------------------
  325|   204k|        {
  326|   204k|            ::new (&inlined_) inlined_storage(other.inlined_);
  327|   204k|        }
  328|   202k|        else
  329|   202k|        {
  330|   202k|            ::new (&allocated_) allocated_storage(other.allocated_, alloc);
  331|   202k|        }
  332|   407k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9normalizeERS4_S5_Ri:
 1994|   100k|    {
 1995|   100k|        auto denom_words = denom.get_words();
 1996|   100k|        if (denom_words.size() == 0)
  ------------------
  |  Branch (1996:13): [True: 0, False: 100k]
  ------------------
 1997|      0|        {
 1998|      0|            return false;
 1999|      0|        }
 2000|   100k|        size_type r = denom_words.size() - 1;
 2001|   100k|        word_type y = denom_words[r];
 2002|       |
 2003|   100k|        x = 0;
 2004|   191k|        while ( (y & l_bit) == 0 )
  ------------------
  |  Branch (2004:17): [True: 91.0k, False: 100k]
  ------------------
 2005|  91.0k|        {
 2006|  91.0k|            y <<= 1;
 2007|  91.0k|            x++;
 2008|  91.0k|        }
 2009|   100k|        denom <<= x;
 2010|   100k|        num <<= x;
 2011|       |
 2012|   100k|        denom_words = denom.get_words();
 2013|   100k|        if ( r > 0 && denom_words[r] < denom_words[r-1] )
  ------------------
  |  Branch (2013:14): [True: 0, False: 100k]
  |  Branch (2013:23): [True: 0, False: 0]
  ------------------
 2014|      0|        {
 2015|      0|            denom *= max_word;
 2016|      0|            num *= max_word;
 2017|      0|            return true;
 2018|      0|        }
 2019|   100k|        return false;
 2020|   100k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEElSEm:
 1172|   201k|    {
 1173|   201k|        auto words = get_words();
 1174|   201k|        size_type q = k / word_bits;
 1175|   201k|        if ( q ) // Increase storage_.size() by q:
  ------------------
  |  Branch (1175:14): [True: 0, False: 201k]
  ------------------
 1176|      0|        {
 1177|      0|            resize(words.size() + q);
 1178|      0|            words = get_words();
 1179|      0|            for (size_type i = words.size(); i-- > 0; )
  ------------------
  |  Branch (1179:46): [True: 0, False: 0]
  ------------------
 1180|      0|                words[i] = ( i < q ? 0 : words[i - q]);
  ------------------
  |  Branch (1180:30): [True: 0, False: 0]
  ------------------
 1181|      0|            k %= word_bits;
 1182|      0|        }
 1183|   201k|        if ( k )  // 0 < k < word_bits:
  ------------------
  |  Branch (1183:14): [True: 60.7k, False: 140k]
  ------------------
 1184|  60.7k|        {
 1185|  60.7k|            size_type k1 = word_bits - k;
 1186|  60.7k|            word_type mask = (word_type(1) << k) - word_type(1);
 1187|  60.7k|            resize( words.size() + 1 );
 1188|  60.7k|            words = get_words();
 1189|  34.6M|            for (size_type i = words.size(); i-- > 0; )
  ------------------
  |  Branch (1189:46): [True: 34.6M, False: 60.7k]
  ------------------
 1190|  34.6M|            {
 1191|  34.6M|                words[i] <<= k;
 1192|  34.6M|                if ( i > 0 )
  ------------------
  |  Branch (1192:22): [True: 34.5M, False: 60.7k]
  ------------------
 1193|  34.5M|                    words[i] |= (words[i-1] >> k1) & mask;
 1194|  34.6M|            }
 1195|  60.7k|        }
 1196|   201k|        reduce();
 1197|   201k|        return *this;
 1198|   201k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE10DDquotientEmmm:
 1921|   110M|    {
 1922|   110M|        word_type left, middle, right, qHi, qLo, x, dLo1,
 1923|   110M|                   dHi = d >> word_half_bits, dLo = d & r_mask;
 1924|   110M|        qHi = A/(dHi + 1);
 1925|       |        // This initial guess of qHi may be too small.
 1926|   110M|        middle = qHi * dLo;
 1927|   110M|        left = qHi * dHi;
 1928|   110M|        x = B - (middle << word_half_bits);
 1929|   110M|        A -= (middle >> word_half_bits) + left + (x > B);
 1930|   110M|        B = x;
 1931|   110M|        dLo1 = dLo << word_half_bits;
 1932|       |        // Increase qHi if necessary:
 1933|   176M|        while ( A > dHi || (A == dHi && B >= dLo1) )
  ------------------
  |  Branch (1933:17): [True: 65.8M, False: 110M]
  |  Branch (1933:29): [True: 100k, False: 110M]
  |  Branch (1933:41): [True: 100k, False: 9]
  ------------------
 1934|  65.9M|        {
 1935|  65.9M|            x = B - dLo1;
 1936|  65.9M|            A -= dHi + (x > B);
 1937|  65.9M|            B = x;
 1938|  65.9M|            qHi++;
 1939|  65.9M|        }
 1940|   110M|        qLo = ((A << word_half_bits) | (B >> word_half_bits))/(dHi + 1);
 1941|       |        // This initial guess of qLo may be too small.
 1942|   110M|        right = qLo * dLo;
 1943|   110M|        middle = qLo * dHi;
 1944|   110M|        x = B - right;
 1945|   110M|        A -= (x > B);
 1946|   110M|        B = x;
 1947|   110M|        x = B - (middle << word_half_bits);
 1948|   110M|            A -= (middle >> word_half_bits) + (x > B);
 1949|   110M|        B = x;
 1950|       |        // Increase qLo if necessary:
 1951|   176M|        while ( A || B >= d )
  ------------------
  |  Branch (1951:17): [True: 1.08M, False: 175M]
  |  Branch (1951:22): [True: 64.9M, False: 110M]
  ------------------
 1952|  66.0M|        {
 1953|  66.0M|            x = B - d;
 1954|  66.0M|            A -= (x > B);
 1955|  66.0M|            B = x;
 1956|  66.0M|            qLo++;
 1957|  66.0M|        }
 1958|   110M|        return (qHi << word_half_bits) + qLo;
 1959|   110M|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11subtractmulEPmS5_mRm:
 1963|   110M|    {
 1964|   110M|        word_type hi, lo, d, carry = 0;
 1965|   110M|        size_type i;
 1966|   221M|        for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1966:22): [True: 110M, False: 110M]
  ------------------
 1967|   110M|        {
 1968|   110M|            DDproduct( b[i], q, hi, lo );
 1969|   110M|            d = a[i];
 1970|   110M|            a[i] -= lo;
 1971|   110M|            if ( a[i] > d )
  ------------------
  |  Branch (1971:18): [True: 20.7M, False: 90.1M]
  ------------------
 1972|  20.7M|                carry++;
 1973|   110M|            d = a[i + 1];
 1974|   110M|            a[i + 1] -= hi + carry;
 1975|   110M|            carry = a[i + 1] > d;
 1976|   110M|        }
 1977|   110M|        if ( carry ) // q was too large
  ------------------
  |  Branch (1977:14): [True: 0, False: 110M]
  ------------------
 1978|      0|        {
 1979|      0|            q--;
 1980|      0|            carry = 0;
 1981|      0|            for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1981:26): [True: 0, False: 0]
  ------------------
 1982|      0|            {
 1983|      0|                d = a[i] + carry;
 1984|      0|                carry = d < carry;
 1985|      0|                a[i] = d + b[i];
 1986|      0|                if ( a[i] < d )
  ------------------
  |  Branch (1986:22): [True: 0, False: 0]
  ------------------
 1987|      0|                    carry = 1;
 1988|      0|            }
 1989|      0|            a[n] = 0;
 1990|      0|        }
 1991|   110M|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9DDproductEmmRmS5_:
 1903|   110M|    {
 1904|   110M|        word_type hiA = A >> word_half_bits, loA = A & r_mask,
 1905|   110M|                   hiB = B >> word_half_bits, loB = B & r_mask;
 1906|       |
 1907|   110M|        lo = loA * loB;
 1908|   110M|        hi = hiA * hiB;
 1909|   110M|        word_type mid1 = loA * hiB;
 1910|   110M|        word_type mid2 = hiA * loB;
 1911|   110M|        word_type old = lo;
 1912|   110M|        lo += mid1 << word_half_bits;
 1913|   110M|            hi += (lo < old) + (mid1 >> word_half_bits);
 1914|   110M|        old = lo;
 1915|   110M|        lo += mid2 << word_half_bits;
 1916|   110M|            hi += (lo < old) + (mid2 >> word_half_bits);
 1917|   110M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4dataEv:
   82|   221M|        {
   83|   221M|            return data_;
   84|   221M|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11unnormalizeERS4_ib:
 2023|   100k|    {
 2024|   100k|        if (secondDone)
  ------------------
  |  Branch (2024:13): [True: 0, False: 100k]
  ------------------
 2025|      0|        {
 2026|      0|            rem /= max_word;
 2027|      0|        }
 2028|   100k|        if ( x > 0 )
  ------------------
  |  Branch (2028:14): [True: 30.3k, False: 70.3k]
  ------------------
 2029|  30.3k|        {
 2030|  30.3k|            rem >>= x;
 2031|  30.3k|        }
 2032|  70.3k|        else
 2033|  70.3k|        {
 2034|  70.3k|            rem.reduce();
 2035|  70.3k|        }
 2036|   100k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2Ev:
  620|  1.12k|    basic_bigint() = default;
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEErSEm:
 1201|  30.3k|    {
 1202|  30.3k|        auto words = get_words();
 1203|  30.3k|        size_type q = k / word_bits;
 1204|  30.3k|        if ( q >= words.size())
  ------------------
  |  Branch (1204:14): [True: 0, False: 30.3k]
  ------------------
 1205|      0|        {
 1206|      0|            resize( 0 );
 1207|      0|            return *this;
 1208|      0|        }
 1209|  30.3k|        if (q > 0)
  ------------------
  |  Branch (1209:13): [True: 0, False: 30.3k]
  ------------------
 1210|      0|        {
 1211|      0|            memmove( words.data(), words.data()+q, size_type((words.size() - q)*sizeof(word_type)) );
 1212|      0|            resize( size_type(words.size() - q) );
 1213|      0|            k %= word_bits;
 1214|      0|            if ( k == 0 )
  ------------------
  |  Branch (1214:18): [True: 0, False: 0]
  ------------------
 1215|      0|            {
 1216|      0|                reduce();
 1217|      0|                return *this;
 1218|      0|            }
 1219|      0|        }
 1220|       |
 1221|  30.3k|        words = get_words();
 1222|  30.3k|        size_type n = size_type(words.size() - 1);
 1223|  30.3k|        ssize_type k1 = word_bits - k;
 1224|  30.3k|        word_type mask = (word_type(1) << k) - 1;
 1225|  34.5M|        for (size_type i = 0; i <= n; i++)
  ------------------
  |  Branch (1225:31): [True: 34.5M, False: 30.3k]
  ------------------
 1226|  34.5M|        {
 1227|  34.5M|            words[i] >>= k;
 1228|  34.5M|            if ( i < n )
  ------------------
  |  Branch (1228:18): [True: 34.4M, False: 30.3k]
  ------------------
 1229|  34.4M|                words[i] |= ((words[i+1] & mask) << k1);
 1230|  34.5M|        }
 1231|  30.3k|        reduce();
 1232|  30.3k|        return *this;
 1233|  30.3k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEED2Ev:
  687|   423k|    {
  688|   423k|        storage_.destroy();
  689|   423k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7destroyEv:
  490|   423k|    {
  491|   423k|        if (is_allocated())
  ------------------
  |  Branch (491:13): [True: 207k, False: 216k]
  ------------------
  492|   207k|        {
  493|   207k|            allocated_.destroy(get_allocator());
  494|   207k|            allocated_.~allocated_storage();
  495|   207k|        }
  496|   216k|        else
  497|   216k|        {
  498|   216k|            inlined_.~inlined_storage();
  499|   216k|        }
  500|   423k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7destroyERKS4_:
  249|   207k|        {
  250|   207k|            if (data_ != nullptr)
  ------------------
  |  Branch (250:17): [True: 207k, False: 0]
  ------------------
  251|   207k|            {
  252|   207k|                real_allocator_type alloc(a);
  253|   207k|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  254|   207k|            }
  255|   207k|        }
_ZN8jsonconsmiENS_12basic_bigintINSt3__19allocatorImEEEERKS4_:
 1587|  1.04k|    {
 1588|  1.04k|        return x -= y;
 1589|  1.04k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IiEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  672|  2.37k|        : storage_(n, alloc)
  673|  2.37k|    {
  674|  2.37k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IiEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  363|  2.37k|        : word_allocator_type(alloc)
  364|  2.37k|    {
  365|  2.37k|        ::new (&inlined_) inlined_storage(n);
  366|  2.37k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IiEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  128|  2.37k|            : is_allocated_(false),
  129|  2.37k|            is_negative_(n < 0),
  130|  2.37k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (130:19): [True: 1.32k, False: 1.04k]
  ------------------
  131|  2.37k|        {
  132|  2.37k|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (132:26): [True: 1.04k, False: 1.32k]
  ------------------
  133|  2.37k|            values_[1] = 0;
  134|  2.37k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEaSERKS4_:
  874|   106k|    {
  875|   106k|        storage_ = y.storage_;
  876|   106k|        return *this;
  877|   106k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEaSERKS5_:
  369|   106k|    {
  370|   106k|        if (this != &other)
  ------------------
  |  Branch (370:13): [True: 106k, False: 0]
  ------------------
  371|   106k|        {
  372|   106k|            auto other_words = other.get_words();
  373|   106k|            resize(other_words.size());
  374|   106k|            auto words = get_words();
  375|   106k|            if (other_words.size() > 0)
  ------------------
  |  Branch (375:17): [True: 104k, False: 1.93k]
  ------------------
  376|   104k|            {
  377|   104k|                common_.is_negative_ = other.common_.is_negative_;
  378|   104k|                std::memcpy(words.data(), other_words.data(), size_type(other_words.size()*sizeof(word_type)));
  379|   104k|            }
  380|   106k|        }
  381|   106k|        return *this;
  382|   106k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4dataEv:
   82|   104k|        {
   83|   104k|            return data_;
   84|   104k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IlEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  672|    164|        : storage_(n, alloc)
  673|    164|    {
  674|    164|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IlEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  363|    164|        : word_allocator_type(alloc)
  364|    164|    {
  365|    164|        ::new (&inlined_) inlined_storage(n);
  366|    164|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IlEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  128|    164|            : is_allocated_(false),
  129|    164|            is_negative_(n < 0),
  130|    164|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (130:19): [True: 0, False: 164]
  ------------------
  131|    164|        {
  132|    164|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (132:26): [True: 164, False: 0]
  ------------------
  133|    164|            values_[1] = 0;
  134|    164|        }
_ZN8jsoncons16append_to_bufferIcNSt3__19allocatorIcEEEEvRKNS_12basic_bigintINS2_ImEEEERNS1_12basic_stringIT_NS1_11char_traitsISA_EET0_EE:
 2118|    617|    {
 2119|    617|        if (value.is_zero())
  ------------------
  |  Branch (2119:13): [True: 126, False: 491]
  ------------------
 2120|    126|        {
 2121|    126|            buf.push_back('0');
 2122|    126|            return;
 2123|    126|        }
 2124|    491|        if (value.is_negative())
  ------------------
  |  Branch (2124:13): [True: 45, False: 446]
  ------------------
 2125|     45|        {
 2126|     45|            buf.push_back('-');
 2127|     45|        }
 2128|       |
 2129|    491|        size_type start = buf.size();
 2130|    491|        basic_bigint v(value);
 2131|    491|        auto v_words = v.get_words();
 2132|       |
 2133|    491|        size_type len = (v_words.size() * word_bits / 3) + 2;
 2134|    491|        buf.reserve(start+len);
 2135|       |
 2136|    491|        word_type r;
 2137|    491|        basic_bigint R(value.get_allocator());
 2138|    491|        basic_bigint LP10(max_unsigned_power_10, value.get_allocator());
 2139|       |
 2140|    491|        do
 2141|  39.1k|        {
 2142|  39.1k|            v.divide(LP10, v, R, true);
 2143|  39.1k|            v_words = v.get_words();
 2144|       |
 2145|  39.1k|            auto R_words = R.get_words();
 2146|  39.1k|            r = (R_words.size() ? R_words[0] : 0);
  ------------------
  |  Branch (2146:18): [True: 39.1k, False: 1]
  ------------------
 2147|   775k|            for (size_type j = 0; j < imax_unsigned_power_10; j++)
  ------------------
  |  Branch (2147:35): [True: 736k, False: 38.6k]
  ------------------
 2148|   736k|            {
 2149|   736k|                buf.push_back(CharT(r % 10u + '0'));
 2150|   736k|                r /= 10u;
 2151|   736k|                if (r + v_words.size() == 0)
  ------------------
  |  Branch (2151:21): [True: 491, False: 736k]
  ------------------
 2152|    491|                    break;
 2153|   736k|            }
 2154|  39.1k|        } while (v_words.size() > 0);
  ------------------
  |  Branch (2154:18): [True: 38.6k, False: 491]
  ------------------
 2155|       |
 2156|    491|        std::reverse(buf.begin()+start, buf.end());
 2157|       |        
 2158|    491|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16write_string_hexIcNS1_11char_traitsIcEENS2_IcEEEEvRNS1_12basic_stringIT_T0_T1_EE:
 1471|    481|    {
 1472|       |
 1473|       |
 1474|    481|        basic_bigint<Allocator> v(*this);
 1475|    481|        auto v_words = v.get_words();
 1476|       |
 1477|    481|        size_type len = (v_words.size() * basic_bigint<Allocator>::word_bits / 3) + 2;
 1478|    481|        data.reserve(len);
 1479|       |
 1480|    481|        if ( v_words.size() == 0 )
  ------------------
  |  Branch (1480:14): [True: 1, False: 480]
  ------------------
 1481|      1|        {
 1482|      1|            data.push_back('0');
 1483|      1|        }
 1484|    480|        else
 1485|    480|        {
 1486|    480|            word_type r;
 1487|    480|            basic_bigint<Allocator> R;
 1488|    480|            basic_bigint<Allocator> LP10 = max_unsigned_power_16; // LP10 = max_unsigned_power_16 = ::pow(16, imax_unsigned_power_16)
 1489|    480|            do
 1490|  30.9k|            {
 1491|  30.9k|                v.divide( LP10, v, R, true );
 1492|  30.9k|                v_words = v.get_words();
 1493|  30.9k|                auto R_words = R.get_words();
 1494|  30.9k|                r = (R_words.size() ? R_words[0] : 0);
  ------------------
  |  Branch (1494:22): [True: 30.0k, False: 965]
  ------------------
 1495|   489k|                for ( size_type j=0; j < imax_unsigned_power_16; j++ )
  ------------------
  |  Branch (1495:38): [True: 459k, False: 30.4k]
  ------------------
 1496|   459k|                {
 1497|   459k|                    uint8_t c = r % 16u;
 1498|   459k|                    data.push_back((c < 10u) ? ('0' + c) : ('A' - 10u + c));
  ------------------
  |  Branch (1498:36): [True: 392k, False: 66.6k]
  ------------------
 1499|   459k|                    r /= 16u;
 1500|   459k|                    if ( r + v_words.size() == 0 )
  ------------------
  |  Branch (1500:26): [True: 480, False: 458k]
  ------------------
 1501|    480|                        break;
 1502|   459k|                }
 1503|  30.9k|            } 
 1504|  30.9k|            while (v_words.size() > 0);
  ------------------
  |  Branch (1504:20): [True: 30.4k, False: 480]
  ------------------
 1505|       |
 1506|    480|            if (is_negative())
  ------------------
  |  Branch (1506:17): [True: 363, False: 117]
  ------------------
 1507|    363|            {
 1508|    363|                data.push_back('-');
 1509|    363|            }
 1510|    480|            std::reverse(data.begin(),data.end());
 1511|    480|        }
 1512|    481|    }

_ZN8jsoncons6binary13big_to_nativeItNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  5.80k|    {
  183|  5.80k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 5.80k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  5.80k|        T val;
  188|  5.80k|        std::memcpy(&val,first,sizeof(T));
  189|  5.80k|        return byte_swap(val);
  190|  5.80k|    }
_ZN8jsoncons6binary9byte_swapItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|  76.8k|    {
   29|  76.8k|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|  76.8k|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  467|  76.8k|#      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|  76.8k|    }
_ZN8jsoncons6binary13big_to_nativeIjNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  1.52k|    {
  183|  1.52k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 1.52k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  1.52k|        T val;
  188|  1.52k|        std::memcpy(&val,first,sizeof(T));
  189|  1.52k|        return byte_swap(val);
  190|  1.52k|    }
_ZN8jsoncons6binary9byte_swapIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|  48.6k|    {
   40|  48.6k|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|  48.6k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  463|  48.6k|#  define JSONCONS_BYTE_SWAP_32 __builtin_bswap32
  ------------------
   42|       |    #else
   43|       |        uint32_t tmp = ((static_cast<uint32_t>(val) << 8) & 0xff00ff00) | ((static_cast<uint32_t>(val) >> 8) & 0xff00ff);
   44|       |        return (tmp << 16) | (tmp >> 16);
   45|       |    #endif
   46|  48.6k|    }
_ZN8jsoncons6binary13big_to_nativeImNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  10.6k|    {
  183|  10.6k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 10.6k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  10.6k|        T val;
  188|  10.6k|        std::memcpy(&val,first,sizeof(T));
  189|  10.6k|        return byte_swap(val);
  190|  10.6k|    }
_ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|  28.9k|    {
   52|  28.9k|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|  28.9k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  462|  28.9k|#  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|  28.9k|    }
_ZN8jsoncons6binary9byte_swapIsEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|   118k|    {
   29|   118k|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|   118k|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  467|   118k|#      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|   118k|    }
_ZN8jsoncons6binary9byte_swapIiEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|  83.9k|    {
   40|  83.9k|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|  83.9k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  463|  83.9k|#  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|  83.9k|    }
_ZN8jsoncons6binary9byte_swapIlEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|    898|    {
   52|    898|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|    898|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  462|    898|#  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|    898|    }
_ZN8jsoncons6binary9byte_swapIfEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   64|  10.9k|    {
   65|  10.9k|        uint32_t x;
   66|  10.9k|        std::memcpy(&x,&val,sizeof(uint32_t));
   67|  10.9k|        uint32_t y = byte_swap(x);
   68|  10.9k|        T val2;
   69|  10.9k|        std::memcpy(&val2,&y,sizeof(uint32_t));
   70|  10.9k|        return val2;
   71|  10.9k|    }
_ZN8jsoncons6binary9byte_swapIdEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   76|  8.80k|    {
   77|  8.80k|        uint64_t x;
   78|  8.80k|        std::memcpy(&x,&val,sizeof(uint64_t));
   79|  8.80k|        uint64_t y = byte_swap(x);
   80|  8.80k|        T val2;
   81|  8.80k|        std::memcpy(&val2,&y,sizeof(uint64_t));
   82|  8.80k|        return val2;
   83|  8.80k|    }
_ZN8jsoncons6binary13big_to_nativeIfNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|    275|    {
  183|    275|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 275]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|    275|        T val;
  188|    275|        std::memcpy(&val,first,sizeof(T));
  189|    275|        return byte_swap(val);
  190|    275|    }
_ZN8jsoncons6binary13big_to_nativeIdNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|    425|    {
  183|    425|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 425]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|    425|        T val;
  188|    425|        std::memcpy(&val,first,sizeof(T));
  189|    425|        return byte_swap(val);
  190|    425|    }

_ZN8jsoncons15bytes_to_base64IPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  188|      2|    {
  189|      2|        static constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  190|      2|                                                   "abcdefghijklmnopqrstuvwxyz"
  191|      2|                                                   "0123456789+/"
  192|      2|                                                   "=";
  193|      2|        return detail::bytes_to_base64_generic(first, last, alphabet, result);
  194|      2|    }
_ZN8jsoncons6detail23bytes_to_base64_genericIPKhNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS4_9enable_ifIXsr3std7is_sameINS4_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESD_SD_PKcRT0_:
   44|     56|    {
   45|     56|        std::size_t count = 0;
   46|     56|        unsigned char a3[3];
   47|     56|        unsigned char a4[4];
   48|     56|        unsigned char fill = alphabet[64];
   49|     56|        int i = 0;
   50|     56|        int j = 0;
   51|       |
   52|   289k|        while (first != last)
  ------------------
  |  Branch (52:16): [True: 289k, False: 56]
  ------------------
   53|   289k|        {
   54|   289k|            a3[i++] = *first++;
   55|   289k|            if (i == 3)
  ------------------
  |  Branch (55:17): [True: 96.3k, False: 192k]
  ------------------
   56|  96.3k|            {
   57|  96.3k|                a4[0] = (a3[0] & 0xfc) >> 2;
   58|  96.3k|                a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   59|  96.3k|                a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   60|  96.3k|                a4[3] = a3[2] & 0x3f;
   61|       |
   62|   481k|                for (i = 0; i < 4; i++) 
  ------------------
  |  Branch (62:29): [True: 385k, False: 96.3k]
  ------------------
   63|   385k|                {
   64|   385k|                    result.push_back(alphabet[a4[i]]);
   65|   385k|                    ++count;
   66|   385k|                }
   67|  96.3k|                i = 0;
   68|  96.3k|            }
   69|   289k|        }
   70|       |
   71|     56|        if (i > 0)
  ------------------
  |  Branch (71:13): [True: 22, False: 34]
  ------------------
   72|     22|        {
   73|     56|            for (j = i; j < 3; ++j) 
  ------------------
  |  Branch (73:25): [True: 34, False: 22]
  ------------------
   74|     34|            {
   75|     34|                a3[j] = 0;
   76|     34|            }
   77|       |
   78|     22|            a4[0] = (a3[0] & 0xfc) >> 2;
   79|     22|            a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   80|     22|            a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   81|       |
   82|     76|            for (j = 0; j < i + 1; ++j) 
  ------------------
  |  Branch (82:25): [True: 54, False: 22]
  ------------------
   83|     54|            {
   84|     54|                result.push_back(alphabet[a4[j]]);
   85|     54|                ++count;
   86|     54|            }
   87|       |
   88|     22|            if (fill != 0)
  ------------------
  |  Branch (88:17): [True: 1, False: 21]
  ------------------
   89|      1|            {
   90|      3|                while (i++ < 3) 
  ------------------
  |  Branch (90:24): [True: 2, False: 1]
  ------------------
   91|      2|                {
   92|      2|                    result.push_back(fill);
   93|      2|                    ++count;
   94|      2|                }
   95|      1|            }
   96|     22|        }
   97|       |
   98|     56|        return count;
   99|     56|    }
_ZN8jsoncons15bytes_to_base16IPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  162|     22|    {
  163|     22|        static constexpr char characters[] = "0123456789ABCDEF";
  164|       |
  165|  15.0k|        for (auto it = first; it != last; ++it)
  ------------------
  |  Branch (165:31): [True: 15.0k, False: 22]
  ------------------
  166|  15.0k|        {
  167|  15.0k|            uint8_t c = *it;
  168|  15.0k|            result.push_back(characters[c >> 4]);
  169|  15.0k|            result.push_back(characters[c & 0xf]);
  170|  15.0k|        }
  171|     22|        return (last-first)*2;
  172|     22|    }
_ZN8jsoncons18bytes_to_base64urlIPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  177|     54|    {
  178|     54|        static constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  179|     54|                                                      "abcdefghijklmnopqrstuvwxyz"
  180|     54|                                                      "0123456789-_"
  181|     54|                                                      "\0";
  182|     54|        return detail::bytes_to_base64_generic(first, last, alphabet, result);
  183|     54|    }
_ZNK8jsoncons16byte_string_view4dataEv:
  399|    906|        {
  400|    906|            return data_;
  401|    906|        }
_ZNK8jsoncons16byte_string_view4sizeEv:
  403|    906|        {
  404|    906|            return size_;
  405|    906|        }
_ZN8jsoncons16byte_string_viewC2EPKhm:
  362|    906|            : data_(data), size_(length)
  363|    906|        {
  364|    906|        }
_ZN8jsoncons16byte_string_viewC2Ev:
  358|    598|        {
  359|    598|        }

_ZN8jsoncons15bytes_to_stringIPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXaasr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valuesr6nonstd9is_stringIT0_EE5valueEmE4typeESC_SC_NS_12semantic_tagERSF_:
   29|     78|{
   30|     78|    switch (tag)
   31|     78|    {
   32|      2|        case semantic_tag::base64:
  ------------------
  |  Branch (32:9): [True: 2, False: 76]
  ------------------
   33|      2|            return bytes_to_base64(first, last, str);
   34|     22|        case semantic_tag::base16:
  ------------------
  |  Branch (34:9): [True: 22, False: 56]
  ------------------
   35|     22|            return bytes_to_base16(first, last, str);
   36|     54|        default:
  ------------------
  |  Branch (36:9): [True: 54, False: 24]
  ------------------
   37|     54|            return bytes_to_base64url(first, last, str);
   38|     78|    }
   39|     78|}

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

_ZN8jsoncons16decstr_to_doubleEPKcmRd:
  889|    111|{
  890|    111|    const char* cur = s+length;
  891|    111|    char *end = nullptr;
  892|    111|    val = strtod(s, &end);
  893|    111|    const char* str_end = end;
  894|    111|    if (JSONCONS_UNLIKELY(end < cur))
  ------------------
  |  |   79|    111|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 111]
  |  |  ------------------
  ------------------
  895|      0|    {
  896|      0|        if (*end == '.')
  ------------------
  |  Branch (896:13): [True: 0, False: 0]
  ------------------
  897|      0|        {
  898|      0|            std::string buf{s, length};
  899|      0|            char* dot_ptr = &buf[0] + (cur - end - 1);
  900|      0|            *dot_ptr = ',';
  901|      0|            end = nullptr;
  902|      0|            val = strtod(buf.c_str(), &end);
  903|      0|            str_end = s + (end - &buf[0]);
  904|      0|        }
  905|      0|        if (JSONCONS_UNLIKELY(str_end != cur))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  906|      0|        {
  907|      0|            return to_number_result<char>{str_end,std::errc::invalid_argument};
  908|      0|        }
  909|      0|    }
  910|    111|    if (JSONCONS_UNLIKELY(val <= -HUGE_VAL || val >= HUGE_VAL))
  ------------------
  |  |   79|    222|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 111]
  |  |  |  Branch (79:50): [True: 0, False: 111]
  |  |  |  Branch (79:50): [True: 0, False: 111]
  |  |  ------------------
  ------------------
  911|      0|    {
  912|      0|        return to_number_result<char>{str_end, std::errc::result_out_of_range};
  913|      0|    }
  914|    111|    return to_number_result<char>{str_end};
  915|    111|}
_ZN8jsoncons16to_number_resultIcEC2EPKc:
  160|    111|        : ptr(ptr_), ec(std::errc{})
  161|    111|    {
  162|    111|    }

_ZN8jsoncons12from_integerImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr6nonstd10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|    344|{
   43|    344|    using char_type = typename Result::value_type;
   44|       |
   45|    344|    char_type buf[255];
   46|    344|    char_type *p = buf;
   47|    344|    const char_type* last = buf+255;
   48|       |
   49|    344|    bool is_negative = value < 0;
   50|       |
   51|    344|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 344]
  ------------------
   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|    344|    else
   60|    344|    {
   61|       |
   62|    344|        do
   63|  2.63k|        {
   64|  2.63k|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  2.63k|        }
   66|  2.63k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 2.29k, False: 344]
  |  Branch (66:33): [True: 2.29k, False: 0]
  ------------------
   67|    344|    }
   68|    344|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   54|    344|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 344]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|    344|    std::size_t count = (p - buf);
   71|    344|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 344]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  2.97k|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 2.63k, False: 344]
  ------------------
   77|  2.63k|    {
   78|  2.63k|        result.push_back(*p);
   79|  2.63k|    }
   80|       |
   81|    344|    return count;
   82|    344|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr6nonstd10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|    415|{
   43|    415|    using char_type = typename Result::value_type;
   44|       |
   45|    415|    char_type buf[255];
   46|    415|    char_type *p = buf;
   47|    415|    const char_type* last = buf+255;
   48|       |
   49|    415|    bool is_negative = value < 0;
   50|       |
   51|    415|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 415, False: 0]
  ------------------
   52|    415|    {
   53|    415|        do
   54|  3.66k|        {
   55|  3.66k|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|  3.66k|        }
   57|  3.66k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 3.25k, False: 415]
  |  Branch (57:33): [True: 3.25k, False: 0]
  ------------------
   58|    415|    }
   59|      0|    else
   60|      0|    {
   61|       |
   62|      0|        do
   63|      0|        {
   64|      0|            *p++ = static_cast<char_type>(48 + value % 10);
   65|      0|        }
   66|      0|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 0, False: 0]
  |  Branch (66:33): [True: 0, False: 0]
  ------------------
   67|      0|    }
   68|    415|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   54|    415|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 415]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|    415|    std::size_t count = (p - buf);
   71|    415|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 415, False: 0]
  ------------------
   72|    415|    {
   73|    415|        result.push_back('-');
   74|    415|        ++count;
   75|    415|    }
   76|  4.08k|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 3.66k, False: 415]
  ------------------
   77|  3.66k|    {
   78|  3.66k|        result.push_back(*p);
   79|  3.66k|    }
   80|       |
   81|    415|    return count;
   82|    415|}
_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|    831|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|    831|    {
  489|    831|#if !defined(JSONCONS_NO_LOCALECONV)
  490|    831|        struct lconv *lc = localeconv();
  491|    831|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 831, False: 0]
  |  Branch (491:30): [True: 831, False: 0]
  ------------------
  492|    831|        {
  493|    831|            decimal_point_ = lc->decimal_point[0];
  494|    831|        }
  495|    831|#endif
  496|    831|    }
_ZN8jsoncons14integer_to_hexImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr6nonstd10is_integerIT_EE5valueEmE4typeES9_RT0_:
   89|    919|{
   90|    919|    using char_type = typename Result::value_type;
   91|       |
   92|    919|    char_type buf[255];
   93|    919|    char_type *p = buf;
   94|    919|    const char_type* last = buf+255;
   95|       |
   96|    919|    bool is_negative = value < 0;
   97|       |
   98|    919|    if (value < 0)
  ------------------
  |  Branch (98:9): [True: 0, False: 919]
  ------------------
   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|    919|    else
  107|    919|    {
  108|       |
  109|    919|        do
  110|  2.99k|        {
  111|  2.99k|            *p++ = to_hex_character(value % 16);
  112|  2.99k|        }
  113|  2.99k|        while ((value /= 16) && (p < last));
  ------------------
  |  Branch (113:16): [True: 2.07k, False: 919]
  |  Branch (113:33): [True: 2.07k, False: 0]
  ------------------
  114|    919|    }
  115|    919|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   54|    919|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 919]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  116|       |
  117|    919|    std::size_t count = (p - buf);
  118|    919|    if (is_negative)
  ------------------
  |  Branch (118:9): [True: 0, False: 919]
  ------------------
  119|      0|    {
  120|      0|        result.push_back('-');
  121|      0|        ++count;
  122|      0|    }
  123|  3.91k|    while (--p >= buf)
  ------------------
  |  Branch (123:12): [True: 2.99k, False: 919]
  ------------------
  124|  2.99k|    {
  125|  2.99k|        result.push_back(*p);
  126|  2.99k|    }
  127|       |
  128|    919|    return count;
  129|    919|}
_ZN8jsoncons16to_hex_characterEh:
   33|  2.99k|{
   34|  2.99k|    return (char)((c < 10) ? ('0' + c) : ('A' - 10 + c));
  ------------------
  |  Branch (34:19): [True: 1.61k, False: 1.38k]
  ------------------
   35|  2.99k|}
_ZN8jsoncons12write_doubleclINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEmdRT_:
  503|    831|    {
  504|    831|        std::size_t count = 0;
  505|       |
  506|    831|        char number_buffer[200];
  507|    831|        int length = 0;
  508|       |
  509|    831|        switch (float_format_)
  510|    831|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 831]
  ------------------
  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: 831]
  ------------------
  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|    831|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 831, False: 0]
  ------------------
  552|    831|            {
  553|    831|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 831]
  ------------------
  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|    831|                else
  563|    831|                {
  564|    831|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 831]
  ------------------
  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|    831|                }             
  569|    831|                break;
  570|    831|            }
  571|    831|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 831]
  ------------------
  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|    831|        }
  575|    831|        return count;
  576|    831|    }
_ZN8jsoncons11dump_bufferINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKcmcRT_:
  243|    111|{
  244|    111|    const char *sbeg = buffer;
  245|    111|    const char *send = sbeg + length;
  246|       |
  247|    111|    if (sbeg != send)
  ------------------
  |  Branch (247:9): [True: 111, False: 0]
  ------------------
  248|    111|    {
  249|    111|        bool needs_dot = true;
  250|  2.01k|        for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (250:36): [True: 1.90k, False: 111]
  ------------------
  251|  1.90k|        {
  252|  1.90k|            switch (*q)
  253|  1.90k|            {
  254|     52|            case '-':
  ------------------
  |  Branch (254:13): [True: 52, False: 1.84k]
  ------------------
  255|    337|            case '0':
  ------------------
  |  Branch (255:13): [True: 285, False: 1.61k]
  ------------------
  256|    524|            case '1':
  ------------------
  |  Branch (256:13): [True: 187, False: 1.71k]
  ------------------
  257|    684|            case '2':
  ------------------
  |  Branch (257:13): [True: 160, False: 1.74k]
  ------------------
  258|    850|            case '3':
  ------------------
  |  Branch (258:13): [True: 166, False: 1.73k]
  ------------------
  259|  1.00k|            case '4':
  ------------------
  |  Branch (259:13): [True: 150, False: 1.75k]
  ------------------
  260|  1.15k|            case '5':
  ------------------
  |  Branch (260:13): [True: 158, False: 1.74k]
  ------------------
  261|  1.28k|            case '6':
  ------------------
  |  Branch (261:13): [True: 131, False: 1.77k]
  ------------------
  262|  1.42k|            case '7':
  ------------------
  |  Branch (262:13): [True: 137, False: 1.76k]
  ------------------
  263|  1.55k|            case '8':
  ------------------
  |  Branch (263:13): [True: 133, False: 1.76k]
  ------------------
  264|  1.71k|            case '9':
  ------------------
  |  Branch (264:13): [True: 157, False: 1.74k]
  ------------------
  265|  1.73k|            case '+':
  ------------------
  |  Branch (265:13): [True: 20, False: 1.88k]
  ------------------
  266|  1.73k|                result.push_back(*q);
  267|  1.73k|                break;
  268|     44|            case 'e':
  ------------------
  |  Branch (268:13): [True: 44, False: 1.85k]
  ------------------
  269|     44|            case 'E':
  ------------------
  |  Branch (269:13): [True: 0, False: 1.90k]
  ------------------
  270|     44|                result.push_back('e');
  271|     44|                needs_dot = false;
  272|     44|                break;
  273|    121|            default:
  ------------------
  |  Branch (273:13): [True: 121, False: 1.78k]
  ------------------
  274|    121|                if (*q == decimal_point)
  ------------------
  |  Branch (274:21): [True: 94, False: 27]
  ------------------
  275|     94|                {
  276|     94|                    needs_dot = false;
  277|     94|                    result.push_back('.');
  278|     94|                }
  279|    121|                break;
  280|  1.90k|            }
  281|  1.90k|        }
  282|    111|        if (needs_dot)
  ------------------
  |  Branch (282:13): [True: 17, False: 94]
  ------------------
  283|     17|        {
  284|     17|            result.push_back('.');
  285|     17|            result.push_back('0');
  286|     17|        }
  287|    111|    }
  288|    111|}
_ZN8jsoncons15prettify_stringINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKciiiiRT_:
  171|    716|{
  172|    716|    int nb_digits = length;
  173|    716|    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|    716|    int kk = nb_digits + k;
  179|       |
  180|    716|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 244, False: 472]
  |  Branch (180:28): [True: 65, False: 179]
  ------------------
  181|     65|    {
  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|    521|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 456, False: 65]
  ------------------
  186|    456|        {
  187|    456|            result.push_back(buffer[i]);
  188|    456|        }
  189|    150|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 85, False: 65]
  ------------------
  190|     85|        {
  191|     85|            result.push_back('0');
  192|     85|        }
  193|     65|        result.push_back('.');
  194|     65|        result.push_back('0');
  195|     65|    } 
  196|    651|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 286, False: 365]
  |  Branch (196:24): [True: 107, False: 179]
  ------------------
  197|    107|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|    384|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 277, False: 107]
  ------------------
  200|    277|        {
  201|    277|            result.push_back(buffer[i]);
  202|    277|        }
  203|    107|        result.push_back('.');
  204|  1.02k|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 919, False: 107]
  ------------------
  205|    919|        {
  206|    919|            result.push_back(buffer[i]);
  207|    919|        }
  208|    107|    } 
  209|    544|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 231, False: 313]
  |  Branch (209:30): [True: 52, False: 179]
  ------------------
  210|     52|    {
  211|     52|        offset = 2 - kk;
  212|       |
  213|     52|        result.push_back('0');
  214|     52|        result.push_back('.');
  215|    137|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 85, False: 52]
  ------------------
  216|     85|            result.push_back('0');
  217|    653|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 601, False: 52]
  ------------------
  218|    601|        {
  219|    601|            result.push_back(buffer[i]);
  220|    601|        }
  221|     52|    } 
  222|    492|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 8, False: 484]
  ------------------
  223|      8|    {
  224|      8|        result.push_back(buffer[0]);
  225|      8|        result.push_back('e');
  226|      8|        fill_exponent(kk - 1, result);
  227|      8|    } 
  228|    484|    else
  229|    484|    {
  230|    484|        result.push_back(buffer[0]);
  231|    484|        result.push_back('.');
  232|  6.67k|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 6.19k, False: 484]
  ------------------
  233|  6.19k|        {
  234|  6.19k|            result.push_back(buffer[i]);
  235|  6.19k|        }
  236|    484|        result.push_back('e');
  237|    484|        fill_exponent(kk - 1, result);
  238|    484|    }
  239|    716|}
_ZN8jsoncons13fill_exponentINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEviRT_:
  136|    492|{
  137|    492|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 313, False: 179]
  ------------------
  138|    313|    {
  139|    313|        result.push_back('-');
  140|    313|        K = -K;
  141|    313|    }
  142|    179|    else
  143|    179|    {
  144|    179|        result.push_back('+'); // compatibility with sprintf
  145|    179|    }
  146|       |
  147|    492|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 34, False: 458]
  ------------------
  148|     34|    {
  149|     34|        result.push_back('0'); // compatibility with sprintf
  150|     34|        result.push_back((char)('0' + K));
  151|     34|    }
  152|    458|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 139, False: 319]
  ------------------
  153|    139|    {
  154|    139|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|    139|        result.push_back((char)('0' + K));
  156|    139|    }
  157|    319|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 319, False: 0]
  ------------------
  158|    319|    {
  159|    319|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|    319|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|    319|        result.push_back((char)('0' + K));
  162|    319|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|    492|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_:
  475|    831|{
  476|    831|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|    831|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_NS1_17integral_constantIbLb1EEE:
  366|    831|{
  367|    831|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 4, False: 827]
  ------------------
  368|      4|    {
  369|      4|        result.push_back('0');
  370|      4|        result.push_back('.');
  371|      4|        result.push_back('0');
  372|      4|        return true;
  373|      4|    }
  374|       |
  375|    827|    int length = 0;
  376|    827|    int k;
  377|       |
  378|    827|    char buffer[100];
  379|       |
  380|    827|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 325, False: 502]
  ------------------
  381|    827|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 716, False: 111]
  ------------------
  382|    716|    {
  383|    716|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 297, False: 419]
  ------------------
  384|    297|        {
  385|    297|            result.push_back('-');
  386|    297|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|    716|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|    716|        return true;
  391|    716|    }
  392|    111|    else
  393|    111|    {
  394|    111|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|    111|    }
  396|    827|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_NS1_17integral_constantIbLb0EEE:
  329|    111|{
  330|    111|    if (val == 0)
  ------------------
  |  Branch (330:9): [True: 0, False: 111]
  ------------------
  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|    111|    char buffer[100];
  339|    111|    int precision = std::numeric_limits<double>::digits10;
  340|    111|    int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  341|    111|    if (length < 0)
  ------------------
  |  Branch (341:9): [True: 0, False: 111]
  ------------------
  342|      0|    {
  343|      0|        return false;
  344|      0|    }
  345|    111|    double x{0};
  346|    111|    auto res = decstr_to_double(buffer, length, x);
  347|    111|    if (res.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (347:9): [True: 0, False: 111]
  ------------------
  348|      0|    {
  349|      0|        return false;
  350|      0|    }
  351|    111|    if (x != val)
  ------------------
  |  Branch (351:9): [True: 70, False: 41]
  ------------------
  352|     70|    {
  353|     70|        const int precision2 = std::numeric_limits<double>::max_digits10;
  354|     70|        length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  355|     70|        if (length < 0)
  ------------------
  |  Branch (355:13): [True: 0, False: 70]
  ------------------
  356|      0|        {
  357|      0|            return false;
  358|      0|        }
  359|     70|    }
  360|    111|    dump_buffer(buffer, length, decimal_point, result);
  361|    111|    return true;
  362|    111|}

_ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr6nonstd8is_char8IT_EE5valueENS0_14unicode_resultIS4_EEE4typeEPKS4_m:
 1147|  2.12M|    {
 1148|  2.12M|        const uint8_t* it = reinterpret_cast<const uint8_t*>(data);
 1149|  2.12M|        const uint8_t* end = it + length;
 1150|       |
 1151|  2.12M|        unicode_errc  result{};
 1152|  5.63M|        while (it != end) 
  ------------------
  |  Branch (1152:16): [True: 3.50M, False: 2.12M]
  ------------------
 1153|  3.50M|        {
 1154|  3.50M|            if ((end - it) >= 8)
  ------------------
  |  Branch (1154:17): [True: 938k, False: 2.57M]
  ------------------
 1155|   938k|            {
 1156|  5.77M|                JSONCONS_REPEAT8({if (JSONCONS_LIKELY((*it & 0x80) == 0)) ++it; else goto non_ascii;})
  ------------------
  |  |  326|  1.87M|#define JSONCONS_REPEAT8(x)  { x x x x x x x x }
  |  |  ------------------
  |  |  |  Branch (326:32): [True: 927k, False: 11.3k]
  |  |  |  Branch (326:34): [True: 881k, False: 45.7k]
  |  |  |  Branch (326:36): [True: 828k, False: 53.7k]
  |  |  |  Branch (326:38): [True: 812k, False: 15.7k]
  |  |  |  Branch (326:40): [True: 786k, False: 26.0k]
  |  |  |  Branch (326:42): [True: 776k, False: 9.41k]
  |  |  |  Branch (326:44): [True: 762k, False: 14.7k]
  |  |  |  Branch (326:46): [True: 734k, False: 27.3k]
  |  |  ------------------
  ------------------
 1157|   734k|                continue;
 1158|  5.77M|            }
 1159|  2.77M|    non_ascii:
 1160|  2.77M|            const std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[*it]) + 1;
 1161|  2.77M|            if (len > (std::size_t)(end - it))
  ------------------
  |  Branch (1161:17): [True: 25, False: 2.77M]
  ------------------
 1162|     25|            {
 1163|     25|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), unicode_errc::source_exhausted};
 1164|     25|            }
 1165|  2.77M|            if ((result=is_legal_utf8(it, len)) != unicode_errc())
  ------------------
  |  Branch (1165:17): [True: 114, False: 2.77M]
  ------------------
 1166|    114|            {
 1167|    114|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1168|    114|            }
 1169|  2.77M|            it += len;
 1170|  2.77M|        }
 1171|  2.12M|        return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1172|  2.12M|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8EPKhm:
  305|  2.77M|    {
  306|  2.77M|        const uint8_t* it = reinterpret_cast<const uint8_t*>(bytes);
  307|  2.77M|        const uint8_t* end = it+length;
  308|       |
  309|  2.77M|        uint8_t byte;
  310|  2.77M|        switch (length) {
  311|     19|        default:
  ------------------
  |  Branch (311:9): [True: 19, False: 2.77M]
  ------------------
  312|     19|            return unicode_errc::over_long_utf8_sequence;
  313|  1.13k|        case 4:
  ------------------
  |  Branch (313:9): [True: 1.13k, False: 2.77M]
  ------------------
  314|  1.13k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 9, False: 1.12k]
  ------------------
  315|      9|                return unicode_errc::bad_continuation_byte;
  316|  1.12k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  565|  1.12k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  317|  2.20k|        case 3:
  ------------------
  |  Branch (317:9): [True: 1.07k, False: 2.77M]
  ------------------
  318|  2.20k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (318:17): [True: 11, False: 2.19k]
  ------------------
  319|     11|                return unicode_errc::bad_continuation_byte;
  320|  2.19k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  565|  2.19k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  321|   205k|        case 2:
  ------------------
  |  Branch (321:9): [True: 202k, False: 2.57M]
  ------------------
  322|   205k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (322:17): [True: 21, False: 205k]
  ------------------
  323|     21|                return unicode_errc::bad_continuation_byte;
  324|       |
  325|   205k|            switch (*it) 
  326|   205k|            {
  327|       |                // no fall-through in this inner switch
  328|    500|                case 0xE0: if (byte < 0xA0) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (328:17): [True: 500, False: 204k]
  |  Branch (328:32): [True: 6, False: 494]
  ------------------
  329|    494|                case 0xED: if (byte > 0x9F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (329:17): [True: 281, False: 204k]
  |  Branch (329:32): [True: 4, False: 277]
  ------------------
  330|    723|                case 0xF0: if (byte < 0x90) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (330:17): [True: 723, False: 204k]
  |  Branch (330:32): [True: 7, False: 716]
  ------------------
  331|    716|                case 0xF4: if (byte > 0x8F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (331:17): [True: 397, False: 204k]
  |  Branch (331:32): [True: 2, False: 395]
  ------------------
  332|   203k|                default:   if (byte < 0x80) return unicode_errc::source_illegal;
  ------------------
  |  Branch (332:17): [True: 203k, False: 1.90k]
  |  Branch (332:32): [True: 0, False: 203k]
  ------------------
  333|   205k|            }
  334|       |
  335|   205k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  565|   205k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  336|  2.77M|        case 1:
  ------------------
  |  Branch (336:9): [True: 2.56M, False: 205k]
  ------------------
  337|  2.77M|            if (*it >= 0x80 && *it < 0xC2)
  ------------------
  |  Branch (337:17): [True: 205k, False: 2.56M]
  |  Branch (337:32): [True: 34, False: 205k]
  ------------------
  338|     34|                return unicode_errc::source_illegal;
  339|  2.77M|            break;
  340|  2.77M|        }
  341|  2.77M|        if (*it > 0xF4) 
  ------------------
  |  Branch (341:13): [True: 1, False: 2.77M]
  ------------------
  342|      1|            return unicode_errc::source_illegal;
  343|       |
  344|  2.77M|        return unicode_errc();
  345|  2.77M|    }

_ZN8jsoncons4cbor17basic_cbor_cursorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEED2Ev:
  101|  6.81k|    ~basic_cbor_cursor() = default;
_ZN8jsoncons4cbor17basic_cbor_cursorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_nextERNS3_10error_codeE:
  305|  10.5k|    {
  306|  10.5k|        parser_.restart();
  307|  18.3k|        while (!parser_.stopped())
  ------------------
  |  Branch (307:16): [True: 10.5k, False: 7.84k]
  ------------------
  308|  10.5k|        {
  309|  10.5k|            parser_.parse(cursor_visitor_, ec);
  310|  10.5k|            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   79|  10.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2.67k, False: 7.84k]
  |  |  ------------------
  ------------------
  311|  10.5k|        }
  312|  10.5k|    }
_ZN8jsoncons4cbor17basic_cbor_cursorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC1IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RNS3_10error_codeE:
   67|  6.81k|        : basic_cbor_cursor(std::allocator_arg, Allocator(),
   68|  6.81k|              std::forward<Sourceable>(source), 
   69|  6.81k|              cbor_decode_options(), 
   70|  6.81k|              ec)
   71|  6.81k|    {
   72|  6.81k|    }
_ZN8jsoncons4cbor17basic_cbor_cursorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC1IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEENS3_15allocator_arg_tERKS7_OT_RKNS0_19cbor_decode_optionsERNS3_10error_codeE:
   90|  6.81k|       : parser_(std::forward<Sourceable>(source), options, alloc), 
   91|  6.81k|         cursor_visitor_(alloc),
   92|  6.81k|         eof_(false)
   93|  6.81k|    {
   94|  6.81k|        parser_.cursor_mode(true);
   95|  6.81k|        if (!read_done())
  ------------------
  |  Branch (95:13): [True: 6.81k, False: 0]
  ------------------
   96|  6.81k|        {
   97|  6.81k|            read_next(ec);
   98|  6.81k|        }
   99|  6.81k|    }
_ZNK8jsoncons4cbor17basic_cbor_cursorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_doneEv:
  290|  6.81k|    {
  291|  6.81k|        return parser_.done();
  292|  6.81k|    }
_ZNK8jsoncons4cbor17basic_cbor_cursorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4doneEv:
  153|  10.9k|    {
  154|  10.9k|        return parser_.done();
  155|  10.9k|    }
_ZNK8jsoncons4cbor17basic_cbor_cursorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE7currentEv:
  199|  4.13k|    {
  200|  4.13k|        return cursor_visitor_.event();
  201|  4.13k|    }
_ZN8jsoncons4cbor17basic_cbor_cursorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4nextERNS3_10error_codeE:
  256|  3.71k|    {
  257|  3.71k|        read_next(ec);
  258|  3.71k|    }

_ZN8jsoncons4cbor15make_error_codeENS0_9cbor_errcE:
  105|  2.67k|{
  106|  2.67k|    return std::error_code(static_cast<int>(e),cbor_error_category());
  107|  2.67k|}
_ZN8jsoncons4cbor19cbor_error_categoryEv:
   98|  2.67k|{
   99|  2.67k|  static cbor_error_category_impl instance;
  100|  2.67k|  return instance;
  101|  2.67k|}

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

_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEED2Ev:
  237|  6.81k|    ~basic_cbor_parser() = default;
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11cursor_modeEb:
  298|  6.81k|    {
  299|  6.81k|        cursor_mode_ = value;
  300|  6.81k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE7restartEv:
  240|  10.5k|    {
  241|  10.5k|        more_ = !done_;
  242|  10.5k|    }
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE7stoppedEv:
  323|  18.3k|    {
  324|  18.3k|        return !more_;
  325|  18.3k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  348|  10.5k|    {
  349|  18.3k|        while (!done_ && more_)
  ------------------
  |  Branch (349:16): [True: 14.6k, False: 3.71k]
  |  Branch (349:26): [True: 10.5k, False: 4.13k]
  ------------------
  350|  10.5k|        {
  351|  10.5k|            switch (state_stack_.back().mode)
  ------------------
  |  Branch (351:21): [True: 10.5k, False: 0]
  ------------------
  352|  10.5k|            {
  353|      0|                case parse_mode::multi_dim:
  ------------------
  |  Branch (353:17): [True: 0, False: 10.5k]
  ------------------
  354|      0|                {
  355|      0|                    JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   54|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  356|      0|                    typed_array_stack_.pop_back();
  357|      0|                    state_stack_.pop_back();
  358|      0|                    break;
  359|      0|                }
  360|      0|                case parse_mode::typed_array:
  ------------------
  |  Branch (360:17): [True: 0, False: 10.5k]
  ------------------
  361|      0|                {
  362|      0|                    JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   54|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  363|      0|                    read_typed_array_item(visitor, ec);
  364|      0|                    auto iter = typed_array_stack_.back();
  365|      0|                    if (iter->done())
  ------------------
  |  Branch (365:25): [True: 0, False: 0]
  ------------------
  366|      0|                    {
  367|      0|                        if (level() == mark_level_)
  ------------------
  |  Branch (367:29): [True: 0, False: 0]
  ------------------
  368|      0|                        {
  369|      0|                            more_ = false;
  370|      0|                        }
  371|      0|                        if (!is_multi_dim())
  ------------------
  |  Branch (371:29): [True: 0, False: 0]
  ------------------
  372|      0|                        {
  373|      0|                            typed_array_stack_.pop_back();
  374|      0|                        }
  375|      0|                        state_stack_.pop_back();
  376|      0|                    }
  377|      0|                    break;
  378|      0|                }
  379|      0|                case parse_mode::array:
  ------------------
  |  Branch (379:17): [True: 0, False: 10.5k]
  ------------------
  380|      0|                {
  381|      0|                    if (is_multi_dim())
  ------------------
  |  Branch (381:25): [True: 0, False: 0]
  ------------------
  382|      0|                    {
  383|      0|                        JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   54|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  384|      0|                        auto iter = typed_array_stack_.back();
  385|      0|                        if (!iter->done())
  ------------------
  |  Branch (385:29): [True: 0, False: 0]
  ------------------
  386|      0|                        {
  387|      0|                            iter->next(visitor, *this, ec);
  388|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  389|      0|                            {
  390|      0|                                return;
  391|      0|                            }
  392|      0|                        }
  393|      0|                        else
  394|      0|                        {
  395|      0|                            if (iter->count() != state_stack_.back().length)
  ------------------
  |  Branch (395:33): [True: 0, False: 0]
  ------------------
  396|      0|                            {
  397|       |                                //std::cout << state_stack_.back().index << "!=" << state_stack_.back().length << "\n";
  398|      0|                                ec = cbor_errc::bad_mdarray;
  399|      0|                                return;
  400|      0|                            }
  401|      0|                            end_classical_array_storage(ec);
  402|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  403|      0|                            {
  404|      0|                                return;
  405|      0|                            }
  406|      0|                        }
  407|      0|                    }
  408|      0|                    else
  409|      0|                    {
  410|      0|                        if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (410:29): [True: 0, False: 0]
  ------------------
  411|      0|                        {
  412|      0|                            ++state_stack_.back().index;
  413|      0|                            read_item(visitor, ec);
  414|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  415|      0|                            {
  416|      0|                                return;
  417|      0|                            }
  418|      0|                        }
  419|      0|                        else
  420|      0|                        {
  421|      0|                            end_array(visitor, ec);
  422|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  423|      0|                            {
  424|      0|                                return;
  425|      0|                            }
  426|      0|                        }
  427|      0|                    }
  428|      0|                    break;
  429|      0|                }
  430|      0|                case parse_mode::indefinite_array:
  ------------------
  |  Branch (430:17): [True: 0, False: 10.5k]
  ------------------
  431|      0|                {
  432|      0|                    if (is_multi_dim()) 
  ------------------
  |  Branch (432:25): [True: 0, False: 0]
  ------------------
  433|      0|                    {
  434|      0|                        JSONCONS_ASSERT(!typed_array_stack_.empty());
  ------------------
  |  |   54|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  435|      0|                        auto iter = typed_array_stack_.back();
  436|      0|                        if (!iter->done())
  ------------------
  |  Branch (436:29): [True: 0, False: 0]
  ------------------
  437|      0|                        {
  438|      0|                            iter->next(visitor, *this, ec);
  439|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  440|      0|                            {
  441|      0|                                return;
  442|      0|                            }
  443|      0|                        }
  444|      0|                        else
  445|      0|                        {
  446|      0|                            auto c = source_.peek();
  447|      0|                            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  448|      0|                            {
  449|      0|                                ec = cbor_errc::unexpected_eof;
  450|      0|                                more_ = false;
  451|      0|                                return;
  452|      0|                            }
  453|      0|                            if (c.value == 0xff)
  ------------------
  |  Branch (453:33): [True: 0, False: 0]
  ------------------
  454|      0|                            {
  455|      0|                                source_.ignore(1);
  456|      0|                            }
  457|      0|                            else
  458|      0|                            {
  459|      0|                                ec = cbor_errc::bad_mdarray;
  460|      0|                                return;
  461|      0|                            }
  462|      0|                            end_classical_array_storage(ec);
  463|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  464|      0|                            {
  465|      0|                                return;
  466|      0|                            }
  467|      0|                        }
  468|      0|                    }
  469|      0|                    else
  470|      0|                    {
  471|      0|                        auto c = source_.peek();
  472|      0|                        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  473|      0|                        {
  474|      0|                            ec = cbor_errc::unexpected_eof;
  475|      0|                            more_ = false;
  476|      0|                            return;
  477|      0|                        }
  478|      0|                        if (c.value == 0xff)
  ------------------
  |  Branch (478:29): [True: 0, False: 0]
  ------------------
  479|      0|                        {
  480|      0|                            source_.ignore(1);
  481|      0|                            end_array(visitor, ec);
  482|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  483|      0|                            {
  484|      0|                                return;
  485|      0|                            }
  486|      0|                        }
  487|      0|                        else
  488|      0|                        {
  489|      0|                            read_item(visitor, ec);
  490|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  491|      0|                            {
  492|      0|                                return;
  493|      0|                            }
  494|      0|                        }
  495|      0|                    }
  496|      0|                    break;
  497|      0|                }
  498|      0|                case parse_mode::map_key:
  ------------------
  |  Branch (498:17): [True: 0, False: 10.5k]
  ------------------
  499|      0|                {
  500|      0|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (500:25): [True: 0, False: 0]
  ------------------
  501|      0|                    {
  502|      0|                        ++state_stack_.back().index;
  503|      0|                        state_stack_.back().mode = parse_mode::map_value;
  504|      0|                        read_item(visitor, ec);
  505|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  506|      0|                        {
  507|      0|                            return;
  508|      0|                        }
  509|      0|                    }
  510|      0|                    else
  511|      0|                    {
  512|      0|                        end_object(visitor, ec);
  513|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  514|      0|                        {
  515|      0|                            return;
  516|      0|                        }
  517|      0|                    }
  518|      0|                    break;
  519|      0|                }
  520|      0|                case parse_mode::map_value:
  ------------------
  |  Branch (520:17): [True: 0, False: 10.5k]
  ------------------
  521|      0|                {
  522|      0|                    state_stack_.back().mode = parse_mode::map_key;
  523|      0|                    read_item(visitor, ec);
  524|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  525|      0|                    {
  526|      0|                        return;
  527|      0|                    }
  528|      0|                    break;
  529|      0|                }
  530|      0|                case parse_mode::indefinite_map_key:
  ------------------
  |  Branch (530:17): [True: 0, False: 10.5k]
  ------------------
  531|      0|                {
  532|      0|                    auto c = source_.peek();
  533|      0|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  534|      0|                    {
  535|      0|                        ec = cbor_errc::unexpected_eof;
  536|      0|                        more_ = false;
  537|      0|                        return;
  538|      0|                    }
  539|      0|                    if (c.value == 0xff)
  ------------------
  |  Branch (539:25): [True: 0, False: 0]
  ------------------
  540|      0|                    {
  541|      0|                        source_.ignore(1);
  542|      0|                        end_object(visitor, ec);
  543|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  544|      0|                        {
  545|      0|                            return;
  546|      0|                        }
  547|      0|                    }
  548|      0|                    else
  549|      0|                    {
  550|      0|                        state_stack_.back().mode = parse_mode::indefinite_map_value;
  551|      0|                        read_item(visitor, ec);
  552|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  553|      0|                        {
  554|      0|                            return;
  555|      0|                        }
  556|      0|                    }
  557|      0|                    break;
  558|      0|                }
  559|      0|                case parse_mode::indefinite_map_value:
  ------------------
  |  Branch (559:17): [True: 0, False: 10.5k]
  ------------------
  560|      0|                {
  561|      0|                    state_stack_.back().mode = parse_mode::indefinite_map_key;
  562|      0|                    read_item(visitor, ec);
  563|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  564|      0|                    {
  565|      0|                        return;
  566|      0|                    }
  567|      0|                    break;
  568|      0|                }
  569|  6.81k|                case parse_mode::root:
  ------------------
  |  Branch (569:17): [True: 6.81k, False: 3.71k]
  ------------------
  570|  6.81k|                {
  571|  6.81k|                    state_stack_.back().mode = parse_mode::accept;
  572|  6.81k|                    read_item(visitor, ec);
  573|  6.81k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  6.81k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2.67k, False: 4.13k]
  |  |  ------------------
  ------------------
  574|  2.67k|                    {
  575|  2.67k|                        return;
  576|  2.67k|                    }
  577|  4.13k|                    break;
  578|  6.81k|                }
  579|  4.13k|                case parse_mode::accept:
  ------------------
  |  Branch (579:17): [True: 3.71k, False: 6.81k]
  ------------------
  580|  3.71k|                {
  581|  3.71k|                    JSONCONS_ASSERT(state_stack_.size() == 1);
  ------------------
  |  |   54|  3.71k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 3.71k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  582|  3.71k|                    state_stack_.clear();
  583|  3.71k|                    more_ = false;
  584|  3.71k|                    done_ = true;
  585|  3.71k|                    visitor.flush();
  586|  3.71k|                    break;
  587|  3.71k|                }
  588|  10.5k|            }
  589|  10.5k|        }
  590|  10.5k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_itemERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  608|  6.81k|    {
  609|  6.81k|        read_tags(ec);
  610|  6.81k|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  6.81k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 309, False: 6.50k]
  |  |  ------------------
  ------------------
  611|    309|        {
  612|    309|            return;
  613|    309|        }
  614|  6.50k|        auto c = source_.peek();
  615|  6.50k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|  6.50k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 6.50k]
  |  |  ------------------
  ------------------
  616|      0|        {
  617|      0|            ec = cbor_errc::unexpected_eof;
  618|      0|            more_ = false;
  619|      0|            return;
  620|      0|        }
  621|  6.50k|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
  622|  6.50k|        uint8_t info = get_additional_information(c.value);
  623|  6.50k|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|  7.30k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 6.50k]
  |  |  |  Branch (79:50): [True: 802, False: 5.70k]
  |  |  |  Branch (79:50): [True: 3, False: 799]
  |  |  ------------------
  ------------------
  624|      3|        {
  625|      3|            ec = cbor_errc::reserved_additional_info;
  626|      3|            more_ = false;
  627|      3|            return;
  628|      3|        }
  629|       |
  630|  6.50k|        switch (major_type)
  631|  6.50k|        {
  632|    177|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (632:13): [True: 177, False: 6.32k]
  ------------------
  633|    177|            {
  634|    177|                source_.ignore(1);
  635|    177|                uint64_t val = read_unsigned_integer(info, ec);
  636|    177|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    177|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 175]
  |  |  ------------------
  ------------------
  637|      2|                {
  638|      2|                    return;
  639|      2|                }
  640|    175|                if (!stringref_map_stack_.empty() && other_tags_[stringref_tag])
  ------------------
  |  Branch (640:21): [True: 0, False: 175]
  |  Branch (640:21): [True: 0, False: 175]
  |  Branch (640:54): [True: 0, False: 0]
  ------------------
  641|      0|                {
  642|      0|                    other_tags_[stringref_tag] = false;
  643|      0|                    if (val >= stringref_map_stack_.back().size())
  ------------------
  |  Branch (643:25): [True: 0, False: 0]
  ------------------
  644|      0|                    {
  645|      0|                        ec = cbor_errc::stringref_too_large;
  646|      0|                        more_ = false;
  647|      0|                        return;
  648|      0|                    }
  649|      0|                    auto index = static_cast<typename stringref_map::size_type>(val);
  650|      0|                    if (index != val)
  ------------------
  |  Branch (650:25): [True: 0, False: 0]
  ------------------
  651|      0|                    {
  652|      0|                        ec = cbor_errc::number_too_large;
  653|      0|                        more_ = false;
  654|      0|                        return;
  655|      0|                    }
  656|      0|                    auto& str = stringref_map_stack_.back().at(index);
  657|      0|                    switch (str.type)
  658|      0|                    {
  659|      0|                        case jsoncons::cbor::detail::cbor_major_type::text_string:
  ------------------
  |  Branch (659:25): [True: 0, False: 0]
  ------------------
  660|      0|                        {
  661|      0|                            handle_string(visitor, jsoncons::string_view(str.str.data(),str.str.length()),ec);
  662|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  663|      0|                            {
  664|      0|                                return;
  665|      0|                            }
  666|      0|                            break;
  667|      0|                        }
  668|      0|                        case jsoncons::cbor::detail::cbor_major_type::byte_string:
  ------------------
  |  Branch (668:25): [True: 0, False: 0]
  ------------------
  669|      0|                        {
  670|      0|                            read_byte_string_from_buffer read(byte_string_view(str.bytes));
  671|      0|                            read_byte_string(read, visitor, ec);
  672|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  673|      0|                            {
  674|      0|                                return;
  675|      0|                            }
  676|      0|                            break;
  677|      0|                        }
  678|      0|                        default:
  ------------------
  |  Branch (678:25): [True: 0, False: 0]
  ------------------
  679|      0|                        {
  680|      0|                            ec = cbor_errc::invalid_major_type;
  681|      0|                            more_ = false;
  682|      0|                            return;
  683|      0|                        }
  684|      0|                    }
  685|      0|                }
  686|    175|                else
  687|    175|                {
  688|    175|                    semantic_tag tag = semantic_tag::none;
  689|    175|                    if (other_tags_[item_tag])
  ------------------
  |  Branch (689:25): [True: 73, False: 102]
  ------------------
  690|     73|                    {
  691|     73|                        if (raw_tag_ == 1)
  ------------------
  |  Branch (691:29): [True: 3, False: 70]
  ------------------
  692|      3|                        {
  693|      3|                            tag = semantic_tag::epoch_second;
  694|      3|                        }
  695|     73|                        other_tags_[item_tag] = false;
  696|     73|                    }
  697|    175|                    visitor.uint64_value(val, tag, *this, ec);
  698|    175|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    175|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 175]
  |  |  ------------------
  ------------------
  699|      0|                    {
  700|      0|                        return;
  701|      0|                    }
  702|    175|                    more_ = !cursor_mode_;
  703|    175|                }
  704|    175|                break;
  705|    175|            }
  706|    401|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (706:13): [True: 401, False: 6.10k]
  ------------------
  707|    401|            {
  708|    401|                source_.ignore(1);
  709|    401|                read_negative_integer (info, visitor, ec);
  710|    401|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    401|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 29, False: 372]
  |  |  ------------------
  ------------------
  711|     29|                {
  712|     29|                    return;
  713|     29|                }
  714|    372|                break;
  715|    401|            }
  716|  1.74k|            case jsoncons::cbor::detail::cbor_major_type::byte_string:
  ------------------
  |  Branch (716:13): [True: 1.74k, False: 4.75k]
  ------------------
  717|  1.74k|            {
  718|  1.74k|                read_byte_string_from_source read(this);
  719|  1.74k|                read_byte_string(read, visitor, ec);
  720|  1.74k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  1.74k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 723, False: 1.02k]
  |  |  ------------------
  ------------------
  721|    723|                {
  722|    723|                    return;
  723|    723|                }
  724|  1.02k|                break;
  725|  1.74k|            }
  726|  1.02k|            case jsoncons::cbor::detail::cbor_major_type::text_string:
  ------------------
  |  Branch (726:13): [True: 838, False: 5.66k]
  ------------------
  727|    838|            {
  728|    838|                source_.ignore(1);
  729|    838|                auto sv = read_text_string_view(info, ec);
  730|    838|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    838|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 533, False: 305]
  |  |  ------------------
  ------------------
  731|    533|                {
  732|    533|                    return;
  733|    533|                }
  734|    305|                auto result = unicode_traits::validate(sv.data(),sv.size());
  735|    305|                if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (735:21): [True: 117, False: 188]
  ------------------
  736|    117|                {
  737|    117|                    ec = cbor_errc::invalid_utf8_text_string;
  738|    117|                    more_ = false;
  739|    117|                    return;
  740|    117|                }
  741|    188|                handle_string(visitor, sv, ec);
  742|    188|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    188|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 188]
  |  |  ------------------
  ------------------
  743|      0|                {
  744|      0|                    return;
  745|      0|                }
  746|    188|                break;
  747|    188|            }
  748|    188|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (748:13): [True: 0, False: 6.50k]
  ------------------
  749|      0|            {
  750|      0|                JSONCONS_UNREACHABLE();
  ------------------
  |  |   80|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
  751|      0|                break;
  752|    188|            }
  753|    858|            case jsoncons::cbor::detail::cbor_major_type::simple:
  ------------------
  |  Branch (753:13): [True: 858, False: 5.64k]
  ------------------
  754|    858|            {
  755|    858|                switch (info)
  756|    858|                {
  757|      1|                    case 0x14:
  ------------------
  |  Branch (757:21): [True: 1, False: 857]
  ------------------
  758|      1|                        source_.ignore(1);
  759|      1|                        visitor.bool_value(false, semantic_tag::none, *this, ec);
  760|      1|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  761|      0|                        {
  762|      0|                            return;
  763|      0|                        }
  764|      1|                        more_ = !cursor_mode_;
  765|      1|                        break;
  766|      1|                    case 0x15:
  ------------------
  |  Branch (766:21): [True: 1, False: 857]
  ------------------
  767|      1|                        source_.ignore(1);
  768|      1|                        visitor.bool_value(true, semantic_tag::none, *this, ec);
  769|      1|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  770|      0|                        {
  771|      0|                            return;
  772|      0|                        }
  773|      1|                        more_ = !cursor_mode_;
  774|      1|                        break;
  775|      3|                    case 0x16:
  ------------------
  |  Branch (775:21): [True: 3, False: 855]
  ------------------
  776|      3|                        source_.ignore(1);
  777|      3|                        visitor.null_value(semantic_tag::none, *this, ec);
  778|      3|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
  779|      0|                        {
  780|      0|                            return;
  781|      0|                        }
  782|      3|                        more_ = !cursor_mode_;
  783|      3|                        break;
  784|      1|                    case 0x17:
  ------------------
  |  Branch (784:21): [True: 1, False: 857]
  ------------------
  785|      1|                        source_.ignore(1);
  786|      1|                        visitor.null_value(semantic_tag::undefined, *this, ec);
  787|      1|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  788|      0|                        {
  789|      0|                            return;
  790|      0|                        }
  791|      1|                        more_ = !cursor_mode_;
  792|      1|                        break;
  793|    133|                    case 0x19: // Half-Precision Float (two-byte IEEE 754)
  ------------------
  |  Branch (793:21): [True: 133, False: 725]
  ------------------
  794|    133|                    {
  795|    133|                        source_.ignore(1);
  796|    133|                        uint64_t val = read_unsigned_integer(info, ec);
  797|    133|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    133|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 131]
  |  |  ------------------
  ------------------
  798|      2|                        {
  799|      2|                            return;
  800|      2|                        }
  801|    131|                        visitor.half_value(static_cast<uint16_t>(val), semantic_tag::none, *this, ec);
  802|    131|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    131|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 131]
  |  |  ------------------
  ------------------
  803|      0|                        {
  804|      0|                            return;
  805|      0|                        }
  806|    131|                        more_ = !cursor_mode_;
  807|    131|                        break;
  808|    131|                    }
  809|    278|                    case 0x1a: // Single-Precision Float (four-byte IEEE 754)
  ------------------
  |  Branch (809:21): [True: 278, False: 580]
  ------------------
  810|    708|                    case 0x1b: // Double-Precision Float (eight-byte IEEE 754)
  ------------------
  |  Branch (810:21): [True: 430, False: 428]
  ------------------
  811|    708|                    {
  812|    708|                        source_.ignore(1);
  813|    708|                        double val = read_double(info, ec);
  814|    708|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    708|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 8, False: 700]
  |  |  ------------------
  ------------------
  815|      8|                        {
  816|      8|                            return;
  817|      8|                        }
  818|    700|                        semantic_tag tag = semantic_tag::none;
  819|    700|                        if (other_tags_[item_tag])
  ------------------
  |  Branch (819:29): [True: 89, False: 611]
  ------------------
  820|     89|                        {
  821|     89|                            if (raw_tag_ == 1)
  ------------------
  |  Branch (821:33): [True: 1, False: 88]
  ------------------
  822|      1|                            {
  823|      1|                                tag = semantic_tag::epoch_second;
  824|      1|                            }
  825|     89|                            other_tags_[item_tag] = false;
  826|     89|                        }
  827|    700|                        visitor.double_value(val, tag, *this, ec);
  828|    700|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    700|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 700]
  |  |  ------------------
  ------------------
  829|      0|                        {
  830|      0|                            return;
  831|      0|                        }
  832|    700|                        more_ = !cursor_mode_;
  833|    700|                        break;
  834|    700|                    }
  835|     11|                    default:
  ------------------
  |  Branch (835:21): [True: 11, False: 847]
  ------------------
  836|     11|                    {
  837|     11|                        ec = cbor_errc::unknown_type;
  838|     11|                        more_ = false;
  839|     11|                        return;
  840|    700|                    }
  841|    858|                }
  842|    837|                break;
  843|    858|            }
  844|  2.45k|            case jsoncons::cbor::detail::cbor_major_type::array:
  ------------------
  |  Branch (844:13): [True: 2.45k, False: 4.04k]
  ------------------
  845|  2.45k|            {
  846|  2.45k|                if (other_tags_[item_tag])
  ------------------
  |  Branch (846:21): [True: 2.43k, False: 23]
  ------------------
  847|  2.43k|                {
  848|  2.43k|                    switch (raw_tag_)
  849|  2.43k|                    {
  850|    968|                        case 0x04:
  ------------------
  |  Branch (850:25): [True: 968, False: 1.46k]
  ------------------
  851|    968|                            source_.ignore(1);
  852|    968|                            text_buffer_.clear();
  853|    968|                            read_bigdecimal(info, text_buffer_, ec);
  854|    968|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    968|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 351, False: 617]
  |  |  ------------------
  ------------------
  855|    351|                            {
  856|    351|                                return;
  857|    351|                            }
  858|    617|                            visitor.string_value(text_buffer_, semantic_tag::bigdec, *this, ec);
  859|    617|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    617|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 617]
  |  |  ------------------
  ------------------
  860|      0|                            {
  861|      0|                                return;
  862|      0|                            }
  863|    617|                            more_ = !cursor_mode_;
  864|    617|                            break;
  865|    877|                        case 0x05:
  ------------------
  |  Branch (865:25): [True: 877, False: 1.55k]
  ------------------
  866|    877|                            source_.ignore(1);
  867|    877|                            text_buffer_.clear();
  868|    877|                            read_bigfloat(info, text_buffer_, ec);
  869|    877|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    877|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 170, False: 707]
  |  |  ------------------
  ------------------
  870|    170|                            {
  871|    170|                                return;
  872|    170|                            }
  873|    707|                            visitor.string_value(text_buffer_, semantic_tag::bigfloat, *this, ec);
  874|    707|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    707|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 707]
  |  |  ------------------
  ------------------
  875|      0|                            {
  876|      0|                                return;
  877|      0|                            }
  878|    707|                            more_ = !cursor_mode_;
  879|    707|                            break;
  880|    413|                        case 40: // row-major storage
  ------------------
  |  Branch (880:25): [True: 413, False: 2.02k]
  ------------------
  881|    413|                            order_ = mdarray_order::row_major;
  882|    413|                            read_mdarray_header(visitor, ec);
  883|    413|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    413|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 386, False: 27]
  |  |  ------------------
  ------------------
  884|    386|                            {
  885|    386|                                return;
  886|    386|                            }
  887|     27|                            break;
  888|     46|                        case 1040: // column-major storage
  ------------------
  |  Branch (888:25): [True: 46, False: 2.38k]
  ------------------
  889|     46|                            order_ = mdarray_order::column_major;
  890|     46|                            read_mdarray_header(visitor, ec);
  891|     46|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     46|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 12, False: 34]
  |  |  ------------------
  ------------------
  892|     12|                            {
  893|     12|                                return;
  894|     12|                            }
  895|     34|                            break;
  896|    130|                        default:
  ------------------
  |  Branch (896:25): [True: 130, False: 2.30k]
  ------------------
  897|    130|                            source_.ignore(1);
  898|    130|                            begin_array(info, visitor, ec);
  899|    130|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    130|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 19, False: 111]
  |  |  ------------------
  ------------------
  900|     19|                            {
  901|     19|                                return;
  902|     19|                            }
  903|    111|                            break;
  904|  2.43k|                    }
  905|  1.49k|                    other_tags_[item_tag] = false;
  906|  1.49k|                }
  907|     23|                else
  908|     23|                {
  909|     23|                    source_.ignore(1);
  910|     23|                    begin_array(info, visitor, ec);
  911|     23|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     23|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 20]
  |  |  ------------------
  ------------------
  912|      3|                    {
  913|      3|                        return;
  914|      3|                    }
  915|     23|                }
  916|  1.51k|                break;
  917|  2.45k|            }
  918|  1.51k|            case jsoncons::cbor::detail::cbor_major_type::map:
  ------------------
  |  Branch (918:13): [True: 24, False: 6.47k]
  ------------------
  919|     24|            {
  920|     24|                source_.ignore(1);
  921|     24|                begin_object(info, visitor, ec);
  922|     24|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     24|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 23]
  |  |  ------------------
  ------------------
  923|      1|                {
  924|      1|                    return;
  925|      1|                }
  926|     23|                break;
  927|     24|            }
  928|     23|            default:
  ------------------
  |  Branch (928:13): [True: 0, False: 6.50k]
  ------------------
  929|      0|                ec = cbor_errc::invalid_major_type;
  930|      0|                more_ = false;
  931|      0|                return;
  932|  6.50k|        }
  933|  4.13k|        other_tags_[item_tag] = false;
  934|  4.13k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_tagsERNS3_10error_codeE:
 2092|  7.02k|    {
 2093|  7.02k|        auto c = source_.peek();
 2094|  7.02k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|  7.02k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 103, False: 6.92k]
  |  |  ------------------
  ------------------
 2095|    103|        {
 2096|    103|            ec = cbor_errc::unexpected_eof;
 2097|    103|            more_ = false;
 2098|    103|            return;
 2099|    103|        }
 2100|  6.92k|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 2101|  6.92k|        uint8_t info = get_additional_information(c.value);
 2102|  6.92k|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|  7.57k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 4, False: 6.92k]
  |  |  |  Branch (79:50): [True: 647, False: 6.27k]
  |  |  |  Branch (79:50): [True: 4, False: 643]
  |  |  ------------------
  ------------------
 2103|      4|        {
 2104|      4|            ec = cbor_errc::reserved_additional_info;
 2105|      4|            more_ = false;
 2106|      4|            return;
 2107|      4|        }
 2108|       |
 2109|  1.04M|        while (major_type == jsoncons::cbor::detail::cbor_major_type::semantic_tag)
  ------------------
  |  Branch (2109:16): [True: 1.03M, False: 6.61k]
  ------------------
 2110|  1.03M|        {
 2111|  1.03M|            source_.ignore(1);
 2112|  1.03M|            uint64_t val = read_unsigned_integer(info, ec);
 2113|  1.03M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  1.03M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 7, False: 1.03M]
  |  |  ------------------
  ------------------
 2114|      7|            {
 2115|      7|                return;
 2116|      7|            }
 2117|  1.03M|            switch(val)
 2118|  1.03M|            {
 2119|    326|                case 25: // stringref
  ------------------
  |  Branch (2119:17): [True: 326, False: 1.03M]
  ------------------
 2120|    326|                    other_tags_[stringref_tag] = true;
 2121|    326|                    break;
 2122|    201|                case 256: // stringref-namespace
  ------------------
  |  Branch (2122:17): [True: 201, False: 1.03M]
  ------------------
 2123|    201|                    other_tags_[stringref_namespace_tag] = true;
 2124|    201|                    break;
 2125|  1.03M|                default:
  ------------------
  |  Branch (2125:17): [True: 1.03M, False: 527]
  ------------------
 2126|  1.03M|                    other_tags_[item_tag] = true;
 2127|  1.03M|                    raw_tag_ = val;
 2128|  1.03M|                    break;
 2129|  1.03M|            }
 2130|  1.03M|            c = source_.peek();
 2131|  1.03M|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|  1.03M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 300, False: 1.03M]
  |  |  ------------------
  ------------------
 2132|    300|            {
 2133|    300|                ec = cbor_errc::unexpected_eof;
 2134|    300|                more_ = false;
 2135|    300|                return;
 2136|    300|            }
 2137|  1.03M|            major_type = get_major_type(c.value);
 2138|  1.03M|        }
 2139|  6.92k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE14get_major_typeEh:
 2078|  6.62M|    {
 2079|  6.62M|        static constexpr uint8_t major_type_shift = 0x05;
 2080|  6.62M|        uint8_t value = type >> major_type_shift;
 2081|  6.62M|        return static_cast<jsoncons::cbor::detail::cbor_major_type>(value);
 2082|  6.62M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE26get_additional_informationEh:
 2085|  8.63M|    {
 2086|  8.63M|        static constexpr uint8_t additional_information_mask = (1U << 5) - 1;
 2087|  8.63M|        uint8_t value = type & additional_information_mask;
 2088|  8.63M|        return value;
 2089|  8.63M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_unsigned_integerEhRNS3_10error_codeE:
 1611|  9.65M|    {
 1612|  9.65M|        switch (info)
 1613|  9.65M|        {
 1614|  9.32M|            case JSONCONS_EXT_CBOR_0x00_0x17: // 0x00..0x17 (0..23)
  ------------------
  |  |   18|  9.32M|    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: 1.90M, False: 7.74M]
  |  |  |  Branch (18:20): [True: 1.08M, False: 8.56M]
  |  |  |  Branch (18:30): [True: 55.6k, False: 9.59M]
  |  |  |  Branch (18:40): [True: 10.2k, False: 9.64M]
  |  |  |  Branch (18:50): [True: 1.91M, False: 7.73M]
  |  |  |  Branch (18:60): [True: 3.26k, False: 9.65M]
  |  |  |  Branch (18:70): [True: 58.1k, False: 9.59M]
  |  |  |  Branch (18:80): [True: 4.41k, False: 9.65M]
  |  |  |  Branch (18:90): [True: 90.9k, False: 9.56M]
  |  |  |  Branch (18:100): [True: 5.96k, False: 9.64M]
  |  |  |  Branch (18:110): [True: 46.7k, False: 9.60M]
  |  |  |  Branch (18:120): [True: 1.00k, False: 9.65M]
  |  |  |  Branch (18:130): [True: 1.88k, False: 9.65M]
  |  |  |  Branch (18:140): [True: 8.33k, False: 9.64M]
  |  |  |  Branch (18:150): [True: 11.9k, False: 9.64M]
  |  |  |  Branch (18:160): [True: 17.0k, False: 9.63M]
  |  |  |  Branch (18:170): [True: 8.04k, False: 9.64M]
  |  |  |  Branch (18:180): [True: 2.72k, False: 9.65M]
  |  |  |  Branch (18:190): [True: 54.0k, False: 9.60M]
  |  |  |  Branch (18:200): [True: 2.02k, False: 9.65M]
  |  |  |  Branch (18:210): [True: 1.22k, False: 9.65M]
  |  |  |  Branch (18:220): [True: 86.5k, False: 9.56M]
  |  |  ------------------
  ------------------
  |  Branch (1614:13): [True: 3.93M, False: 5.72M]
  ------------------
 1615|  9.32M|            {
 1616|  9.32M|                return info;
 1617|   190M|            }
 1618|   317k|            case 0x18: // Unsigned integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1618:13): [True: 317k, False: 9.33M]
  ------------------
 1619|   317k|            {
 1620|   317k|                uint8_t b;
 1621|   317k|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1621:21): [True: 11, False: 317k]
  ------------------
 1622|     11|                {
 1623|     11|                    ec = cbor_errc::unexpected_eof;
 1624|     11|                    return uint64_t{};
 1625|     11|                }
 1626|   317k|                return b;
 1627|   317k|            }
 1628|  5.72k|            case 0x19: // Unsigned integer (two-byte uint16_t follows)
  ------------------
  |  Branch (1628:13): [True: 5.72k, False: 9.64M]
  ------------------
 1629|  5.72k|            {
 1630|  5.72k|                uint8_t buf[sizeof(uint16_t)];
 1631|  5.72k|                if (source_.read(buf, sizeof(uint16_t)) != sizeof(uint16_t))
  ------------------
  |  Branch (1631:21): [True: 13, False: 5.71k]
  ------------------
 1632|     13|                {
 1633|     13|                    ec = cbor_errc::unexpected_eof;
 1634|     13|                    return uint64_t{};
 1635|     13|                }
 1636|  5.71k|                auto u = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1637|  5.71k|                return u;
 1638|  5.72k|            }
 1639|  1.44k|            case 0x1a: // Unsigned integer (four-byte uint32_t follows)
  ------------------
  |  Branch (1639:13): [True: 1.44k, False: 9.65M]
  ------------------
 1640|  1.44k|            {
 1641|  1.44k|                uint8_t buf[sizeof(uint32_t)];
 1642|  1.44k|                if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (1642:21): [True: 18, False: 1.42k]
  ------------------
 1643|     18|                {
 1644|     18|                    ec = cbor_errc::unexpected_eof;
 1645|     18|                    return uint64_t{};
 1646|     18|                }
 1647|  1.42k|                auto u = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1648|  1.42k|                return u;
 1649|  1.44k|            }
 1650|  10.2k|            case 0x1b: // Unsigned integer (eight-byte uint64_t follows)
  ------------------
  |  Branch (1650:13): [True: 10.2k, False: 9.64M]
  ------------------
 1651|  10.2k|            {
 1652|  10.2k|                uint8_t buf[sizeof(uint64_t)];
 1653|  10.2k|                if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (1653:21): [True: 28, False: 10.1k]
  ------------------
 1654|     28|                {
 1655|     28|                    ec = cbor_errc::unexpected_eof;
 1656|     28|                    return uint64_t{};
 1657|     28|                }
 1658|  10.1k|                auto u = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1659|  10.1k|                return u;
 1660|  10.2k|            }
 1661|     33|            default:
  ------------------
  |  Branch (1661:13): [True: 33, False: 9.65M]
  ------------------
 1662|     33|                ec = info == jsoncons::cbor::detail::additional_info::indefinite_length ? cbor_errc::unknown_type : cbor_errc::reserved_additional_info;
  ------------------
  |  Branch (1662:22): [True: 16, False: 17]
  ------------------
 1663|     33|                return uint64_t{};
 1664|  9.65M|        }
 1665|  9.65M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13handle_stringERNS_21basic_generic_visitorIcEERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERNS3_10error_codeE:
 2142|    188|    {
 2143|    188|        semantic_tag tag = semantic_tag::none;
 2144|    188|        if (other_tags_[item_tag])
  ------------------
  |  Branch (2144:13): [True: 14, False: 174]
  ------------------
 2145|     14|        {
 2146|     14|            switch (raw_tag_)
 2147|     14|            {
 2148|      1|                case 0:
  ------------------
  |  Branch (2148:17): [True: 1, False: 13]
  ------------------
 2149|      1|                    tag = semantic_tag::datetime;
 2150|      1|                    break;
 2151|      1|                case 32:
  ------------------
  |  Branch (2151:17): [True: 1, False: 13]
  ------------------
 2152|      1|                    tag = semantic_tag::uri;
 2153|      1|                    break;
 2154|      1|                case 33:
  ------------------
  |  Branch (2154:17): [True: 1, False: 13]
  ------------------
 2155|      1|                    tag = semantic_tag::base64url;
 2156|      1|                    break;
 2157|      1|                case 34:
  ------------------
  |  Branch (2157:17): [True: 1, False: 13]
  ------------------
 2158|      1|                    tag = semantic_tag::base64;
 2159|      1|                    break;
 2160|     10|                default:
  ------------------
  |  Branch (2160:17): [True: 10, False: 4]
  ------------------
 2161|     10|                    break;
 2162|     14|            }
 2163|     14|            other_tags_[item_tag] = false;
 2164|     14|        }
 2165|    188|        visitor.string_value(v, tag, *this, ec);
 2166|    188|        more_ = !cursor_mode_;
 2167|    188|    }
_ZN8jsoncons4cbor11parse_stateC2ENS0_10parse_modeEmb:
   52|  7.34k|        : mode(mode), length(length), pop_stringref_map_stack(pop_stringref_map_stack)
   53|  7.34k|    {
   54|  7.34k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE26get_typed_array_endiannessEh:
 2170|    202|    {
 2171|    202|        return ((tag & detail::cbor_array_tags_e_mask) >> detail::cbor_array_tags_e_shift) == 0 ? jsoncons::endian::big : jsoncons::endian::little; 
  ------------------
  |  Branch (2171:16): [True: 191, False: 11]
  ------------------
 2172|    202|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_negative_integerEhRNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 1506|    401|    {
 1507|    401|        semantic_tag tag = semantic_tag::none;
 1508|    401|        if (other_tags_[item_tag])
  ------------------
  |  Branch (1508:13): [True: 103, False: 298]
  ------------------
 1509|    103|        {
 1510|    103|            if (raw_tag_ == 1)
  ------------------
  |  Branch (1510:17): [True: 1, False: 102]
  ------------------
 1511|      1|            {
 1512|      1|                tag = semantic_tag::epoch_second;
 1513|      1|            }
 1514|    103|            other_tags_[item_tag] = false;
 1515|    103|        }
 1516|       |
 1517|    401|        switch (info)
 1518|    401|        {
 1519|    110|            case JSONCONS_EXT_CBOR_0x00_0x17: // 0x00..0x17 (0..23)
  ------------------
  |  |   18|    110|    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: 5, False: 396]
  |  |  |  Branch (18:20): [True: 1, False: 400]
  |  |  |  Branch (18:30): [True: 2, False: 399]
  |  |  |  Branch (18:40): [True: 8, False: 393]
  |  |  |  Branch (18:50): [True: 5, False: 396]
  |  |  |  Branch (18:60): [True: 2, False: 399]
  |  |  |  Branch (18:70): [True: 1, False: 400]
  |  |  |  Branch (18:80): [True: 5, False: 396]
  |  |  |  Branch (18:90): [True: 3, False: 398]
  |  |  |  Branch (18:100): [True: 5, False: 396]
  |  |  |  Branch (18:110): [True: 3, False: 398]
  |  |  |  Branch (18:120): [True: 3, False: 398]
  |  |  |  Branch (18:130): [True: 5, False: 396]
  |  |  |  Branch (18:140): [True: 9, False: 392]
  |  |  |  Branch (18:150): [True: 3, False: 398]
  |  |  |  Branch (18:160): [True: 9, False: 392]
  |  |  |  Branch (18:170): [True: 7, False: 394]
  |  |  |  Branch (18:180): [True: 9, False: 392]
  |  |  |  Branch (18:190): [True: 5, False: 396]
  |  |  |  Branch (18:200): [True: 3, False: 398]
  |  |  |  Branch (18:210): [True: 1, False: 400]
  |  |  |  Branch (18:220): [True: 5, False: 396]
  |  |  ------------------
  ------------------
  |  Branch (1519:13): [True: 8, False: 393]
  ------------------
 1520|    110|            {
 1521|    110|                int64_t val = static_cast<int8_t>(- 1 - info);
 1522|    110|                visitor.int64_value(val, tag, *this, ec);
 1523|    110|                more_ = !cursor_mode_;
 1524|    110|                break;
 1525|  1.23k|            }
 1526|     12|            case 0x18: // Negative integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1526:13): [True: 12, False: 389]
  ------------------
 1527|     12|            {
 1528|     12|                uint8_t b;
 1529|     12|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1529:21): [True: 4, False: 8]
  ------------------
 1530|      4|                {
 1531|      4|                    ec = cbor_errc::unexpected_eof;
 1532|      4|                    more_ = false;
 1533|      4|                    return;
 1534|      4|                }
 1535|      8|                int64_t val = static_cast<int64_t>(-1) - static_cast<int64_t>(b);
 1536|      8|                visitor.int64_value(val, tag, *this, ec);
 1537|      8|                more_ = !cursor_mode_;
 1538|      8|                break;
 1539|     12|            }
 1540|     16|            case 0x19: // Negative integer -1-n (two-byte uint16_t follows)
  ------------------
  |  Branch (1540:13): [True: 16, False: 385]
  ------------------
 1541|     16|            {
 1542|     16|                uint8_t buf[sizeof(uint16_t)];
 1543|     16|                if (source_.read(buf, sizeof(uint16_t)) != sizeof(uint16_t))
  ------------------
  |  Branch (1543:21): [True: 3, False: 13]
  ------------------
 1544|      3|                {
 1545|      3|                    ec = cbor_errc::unexpected_eof;
 1546|      3|                    more_ = false;
 1547|      3|                    return;
 1548|      3|                }
 1549|     13|                auto u = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1550|     13|                int64_t val = static_cast<int64_t>(-1)- u;
 1551|     13|                visitor.int64_value(val, tag, *this, ec);
 1552|     13|                more_ = !cursor_mode_;
 1553|     13|                break;
 1554|     16|            }
 1555|     37|            case 0x1a: // Negative integer -1-n (four-byte uint32_t follows)
  ------------------
  |  Branch (1555:13): [True: 37, False: 364]
  ------------------
 1556|     37|            {
 1557|     37|                uint8_t buf[sizeof(uint32_t)];
 1558|     37|                if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (1558:21): [True: 8, False: 29]
  ------------------
 1559|      8|                {
 1560|      8|                    ec = cbor_errc::unexpected_eof;
 1561|      8|                    more_ = false;
 1562|      8|                    return;
 1563|      8|                }
 1564|     29|                auto u = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1565|     29|                int64_t val = static_cast<int64_t>(-1)- u;
 1566|     29|                visitor.int64_value(val, tag, *this, ec);
 1567|     29|                more_ = !cursor_mode_;
 1568|     29|                break;
 1569|     37|            }
 1570|    224|            case 0x1b: // Negative integer -1-n (eight-byte uint64_t follows)
  ------------------
  |  Branch (1570:13): [True: 224, False: 177]
  ------------------
 1571|    224|            {
 1572|    224|                uint8_t buf[sizeof(uint64_t)];
 1573|    224|                if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (1573:21): [True: 12, False: 212]
  ------------------
 1574|     12|                {
 1575|     12|                    ec = cbor_errc::unexpected_eof;
 1576|     12|                    more_ = false;
 1577|     12|                    return;
 1578|     12|                }
 1579|    212|                auto u = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1580|    212|                if (u > static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1580:21): [True: 119, False: 93]
  ------------------
 1581|    119|                {
 1582|       |                    //ec = cbor_errc::invalid_negative_integer;
 1583|       |                    //more_ = false;
 1584|       |                    //return;
 1585|    119|                    bigint b(u);
 1586|    119|                    bigint b2 = -1 - b;
 1587|    119|                    text_buffer_.clear();
 1588|    119|                    b2.append_to_buffer(text_buffer_);
 1589|    119|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 1590|    119|                }
 1591|     93|                else if (JSONCONS_UNLIKELY(u == static_cast<uint64_t>((std::numeric_limits<int64_t>::max)())))
  ------------------
  |  |   79|     93|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 92]
  |  |  ------------------
  ------------------
 1592|      1|                {
 1593|      1|                    visitor.int64_value((std::numeric_limits<int64_t>::min)(), tag, *this, ec);
 1594|      1|                }
 1595|     92|                else
 1596|     92|                {
 1597|     92|                    int64_t val = static_cast<int64_t>(-1) - static_cast<int64_t>(u);
 1598|     92|                    visitor.int64_value(val, tag, *this, ec);
 1599|     92|                }
 1600|    212|                more_ = !cursor_mode_;
 1601|    212|                break;
 1602|    224|            }
 1603|      2|            default:
  ------------------
  |  Branch (1603:13): [True: 2, False: 399]
  ------------------
 1604|      2|                ec = info == jsoncons::cbor::detail::additional_info::indefinite_length ? cbor_errc::unknown_type : cbor_errc::reserved_additional_info;
  ------------------
  |  Branch (1604:22): [True: 2, False: 0]
  ------------------
 1605|      2|                more_ = false;
 1606|      2|                return;
 1607|    401|        }
 1608|    401|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_sourceC2EPS8_:
  200|  1.75k|            : source(source)
  201|  1.75k|        {
  202|  1.75k|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringINS8_28read_byte_string_from_sourceEEEvT_RNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 2184|  1.75k|    {
 2185|  1.75k|        if (other_tags_[item_tag])
  ------------------
  |  Branch (2185:13): [True: 1.13k, False: 623]
  ------------------
 2186|  1.13k|        {
 2187|  1.13k|            switch (raw_tag_)
 2188|  1.13k|            {
 2189|    331|                case 0x2:
  ------------------
  |  Branch (2189:17): [True: 331, False: 804]
  ------------------
 2190|    331|                {
 2191|    331|                    auto bytes = read.view(ec);
 2192|    331|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    331|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 328]
  |  |  ------------------
  ------------------
 2193|      3|                    {
 2194|      3|                        more_ = false;
 2195|      3|                        return;
 2196|      3|                    }
 2197|    328|                    bigint b = bigint::from_bytes_be(1, bytes.data(), bytes.size());
 2198|    328|                    text_buffer_.clear();
 2199|    328|                    b.append_to_buffer(text_buffer_);
 2200|    328|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2201|    328|                    more_ = !cursor_mode_;
 2202|    328|                    break;
 2203|    331|                }
 2204|    423|                case 0x3:
  ------------------
  |  Branch (2204:17): [True: 423, False: 712]
  ------------------
 2205|    423|                {
 2206|    423|                    auto bytes = read.view(ec);
 2207|    423|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    423|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 9, False: 414]
  |  |  ------------------
  ------------------
 2208|      9|                    {
 2209|      9|                        more_ = false;
 2210|      9|                        return;
 2211|      9|                    }
 2212|    414|                    bigint b = bigint::from_bytes_be(1, bytes.data(), bytes.size());
 2213|    414|                    b = -1 - b;
 2214|    414|                    text_buffer_.clear();
 2215|    414|                    b.append_to_buffer(text_buffer_);
 2216|    414|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2217|    414|                    more_ = !cursor_mode_;
 2218|    414|                    break;
 2219|    423|                }
 2220|      1|                case 0x15:
  ------------------
  |  Branch (2220:17): [True: 1, False: 1.13k]
  ------------------
 2221|      4|                case 0x16:
  ------------------
  |  Branch (2221:17): [True: 3, False: 1.13k]
  ------------------
 2222|     29|                case 0x17:
  ------------------
  |  Branch (2222:17): [True: 25, False: 1.11k]
  ------------------
 2223|     29|                {
 2224|     29|                    auto bytes = read.view(ec);
 2225|     29|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     29|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 27]
  |  |  ------------------
  ------------------
 2226|      2|                    {
 2227|      2|                        more_ = false;
 2228|      2|                        return;
 2229|      2|                    }
 2230|     27|                    const semantic_tag tag = raw_tag_ == 0x15 ? semantic_tag::base64url
  ------------------
  |  Branch (2230:46): [True: 1, False: 26]
  ------------------
 2231|     27|                        : raw_tag_ == 0x16 ? semantic_tag::base64
  ------------------
  |  Branch (2231:27): [True: 2, False: 24]
  ------------------
 2232|     26|                        : semantic_tag::base16;
 2233|     27|                    visitor.byte_string_value(bytes, tag, *this, ec);
 2234|     27|                    more_ = !cursor_mode_;
 2235|     27|                    break;
 2236|     29|                }
 2237|      6|                case 0x40:
  ------------------
  |  Branch (2237:17): [True: 6, False: 1.12k]
  ------------------
 2238|      6|                {
 2239|      6|                    array_tag_ = typed_array_tags::uint8;
 2240|      6|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2241|      6|                    read(array_buffer, ec);
 2242|      6|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      6|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 4, False: 2]
  |  |  ------------------
  ------------------
 2243|      4|                    {
 2244|      4|                        more_ = false;
 2245|      4|                        return;
 2246|      4|                    }
 2247|      2|                    auto ta = typed_array_cast<const uint8_t>(array_buffer);
 2248|      2|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2248:25): [True: 0, False: 2]
  |  Branch (2248:42): [True: 0, False: 0]
  ------------------
 2249|      0|                    {
 2250|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2250:29): [True: 0, False: 0]
  ------------------
 2251|      0|                        {
 2252|      0|                            ec = cbor_errc::bad_extents;
 2253|      0|                            more_ = false;
 2254|      0|                            return;
 2255|      0|                        }
 2256|      0|                        auto iter = std::make_shared<mdarray_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2257|      0|                            typed_array_tags::uint8, extents_, order_, alloc_);
 2258|      0|                        typed_array_stack_.push_back(iter);
 2259|      0|                        iter->next(visitor, *this, ec);
 2260|      0|                    }
 2261|      2|                    else
 2262|      2|                    {
 2263|      2|                        auto iter = std::make_shared<oned_typed_array_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2264|      2|                            typed_array_tags::uint8, semantic_tag::none, alloc_);
 2265|      2|                        typed_array_stack_.push_back(iter);
 2266|      2|                        iter->next(visitor, *this, ec);
 2267|      2|                    }
 2268|      2|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2269|      2|                    more_ = !cursor_mode_;
 2270|      2|                    break;
 2271|      2|                }
 2272|      4|                case 0x44:
  ------------------
  |  Branch (2272:17): [True: 4, False: 1.13k]
  ------------------
 2273|      4|                {
 2274|      4|                    array_tag_ = typed_array_tags::uint8;
 2275|      4|                    typed_array_tag_ = semantic_tag::clamped;
 2276|      4|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2277|      4|                    read(array_buffer, ec);
 2278|      4|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 1]
  |  |  ------------------
  ------------------
 2279|      3|                    {
 2280|      3|                        more_ = false;
 2281|      3|                        return;
 2282|      3|                    }
 2283|      1|                    auto ta = typed_array_cast<const uint8_t>(array_buffer);
 2284|      1|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2284:25): [True: 0, False: 1]
  |  Branch (2284:42): [True: 0, False: 0]
  ------------------
 2285|      0|                    {
 2286|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2286:29): [True: 0, False: 0]
  ------------------
 2287|      0|                        {
 2288|      0|                            ec = cbor_errc::bad_extents;
 2289|      0|                            more_ = false;
 2290|      0|                            return;
 2291|      0|                        }
 2292|      0|                        auto iter = std::make_shared<mdarray_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2293|      0|                            typed_array_tags::uint8, extents_, order_, alloc_);
 2294|      0|                        typed_array_stack_.push_back(iter);
 2295|      0|                        iter->next(visitor, *this, ec);
 2296|      0|                    }
 2297|      1|                    else
 2298|      1|                    {
 2299|      1|                        auto iter = std::make_shared<oned_typed_array_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2300|      1|                            typed_array_tags::uint8, semantic_tag::clamped, alloc_);
 2301|      1|                        typed_array_stack_.push_back(iter);
 2302|      1|                        iter->next(visitor, *this, ec);
 2303|      1|                    }
 2304|      1|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2305|      1|                    more_ = !cursor_mode_;
 2306|      1|                    break;
 2307|      1|                }
 2308|     29|                case 0x41:
  ------------------
  |  Branch (2308:17): [True: 29, False: 1.10k]
  ------------------
 2309|     31|                case 0x45:
  ------------------
  |  Branch (2309:17): [True: 2, False: 1.13k]
  ------------------
 2310|     31|                {
 2311|     31|                    array_tag_ = typed_array_tags::uint16;
 2312|     31|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2313|     31|                    read(array_buffer, ec);
 2314|     31|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     31|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 6, False: 25]
  |  |  ------------------
  ------------------
 2315|      6|                    {
 2316|      6|                        more_ = false;
 2317|      6|                        return;
 2318|      6|                    }
 2319|     25|                    const uint8_t tag = (uint8_t)raw_tag_;
 2320|     25|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2321|     25|                    auto ta = typed_array_cast<uint16_t>(array_buffer);
 2322|     25|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2322:25): [True: 24, False: 1]
  ------------------
 2323|     24|                    {
 2324|  38.1k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2324:49): [True: 38.0k, False: 24]
  ------------------
 2325|  38.0k|                        {
 2326|  38.0k|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2327|  38.0k|                        }
 2328|     24|                    }
 2329|     25|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2329:25): [True: 0, False: 25]
  |  Branch (2329:42): [True: 0, False: 0]
  ------------------
 2330|      0|                    {
 2331|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2331:29): [True: 0, False: 0]
  ------------------
 2332|      0|                        {
 2333|      0|                            ec = cbor_errc::bad_extents;
 2334|      0|                            more_ = false;
 2335|      0|                            return;
 2336|      0|                        }
 2337|      0|                        auto iter = std::make_shared<mdarray_iterator<uint16_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2338|      0|                            typed_array_tags::uint16, extents_, order_, alloc_);
 2339|      0|                        typed_array_stack_.push_back(iter);
 2340|      0|                        iter->next(visitor, *this, ec);
 2341|      0|                    }
 2342|     25|                    else
 2343|     25|                    {
 2344|     25|                        auto iter = std::make_shared<oned_typed_array_iterator<uint16_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2345|     25|                            typed_array_tags::uint16, semantic_tag::none, alloc_);
 2346|     25|                        typed_array_stack_.push_back(iter);
 2347|     25|                        iter->next(visitor, *this, ec);
 2348|     25|                    }
 2349|     25|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2350|     25|                    more_ = !cursor_mode_;
 2351|     25|                    break;
 2352|     25|                }
 2353|     31|                case 0x42:
  ------------------
  |  Branch (2353:17): [True: 31, False: 1.10k]
  ------------------
 2354|     36|                case 0x46:
  ------------------
  |  Branch (2354:17): [True: 5, False: 1.13k]
  ------------------
 2355|     36|                {
 2356|     36|                    array_tag_ = typed_array_tags::uint32;
 2357|     36|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2358|     36|                    read(array_buffer, ec);
 2359|     36|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     36|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 8, False: 28]
  |  |  ------------------
  ------------------
 2360|      8|                    {
 2361|      8|                        more_ = false;
 2362|      8|                        return;
 2363|      8|                    }
 2364|     28|                    const uint8_t tag = (uint8_t)raw_tag_;
 2365|     28|                    jsoncons::endian e = get_typed_array_endianness(tag);
 2366|     28|                    auto ta = typed_array_cast<uint32_t>(array_buffer);
 2367|     28|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2367:25): [True: 27, False: 1]
  ------------------
 2368|     27|                    {
 2369|  36.1k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2369:49): [True: 36.1k, False: 27]
  ------------------
 2370|  36.1k|                        {
 2371|  36.1k|                            ta[i] = binary::byte_swap<uint32_t>(ta[i]);
 2372|  36.1k|                        }
 2373|     27|                    }
 2374|     28|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2374:25): [True: 0, False: 28]
  |  Branch (2374:42): [True: 0, False: 0]
  ------------------
 2375|      0|                    {
 2376|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2376:29): [True: 0, False: 0]
  ------------------
 2377|      0|                        {
 2378|      0|                            ec = cbor_errc::bad_extents;
 2379|      0|                            more_ = false;
 2380|      0|                            return;
 2381|      0|                        }
 2382|      0|                        auto iter = std::make_shared<mdarray_iterator<uint32_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2383|      0|                            typed_array_tags::uint32, extents_, order_, alloc_);
 2384|      0|                        typed_array_stack_.push_back(iter);
 2385|      0|                        iter->next(visitor, *this, ec);
 2386|      0|                    }
 2387|     28|                    else
 2388|     28|                    {
 2389|     28|                        auto iter = std::make_shared<oned_typed_array_iterator<uint32_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2390|     28|                            typed_array_tags::uint32, semantic_tag::none, alloc_);
 2391|     28|                        typed_array_stack_.push_back(iter);
 2392|     28|                        iter->next(visitor, *this, ec);
 2393|     28|                    }
 2394|     28|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2395|     28|                    more_ = !cursor_mode_;
 2396|     28|                    break;
 2397|     28|                }
 2398|     59|                case 0x43:
  ------------------
  |  Branch (2398:17): [True: 59, False: 1.07k]
  ------------------
 2399|     71|                case 0x47:
  ------------------
  |  Branch (2399:17): [True: 12, False: 1.12k]
  ------------------
 2400|     71|                {
 2401|     71|                    array_tag_ = typed_array_tags::uint64;
 2402|     71|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2403|     71|                    read(array_buffer, ec);
 2404|     71|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     71|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 51, False: 20]
  |  |  ------------------
  ------------------
 2405|     51|                    {
 2406|     51|                        more_ = false;
 2407|     51|                        return;
 2408|     51|                    }
 2409|     20|                    const uint8_t tag = (uint8_t)raw_tag_;
 2410|     20|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2411|     20|                    auto ta = typed_array_cast<uint64_t>(array_buffer);
 2412|     20|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2412:25): [True: 18, False: 2]
  ------------------
 2413|     18|                    {
 2414|  9.52k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2414:49): [True: 9.51k, False: 18]
  ------------------
 2415|  9.51k|                        {
 2416|  9.51k|                            ta[i] = binary::byte_swap<uint64_t>(ta[i]);
 2417|  9.51k|                        }
 2418|     18|                    }
 2419|     20|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2419:25): [True: 0, False: 20]
  |  Branch (2419:42): [True: 0, False: 0]
  ------------------
 2420|      0|                    {
 2421|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2421:29): [True: 0, False: 0]
  ------------------
 2422|      0|                        {
 2423|      0|                            ec = cbor_errc::bad_extents;
 2424|      0|                            more_ = false;
 2425|      0|                            return;
 2426|      0|                        }
 2427|      0|                        auto iter = std::make_shared<mdarray_iterator<uint64_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2428|      0|                            typed_array_tags::uint64, extents_, order_, alloc_);
 2429|      0|                        typed_array_stack_.push_back(iter);
 2430|      0|                        iter->next(visitor, *this, ec);
 2431|      0|                    }
 2432|     20|                    else
 2433|     20|                    {
 2434|     20|                        auto iter = std::make_shared<oned_typed_array_iterator<uint64_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2435|     20|                            typed_array_tags::uint64, semantic_tag::none, alloc_);
 2436|     20|                        typed_array_stack_.push_back(iter);
 2437|     20|                        iter->next(visitor, *this, ec);
 2438|     20|                    }
 2439|     20|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2440|     20|                    more_ = !cursor_mode_;
 2441|     20|                    break;
 2442|     20|                }
 2443|      2|                case 0x48:
  ------------------
  |  Branch (2443:17): [True: 2, False: 1.13k]
  ------------------
 2444|      2|                {
 2445|      2|                    array_tag_ = typed_array_tags::int8;
 2446|      2|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2447|      2|                    read(array_buffer, ec);
 2448|      2|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 1]
  |  |  ------------------
  ------------------
 2449|      1|                    {
 2450|      1|                        more_ = false;
 2451|      1|                        return;
 2452|      1|                    }
 2453|      1|                    auto ta = typed_array_cast<int8_t>(array_buffer);
 2454|      1|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2454:25): [True: 0, False: 1]
  |  Branch (2454:42): [True: 0, False: 0]
  ------------------
 2455|      0|                    {
 2456|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2456:29): [True: 0, False: 0]
  ------------------
 2457|      0|                        {
 2458|      0|                            ec = cbor_errc::bad_extents;
 2459|      0|                            more_ = false;
 2460|      0|                            return;
 2461|      0|                        }
 2462|      0|                        auto iter = std::make_shared<mdarray_iterator<int8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2463|      0|                            typed_array_tags::int8, extents_, order_, alloc_);
 2464|      0|                        typed_array_stack_.push_back(iter);
 2465|      0|                        iter->next(visitor, *this, ec);
 2466|      0|                    }
 2467|      1|                    else
 2468|      1|                    {
 2469|      1|                        auto iter = std::make_shared<oned_typed_array_iterator<int8_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2470|      1|                            typed_array_tags::int8, semantic_tag::none, alloc_);
 2471|      1|                        typed_array_stack_.push_back(iter);
 2472|      1|                        iter->next(visitor, *this, ec);
 2473|      1|                    }
 2474|      1|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2475|      1|                    more_ = !cursor_mode_;
 2476|      1|                    break;
 2477|      1|                }
 2478|     27|                case 0x49:
  ------------------
  |  Branch (2478:17): [True: 27, False: 1.10k]
  ------------------
 2479|     30|                case 0x4d:
  ------------------
  |  Branch (2479:17): [True: 3, False: 1.13k]
  ------------------
 2480|     30|                {
 2481|     30|                    array_tag_ = typed_array_tags::int16;
 2482|     30|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2483|     30|                    read(array_buffer, ec);
 2484|     30|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     30|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 5, False: 25]
  |  |  ------------------
  ------------------
 2485|      5|                    {
 2486|      5|                        more_ = false;
 2487|      5|                        return;
 2488|      5|                    }
 2489|     25|                    const uint8_t tag = (uint8_t)raw_tag_;
 2490|     25|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2491|     25|                    auto ta = typed_array_cast<int16_t>(array_buffer);
 2492|     25|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2492:25): [True: 24, False: 1]
  ------------------
 2493|     24|                    {
 2494|   118k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2494:49): [True: 118k, False: 24]
  ------------------
 2495|   118k|                        {
 2496|   118k|                            ta[i] = binary::byte_swap<int16_t>(ta[i]);
 2497|   118k|                        }
 2498|     24|                    }
 2499|     25|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2499:25): [True: 0, False: 25]
  |  Branch (2499:42): [True: 0, False: 0]
  ------------------
 2500|      0|                    {
 2501|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2501:29): [True: 0, False: 0]
  ------------------
 2502|      0|                        {
 2503|      0|                            ec = cbor_errc::bad_extents;
 2504|      0|                            more_ = false;
 2505|      0|                            return;
 2506|      0|                        }
 2507|      0|                        auto iter = std::make_shared<mdarray_iterator<int16_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2508|      0|                            typed_array_tags::int16, extents_, order_, alloc_);
 2509|      0|                        typed_array_stack_.push_back(iter);
 2510|      0|                        iter->next(visitor, *this, ec);
 2511|      0|                    }
 2512|     25|                    else
 2513|     25|                    {
 2514|     25|                        auto iter = std::make_shared<oned_typed_array_iterator<int16_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2515|     25|                            typed_array_tags::int16, semantic_tag::none, alloc_);
 2516|     25|                        typed_array_stack_.push_back(iter);
 2517|     25|                        iter->next(visitor, *this, ec);
 2518|     25|                    }
 2519|     25|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2520|     25|                    more_ = !cursor_mode_;
 2521|     25|                    break;
 2522|     25|                }
 2523|     33|                case 0x4a:
  ------------------
  |  Branch (2523:17): [True: 33, False: 1.10k]
  ------------------
 2524|     34|                case 0x4e:
  ------------------
  |  Branch (2524:17): [True: 1, False: 1.13k]
  ------------------
 2525|     34|                {
 2526|     34|                    array_tag_ = typed_array_tags::int32;
 2527|     34|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2528|     34|                    read(array_buffer, ec);
 2529|     34|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     34|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 6, False: 28]
  |  |  ------------------
  ------------------
 2530|      6|                    {
 2531|      6|                        more_ = false;
 2532|      6|                        return;
 2533|      6|                    }
 2534|     28|                    const uint8_t tag = (uint8_t)raw_tag_;
 2535|     28|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2536|     28|                    auto ta = typed_array_cast<int32_t>(array_buffer);
 2537|     28|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2537:25): [True: 27, False: 1]
  ------------------
 2538|     27|                    {
 2539|  83.9k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2539:49): [True: 83.9k, False: 27]
  ------------------
 2540|  83.9k|                        {
 2541|  83.9k|                            ta[i] = binary::byte_swap<int32_t>(ta[i]);
 2542|  83.9k|                        }
 2543|     27|                    }
 2544|     28|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2544:25): [True: 0, False: 28]
  |  Branch (2544:42): [True: 0, False: 0]
  ------------------
 2545|      0|                    {
 2546|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2546:29): [True: 0, False: 0]
  ------------------
 2547|      0|                        {
 2548|      0|                            ec = cbor_errc::bad_extents;
 2549|      0|                            more_ = false;
 2550|      0|                            return;
 2551|      0|                        }
 2552|      0|                        auto iter = std::make_shared<mdarray_iterator<int32_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2553|      0|                            typed_array_tags::int32, extents_, order_, alloc_);
 2554|      0|                        typed_array_stack_.push_back(iter);
 2555|      0|                        iter->next(visitor, *this, ec);
 2556|      0|                    }
 2557|     28|                    else
 2558|     28|                    {
 2559|     28|                        auto iter = std::make_shared<oned_typed_array_iterator<int32_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2560|     28|                            typed_array_tags::int32, semantic_tag::none, alloc_);
 2561|     28|                        typed_array_stack_.push_back(iter);
 2562|     28|                        iter->next(visitor, *this, ec);
 2563|     28|                    }
 2564|     28|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2565|     28|                    more_ = !cursor_mode_;
 2566|     28|                    break;
 2567|     28|                }
 2568|     30|                case 0x4b:
  ------------------
  |  Branch (2568:17): [True: 30, False: 1.10k]
  ------------------
 2569|     34|                case 0x4f:
  ------------------
  |  Branch (2569:17): [True: 4, False: 1.13k]
  ------------------
 2570|     34|                {
 2571|     34|                    array_tag_ = typed_array_tags::int64;
 2572|     34|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2573|     34|                    read(array_buffer, ec);
 2574|     34|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     34|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 8, False: 26]
  |  |  ------------------
  ------------------
 2575|      8|                    {
 2576|      8|                        more_ = false;
 2577|      8|                        return;
 2578|      8|                    }
 2579|     26|                    const uint8_t tag = (uint8_t)raw_tag_;
 2580|     26|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2581|     26|                    auto ta = typed_array_cast<int64_t>(array_buffer);
 2582|     26|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2582:25): [True: 24, False: 2]
  ------------------
 2583|     24|                    {
 2584|    922|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2584:49): [True: 898, False: 24]
  ------------------
 2585|    898|                        {
 2586|    898|                            ta[i] = binary::byte_swap<int64_t>(ta[i]);
 2587|    898|                        }
 2588|     24|                    }
 2589|     26|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2589:25): [True: 0, False: 26]
  |  Branch (2589:42): [True: 0, False: 0]
  ------------------
 2590|      0|                    {
 2591|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2591:29): [True: 0, False: 0]
  ------------------
 2592|      0|                        {
 2593|      0|                            ec = cbor_errc::bad_extents;
 2594|      0|                            more_ = false;
 2595|      0|                            return;
 2596|      0|                        }
 2597|      0|                        auto iter = std::make_shared<mdarray_iterator<int64_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2598|      0|                            typed_array_tags::int64, extents_, order_, alloc_);
 2599|      0|                        typed_array_stack_.push_back(iter);
 2600|      0|                        iter->next(visitor, *this, ec);
 2601|      0|                    }
 2602|     26|                    else
 2603|     26|                    {
 2604|     26|                        auto iter = std::make_shared<oned_typed_array_iterator<int64_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2605|     26|                            typed_array_tags::int64, semantic_tag::none, alloc_);
 2606|     26|                        typed_array_stack_.push_back(iter);
 2607|     26|                        iter->next(visitor, *this, ec);
 2608|     26|                    }
 2609|     26|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2610|     26|                    more_ = !cursor_mode_;
 2611|     26|                    break;
 2612|     26|                }
 2613|     21|                case 0x50:
  ------------------
  |  Branch (2613:17): [True: 21, False: 1.11k]
  ------------------
 2614|     24|                case 0x54:
  ------------------
  |  Branch (2614:17): [True: 3, False: 1.13k]
  ------------------
 2615|     24|                {
 2616|     24|                    array_tag_ = typed_array_tags::half_float;
 2617|     24|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2618|     24|                    read(array_buffer, ec);
 2619|     24|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     24|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 11, False: 13]
  |  |  ------------------
  ------------------
 2620|     11|                    {
 2621|     11|                        more_ = false;
 2622|     11|                        return;
 2623|     11|                    }
 2624|     13|                    const uint8_t tag = (uint8_t)raw_tag_;
 2625|     13|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2626|     13|                    auto ta = typed_array_cast<uint16_t>(array_buffer);
 2627|     13|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2627:25): [True: 12, False: 1]
  ------------------
 2628|     12|                    {
 2629|  32.9k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2629:49): [True: 32.9k, False: 12]
  ------------------
 2630|  32.9k|                        {
 2631|  32.9k|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2632|  32.9k|                        }
 2633|     12|                    }
 2634|     13|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2634:25): [True: 0, False: 13]
  |  Branch (2634:42): [True: 0, False: 0]
  ------------------
 2635|      0|                    {
 2636|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2636:29): [True: 0, False: 0]
  ------------------
 2637|      0|                        {
 2638|      0|                            ec = cbor_errc::bad_extents;
 2639|      0|                            more_ = false;
 2640|      0|                            return;
 2641|      0|                        }
 2642|      0|                        auto iter = std::make_shared<mdarray_iterator<uint16_t,decode_half,Allocator>>(std::move(array_buffer), 
 2643|      0|                            typed_array_tags::half_float, extents_, order_, alloc_);
 2644|      0|                        typed_array_stack_.push_back(iter);
 2645|      0|                        iter->next(visitor, *this, ec);
 2646|      0|                    }
 2647|     13|                    else
 2648|     13|                    {
 2649|     13|                        auto iter = std::make_shared<oned_typed_array_iterator<uint16_t,decode_half,Allocator>>(std::move(array_buffer),
 2650|     13|                            typed_array_tags::half_float, semantic_tag::none, alloc_);
 2651|     13|                        typed_array_stack_.push_back(iter);
 2652|     13|                        iter->next(visitor, *this, ec);
 2653|     13|                    }
 2654|     13|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2655|     13|                    more_ = !cursor_mode_;
 2656|     13|                    break;
 2657|     13|                }
 2658|     20|                case 0x51:
  ------------------
  |  Branch (2658:17): [True: 20, False: 1.11k]
  ------------------
 2659|     24|                case 0x55:
  ------------------
  |  Branch (2659:17): [True: 4, False: 1.13k]
  ------------------
 2660|     24|                {
 2661|     24|                    array_tag_ = typed_array_tags::float32;
 2662|     24|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2663|     24|                    read(array_buffer, ec);
 2664|     24|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     24|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 4, False: 20]
  |  |  ------------------
  ------------------
 2665|      4|                    {
 2666|      4|                        more_ = false;
 2667|      4|                        return;
 2668|      4|                    }
 2669|     20|                    const uint8_t tag = (uint8_t)raw_tag_;
 2670|     20|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2671|     20|                    auto ta = typed_array_cast<float>(array_buffer);
 2672|     20|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2672:25): [True: 19, False: 1]
  ------------------
 2673|     19|                    {
 2674|  10.6k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2674:49): [True: 10.6k, False: 19]
  ------------------
 2675|  10.6k|                        {
 2676|  10.6k|                            ta[i] = binary::byte_swap<float>(ta[i]);
 2677|  10.6k|                        }
 2678|     19|                    }
 2679|     20|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2679:25): [True: 0, False: 20]
  |  Branch (2679:42): [True: 0, False: 0]
  ------------------
 2680|      0|                    {
 2681|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2681:29): [True: 0, False: 0]
  ------------------
 2682|      0|                        {
 2683|      0|                            ec = cbor_errc::bad_extents;
 2684|      0|                            more_ = false;
 2685|      0|                            return;
 2686|      0|                        }
 2687|      0|                        auto iter = std::make_shared<mdarray_iterator<float,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2688|      0|                            typed_array_tags::float32, extents_, order_, alloc_);
 2689|      0|                        typed_array_stack_.push_back(iter);
 2690|      0|                        iter->next(visitor, *this, ec);
 2691|      0|                    }
 2692|     20|                    else
 2693|     20|                    {
 2694|     20|                        auto iter = std::make_shared<oned_typed_array_iterator<float,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2695|     20|                            typed_array_tags::float32, semantic_tag::none, alloc_);
 2696|     20|                        typed_array_stack_.push_back(iter);
 2697|     20|                        iter->next(visitor, *this, ec);
 2698|     20|                    }
 2699|     20|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2700|     20|                    more_ = !cursor_mode_;
 2701|     20|                    break;
 2702|     20|                }
 2703|     36|                case 0x52:
  ------------------
  |  Branch (2703:17): [True: 36, False: 1.09k]
  ------------------
 2704|     40|                case 0x56:
  ------------------
  |  Branch (2704:17): [True: 4, False: 1.13k]
  ------------------
 2705|     40|                {
 2706|     40|                    array_tag_ = typed_array_tags::float64;
 2707|     40|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2708|     40|                    read(array_buffer, ec);
 2709|     40|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     40|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 23, False: 17]
  |  |  ------------------
  ------------------
 2710|     23|                    {
 2711|     23|                        more_ = false;
 2712|     23|                        return;
 2713|     23|                    }
 2714|     17|                    const uint8_t tag = (uint8_t)raw_tag_;
 2715|     17|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2716|     17|                    auto ta = typed_array_cast<double>(array_buffer);
 2717|     17|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2717:25): [True: 16, False: 1]
  ------------------
 2718|     16|                    {
 2719|  8.40k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2719:49): [True: 8.38k, False: 16]
  ------------------
 2720|  8.38k|                        {
 2721|  8.38k|                            ta[i] = binary::byte_swap<double>(ta[i]);
 2722|  8.38k|                        }
 2723|     16|                    }
 2724|     17|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2724:25): [True: 0, False: 17]
  |  Branch (2724:42): [True: 0, False: 0]
  ------------------
 2725|      0|                    {
 2726|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2726:29): [True: 0, False: 0]
  ------------------
 2727|      0|                        {
 2728|      0|                            ec = cbor_errc::bad_extents;
 2729|      0|                            more_ = false;
 2730|      0|                            return;
 2731|      0|                        }
 2732|      0|                        auto iter = std::make_shared<mdarray_iterator<double,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2733|      0|                            typed_array_tags::float64, extents_, order_, alloc_);
 2734|      0|                        typed_array_stack_.push_back(iter);
 2735|      0|                        iter->next(visitor, *this, ec);
 2736|      0|                    }
 2737|     17|                    else
 2738|     17|                    {
 2739|     17|                        auto iter = std::make_shared<oned_typed_array_iterator<double,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2740|     17|                            typed_array_tags::float64, semantic_tag::none, alloc_);
 2741|     17|                        typed_array_stack_.push_back(iter);
 2742|     17|                        iter->next(visitor, *this, ec);
 2743|     17|                    }
 2744|     17|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2745|     17|                    more_ = !cursor_mode_;
 2746|     17|                    break;
 2747|     17|                }
 2748|     16|                default:
  ------------------
  |  Branch (2748:17): [True: 16, False: 1.11k]
  ------------------
 2749|     16|                {
 2750|     16|                    auto bytes = read.view(ec);
 2751|     16|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     16|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 13, False: 3]
  |  |  ------------------
  ------------------
 2752|     13|                    {
 2753|     13|                        more_ = false;
 2754|     13|                        return;
 2755|     13|                    }
 2756|      3|                    visitor.byte_string_value(bytes, raw_tag_, *this, ec);
 2757|      3|                    more_ = !cursor_mode_;
 2758|      3|                    break;
 2759|     16|                }
 2760|  1.13k|            }
 2761|    978|            other_tags_[item_tag] = false;
 2762|    978|        }
 2763|    623|        else
 2764|    623|        {
 2765|    623|            auto bytes = read.view(ec);
 2766|    623|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    623|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 571, False: 52]
  |  |  ------------------
  ------------------
 2767|    571|            {
 2768|    571|                return;
 2769|    571|            }
 2770|     52|            visitor.byte_string_value(bytes, semantic_tag::none, *this, ec);
 2771|     52|            more_ = !cursor_mode_;
 2772|     52|        }
 2773|  1.75k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_source4viewERNS3_10error_codeE:
  210|  1.42k|        {
  211|  1.42k|            return source->read_byte_string_view(ec);
  212|  1.42k|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_byte_string_viewERNS3_10error_codeE:
 1143|  1.42k|    {
 1144|  1.42k|        auto c = source_.peek();
 1145|  1.42k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|  1.42k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1.42k]
  |  |  ------------------
  ------------------
 1146|      0|        {
 1147|      0|            ec = cbor_errc::unexpected_eof;
 1148|      0|            more_ = false;
 1149|      0|            return byte_string_view();
 1150|      0|        }
 1151|  1.42k|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1152|  1.42k|        uint8_t info = get_additional_information(c.value);
 1153|  1.42k|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|  1.71k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1.42k]
  |  |  |  Branch (79:50): [True: 290, False: 1.13k]
  |  |  |  Branch (79:50): [True: 0, False: 290]
  |  |  ------------------
  ------------------
 1154|      0|        {
 1155|      0|            ec = cbor_errc::reserved_additional_info;
 1156|      0|            more_ = false;
 1157|      0|            return byte_string_view();
 1158|      0|        }
 1159|       |
 1160|  1.42k|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::byte_string);
  ------------------
  |  |   54|  1.42k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 1.42k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1161|       |
 1162|  1.42k|        source_.ignore(1);
 1163|  1.42k|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1163:13): [True: 290, False: 1.13k]
  ------------------
 1164|    290|        {
 1165|    290|            bytes_buffer_.clear();
 1166|    290|            iterate_byte_string_chunks(bytes_buffer_, ec);
 1167|    290|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    290|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 247, False: 43]
  |  |  ------------------
  ------------------
 1168|    247|            {
 1169|    247|                return byte_string_view();
 1170|    247|            }
 1171|     43|            return byte_string_view(bytes_buffer_.data(), bytes_buffer_.size());
 1172|    290|        }
 1173|       |
 1174|  1.13k|        std::size_t length = read_size(info, ec);
 1175|  1.13k|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  1.13k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 7, False: 1.12k]
  |  |  ------------------
  ------------------
 1176|      7|        {
 1177|      7|            return byte_string_view();
 1178|      7|        }
 1179|  1.12k|        auto data = source_.read_span(length, bytes_buffer_);
 1180|  1.12k|        if (data.size() != length)
  ------------------
  |  Branch (1180:13): [True: 344, False: 781]
  ------------------
 1181|    344|        {
 1182|    344|            ec = cbor_errc::unexpected_eof;
 1183|    344|            more_ = false;
 1184|    344|            return byte_string_view();
 1185|    344|        }
 1186|       |        
 1187|    781|        byte_string_view bytes(data.data(), data.size());
 1188|    781|        if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1188:13): [True: 0, False: 781]
  ------------------
 1189|      0|            bytes.size() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1189:13): [True: 0, False: 0]
  ------------------
 1190|      0|        {
 1191|      0|            stringref_map_stack_.back().emplace_back(mapped_string(bytes, alloc_));
 1192|      0|        }
 1193|    781|        return bytes;
 1194|  1.12k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE26iterate_byte_string_chunksINS3_6vectorIhS5_EEEEvRT_RNS3_10error_codeE:
 1327|    423|    {
 1328|    423|        bool done = false;
 1329|  1.15M|        while (!done)
  ------------------
  |  Branch (1329:16): [True: 1.15M, False: 145]
  ------------------
 1330|  1.15M|        {
 1331|  1.15M|            auto c = source_.peek();
 1332|  1.15M|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|  1.15M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 39, False: 1.15M]
  |  |  ------------------
  ------------------
 1333|     39|            {
 1334|     39|                ec = cbor_errc::unexpected_eof;
 1335|     39|                more_ = false;
 1336|     39|                return;
 1337|     39|            }
 1338|  1.15M|            if (c.value == 0xff)
  ------------------
  |  Branch (1338:17): [True: 145, False: 1.15M]
  ------------------
 1339|    145|            {
 1340|    145|                source_.ignore(1);
 1341|    145|                done = true;
 1342|    145|                continue;
 1343|    145|            }
 1344|       |
 1345|  1.15M|            jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1346|  1.15M|            if (major_type != jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (1346:17): [True: 32, False: 1.15M]
  ------------------
 1347|     32|            {
 1348|     32|                ec = cbor_errc::illegal_chunked_string;
 1349|     32|                more_ = false;
 1350|     32|                return;
 1351|     32|            }
 1352|  1.15M|            uint8_t info = get_additional_information(c.value);
 1353|  1.15M|            if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1353:17): [True: 2, False: 1.15M]
  ------------------
 1354|      2|            {
 1355|      2|                ec = cbor_errc::illegal_chunked_string;
 1356|      2|                more_ = false;
 1357|      2|                return;
 1358|      2|            }
 1359|       |
 1360|  1.15M|            source_.ignore(1);
 1361|  1.15M|            std::size_t length = read_size(info, ec);
 1362|  1.15M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  1.15M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 14, False: 1.15M]
  |  |  ------------------
  ------------------
 1363|     14|            {
 1364|     14|                return;
 1365|     14|            }
 1366|  1.15M|            if (source_reader<Source>::read(source_, v, length) != length)
  ------------------
  |  Branch (1366:17): [True: 191, False: 1.15M]
  ------------------
 1367|    191|            {
 1368|    191|                ec = cbor_errc::unexpected_eof;
 1369|    191|            }
 1370|  1.15M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  1.15M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 191, False: 1.15M]
  |  |  ------------------
  ------------------
 1371|    191|            {
 1372|    191|                return;
 1373|    191|            }
 1374|  1.15M|        }
 1375|    423|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_sizeEhRNS3_10error_codeE:
 1197|  8.61M|    {
 1198|  8.61M|        uint64_t u = read_unsigned_integer(info, ec);
 1199|  8.61M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  8.61M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 79, False: 8.61M]
  |  |  ------------------
  ------------------
 1200|     79|        {
 1201|     79|            return 0;
 1202|     79|        }
 1203|  8.61M|        std::size_t len = static_cast<std::size_t>(u);
 1204|  8.61M|        if (len != u)
  ------------------
  |  Branch (1204:13): [True: 0, False: 8.61M]
  ------------------
 1205|      0|        {
 1206|      0|            ec = cbor_errc::number_too_large;
 1207|      0|            more_ = false;
 1208|      0|        }
 1209|  8.61M|        return len;
 1210|  8.61M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_sourceclINS3_6vectorIhS5_EEEEvRT_RNS3_10error_codeE:
  205|    336|        {
  206|    336|            source->read_byte_string(cont,ec);
  207|    336|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringERNS3_6vectorIhS5_EERNS3_10error_codeE:
 1213|    955|    {
 1214|    955|        v.clear();
 1215|    955|        auto c = source_.peek();
 1216|    955|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|    955|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 955]
  |  |  ------------------
  ------------------
 1217|      0|        {
 1218|      0|            ec = cbor_errc::unexpected_eof;
 1219|      0|            return;
 1220|      0|        }
 1221|    955|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1222|    955|        uint8_t info = get_additional_information(c.value);
 1223|    955|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|  1.09k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 953]
  |  |  |  Branch (79:50): [True: 135, False: 820]
  |  |  |  Branch (79:50): [True: 2, False: 133]
  |  |  ------------------
  ------------------
 1224|      2|        {
 1225|      2|            ec = cbor_errc::reserved_additional_info;
 1226|      2|            more_ = false;
 1227|      2|            return;
 1228|      2|        }
 1229|       |
 1230|    953|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::byte_string);
  ------------------
  |  |   54|    953|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 953]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1231|       |
 1232|    953|        source_.ignore(1);
 1233|    953|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1233:13): [True: 133, False: 820]
  ------------------
 1234|    133|        {
 1235|    133|            iterate_byte_string_chunks(v, ec);
 1236|    133|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    133|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 31, False: 102]
  |  |  ------------------
  ------------------
 1237|     31|            {
 1238|     31|                return;
 1239|     31|            }
 1240|    133|        }
 1241|    820|        else 
 1242|    820|        {
 1243|    820|            std::size_t length = read_size(info, ec);
 1244|    820|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    820|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 7, False: 813]
  |  |  ------------------
  ------------------
 1245|      7|            {
 1246|      7|                return;
 1247|      7|            }
 1248|    813|            if (source_reader<Source>::read(source_, v, length) != length)
  ------------------
  |  Branch (1248:17): [True: 118, False: 695]
  ------------------
 1249|    118|            {
 1250|    118|                ec = cbor_errc::unexpected_eof;
 1251|    118|                return;
 1252|    118|            }
 1253|    695|            if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1253:17): [True: 0, False: 695]
  ------------------
 1254|      0|                v.size() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1254:17): [True: 0, False: 0]
  ------------------
 1255|      0|            {
 1256|      0|                stringref_map_stack_.back().emplace_back(mapped_string(v, alloc_));
 1257|      0|            }
 1258|    695|        }
 1259|    953|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_text_string_viewEhRNS3_10error_codeE:
 1109|    838|    {
 1110|    838|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1110:13): [True: 371, False: 467]
  ------------------
 1111|    371|        {
 1112|    371|            text_buffer_.clear();
 1113|    371|            iterate_text_string_chunks(text_buffer_, ec);
 1114|    371|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    371|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 235, False: 136]
  |  |  ------------------
  ------------------
 1115|    235|            {
 1116|    235|                return string_view_type();
 1117|    235|            }
 1118|    136|            return string_view_type(text_buffer_.data(), text_buffer_.size());
 1119|    371|        }
 1120|       |
 1121|    467|        std::size_t length = read_size(info, ec);
 1122|    467|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    467|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 465]
  |  |  ------------------
  ------------------
 1123|      2|        {
 1124|      2|            return string_view_type();
 1125|      2|        }
 1126|    465|        auto data = source_.read_span(length, text_buffer_);
 1127|    465|        if (data.size() != length)
  ------------------
  |  Branch (1127:13): [True: 296, False: 169]
  ------------------
 1128|    296|        {
 1129|    296|            ec = cbor_errc::unexpected_eof;
 1130|    296|            more_ = false;
 1131|    296|            return string_view_type();
 1132|    296|        }
 1133|    169|        string_view_type sv(reinterpret_cast<const char_type*>(data.data()), data.size());
 1134|    169|        if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1134:13): [True: 0, False: 169]
  ------------------
 1135|      0|            sv.length() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1135:13): [True: 0, False: 0]
  ------------------
 1136|      0|        {
 1137|      0|            stringref_map_stack_.back().emplace_back(mapped_string(sv,alloc_));
 1138|      0|        }
 1139|    169|        return sv;
 1140|    465|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE26iterate_text_string_chunksINS3_12basic_stringIcNS3_11char_traitsIcEES7_EEEEvRT_RNS3_10error_codeE:
 1263|    371|    {
 1264|    371|        bool done = false;
 1265|  2.12M|        while (!done)
  ------------------
  |  Branch (1265:16): [True: 2.12M, False: 136]
  ------------------
 1266|  2.12M|        {
 1267|  2.12M|            auto c = source_.peek();
 1268|  2.12M|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|  2.12M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 32, False: 2.12M]
  |  |  ------------------
  ------------------
 1269|     32|            {
 1270|     32|                ec = cbor_errc::unexpected_eof;
 1271|     32|                more_ = false;
 1272|     32|                return;
 1273|     32|            }
 1274|  2.12M|            if (c.value == 0xff)
  ------------------
  |  Branch (1274:17): [True: 136, False: 2.12M]
  ------------------
 1275|    136|            {
 1276|    136|                source_.ignore(1);
 1277|    136|                done = true;
 1278|    136|                continue;
 1279|    136|            }
 1280|       |
 1281|  2.12M|            jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1282|  2.12M|            if (major_type != jsoncons::cbor::detail::cbor_major_type::text_string)
  ------------------
  |  Branch (1282:17): [True: 18, False: 2.12M]
  ------------------
 1283|     18|            {
 1284|     18|                ec = cbor_errc::illegal_chunked_string;
 1285|     18|                more_ = false;
 1286|     18|                return;
 1287|     18|            }
 1288|  2.12M|            uint8_t info = get_additional_information(c.value);
 1289|  2.12M|            if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1289:17): [True: 2, False: 2.12M]
  ------------------
 1290|      2|            {
 1291|      2|                ec = cbor_errc::illegal_chunked_string;
 1292|      2|                more_ = false;
 1293|      2|                return;
 1294|      2|            }
 1295|       |
 1296|  2.12M|            source_.ignore(1);
 1297|  2.12M|            std::size_t length = read_size(info, ec);
 1298|  2.12M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  2.12M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 2.12M]
  |  |  ------------------
  ------------------
 1299|      3|            {
 1300|      3|                return;
 1301|      3|            }
 1302|  2.12M|            const std::size_t offset = v.size();
 1303|  2.12M|            if (source_reader<Source>::read(source_, v, length) != length)
  ------------------
  |  Branch (1303:17): [True: 158, False: 2.12M]
  ------------------
 1304|    158|            {
 1305|    158|                ec = cbor_errc::unexpected_eof;
 1306|    158|            }
 1307|  2.12M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  2.12M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 158, False: 2.12M]
  |  |  ------------------
  ------------------
 1308|    158|            {
 1309|    158|                return;
 1310|    158|            }
 1311|       |            // RFC 8949 3.2.3: each chunk of an indefinite-length text
 1312|       |            // string must itself be well-formed UTF-8, so a code point
 1313|       |            // may not be split across chunks.
 1314|  2.12M|            auto result = unicode_traits::validate(
 1315|  2.12M|                reinterpret_cast<const char*>(v.data()) + offset, length);
 1316|  2.12M|            if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (1316:17): [True: 22, False: 2.12M]
  ------------------
 1317|     22|            {
 1318|     22|                ec = cbor_errc::invalid_utf8_text_string;
 1319|     22|                more_ = false;
 1320|     22|                return;
 1321|     22|            }
 1322|  2.12M|        }
 1323|    371|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11read_doubleEhRNS3_10error_codeE:
 1668|    708|    {
 1669|    708|        double val = 0;
 1670|       |
 1671|    708|        switch (info)
 1672|    708|        {
 1673|    278|            case 0x1a: // Single-Precision Float (four-byte IEEE 754)
  ------------------
  |  Branch (1673:13): [True: 278, False: 430]
  ------------------
 1674|    278|            {
 1675|    278|                uint8_t buf[sizeof(float)];
 1676|    278|                if (source_.read(buf, sizeof(float)) !=sizeof(float)) 
  ------------------
  |  Branch (1676:21): [True: 3, False: 275]
  ------------------
 1677|      3|                {
 1678|      3|                    ec = cbor_errc::unexpected_eof;
 1679|      3|                    more_ = false;
 1680|      3|                    return 0;
 1681|      3|                }
 1682|    275|                val = binary::big_to_native<float>(buf, sizeof(buf));
 1683|    275|                break;
 1684|    278|            }
 1685|       |
 1686|    430|            case 0x1b: //  Double-Precision Float (eight-byte IEEE 754)
  ------------------
  |  Branch (1686:13): [True: 430, False: 278]
  ------------------
 1687|    430|            {
 1688|    430|                uint8_t buf[sizeof(double)];
 1689|    430|                if (source_.read(buf, sizeof(double)) != sizeof(double))
  ------------------
  |  Branch (1689:21): [True: 5, False: 425]
  ------------------
 1690|      5|                {
 1691|      5|                    ec = cbor_errc::unexpected_eof;
 1692|      5|                    more_ = false;
 1693|      5|                    return 0;
 1694|      5|                }
 1695|    425|                val = binary::big_to_native<double>(buf, sizeof(buf));
 1696|    425|                break;
 1697|    430|            }
 1698|      0|            default:
  ------------------
  |  Branch (1698:13): [True: 0, False: 708]
  ------------------
 1699|      0|            {
 1700|      0|                ec = cbor_errc::unknown_type;
 1701|      0|                more_ = false;
 1702|      0|                return 0;
 1703|    430|            }
 1704|    708|        }
 1705|       |        
 1706|    700|        return val;
 1707|    708|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE15read_bigdecimalEhRNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 1710|    968|    {
 1711|    968|        std::size_t size = read_unsigned_integer(container_info, ec);
 1712|    968|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    968|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 967]
  |  |  ------------------
  ------------------
 1713|      1|        {
 1714|      1|            return;
 1715|      1|        }
 1716|    967|        if (size != 2)
  ------------------
  |  Branch (1716:13): [True: 101, False: 866]
  ------------------
 1717|    101|        {
 1718|    101|            ec = cbor_errc::invalid_bigdecimal;
 1719|    101|            more_ = false;
 1720|    101|            return;
 1721|    101|        }
 1722|       |
 1723|    866|        auto c = source_.peek();
 1724|    866|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|    866|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 865]
  |  |  ------------------
  ------------------
 1725|      1|        {
 1726|      1|            ec = cbor_errc::unexpected_eof;
 1727|      1|            more_ = false;
 1728|      1|            return;
 1729|      1|        }
 1730|    865|        int64_t exponent = 0;
 1731|    865|        auto major_type = get_major_type(c.value);
 1732|    865|        auto info = get_additional_information(c.value);
 1733|    865|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|    884|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 863]
  |  |  |  Branch (79:50): [True: 19, False: 846]
  |  |  |  Branch (79:50): [True: 2, False: 17]
  |  |  ------------------
  ------------------
 1734|      2|        {
 1735|      2|            ec = cbor_errc::reserved_additional_info;
 1736|      2|            more_ = false;
 1737|      2|            return;
 1738|      2|        }
 1739|       |
 1740|    863|        switch (major_type)
 1741|    863|        {
 1742|    326|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1742:13): [True: 326, False: 537]
  ------------------
 1743|    326|            {
 1744|    326|                source_.ignore(1);
 1745|    326|                auto u = read_unsigned_integer(info, ec);
 1746|    326|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    326|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 323]
  |  |  ------------------
  ------------------
 1747|      3|                {
 1748|      3|                    more_ = false;
 1749|      3|                    return;
 1750|      3|                }
 1751|    323|                if (u > static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1751:21): [True: 68, False: 255]
  ------------------
 1752|     68|                {
 1753|     68|                    ec = cbor_errc::invalid_bigdecimal;
 1754|     68|                    more_ = false;
 1755|     68|                    return;
 1756|     68|                }
 1757|    255|                exponent = static_cast<int64_t>(u);
 1758|    255|                break;
 1759|    323|            }
 1760|    531|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1760:13): [True: 531, False: 332]
  ------------------
 1761|    531|            {
 1762|    531|                auto u = read_int64(ec);
 1763|    531|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    531|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 45, False: 486]
  |  |  ------------------
  ------------------
 1764|     45|                {
 1765|     45|                    return;
 1766|     45|                }
 1767|    486|                if (JSONCONS_UNLIKELY(u == (std::numeric_limits<int64_t>::min)()))
  ------------------
  |  |   79|    486|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 485]
  |  |  ------------------
  ------------------
 1768|      1|                {
 1769|      1|                    ec = cbor_errc::invalid_bigdecimal;
 1770|      1|                    more_ = false;
 1771|      1|                    return;
 1772|      1|                }
 1773|    485|                exponent = u;
 1774|    485|                break;
 1775|    486|            }
 1776|      6|            default:
  ------------------
  |  Branch (1776:13): [True: 6, False: 857]
  ------------------
 1777|      6|            {
 1778|      6|                ec = cbor_errc::invalid_bigdecimal;
 1779|      6|                more_ = false;
 1780|      6|                return;
 1781|    486|            }
 1782|    863|        }
 1783|       |
 1784|    740|        c = source_.peek();
 1785|    740|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|    740|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 93, False: 647]
  |  |  ------------------
  ------------------
 1786|     93|        {
 1787|     93|            ec = cbor_errc::unexpected_eof;
 1788|     93|            more_ = false;
 1789|     93|            return;
 1790|     93|        }
 1791|       |
 1792|    647|        major_type = get_major_type(c.value);
 1793|    647|        info = get_additional_information(c.value);
 1794|    647|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|    652|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 646]
  |  |  |  Branch (79:50): [True: 5, False: 642]
  |  |  |  Branch (79:50): [True: 1, False: 4]
  |  |  ------------------
  ------------------
 1795|      1|        {
 1796|      1|            ec = cbor_errc::reserved_additional_info;
 1797|      1|            more_ = false;
 1798|      1|            return;
 1799|      1|        }
 1800|       |
 1801|    646|        bigint unscaled;
 1802|    646|        switch (major_type)
 1803|    646|        {
 1804|    264|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1804:13): [True: 264, False: 382]
  ------------------
 1805|    264|            {
 1806|    264|                source_.ignore(1);
 1807|    264|                uint64_t u = read_unsigned_integer(info, ec);
 1808|    264|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    264|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 261]
  |  |  ------------------
  ------------------
 1809|      3|                {
 1810|      3|                    return;
 1811|      3|                }
 1812|    261|                unscaled = bigint(u);
 1813|    261|                break;
 1814|    264|            }
 1815|    234|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1815:13): [True: 234, False: 412]
  ------------------
 1816|    234|            {
 1817|    234|                if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|    235|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 234]
  |  |  |  Branch (79:50): [True: 1, False: 233]
  |  |  |  Branch (79:50): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1818|      0|                {
 1819|      0|                    ec = cbor_errc::reserved_additional_info;
 1820|      0|                    more_ = false;
 1821|      0|                    return;
 1822|      0|                }
 1823|    234|                source_.ignore(1);
 1824|    234|                auto u = read_unsigned_integer(info, ec);
 1825|    234|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    234|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 233]
  |  |  ------------------
  ------------------
 1826|      1|                {
 1827|      1|                    return;
 1828|      1|                }
 1829|    233|                if (u > static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1829:21): [True: 69, False: 164]
  ------------------
 1830|     69|                {
 1831|     69|                    unscaled = -1 - bigint(u);
 1832|     69|                }
 1833|    164|                else if (JSONCONS_UNLIKELY(u == static_cast<uint64_t>((std::numeric_limits<int64_t>::max)())))
  ------------------
  |  |   79|    164|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 163]
  |  |  ------------------
  ------------------
 1834|      1|                {
 1835|      1|                    unscaled = bigint((std::numeric_limits<int64_t>::min)());
 1836|      1|                }
 1837|    163|                else
 1838|    163|                {
 1839|    163|                    unscaled = bigint(static_cast<int64_t>(-1) - static_cast<int64_t>(u));
 1840|    163|                }
 1841|    233|                break;
 1842|    234|            }
 1843|    141|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (1843:13): [True: 141, False: 505]
  ------------------
 1844|    141|            {
 1845|    141|                uint8_t b;
 1846|    141|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1846:21): [True: 0, False: 141]
  ------------------
 1847|      0|                {
 1848|      0|                    ec = cbor_errc::unexpected_eof;
 1849|      0|                    more_ = false;
 1850|      0|                    return;
 1851|      0|                }
 1852|    141|                info = get_additional_information(b);
 1853|    141|                if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|    142|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 141]
  |  |  |  Branch (79:50): [True: 1, False: 140]
  |  |  |  Branch (79:50): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1854|      0|                {
 1855|      0|                    ec = cbor_errc::reserved_additional_info;
 1856|      0|                    more_ = false;
 1857|      0|                    return;
 1858|      0|                }
 1859|    141|                c = source_.peek();
 1860|    141|                if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|    141|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 10, False: 131]
  |  |  ------------------
  ------------------
 1861|     10|                {
 1862|     10|                    ec = cbor_errc::unexpected_eof;
 1863|     10|                    more_ = false;
 1864|     10|                    return;
 1865|     10|                }
 1866|       |
 1867|    131|                if (get_major_type(c.value) == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (1867:21): [True: 112, False: 19]
  ------------------
 1868|    112|                {
 1869|    112|                    bytes_buffer_.clear();
 1870|    112|                    read_byte_string(bytes_buffer_, ec);
 1871|    112|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    112|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 8, False: 104]
  |  |  ------------------
  ------------------
 1872|      8|                    {
 1873|      8|                        more_ = false;
 1874|      8|                        return;
 1875|      8|                    }
 1876|    104|                    if (info == 2)
  ------------------
  |  Branch (1876:25): [True: 15, False: 89]
  ------------------
 1877|     15|                    {
 1878|     15|                        unscaled = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1879|     15|                    }
 1880|     89|                    else if (info == 3)
  ------------------
  |  Branch (1880:30): [True: 84, False: 5]
  ------------------
 1881|     84|                    {
 1882|     84|                        unscaled = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1883|     84|                        unscaled = -1 - unscaled;
 1884|     84|                    }
 1885|    104|                }
 1886|    123|                break;
 1887|    131|            }
 1888|    123|            default:
  ------------------
  |  Branch (1888:13): [True: 7, False: 639]
  ------------------
 1889|      7|            {
 1890|      7|                ec = cbor_errc::invalid_bigdecimal;
 1891|      7|                more_ = false;
 1892|      7|                return;
 1893|    131|            }
 1894|    646|        }
 1895|       |
 1896|    617|        bigdec dec(std::move(unscaled), -exponent);
 1897|    617|        append_to_buffer(dec, result);
 1898|    617|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10read_int64ERNS3_10error_codeE:
 1378|  1.03k|    {
 1379|  1.03k|        int64_t val = 0;
 1380|       |
 1381|  1.03k|        auto ch = source_.peek();
 1382|  1.03k|        if (ch.eof)
  ------------------
  |  Branch (1382:13): [True: 0, False: 1.03k]
  ------------------
 1383|      0|        {
 1384|      0|            ec = cbor_errc::unexpected_eof;
 1385|      0|            more_ = false;
 1386|      0|            return val;
 1387|      0|        }
 1388|       |
 1389|  1.03k|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(ch.value);
 1390|  1.03k|        uint8_t info = get_additional_information(ch.value);
 1391|  1.03k|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|  1.06k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1.03k]
  |  |  |  Branch (79:50): [True: 25, False: 1.01k]
  |  |  |  Branch (79:50): [True: 0, False: 25]
  |  |  ------------------
  ------------------
 1392|      0|        {
 1393|      0|            ec = cbor_errc::reserved_additional_info;
 1394|      0|            more_ = false;
 1395|      0|            return val;
 1396|      0|        }
 1397|  1.03k|        switch (major_type)
 1398|  1.03k|        {
 1399|  1.03k|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1399:13): [True: 1.03k, False: 0]
  ------------------
 1400|  1.03k|                source_.ignore(1);
 1401|  1.03k|                switch (info)
  ------------------
  |  Branch (1401:25): [True: 1.01k, False: 25]
  ------------------
 1402|  1.03k|                {
 1403|    619|                    case JSONCONS_EXT_CBOR_0x00_0x17: // 0x00..0x17 (0..23)
  ------------------
  |  |   18|    619|    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: 20, False: 1.01k]
  |  |  |  Branch (18:20): [True: 11, False: 1.02k]
  |  |  |  Branch (18:30): [True: 28, False: 1.00k]
  |  |  |  Branch (18:40): [True: 19, False: 1.01k]
  |  |  |  Branch (18:50): [True: 51, False: 986]
  |  |  |  Branch (18:60): [True: 79, False: 958]
  |  |  |  Branch (18:70): [True: 26, False: 1.01k]
  |  |  |  Branch (18:80): [True: 13, False: 1.02k]
  |  |  |  Branch (18:90): [True: 8, False: 1.02k]
  |  |  |  Branch (18:100): [True: 19, False: 1.01k]
  |  |  |  Branch (18:110): [True: 15, False: 1.02k]
  |  |  |  Branch (18:120): [True: 13, False: 1.02k]
  |  |  |  Branch (18:130): [True: 19, False: 1.01k]
  |  |  |  Branch (18:140): [True: 52, False: 985]
  |  |  |  Branch (18:150): [True: 65, False: 972]
  |  |  |  Branch (18:160): [True: 53, False: 984]
  |  |  |  Branch (18:170): [True: 45, False: 992]
  |  |  |  Branch (18:180): [True: 20, False: 1.01k]
  |  |  |  Branch (18:190): [True: 6, False: 1.03k]
  |  |  |  Branch (18:200): [True: 12, False: 1.02k]
  |  |  |  Branch (18:210): [True: 14, False: 1.02k]
  |  |  |  Branch (18:220): [True: 8, False: 1.02k]
  |  |  ------------------
  ------------------
  |  Branch (1403:21): [True: 17, False: 1.02k]
  ------------------
 1404|    619|                    {
 1405|    619|                        val = static_cast<int8_t>(- 1 - info);
 1406|    619|                        break;
 1407|  7.53k|                    }
 1408|     18|                    case 0x18: // Negative integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1408:21): [True: 18, False: 1.01k]
  ------------------
 1409|     18|                        {
 1410|     18|                            uint8_t b;
 1411|     18|                            if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1411:33): [True: 2, False: 16]
  ------------------
 1412|      2|                            {
 1413|      2|                                ec = cbor_errc::unexpected_eof;
 1414|      2|                                more_ = false;
 1415|      2|                                return val;
 1416|      2|                            }
 1417|     16|                            val = static_cast<int64_t>(-1) - static_cast<int64_t>(b);
 1418|     16|                            break;
 1419|     18|                        }
 1420|       |
 1421|     77|                    case 0x19: // Negative integer -1-n (two-byte uint16_t follows)
  ------------------
  |  Branch (1421:21): [True: 77, False: 960]
  ------------------
 1422|     77|                        {
 1423|     77|                            uint8_t buf[sizeof(uint16_t)];
 1424|     77|                            if (source_.read(buf, sizeof(uint16_t)) != sizeof(uint16_t))
  ------------------
  |  Branch (1424:33): [True: 1, False: 76]
  ------------------
 1425|      1|                            {
 1426|      1|                                ec = cbor_errc::unexpected_eof;
 1427|      1|                                more_ = false;
 1428|      1|                                return val;
 1429|      1|                            }
 1430|     76|                            auto u = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1431|     76|                            val = static_cast<int64_t>(-1)- u;
 1432|     76|                            break;
 1433|     77|                        }
 1434|       |
 1435|     70|                    case 0x1a: // Negative integer -1-n (four-byte uint32_t follows)
  ------------------
  |  Branch (1435:21): [True: 70, False: 967]
  ------------------
 1436|     70|                        {
 1437|     70|                            uint8_t buf[sizeof(uint32_t)];
 1438|     70|                            if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (1438:33): [True: 3, False: 67]
  ------------------
 1439|      3|                            {
 1440|      3|                                ec = cbor_errc::unexpected_eof;
 1441|      3|                                more_ = false;
 1442|      3|                                return val;
 1443|      3|                            }
 1444|     67|                            auto u = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1445|     67|                            val = static_cast<int64_t>(-1)- u;
 1446|     67|                            break;
 1447|     70|                        }
 1448|       |
 1449|    228|                    case 0x1b: // Negative integer -1-n (eight-byte uint64_t follows)
  ------------------
  |  Branch (1449:21): [True: 228, False: 809]
  ------------------
 1450|    228|                        {
 1451|    228|                            uint8_t buf[sizeof(uint64_t)];
 1452|    228|                            if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (1452:33): [True: 7, False: 221]
  ------------------
 1453|      7|                            {
 1454|      7|                                ec = cbor_errc::unexpected_eof;
 1455|      7|                                more_ = false;
 1456|      7|                                return val;
 1457|      7|                            }
 1458|    221|                            auto u = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1459|    221|                            if (u > static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1459:33): [True: 63, False: 158]
  ------------------
 1460|     63|                            {
 1461|     63|                                ec = cbor_errc::invalid_bigdecimal;
 1462|     63|                                more_ = false;
 1463|     63|                                return val;
 1464|     63|                            }
 1465|    158|                            if (JSONCONS_UNLIKELY(u == static_cast<uint64_t>((std::numeric_limits<int64_t>::max)())))
  ------------------
  |  |   79|    158|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 4, False: 154]
  |  |  ------------------
  ------------------
 1466|      4|                            {
 1467|      4|                                val = (std::numeric_limits<int64_t>::min)();
 1468|      4|                            }
 1469|    154|                            else
 1470|    154|                            {
 1471|    154|                                val = static_cast<int64_t>(-1)- static_cast<int64_t>(u);
 1472|    154|                            }
 1473|    158|                            break;
 1474|    221|                        }
 1475|  1.03k|                }
 1476|    961|                break;
 1477|       |
 1478|    961|                case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1478:17): [True: 0, False: 1.03k]
  ------------------
 1479|      0|                {
 1480|      0|                    source_.ignore(1);
 1481|      0|                    uint64_t u = read_unsigned_integer(info, ec);
 1482|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1483|      0|                    {
 1484|      0|                        return 0;
 1485|      0|                    }
 1486|      0|                    if (u <= static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1486:25): [True: 0, False: 0]
  ------------------
 1487|      0|                    {
 1488|      0|                        val = u;
 1489|      0|                    }
 1490|      0|                    else
 1491|      0|                    {
 1492|       |                        // error;
 1493|      0|                    }
 1494|       |                    
 1495|      0|                    break;
 1496|      0|                }
 1497|      0|                break;
 1498|      0|            default:
  ------------------
  |  Branch (1498:13): [True: 0, False: 1.03k]
  ------------------
 1499|      0|                break;
 1500|  1.03k|        }
 1501|       |
 1502|    961|        return val;
 1503|  1.03k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13read_bigfloatEhRNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 1901|    877|    {
 1902|    877|        std::size_t size = read_unsigned_integer(container_info, ec);
 1903|    877|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    877|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 875]
  |  |  ------------------
  ------------------
 1904|      2|        {
 1905|      2|            return;
 1906|      2|        }
 1907|    875|        if (size != 2)
  ------------------
  |  Branch (1907:13): [True: 75, False: 800]
  ------------------
 1908|     75|        {
 1909|     75|            ec = cbor_errc::invalid_bigfloat;
 1910|     75|            more_ = false;
 1911|     75|            return;
 1912|     75|        }
 1913|       |
 1914|    800|        auto c = source_.peek();
 1915|    800|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|    800|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 799]
  |  |  ------------------
  ------------------
 1916|      1|        {
 1917|      1|            ec = cbor_errc::unexpected_eof;
 1918|      1|            more_ = false;
 1919|      1|            return;
 1920|      1|        }
 1921|    799|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1922|    799|        uint8_t info = get_additional_information(c.value);
 1923|    799|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|    812|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 797]
  |  |  |  Branch (79:50): [True: 13, False: 786]
  |  |  |  Branch (79:50): [True: 2, False: 11]
  |  |  ------------------
  ------------------
 1924|      2|        {
 1925|      2|            ec = cbor_errc::reserved_additional_info;
 1926|      2|            more_ = false;
 1927|      2|            return;
 1928|      2|        }
 1929|       |
 1930|    797|        int64_t exponent = 0;
 1931|    797|        switch (major_type)
 1932|    797|        {
 1933|    361|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1933:13): [True: 361, False: 436]
  ------------------
 1934|    361|            {
 1935|    361|                source_.ignore(1);
 1936|    361|                exponent = read_unsigned_integer(info, ec);
 1937|    361|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    361|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 359]
  |  |  ------------------
  ------------------
 1938|      2|                {
 1939|      2|                    return;
 1940|      2|                }
 1941|    359|                break;
 1942|    361|            }
 1943|    432|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1943:13): [True: 432, False: 365]
  ------------------
 1944|    432|            {
 1945|    432|                exponent = read_int64(ec);
 1946|    432|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    432|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 29, False: 403]
  |  |  ------------------
  ------------------
 1947|     29|                {
 1948|     29|                    return;
 1949|     29|                }
 1950|    403|                break;
 1951|    432|            }
 1952|    403|            default:
  ------------------
  |  Branch (1952:13): [True: 4, False: 793]
  ------------------
 1953|      4|            {
 1954|      4|                ec = cbor_errc::invalid_bigfloat;
 1955|      4|                more_ = false;
 1956|      4|                return;
 1957|    432|            }
 1958|    797|        }
 1959|       |
 1960|    762|        c = source_.peek();
 1961|    762|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|    762|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 19, False: 743]
  |  |  ------------------
  ------------------
 1962|     19|        {
 1963|     19|            ec = cbor_errc::unexpected_eof;
 1964|     19|            more_ = false;
 1965|     19|            return;
 1966|     19|        }
 1967|    743|        major_type = get_major_type(c.value);
 1968|    743|        info = get_additional_information(c.value);
 1969|    743|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|    752|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 741]
  |  |  |  Branch (79:50): [True: 9, False: 734]
  |  |  |  Branch (79:50): [True: 2, False: 7]
  |  |  ------------------
  ------------------
 1970|      2|        {
 1971|      2|            ec = cbor_errc::reserved_additional_info;
 1972|      2|            more_ = false;
 1973|      2|            return;
 1974|      2|        }
 1975|       |
 1976|    741|        switch (major_type)
 1977|    741|        {
 1978|    141|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1978:13): [True: 141, False: 600]
  ------------------
 1979|    141|            {
 1980|    141|                source_.ignore(1);
 1981|    141|                uint64_t val = read_unsigned_integer(info, ec);
 1982|    141|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    141|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 140]
  |  |  ------------------
  ------------------
 1983|      1|                {
 1984|      1|                    return;
 1985|      1|                }
 1986|    140|                str.push_back('0');
 1987|    140|                str.push_back('x');
 1988|    140|                jsoncons::integer_to_hex(val, str);
 1989|    140|                break;
 1990|    141|            }
 1991|     74|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1991:13): [True: 74, False: 667]
  ------------------
 1992|     74|            {
 1993|     74|                int64_t val = read_int64(ec);
 1994|     74|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     74|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 72]
  |  |  ------------------
  ------------------
 1995|      2|                {
 1996|      2|                    return;
 1997|      2|                }
 1998|     72|                str.push_back('-');
 1999|     72|                str.push_back('0');
 2000|     72|                str.push_back('x');
 2001|     72|                jsoncons::integer_to_hex(static_cast<uint64_t>(-1 - val) + 1u, str);
 2002|     72|                break;
 2003|     74|            }
 2004|    523|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (2004:13): [True: 523, False: 218]
  ------------------
 2005|    523|            {
 2006|    523|                uint8_t x;
 2007|    523|                if (source_.read(&x, 1) == 0)
  ------------------
  |  Branch (2007:21): [True: 0, False: 523]
  ------------------
 2008|      0|                {
 2009|      0|                    ec = cbor_errc::unexpected_eof;
 2010|      0|                    more_ = false;
 2011|      0|                    return;
 2012|      0|                }
 2013|    523|                uint8_t tag = get_additional_information(x);
 2014|    523|                if (JSONCONS_UNLIKELY(tag >= 0x1C && tag <= 0x1E))
  ------------------
  |  |   79|    526|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 523]
  |  |  |  Branch (79:50): [True: 3, False: 520]
  |  |  |  Branch (79:50): [True: 0, False: 3]
  |  |  ------------------
  ------------------
 2015|      0|                {
 2016|      0|                    ec = cbor_errc::reserved_additional_info;
 2017|      0|                    more_ = false;
 2018|      0|                    return;
 2019|      0|                }
 2020|       |
 2021|    523|                c = source_.peek();
 2022|    523|                if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|    523|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 8, False: 515]
  |  |  ------------------
  ------------------
 2023|      8|                {
 2024|      8|                    ec = cbor_errc::unexpected_eof;
 2025|      8|                    more_ = false;
 2026|      8|                    return;
 2027|      8|                }
 2028|       |
 2029|    515|                if (get_major_type(c.value) == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (2029:21): [True: 507, False: 8]
  ------------------
 2030|    507|                {
 2031|    507|                    bytes_buffer_.clear(); 
 2032|    507|                    read_byte_string(bytes_buffer_, ec);
 2033|    507|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    507|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 20, False: 487]
  |  |  ------------------
  ------------------
 2034|     20|                    {
 2035|     20|                        more_ = false;
 2036|     20|                        return;
 2037|     20|                    }
 2038|    487|                    if (tag == 2)
  ------------------
  |  Branch (2038:25): [True: 118, False: 369]
  ------------------
 2039|    118|                    {
 2040|    118|                        str.push_back('0');
 2041|    118|                        str.push_back('x');
 2042|    118|                        bigint b = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 2043|    118|                        b.write_string_hex(str);
 2044|    118|                    }
 2045|    369|                    else if (tag == 3)
  ------------------
  |  Branch (2045:30): [True: 363, False: 6]
  ------------------
 2046|    363|                    {
 2047|    363|                        str.push_back('-');
 2048|    363|                        str.push_back('0');
 2049|    363|                        bigint b = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 2050|    363|                        b = -1 - b;
 2051|    363|                        b.write_string_hex(str);
 2052|    363|                        str[2] = 'x'; // overwrite minus
 2053|    363|                    }
 2054|    487|                }
 2055|    495|                break;
 2056|    515|            }
 2057|    495|            default:
  ------------------
  |  Branch (2057:13): [True: 3, False: 738]
  ------------------
 2058|      3|            {
 2059|      3|                ec = cbor_errc::invalid_bigfloat;
 2060|      3|                more_ = false;
 2061|      3|                return;
 2062|    515|            }
 2063|    741|        }
 2064|       |
 2065|    707|        str.push_back('p');
 2066|    707|        if (exponent >=0)
  ------------------
  |  Branch (2066:13): [True: 345, False: 362]
  ------------------
 2067|    345|        {
 2068|    345|            jsoncons::integer_to_hex(static_cast<uint64_t>(exponent), str);
 2069|    345|        }
 2070|    362|        else
 2071|    362|        {
 2072|    362|            str.push_back('-');
 2073|    362|            jsoncons::integer_to_hex(static_cast<uint64_t>(-1 - exponent) + 1u, str);
 2074|    362|        }
 2075|    707|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE19read_mdarray_headerERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 2776|    459|    {
 2777|    459|        uint8_t b;
 2778|    459|        if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (2778:13): [True: 0, False: 459]
  ------------------
 2779|      0|        {
 2780|      0|            ec = cbor_errc::unexpected_eof;
 2781|      0|            more_ = false;
 2782|      0|            return;
 2783|      0|        }
 2784|    459|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(b);
 2785|    459|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::array);
  ------------------
  |  |   54|    459|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 459]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 2786|    459|        uint8_t info = get_additional_information(b);
 2787|    459|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|    495|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 459]
  |  |  |  Branch (79:50): [True: 36, False: 423]
  |  |  |  Branch (79:50): [True: 0, False: 36]
  |  |  ------------------
  ------------------
 2788|      0|        {
 2789|      0|            ec = cbor_errc::reserved_additional_info;
 2790|      0|            more_ = false;
 2791|      0|            return;
 2792|      0|        }
 2793|       |       
 2794|    459|        read_extents(ec);   
 2795|    459|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    459|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 243, False: 216]
  |  |  ------------------
  ------------------
 2796|    243|        {
 2797|    243|            return;
 2798|    243|        }
 2799|       |
 2800|    216|        read_tags(ec);
 2801|    216|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    216|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 105, False: 111]
  |  |  ------------------
  ------------------
 2802|    105|        {
 2803|    105|            return;
 2804|    105|        }
 2805|    111|        auto c = source_.peek();
 2806|    111|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|    111|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 111]
  |  |  ------------------
  ------------------
 2807|      0|        {
 2808|      0|            ec = cbor_errc::unexpected_eof;
 2809|      0|            more_ = false;
 2810|      0|            return;
 2811|      0|        }
 2812|    111|        major_type = get_major_type(c.value);
 2813|    111|        info = get_additional_information(c.value);
 2814|    111|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|    137|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 109]
  |  |  |  Branch (79:50): [True: 26, False: 85]
  |  |  |  Branch (79:50): [True: 2, False: 24]
  |  |  ------------------
  ------------------
 2815|      2|        {
 2816|      2|            ec = cbor_errc::reserved_additional_info;
 2817|      2|            more_ = false;
 2818|      2|            return;
 2819|      2|        }
 2820|    109|        state_stack_.emplace_back(parse_mode::multi_dim, 0);
 2821|    109|        ++state_stack_.back().index;
 2822|       |
 2823|    109|        if (major_type == jsoncons::cbor::detail::cbor_major_type::array && order_ == mdarray_order::row_major) 
  ------------------
  |  Branch (2823:13): [True: 64, False: 45]
  |  Branch (2823:77): [True: 29, False: 35]
  ------------------
 2824|     29|        {
 2825|     29|            source_.ignore(1);
 2826|     29|            begin_classical_array_storage(info, ec);
 2827|     29|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     29|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 4, False: 25]
  |  |  ------------------
  ------------------
 2828|      4|            {
 2829|      4|                return;
 2830|      4|            }
 2831|     25|            auto iter = std::make_shared<cbor_mdarray_row_major_iterator<Source,Allocator>>(extents_, this, cursor_mode_, alloc_);
 2832|     25|            typed_array_stack_.push_back(iter);
 2833|     25|            if (!iter->done())
  ------------------
  |  Branch (2833:17): [True: 25, False: 0]
  ------------------
 2834|     25|            {
 2835|     25|                iter->next(visitor, *this, ec);
 2836|     25|            }
 2837|     25|        }
 2838|     80|        else if (major_type == jsoncons::cbor::detail::cbor_major_type::array && order_ == mdarray_order::column_major) 
  ------------------
  |  Branch (2838:18): [True: 35, False: 45]
  |  Branch (2838:82): [True: 35, False: 0]
  ------------------
 2839|     35|        {
 2840|     35|            source_.ignore(1);
 2841|     35|            begin_classical_array_storage(info, ec);
 2842|     35|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     35|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 34]
  |  |  ------------------
  ------------------
 2843|      1|            {
 2844|      1|                return;
 2845|      1|            }
 2846|     34|            auto iter = std::make_shared<cbor_mdarray_column_major_iterator<Source,Allocator>>(extents_, this, cursor_mode_, alloc_);
 2847|     34|            typed_array_stack_.push_back(iter);
 2848|     34|            if (!iter->done())
  ------------------
  |  Branch (2848:17): [True: 34, False: 0]
  ------------------
 2849|     34|            {
 2850|     34|                iter->next(visitor, *this, ec);
 2851|     34|            }
 2852|     34|        }
 2853|     45|        else if (major_type == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (2853:18): [True: 12, False: 33]
  ------------------
 2854|     12|        {
 2855|     12|            std::size_t typed_array_count = typed_array_stack_.size();
 2856|     12|            read_byte_string_from_source read(this);
 2857|     12|            read_byte_string(read, visitor, ec);
 2858|     12|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     12|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 5, False: 7]
  |  |  ------------------
  ------------------
 2859|      5|            {
 2860|      5|                return;
 2861|      5|            }
 2862|      7|            if (typed_array_stack_.size() == typed_array_count)
  ------------------
  |  Branch (2862:17): [True: 5, False: 2]
  ------------------
 2863|      5|            {
 2864|       |                // Byte string storage must be a typed array
 2865|      5|                ec = cbor_errc::bad_mdarray;
 2866|      5|                return;
 2867|      5|            }
 2868|      7|        }
 2869|     33|        else
 2870|     33|        {
 2871|     33|            ec = cbor_errc::bad_mdarray;
 2872|     33|            return;
 2873|     33|        }
 2874|       |        // cursor case
 2875|    109|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12read_extentsERNS3_10error_codeE:
 2878|    459|    {
 2879|    459|        extents_.clear();
 2880|       |
 2881|    459|        auto b = source_.peek();
 2882|    459|        if (JSONCONS_UNLIKELY(b.eof))
  ------------------
  |  |   79|    459|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 10, False: 449]
  |  |  ------------------
  ------------------
 2883|     10|        {
 2884|     10|            ec = cbor_errc::unexpected_eof;
 2885|     10|            more_ = false;
 2886|     10|            return;
 2887|     10|        }
 2888|    449|        if (get_major_type(b.value) != jsoncons::cbor::detail::cbor_major_type::array)
  ------------------
  |  Branch (2888:13): [True: 11, False: 438]
  ------------------
 2889|     11|        {
 2890|     11|            ec = cbor_errc::bad_extents;
 2891|     11|            more_ = false;
 2892|     11|            return;
 2893|     11|        }
 2894|    438|        uint8_t info = get_additional_information(b.value);
 2895|    438|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|    688|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 435]
  |  |  |  Branch (79:50): [True: 250, False: 188]
  |  |  |  Branch (79:50): [True: 3, False: 247]
  |  |  ------------------
  ------------------
 2896|      3|        {
 2897|      3|            ec = cbor_errc::reserved_additional_info;
 2898|      3|            more_ = false;
 2899|      3|            return;
 2900|      3|        }
 2901|       |
 2902|    435|        source_.ignore(1);
 2903|    435|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (2903:13): [True: 247, False: 188]
  ------------------
 2904|    247|        {
 2905|    247|             bool done = false;
 2906|  3.04M|             while (!done)
  ------------------
  |  Branch (2906:21): [True: 3.04M, False: 196]
  ------------------
 2907|  3.04M|             {
 2908|  3.04M|                 auto c = source_.peek();
 2909|  3.04M|                 if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|  3.04M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 39, False: 3.04M]
  |  |  ------------------
  ------------------
 2910|     39|                 {
 2911|     39|                     ec = cbor_errc::unexpected_eof;
 2912|     39|                     more_ = false;
 2913|     39|                     return;
 2914|     39|                 }
 2915|  3.04M|                 if (c.value == 0xff)
  ------------------
  |  Branch (2915:22): [True: 196, False: 3.04M]
  ------------------
 2916|    196|                 {
 2917|    196|                     source_.ignore(1);
 2918|    196|                     done = true;
 2919|    196|                 }
 2920|  3.04M|                 else
 2921|  3.04M|                 {
 2922|  3.04M|                     source_.ignore(1);
 2923|  3.04M|                     std::size_t extent = read_size(get_additional_information(c.value), ec);
 2924|  3.04M|                     if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  3.04M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 12, False: 3.04M]
  |  |  ------------------
  ------------------
 2925|     12|                     {
 2926|     12|                         more_ = false;
 2927|     12|                         return;
 2928|     12|                     }
 2929|  3.04M|                     extents_.push_back(extent);
 2930|  3.04M|                 }
 2931|  3.04M|             }
 2932|    247|        }
 2933|    188|        else 
 2934|    188|        {
 2935|    188|            std::size_t size = read_size(info, ec);
 2936|    188|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    188|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 185]
  |  |  ------------------
  ------------------
 2937|      3|            {
 2938|      3|                more_ = false;
 2939|      3|                return;
 2940|      3|            }
 2941|  2.28M|            for (std::size_t i = 0; more_ && i < size; ++i)
  ------------------
  |  Branch (2941:37): [True: 2.28M, False: 0]
  |  Branch (2941:46): [True: 2.28M, False: 59]
  ------------------
 2942|  2.28M|            {
 2943|  2.28M|                uint8_t initial_byte;
 2944|  2.28M|                if (source_.read(&initial_byte, 1) == 0)
  ------------------
  |  Branch (2944:21): [True: 109, False: 2.28M]
  ------------------
 2945|    109|                {
 2946|    109|                    ec = cbor_errc::unexpected_eof;
 2947|    109|                    more_ = false;
 2948|    109|                    return;
 2949|    109|                }
 2950|  2.28M|                if (JSONCONS_UNLIKELY(get_major_type(initial_byte) != jsoncons::cbor::detail::cbor_major_type::unsigned_integer))
  ------------------
  |  |   79|  2.28M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 11, False: 2.28M]
  |  |  ------------------
  ------------------
 2951|     11|                {
 2952|     11|                    ec = cbor_errc::unknown_type;
 2953|     11|                    more_ = false;
 2954|     11|                    return;
 2955|     11|                }
 2956|  2.28M|                info = get_additional_information(initial_byte);
 2957|  2.28M|                if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|  2.28M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 2.28M]
  |  |  |  Branch (79:50): [True: 4, False: 2.28M]
  |  |  |  Branch (79:50): [True: 3, False: 1]
  |  |  ------------------
  ------------------
 2958|      3|                {
 2959|      3|                    ec = cbor_errc::reserved_additional_info;
 2960|      3|                    more_ = false;
 2961|      3|                    return;
 2962|      3|                }
 2963|  2.28M|                std::size_t extent = read_size(info, ec);
 2964|  2.28M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  2.28M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 2.28M]
  |  |  ------------------
  ------------------
 2965|      3|                {
 2966|      3|                    more_ = false;
 2967|      3|                    return;
 2968|      3|                }
 2969|  2.28M|                extents_.push_back(extent);
 2970|  2.28M|            }
 2971|    185|        }
 2972|    255|        auto r = calculate_mdarray_size(extents_);
 2973|    255|        if (!r || *r == 0)
  ------------------
  |  Branch (2973:13): [True: 33, False: 222]
  |  Branch (2973:19): [True: 6, False: 216]
  ------------------
 2974|     39|        {
 2975|     39|            ec = cbor_errc::bad_extents;
 2976|     39|            more_ = false;
 2977|     39|            return;
 2978|     39|        }
 2979|    216|        mdarray_size_ = *r;
 2980|    216|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE29begin_classical_array_storageEhRNS3_10error_codeE:
 1001|     64|    {
 1002|     64|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   79|     64|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 64]
  |  |  ------------------
  ------------------
 1003|      0|        {
 1004|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
 1005|      0|            more_ = false;
 1006|      0|            return;
 1007|      0|        }
 1008|     64|        bool pop_stringref_map_stack = false;
 1009|     64|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (1009:13): [True: 5, False: 59]
  ------------------
 1010|      5|        {
 1011|      5|            stringref_map_stack_.emplace_back();
 1012|      5|            other_tags_[stringref_namespace_tag] = false;
 1013|      5|            pop_stringref_map_stack = true;
 1014|      5|        }
 1015|     64|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1015:13): [True: 10, False: 54]
  ------------------
 1016|     10|        {
 1017|     10|            state_stack_.emplace_back(parse_mode::indefinite_array, 0, pop_stringref_map_stack);
 1018|     10|        }
 1019|     54|        else // definite length
 1020|     54|        {
 1021|     54|            std::size_t len = read_size(info, ec);
 1022|     54|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     54|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 5, False: 49]
  |  |  ------------------
  ------------------
 1023|      5|            {
 1024|      5|                return;
 1025|      5|            }
 1026|     49|            state_stack_.emplace_back(parse_mode::array, len, pop_stringref_map_stack);
 1027|     49|        }
 1028|     59|        more_ = !cursor_mode_;
 1029|     59|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayEhRNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  938|    153|    {
  939|    153|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   79|    153|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 153]
  |  |  ------------------
  ------------------
  940|      0|        {
  941|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  942|      0|            more_ = false;
  943|      0|            return;
  944|      0|        } 
  945|    153|        semantic_tag tag = semantic_tag::none;
  946|    153|        bool pop_stringref_map_stack = false;
  947|    153|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (947:13): [True: 1, False: 152]
  ------------------
  948|      1|        {
  949|      1|            stringref_map_stack_.emplace_back();
  950|      1|            other_tags_[stringref_namespace_tag] = false;
  951|      1|            pop_stringref_map_stack = true;
  952|      1|        }
  953|    153|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (953:13): [True: 15, False: 138]
  ------------------
  954|     15|        {
  955|     15|            state_stack_.emplace_back(parse_mode::indefinite_array,0,pop_stringref_map_stack);
  956|     15|            visitor.begin_array(tag, *this, ec);
  957|     15|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     15|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 15]
  |  |  ------------------
  ------------------
  958|      0|            {
  959|      0|                return;
  960|      0|            }
  961|     15|        }
  962|    138|        else // definite length
  963|    138|        {
  964|    138|            std::size_t len = read_size(info, ec);
  965|    138|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    138|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 22, False: 116]
  |  |  ------------------
  ------------------
  966|     22|            {
  967|     22|                return;
  968|     22|            }
  969|    116|            state_stack_.emplace_back(parse_mode::array,len,pop_stringref_map_stack);
  970|    116|            visitor.begin_array(len, tag, *this, ec);
  971|    116|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    116|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 116]
  |  |  ------------------
  ------------------
  972|      0|            {
  973|      0|                return;
  974|      0|            }
  975|    116|        }
  976|    131|        more_ = !cursor_mode_;
  977|    131|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12begin_objectEhRNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 1048|     24|    {
 1049|     24|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   79|     24|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 24]
  |  |  ------------------
  ------------------
 1050|      0|        {
 1051|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
 1052|      0|            more_ = false;
 1053|      0|            return;
 1054|      0|        } 
 1055|     24|        bool pop_stringref_map_stack = false;
 1056|     24|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (1056:13): [True: 1, False: 23]
  ------------------
 1057|      1|        {
 1058|      1|            stringref_map_stack_.emplace_back();
 1059|      1|            other_tags_[stringref_namespace_tag] = false;
 1060|      1|            pop_stringref_map_stack = true;
 1061|      1|        }
 1062|     24|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1062:13): [True: 2, False: 22]
  ------------------
 1063|      2|        {
 1064|      2|            state_stack_.emplace_back(parse_mode::indefinite_map_key,0,pop_stringref_map_stack);
 1065|      2|            visitor.begin_object(semantic_tag::none, *this, ec);
 1066|      2|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 1067|      0|            {
 1068|      0|                return;
 1069|      0|            }
 1070|      2|        }
 1071|     22|        else // definite_length
 1072|     22|        {
 1073|     22|            std::size_t len = read_size(info, ec);
 1074|     22|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     22|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 21]
  |  |  ------------------
  ------------------
 1075|      1|            {
 1076|      1|                return;
 1077|      1|            }
 1078|     21|            state_stack_.emplace_back(parse_mode::map_key,len,pop_stringref_map_stack);
 1079|     21|            visitor.begin_object(len, semantic_tag::none, *this, ec);
 1080|     21|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     21|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 21]
  |  |  ------------------
  ------------------
 1081|      0|            {
 1082|      0|                return;
 1083|      0|            }
 1084|     21|        }
 1085|     23|        more_ = !cursor_mode_;
 1086|     23|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RKNS0_19cbor_decode_optionsERKS7_:
  220|  6.81k|       : alloc_(alloc),
  221|  6.81k|         source_(std::forward<Sourceable>(source)),
  222|  6.81k|         max_nesting_depth_(options.max_nesting_depth()),
  223|  6.81k|         text_buffer_(alloc),
  224|  6.81k|         bytes_buffer_(alloc),
  225|  6.81k|         state_stack_(alloc),
  226|  6.81k|         stringref_map_stack_(alloc),
  227|  6.81k|         extents_(alloc)
  228|  6.81k|    {
  229|  6.81k|        state_stack_.emplace_back(parse_mode::root,0);
  230|  6.81k|    }
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4doneEv:
  318|  17.7k|    {
  319|  17.7k|        return done_;
  320|  17.7k|    }

_ZN8jsoncons4cbor20typed_array_iteratorD2Ev:
   43|    265|    virtual ~typed_array_iterator() = default;
_ZN8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|      3|        : data_(std::move(data), alloc), 
  107|      3|          span_(typed_array_cast<ValueType>(data_)), 
  108|      3|          array_tag_(array_tag), 
  109|      3|          extent_(span_.size()), 
  110|      3|          tag_(tag), 
  111|      3|          func_(Func{})
  112|      3|    {
  113|      3|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|      3|    {
  148|      3|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 0]
  |  |  ------------------
  ------------------
  149|      3|        {
  150|      3|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|      3|            first_ = false;
  152|      3|        }
  153|      0|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      0|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 0, False: 0]
  ------------------
  159|      0|        {
  160|      0|            visitor.end_array(context, ec);
  161|      0|            done_ = true;
  162|      0|        }
  163|      3|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|     25|        : data_(std::move(data), alloc), 
  107|     25|          span_(typed_array_cast<ValueType>(data_)), 
  108|     25|          array_tag_(array_tag), 
  109|     25|          extent_(span_.size()), 
  110|     25|          tag_(tag), 
  111|     25|          func_(Func{})
  112|     25|    {
  113|     25|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|     25|    {
  148|     25|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|     25|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 25, False: 0]
  |  |  ------------------
  ------------------
  149|     25|        {
  150|     25|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|     25|            first_ = false;
  152|     25|        }
  153|      0|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      0|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 0, False: 0]
  ------------------
  159|      0|        {
  160|      0|            visitor.end_array(context, ec);
  161|      0|            done_ = true;
  162|      0|        }
  163|     25|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIjNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|     28|        : data_(std::move(data), alloc), 
  107|     28|          span_(typed_array_cast<ValueType>(data_)), 
  108|     28|          array_tag_(array_tag), 
  109|     28|          extent_(span_.size()), 
  110|     28|          tag_(tag), 
  111|     28|          func_(Func{})
  112|     28|    {
  113|     28|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIjNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|     28|    {
  148|     28|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|     28|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 28, False: 0]
  |  |  ------------------
  ------------------
  149|     28|        {
  150|     28|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|     28|            first_ = false;
  152|     28|        }
  153|      0|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      0|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 0, False: 0]
  ------------------
  159|      0|        {
  160|      0|            visitor.end_array(context, ec);
  161|      0|            done_ = true;
  162|      0|        }
  163|     28|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|     20|        : data_(std::move(data), alloc), 
  107|     20|          span_(typed_array_cast<ValueType>(data_)), 
  108|     20|          array_tag_(array_tag), 
  109|     20|          extent_(span_.size()), 
  110|     20|          tag_(tag), 
  111|     20|          func_(Func{})
  112|     20|    {
  113|     20|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|     20|    {
  148|     20|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|     20|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 20, False: 0]
  |  |  ------------------
  ------------------
  149|     20|        {
  150|     20|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|     20|            first_ = false;
  152|     20|        }
  153|      0|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      0|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 0, False: 0]
  ------------------
  159|      0|        {
  160|      0|            visitor.end_array(context, ec);
  161|      0|            done_ = true;
  162|      0|        }
  163|     20|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIaNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|      1|        : data_(std::move(data), alloc), 
  107|      1|          span_(typed_array_cast<ValueType>(data_)), 
  108|      1|          array_tag_(array_tag), 
  109|      1|          extent_(span_.size()), 
  110|      1|          tag_(tag), 
  111|      1|          func_(Func{})
  112|      1|    {
  113|      1|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIaNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|      1|    {
  148|      1|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  149|      1|        {
  150|      1|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|      1|            first_ = false;
  152|      1|        }
  153|      0|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      0|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 0, False: 0]
  ------------------
  159|      0|        {
  160|      0|            visitor.end_array(context, ec);
  161|      0|            done_ = true;
  162|      0|        }
  163|      1|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIsNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|     25|        : data_(std::move(data), alloc), 
  107|     25|          span_(typed_array_cast<ValueType>(data_)), 
  108|     25|          array_tag_(array_tag), 
  109|     25|          extent_(span_.size()), 
  110|     25|          tag_(tag), 
  111|     25|          func_(Func{})
  112|     25|    {
  113|     25|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIsNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|     25|    {
  148|     25|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|     25|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 25, False: 0]
  |  |  ------------------
  ------------------
  149|     25|        {
  150|     25|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|     25|            first_ = false;
  152|     25|        }
  153|      0|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      0|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 0, False: 0]
  ------------------
  159|      0|        {
  160|      0|            visitor.end_array(context, ec);
  161|      0|            done_ = true;
  162|      0|        }
  163|     25|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIiNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|     28|        : data_(std::move(data), alloc), 
  107|     28|          span_(typed_array_cast<ValueType>(data_)), 
  108|     28|          array_tag_(array_tag), 
  109|     28|          extent_(span_.size()), 
  110|     28|          tag_(tag), 
  111|     28|          func_(Func{})
  112|     28|    {
  113|     28|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIiNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|     28|    {
  148|     28|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|     28|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 28, False: 0]
  |  |  ------------------
  ------------------
  149|     28|        {
  150|     28|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|     28|            first_ = false;
  152|     28|        }
  153|      0|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      0|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 0, False: 0]
  ------------------
  159|      0|        {
  160|      0|            visitor.end_array(context, ec);
  161|      0|            done_ = true;
  162|      0|        }
  163|     28|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|     26|        : data_(std::move(data), alloc), 
  107|     26|          span_(typed_array_cast<ValueType>(data_)), 
  108|     26|          array_tag_(array_tag), 
  109|     26|          extent_(span_.size()), 
  110|     26|          tag_(tag), 
  111|     26|          func_(Func{})
  112|     26|    {
  113|     26|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|     26|    {
  148|     26|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|     26|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 26, False: 0]
  |  |  ------------------
  ------------------
  149|     26|        {
  150|     26|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|     26|            first_ = false;
  152|     26|        }
  153|      0|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      0|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 0, False: 0]
  ------------------
  159|      0|        {
  160|      0|            visitor.end_array(context, ec);
  161|      0|            done_ = true;
  162|      0|        }
  163|     26|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_11decode_halfENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|     13|        : data_(std::move(data), alloc), 
  107|     13|          span_(typed_array_cast<ValueType>(data_)), 
  108|     13|          array_tag_(array_tag), 
  109|     13|          extent_(span_.size()), 
  110|     13|          tag_(tag), 
  111|     13|          func_(Func{})
  112|     13|    {
  113|     13|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_11decode_halfENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|     13|    {
  148|     13|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|     13|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 13, False: 0]
  |  |  ------------------
  ------------------
  149|     13|        {
  150|     13|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|     13|            first_ = false;
  152|     13|        }
  153|      0|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      0|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 0, False: 0]
  ------------------
  159|      0|        {
  160|      0|            visitor.end_array(context, ec);
  161|      0|            done_ = true;
  162|      0|        }
  163|     13|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|     20|        : data_(std::move(data), alloc), 
  107|     20|          span_(typed_array_cast<ValueType>(data_)), 
  108|     20|          array_tag_(array_tag), 
  109|     20|          extent_(span_.size()), 
  110|     20|          tag_(tag), 
  111|     20|          func_(Func{})
  112|     20|    {
  113|     20|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|     20|    {
  148|     20|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|     20|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 20, False: 0]
  |  |  ------------------
  ------------------
  149|     20|        {
  150|     20|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|     20|            first_ = false;
  152|     20|        }
  153|      0|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      0|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 0, False: 0]
  ------------------
  159|      0|        {
  160|      0|            visitor.end_array(context, ec);
  161|      0|            done_ = true;
  162|      0|        }
  163|     20|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIdNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|     17|        : data_(std::move(data), alloc), 
  107|     17|          span_(typed_array_cast<ValueType>(data_)), 
  108|     17|          array_tag_(array_tag), 
  109|     17|          extent_(span_.size()), 
  110|     17|          tag_(tag), 
  111|     17|          func_(Func{})
  112|     17|    {
  113|     17|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIdNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|     17|    {
  148|     17|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|     17|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 17, False: 0]
  |  |  ------------------
  ------------------
  149|     17|        {
  150|     17|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|     17|            first_ = false;
  152|     17|        }
  153|      0|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      0|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 0, False: 0]
  ------------------
  159|      0|        {
  160|      0|            visitor.end_array(context, ec);
  161|      0|            done_ = true;
  162|      0|        }
  163|     17|    }
_ZN8jsoncons4cbor31cbor_mdarray_row_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2ERKNS3_6vectorImNS4_ImEEEEPNS0_17basic_cbor_parserIS6_S7_EEbRKS7_:
  337|     25|        : extents_(extents, alloc), dimensions_(extents.size(), mdarray_dimension{}, alloc),
  338|     25|          parser_(parser), cursor_mode_(cursor_mode)
  339|     25|    {
  340|     25|        std::vector<std::size_t> strides(extents.size(), 0);
  341|     25|        std::size_t stride = 1;
  342|     25|        const size_t num_extents = extents.size();
  343|  2.79k|        for (size_t i = 0; i < num_extents; ++i)
  ------------------
  |  Branch (343:28): [True: 2.77k, False: 25]
  ------------------
  344|  2.77k|        {
  345|  2.77k|            strides[num_extents - i - 1] = stride;
  346|  2.77k|            stride *= extents[num_extents - i - 1];
  347|  2.77k|        }
  348|  2.79k|        for (std::size_t i = 0; i < strides.size(); ++i)
  ------------------
  |  Branch (348:33): [True: 2.77k, False: 25]
  ------------------
  349|  2.77k|        {
  350|  2.77k|            dimensions_[i].extent = extents[i];
  351|  2.77k|            dimensions_[i].stride = strides[i];
  352|  2.77k|            dimensions_[i].index = 0;
  353|  2.77k|            dimensions_[i].end = strides[i] * extents[i];
  354|  2.77k|        }
  355|     25|    }
_ZNK8jsoncons4cbor31cbor_mdarray_row_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4doneEv:
  378|     25|    {
  379|     25|        return done_;
  380|     25|    }
_ZN8jsoncons4cbor31cbor_mdarray_row_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  389|     25|    {
  390|     25|        JSONCONS_ASSERT(!dimensions_.empty());
  ------------------
  |  |   54|     25|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 25]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  391|       |
  392|     25|        if (dim_ == 0)
  ------------------
  |  Branch (392:13): [True: 25, False: 0]
  ------------------
  393|     25|        {
  394|     25|            if (first_)
  ------------------
  |  Branch (394:17): [True: 25, False: 0]
  ------------------
  395|     25|            {
  396|     25|                visitor.begin_array(dimensions_[dim_].extent, tag_, context, ec);
  397|     25|                first_ = false;
  398|     25|                return;
  399|     25|            }
  400|      0|            if (dimensions_[dim_].index == dimensions_[dim_].end)
  ------------------
  |  Branch (400:17): [True: 0, False: 0]
  ------------------
  401|      0|            {
  402|      0|                visitor.end_array(context, ec);
  403|      0|                done_ = true;
  404|      0|                return;
  405|      0|            }
  406|      0|        }
  407|      0|        if (dim_+1 < dimensions_.size() && dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (407:13): [True: 0, False: 0]
  |  Branch (407:44): [True: 0, False: 0]
  ------------------
  408|      0|        {
  409|      0|            if (!cursor_mode_)
  ------------------
  |  Branch (409:17): [True: 0, False: 0]
  ------------------
  410|      0|            {
  411|      0|                visitor.begin_array(dimensions_[dim_].extent, semantic_tag::none, context, ec);
  412|      0|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  413|      0|                {
  414|      0|                    return;
  415|      0|                }
  416|      0|            }
  417|      0|            ++dim_;
  418|      0|            return;
  419|      0|        }
  420|      0|        if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (420:13): [True: 0, False: 0]
  ------------------
  421|      0|        {
  422|      0|            parser_->read_item(visitor, ec);
  423|      0|            dimensions_[dim_].index += dimensions_[dim_].stride;
  424|      0|            ++count_;
  425|      0|            return;
  426|      0|        }
  427|      0|        if (dimensions_[dim_].index + dimensions_[dim_].stride >= dimensions_[dim_].end)
  ------------------
  |  Branch (427:13): [True: 0, False: 0]
  ------------------
  428|      0|        {
  429|      0|            if (!cursor_mode_)
  ------------------
  |  Branch (429:17): [True: 0, False: 0]
  ------------------
  430|      0|            {
  431|      0|                visitor.end_array(context, ec);
  432|      0|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  433|      0|                {
  434|      0|                    return;
  435|      0|                }
  436|      0|            }
  437|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  438|      0|            {
  439|      0|                return;
  440|      0|            }
  441|      0|            if (dim_ > 0)
  ------------------
  |  Branch (441:17): [True: 0, False: 0]
  ------------------
  442|      0|            {
  443|      0|                --dim_;
  444|      0|                dimensions_[dim_].index += dimensions_[dim_].stride;
  445|      0|                if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (445:21): [True: 0, False: 0]
  ------------------
  446|      0|                {
  447|      0|                    for (std::size_t i = dim_+1; i < dimensions_.size(); ++i)
  ------------------
  |  Branch (447:50): [True: 0, False: 0]
  ------------------
  448|      0|                    {
  449|      0|                        dimensions_[i].index = dimensions_[i-1].index;
  450|      0|                        dimensions_[i].end = dimensions_[i].index + dimensions_[i].stride*dimensions_[i].extent;
  451|      0|                    }
  452|      0|                }
  453|      0|            }
  454|      0|        }
  455|      0|    }
_ZN8jsoncons4cbor34cbor_mdarray_column_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2ERKNS3_6vectorImNS4_ImEEEEPNS0_17basic_cbor_parserIS6_S7_EEbRKS7_:
  478|     34|        : extents_(extents,alloc), dimensions_(extents.size(), mdarray_dimension{},alloc),
  479|     34|          parser_(parser), cursor_mode_(cursor_mode)
  480|     34|    {
  481|     34|        std::vector<std::size_t> strides(extents.size(), 0);
  482|     34|        std::size_t stride = 1;
  483|     34|        const size_t num_extents = extents.size();
  484|    567|        for (size_t i = 0; i < num_extents; ++i)
  ------------------
  |  Branch (484:28): [True: 533, False: 34]
  ------------------
  485|    533|        {
  486|    533|            strides[num_extents - i - 1] = stride;
  487|    533|            stride *= extents[num_extents - i - 1];
  488|    533|        }
  489|    567|        for (std::size_t i = 0; i < strides.size(); ++i)
  ------------------
  |  Branch (489:33): [True: 533, False: 34]
  ------------------
  490|    533|        {
  491|    533|            dimensions_[i].extent = extents[i];
  492|    533|            dimensions_[i].stride = strides[i];
  493|    533|            dimensions_[i].index = 0;
  494|    533|            dimensions_[i].end = strides[i] * extents[i];
  495|    533|        }
  496|     34|    }
_ZNK8jsoncons4cbor34cbor_mdarray_column_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4doneEv:
  519|     34|    {
  520|     34|        return done_;
  521|     34|    }
_ZN8jsoncons4cbor34cbor_mdarray_column_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  530|     34|    {
  531|     34|        JSONCONS_ASSERT(!dimensions_.empty());
  ------------------
  |  |   54|     34|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 34]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  532|       |
  533|     34|        if (dim_ == 0)
  ------------------
  |  Branch (533:13): [True: 34, False: 0]
  ------------------
  534|     34|        {
  535|     34|            if (first_)
  ------------------
  |  Branch (535:17): [True: 34, False: 0]
  ------------------
  536|     34|            {
  537|     34|                if (!cursor_mode_)
  ------------------
  |  Branch (537:21): [True: 0, False: 34]
  ------------------
  538|      0|                {
  539|      0|                    visitor.begin_array(dimensions_[dim_].extent, semantic_tag::multi_dim_column_major, context, ec);
  540|      0|                    visitor.begin_array(dimensions_[dim_].extent, semantic_tag::none, context, ec);
  541|      0|                    for (auto item : dimensions_)
  ------------------
  |  Branch (541:36): [True: 0, False: 0]
  ------------------
  542|      0|                    {
  543|      0|                        visitor.uint64_value(item.extent, semantic_tag::none, context, ec);
  544|      0|                    }
  545|      0|                    visitor.end_array(context, ec);
  546|      0|                }
  547|     34|                visitor.begin_array(dimensions_[dim_].extent, tag_, context, ec);
  548|     34|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     34|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 34]
  |  |  ------------------
  ------------------
  549|      0|                {
  550|      0|                    return;
  551|      0|                }
  552|     34|                first_ = false;
  553|     34|                return;
  554|     34|            }
  555|      0|            if (dimensions_[dim_].index == dimensions_[dim_].end)
  ------------------
  |  Branch (555:17): [True: 0, False: 0]
  ------------------
  556|      0|            {
  557|      0|                visitor.end_array(context, ec);
  558|      0|                if (!cursor_mode_)
  ------------------
  |  Branch (558:21): [True: 0, False: 0]
  ------------------
  559|      0|                {
  560|      0|                    visitor.end_array(context, ec);
  561|      0|                }
  562|      0|                done_ = true;
  563|      0|                return;
  564|      0|            }
  565|      0|        }
  566|      0|        if (dim_+1 < dimensions_.size() && dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (566:13): [True: 0, False: 0]
  |  Branch (566:44): [True: 0, False: 0]
  ------------------
  567|      0|        {
  568|      0|            ++dim_;
  569|      0|            return;
  570|      0|        }
  571|      0|        if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (571:13): [True: 0, False: 0]
  ------------------
  572|      0|        {
  573|      0|            parser_->read_item(visitor, ec);
  574|      0|            dimensions_[dim_].index += dimensions_[dim_].stride;
  575|      0|            ++count_;
  576|      0|            return;
  577|      0|        }
  578|      0|        if (dimensions_[dim_].index + dimensions_[dim_].stride >= dimensions_[dim_].end)
  ------------------
  |  Branch (578:13): [True: 0, False: 0]
  ------------------
  579|      0|        {
  580|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  581|      0|            {
  582|      0|                return;
  583|      0|            }
  584|      0|            if (dim_ > 0)
  ------------------
  |  Branch (584:17): [True: 0, False: 0]
  ------------------
  585|      0|            {
  586|      0|                --dim_;
  587|      0|                dimensions_[dim_].index += dimensions_[dim_].stride;
  588|      0|                if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (588:21): [True: 0, False: 0]
  ------------------
  589|      0|                {
  590|      0|                    for (std::size_t i = dim_+1; i < dimensions_.size(); ++i)
  ------------------
  |  Branch (590:50): [True: 0, False: 0]
  ------------------
  591|      0|                    {
  592|      0|                        dimensions_[i].index = dimensions_[i-1].index;
  593|      0|                        dimensions_[i].end = dimensions_[i].index + dimensions_[i].stride*dimensions_[i].extent;
  594|      0|                    }
  595|      0|                }
  596|      0|            }
  597|      0|        }
  598|      0|    }