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

_ZN8jsoncons11countr_zeroImEEiT_:
  294|      7|{
  295|      7|    return jsoncons::nonstd::countr_zero(x);
  296|      7|}
_ZN8jsoncons11countl_zeroImEEiT_:
  289|      6|{
  290|      6|    return jsoncons::nonstd::countl_zero(x);
  291|      6|}

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

_ZN8jsoncons21basic_generic_visitorIcEC2Ev:
   52|    348|    basic_generic_visitor() = default;
_ZN8jsoncons21basic_generic_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  294|     21|    {
  295|     21|        visit_begin_array(length, tag, context, ec);
  296|     21|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     21|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  297|     21|    }
_ZN8jsoncons21basic_generic_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  363|      2|    {
  364|      2|        visit_uint64(value, tag, context, ec);
  365|      2|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  366|      2|    }
_ZN8jsoncons21basic_generic_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  372|      1|    {
  373|      1|        visit_int64(value, tag, context, ec);
  374|      1|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      1|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  375|      1|    }
_ZN8jsoncons21basic_generic_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  390|      2|    {
  391|      2|        visit_double(value, tag, context, ec);
  392|      2|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  393|      2|    }
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr6nonstd18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  343|      4|    {
  344|      4|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  345|      4|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      4|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  346|      4|    }
_ZN8jsoncons21basic_generic_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  332|     58|    {
  333|     58|        visit_string(value, tag, context, ec);
  334|     58|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     58|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  335|     58|    }
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  276|      1|    {
  277|      1|        visit_begin_object(length, tag, context, ec);
  278|      1|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      1|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  279|      1|    }
_ZN8jsoncons21basic_generic_visitorIcE5flushEv:
   57|     67|    {
   58|     67|        visit_flush();
   59|     67|    }

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

_ZN8jsoncons6nonstd11countr_zeroImEEiT_:
   75|      7|int countr_zero(T value) {
   76|      7|    static_assert(std::is_integral<T>::value && std::is_unsigned<T>::value, "Type must be unsigned integer");
   77|       |    
   78|      7|    if (value == 0) {
  ------------------
  |  Branch (78:9): [True: 0, False: 7]
  ------------------
   79|      0|        return sizeof(T) * 8; // Or std::numeric_limits<T>::digits
   80|      0|    }
   81|       |    
   82|      7|    #if defined(__GNUC__) || defined(__clang__)
   83|      7|        if (sizeof(T) <= sizeof(unsigned int)) {
  ------------------
  |  Branch (83:13): [Folded, False: 7]
  ------------------
   84|      0|            return __builtin_ctz(static_cast<unsigned int>(value));
   85|      7|        } else if (sizeof(T) <= sizeof(unsigned long)) {
  ------------------
  |  Branch (85:20): [True: 7, Folded]
  ------------------
   86|      7|            return __builtin_ctzl(static_cast<unsigned long>(value));
   87|      7|        } else {
   88|      0|            return __builtin_ctzll(static_cast<unsigned long long>(value));
   89|      0|        }
   90|       |    #elif defined(_MSC_VER)
   91|       |        unsigned long index;
   92|       |        #if defined(_M_X64) || defined(_M_ARM64)
   93|       |            JSONCONS_IF_CONSTEXPR (sizeof(T) == 8) 
   94|       |            {
   95|       |                _BitScanForward64(&index, static_cast<unsigned __int64>(value));
   96|       |                return static_cast<int>(index);
   97|       |            }
   98|       |            else
   99|       |            {
  100|       |                _BitScanForward(&index, static_cast<unsigned long>(value));
  101|       |                return static_cast<int>(index);
  102|       |            }
  103|       |        #else
  104|       |            _BitScanForward(&index, static_cast<unsigned long>(value));
  105|       |            return static_cast<int>(index);
  106|       |        #endif
  107|       |    #else
  108|       |        int count = 0;
  109|       |        while ((value & 1) == 0) {
  110|       |            count++;
  111|       |            value >>= 1;
  112|       |        }
  113|       |        return count;
  114|       |    #endif
  115|      7|}
_ZN8jsoncons6nonstd11countl_zeroImEEiT_:
   20|      6|{
   21|      6|    static_assert(std::is_integral<T>::value && std::is_unsigned<T>::value, "Type must be unsigned integer");
   22|       |
   23|      6|    if (x == 0) return std::numeric_limits<T>::digits;
  ------------------
  |  Branch (23:9): [True: 0, False: 6]
  ------------------
   24|      6|#if defined(__GNUC__) || defined(__clang__)
   25|      6|    JSONCONS_IF_CONSTEXPR (sizeof(T) <= sizeof(unsigned int)) {
  ------------------
  |  |  195|      6|    #define JSONCONS_IF_CONSTEXPR if constexpr
  ------------------
   26|      6|        return __builtin_clz(x) - (sizeof(unsigned int) - sizeof(T)) * 8;
   27|      6|    }
   28|      6|    else JSONCONS_IF_CONSTEXPR (sizeof(T) <= sizeof(unsigned long long)) {
  ------------------
  |  |  195|      6|    #define JSONCONS_IF_CONSTEXPR if constexpr
  ------------------
   29|      6|        return __builtin_clzll(x) - (sizeof(unsigned long long) - sizeof(T)) * 8;
   30|      6|    }
   31|      0|#endif
   32|       |
   33|       |    // windows
   34|       |    // _BitScanReverse64
   35|      6|        if (x == 0)
  ------------------
  |  Branch (35:13): [True: 0, False: 6]
  ------------------
   36|      0|        return 64;
   37|       |
   38|       |/* 
   39|       |#include <intrin.h>
   40|       |#include <cstdint> 
   41|       | 
   42|       |#ifdef _MSC_VER
   43|       |    unsigned long index;
   44|       |
   45|       |#if defined(_M_X64) || defined(_M_ARM64)
   46|       |    _BitScanReverse64(&index, x);
   47|       |#else
   48|       |    // Support 32-bit MSVC.
   49|       |    if (x >> 32) {
   50|       |        _BitScanReverse(&index, uint32_t(x >> 32));
   51|       |        return 31 - index;
   52|       |    }
   53|       |
   54|       |    _BitScanReverse(&index, uint32_t(x));
   55|       |    return 63 - index;
   56|       |#endif
   57|       |
   58|       |    return 63 - index;
   59|       |#else
   60|       |    return __builtin_clzll(x);
   61|       |#endif
   62|       |*/
   63|       |
   64|      6|    int bits = std::numeric_limits<T>::digits;
   65|      6|    T mask = static_cast<T>(1) << (bits - 1);
   66|      6|    int leading_zeros = 0;
   67|      6|    while ((x & mask) == 0 && leading_zeros < bits) {
  ------------------
  |  Branch (67:12): [True: 0, False: 6]
  |  Branch (67:31): [True: 0, False: 0]
  ------------------
   68|      0|        leading_zeros++;
   69|      0|        x <<= 1;
   70|      0|    }
   71|      6|    return leading_zeros;
   72|      6|}

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

_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|     58|{
   17|     58|    return T(std::forward<Args>(args)..., alloc);
   18|     58|}
_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|      9|{
   17|      9|    return T(std::forward<Args>(args)..., alloc);
   18|      9|}

_ZN8jsoncons6nonstd16to_plain_pointerImEEPT_S3_:
  265|   204k|    {       
  266|   204k|        return (ptr);
  267|   204k|    }  

_ZNK8jsoncons6nonstd4spanIKhLm18446744073709551615EE4sizeEv:
  116|     63|        {
  117|     63|            return size_;
  118|     63|        }
_ZNK8jsoncons6nonstd4spanIKtLm18446744073709551615EE4sizeEv:
  116|      4|        {
  117|      4|            return size_;
  118|      4|        }
_ZNK8jsoncons6nonstd4spanIKjLm18446744073709551615EE4sizeEv:
  116|      2|        {
  117|      2|            return size_;
  118|      2|        }
_ZNK8jsoncons6nonstd4spanIKmLm18446744073709551615EE4sizeEv:
  116|  27.7k|        {
  117|  27.7k|            return size_;
  118|  27.7k|        }
_ZNK8jsoncons6nonstd4spanIKsLm18446744073709551615EE4sizeEv:
  116|      8|        {
  117|      8|            return size_;
  118|      8|        }
_ZNK8jsoncons6nonstd4spanIKiLm18446744073709551615EE4sizeEv:
  116|     14|        {
  117|     14|            return size_;
  118|     14|        }
_ZNK8jsoncons6nonstd4spanIKfLm18446744073709551615EE4sizeEv:
  116|      2|        {
  117|      2|            return size_;
  118|      2|        }
_ZNK8jsoncons6nonstd4spanIKdLm18446744073709551615EE4sizeEv:
  116|      2|        {
  117|      2|            return size_;
  118|      2|        }
_ZNK8jsoncons6nonstd4spanIhLm18446744073709551615EE4dataEv:
  111|     38|        {
  112|     38|            return data_;
  113|     38|        }
_ZNK8jsoncons6nonstd4spanIhLm18446744073709551615EE4sizeEv:
  116|     38|        {
  117|     38|            return size_;
  118|     38|        }
_ZN8jsoncons6nonstd4spanIKhLm18446744073709551615EEC2EPS2_m:
   61|     51|            : data_(data), size_(size)
   62|     51|        {
   63|     51|        }
_ZN8jsoncons6nonstd4spanIhLm18446744073709551615EEC2INSt3__16vectorIhNS4_9allocatorIhEEEEEERT_PNS4_9enable_ifIXaaaaaantsr7is_spanIS9_EE5valuentsr6nonstd12is_std_arrayIS9_EE5valuesr6nonstd21is_compatible_elementIS9_hEE5valuesr6nonstd17has_data_and_sizeIS9_EE5valueEvE4typeE:
   68|     38|            : data_(c.data()), size_(c.size())
   69|     38|        {
   70|     38|        }
_ZN8jsoncons6nonstd4spanItLm18446744073709551615EEC2EPtm:
   61|      4|            : data_(data), size_(size)
   62|      4|        {
   63|      4|        }
_ZNK8jsoncons6nonstd4spanItLm18446744073709551615EE4sizeEv:
  116|  65.4k|        {
  117|  65.4k|            return size_;
  118|  65.4k|        }
_ZNK8jsoncons6nonstd4spanItLm18446744073709551615EEixEm:
  126|   130k|         {
  127|   130k|             return data_[index];
  128|   130k|         }
_ZN8jsoncons6nonstd4spanIKtLm18446744073709551615EEC2ItLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|      2|            : data_(s.data()), size_(s.size())
  103|      2|        {
  104|      2|        }
_ZNK8jsoncons6nonstd4spanItLm18446744073709551615EE4dataEv:
  111|      2|        {
  112|      2|            return data_;
  113|      2|        }
_ZN8jsoncons6nonstd4spanIjLm18446744073709551615EEC2EPjm:
   61|      2|            : data_(data), size_(size)
   62|      2|        {
   63|      2|        }
_ZNK8jsoncons6nonstd4spanIjLm18446744073709551615EE4sizeEv:
  116|  15.3k|        {
  117|  15.3k|            return size_;
  118|  15.3k|        }
_ZNK8jsoncons6nonstd4spanIjLm18446744073709551615EEixEm:
  126|  30.7k|         {
  127|  30.7k|             return data_[index];
  128|  30.7k|         }
_ZN8jsoncons6nonstd4spanIKjLm18446744073709551615EEC2IjLm18446744073709551615EEERKNS1_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|        }
_ZNK8jsoncons6nonstd4spanIjLm18446744073709551615EE4dataEv:
  111|      1|        {
  112|      1|            return data_;
  113|      1|        }
_ZN8jsoncons6nonstd4spanImLm18446744073709551615EEC2EPmm:
   61|      6|            : data_(data), size_(size)
   62|      6|        {
   63|      6|        }
_ZNK8jsoncons6nonstd4spanImLm18446744073709551615EE4sizeEv:
  116|  9.18k|        {
  117|  9.18k|            return size_;
  118|  9.18k|        }
_ZNK8jsoncons6nonstd4spanImLm18446744073709551615EEixEm:
  126|  18.3k|         {
  127|  18.3k|             return data_[index];
  128|  18.3k|         }
_ZN8jsoncons6nonstd4spanIKmLm18446744073709551615EEC2ImLm18446744073709551615EEERKNS1_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|        }
_ZNK8jsoncons6nonstd4spanImLm18446744073709551615EE4dataEv:
  111|      3|        {
  112|      3|            return data_;
  113|      3|        }
_ZNK8jsoncons6nonstd4spanIKmLm18446744073709551615EEixEm:
  126|  83.2k|         {
  127|  83.2k|             return data_[index];
  128|  83.2k|         }
_ZN8jsoncons6nonstd4spanIsLm18446744073709551615EEC2EPsm:
   61|      8|            : data_(data), size_(size)
   62|      8|        {
   63|      8|        }
_ZNK8jsoncons6nonstd4spanIsLm18446744073709551615EE4sizeEv:
  116|   115k|        {
  117|   115k|            return size_;
  118|   115k|        }
_ZNK8jsoncons6nonstd4spanIsLm18446744073709551615EEixEm:
  126|   231k|         {
  127|   231k|             return data_[index];
  128|   231k|         }
_ZN8jsoncons6nonstd4spanIKsLm18446744073709551615EEC2IsLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|      4|            : data_(s.data()), size_(s.size())
  103|      4|        {
  104|      4|        }
_ZNK8jsoncons6nonstd4spanIsLm18446744073709551615EE4dataEv:
  111|      4|        {
  112|      4|            return data_;
  113|      4|        }
_ZN8jsoncons6nonstd4spanIiLm18446744073709551615EEC2EPim:
   61|     14|            : data_(data), size_(size)
   62|     14|        {
   63|     14|        }
_ZNK8jsoncons6nonstd4spanIiLm18446744073709551615EE4sizeEv:
  116|  80.3k|        {
  117|  80.3k|            return size_;
  118|  80.3k|        }
_ZNK8jsoncons6nonstd4spanIiLm18446744073709551615EEixEm:
  126|   160k|         {
  127|   160k|             return data_[index];
  128|   160k|         }
_ZN8jsoncons6nonstd4spanIKiLm18446744073709551615EEC2IiLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|      7|            : data_(s.data()), size_(s.size())
  103|      7|        {
  104|      7|        }
_ZNK8jsoncons6nonstd4spanIiLm18446744073709551615EE4dataEv:
  111|      7|        {
  112|      7|            return data_;
  113|      7|        }
_ZN8jsoncons6nonstd4spanIfLm18446744073709551615EEC2EPfm:
   61|      2|            : data_(data), size_(size)
   62|      2|        {
   63|      2|        }
_ZNK8jsoncons6nonstd4spanIfLm18446744073709551615EE4sizeEv:
  116|  1.79k|        {
  117|  1.79k|            return size_;
  118|  1.79k|        }
_ZNK8jsoncons6nonstd4spanIfLm18446744073709551615EEixEm:
  126|  3.58k|         {
  127|  3.58k|             return data_[index];
  128|  3.58k|         }
_ZN8jsoncons6nonstd4spanIKfLm18446744073709551615EEC2IfLm18446744073709551615EEERKNS1_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|        }
_ZNK8jsoncons6nonstd4spanIfLm18446744073709551615EE4dataEv:
  111|      1|        {
  112|      1|            return data_;
  113|      1|        }
_ZN8jsoncons6nonstd4spanIdLm18446744073709551615EEC2EPdm:
   61|      2|            : data_(data), size_(size)
   62|      2|        {
   63|      2|        }
_ZNK8jsoncons6nonstd4spanIdLm18446744073709551615EE4sizeEv:
  116|  8.17k|        {
  117|  8.17k|            return size_;
  118|  8.17k|        }
_ZNK8jsoncons6nonstd4spanIdLm18446744073709551615EEixEm:
  126|  16.3k|         {
  127|  16.3k|             return data_[index];
  128|  16.3k|         }
_ZN8jsoncons6nonstd4spanIKdLm18446744073709551615EEC2IdLm18446744073709551615EEERKNS1_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|        }
_ZNK8jsoncons6nonstd4spanIdLm18446744073709551615EE4dataEv:
  111|      1|        {
  112|      1|            return data_;
  113|      1|        }
_ZNK8jsoncons6nonstd4spanIKhLm18446744073709551615EE4dataEv:
  111|     12|        {
  112|     12|            return data_;
  113|     12|        }
_ZNK8jsoncons6nonstd4spanIKmLm18446744073709551615EE5emptyEv:
  121|      8|        { 
  122|      8|            return size_ == 0; 
  123|      8|        }
_ZN8jsoncons6nonstd4spanIKmLm18446744073709551615EEC2INSt3__16vectorImNS5_9allocatorImEEEEEERT_PNS5_9enable_ifIXaaaaaantsr7is_spanISA_EE5valuentsr6nonstd12is_std_arrayISA_EE5valuesr6nonstd21is_compatible_elementISA_S2_EE5valuesr6nonstd17has_data_and_sizeISA_EE5valueEvE4typeE:
   68|      8|            : data_(c.data()), size_(c.size())
   69|      8|        {
   70|      8|        }

_ZN8jsoncons6nonstd4u128C2Em:
   29|  3.12G|    constexpr u128(uint64_t lo) : hi(0), lo(lo) {}
_ZNK8jsoncons6nonstd4u128mlERKS1_:
  111|  1.56G|    u128 operator*(const u128& rhs) const {
  112|       |        // Split components into 32-bit chunks to avoid 64-bit overflow during multiplication
  113|  1.56G|        uint64_t a3 = hi >> 32;
  114|  1.56G|        uint64_t a2 = hi & 0xFFFFFFFFFFFFFFULL; // lower 32 bits of hi
  115|  1.56G|        uint64_t a1 = lo >> 32;
  116|  1.56G|        uint64_t a0 = lo & 0xFFFFFFFFULL;
  117|       |
  118|  1.56G|        uint64_t b3 = rhs.hi >> 32;
  119|  1.56G|        uint64_t b2 = rhs.hi & 0xFFFFFFFFFFFFFFULL;
  120|  1.56G|        uint64_t b1 = rhs.lo >> 32;
  121|  1.56G|        uint64_t b0 = rhs.lo & 0xFFFFFFFFULL;
  122|       |
  123|       |        // Long multiplication matrix
  124|       |        // We only care about terms that fit in the final 128 bits.
  125|       |        // Chunks exceeding indices that add up to 3 (e.g., a2*b2, a3*b1) drop out of range.
  126|       |
  127|  1.56G|        uint64_t c0 = a0 * b0;
  128|  1.56G|        uint64_t c1 = a0 * b1 + a1 * b0;
  129|  1.56G|        uint64_t c2 = a0 * b2 + a1 * b1 + a2 * b0;
  130|  1.56G|        uint64_t c3 = a0 * b3 + a1 * b2 + a2 * b1 + a3 * b0;
  131|       |
  132|       |        // Carry propagation
  133|  1.56G|        c1 += (c0 >> 32);
  134|  1.56G|        c2 += (c1 >> 32);
  135|  1.56G|        c3 += (c2 >> 32);
  136|       |
  137|       |        // Reconstruct hi and lo 64-bit values
  138|  1.56G|        uint64_t new_low = (c0 & 0xFFFFFFFFULL) | (c1 << 32);
  139|  1.56G|        uint64_t new_high = (c2 & 0xFFFFFFFFULL) | (c3 << 32);
  140|       |
  141|  1.56G|        return {new_high, new_low};
  142|  1.56G|    }
_ZN8jsoncons6nonstd4u128C2Emm:
   30|  4.68G|    constexpr u128(uint64_t hi, uint64_t lo) : hi(hi), lo(lo) {}
_ZNK8jsoncons6nonstd4u128plERKS1_:
   41|  1.56G|    u128 operator+(const u128& rhs) const {
   42|  1.56G|        uint64_t new_low = lo + rhs.lo;
   43|       |        // Carry occurs if the result wrapped around and is less than one of the inputs
   44|  1.56G|        uint64_t carry = (new_low < lo) ? 1 : 0;
  ------------------
  |  Branch (44:26): [True: 0, False: 1.56G]
  ------------------
   45|  1.56G|        uint64_t new_high = hi + rhs.hi + carry;
   46|  1.56G|        return {new_high, new_low};
   47|  1.56G|    }
_ZNK8jsoncons6nonstd4u128cvmEv:
  154|  1.56G|    explicit operator uint64_t() const {
  155|  1.56G|        return lo;
  156|  1.56G|    }
_ZNK8jsoncons6nonstd4u128rsEj:
   95|  1.56G|    u128 operator>>(unsigned int shift) const {
   96|  1.56G|        if (shift == 0) return *this;
  ------------------
  |  Branch (96:13): [True: 0, False: 1.56G]
  ------------------
   97|  1.56G|        if (shift >= 128) return {0, 0};
  ------------------
  |  Branch (97:13): [True: 0, False: 1.56G]
  ------------------
   98|       |
   99|  1.56G|        if (shift >= 64) {
  ------------------
  |  Branch (99:13): [True: 1.56G, False: 0]
  ------------------
  100|  1.56G|            return {0, hi >> (shift - 64)};
  101|  1.56G|        }
  102|      0|        else {
  103|      0|            return {
  104|      0|                hi >> shift,
  105|      0|                (lo >> shift) | (hi << (64 - shift))
  106|      0|            };
  107|      0|        }
  108|  1.56G|    }
_ZNK8jsoncons6nonstd4u128cvbEv:
   32|   828k|    explicit operator bool() const {
   33|   828k|        return hi != 0 || lo != 0;
  ------------------
  |  Branch (33:16): [True: 0, False: 828k]
  |  Branch (33:27): [True: 103k, False: 724k]
  ------------------
   34|   828k|    }
_ZNK8jsoncons6nonstd4u128geERKS1_:
   71|     13|    {
   72|     13|        if (hi != rhs.hi)
  ------------------
  |  Branch (72:13): [True: 0, False: 13]
  ------------------
   73|      0|            return hi > rhs.hi;
   74|       |
   75|     13|        return lo >= rhs.lo;
   76|     13|    }

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

_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev:
  193|    348|    {
  194|    348|        if (chunk_)
  ------------------
  |  Branch (194:13): [True: 348, False: 0]
  ------------------
  195|    348|        {
  196|    348|            std::allocator_traits<char_allocator_type>::deallocate(alloc_, chunk_, chunk_size_);
  197|    348|        }
  198|    348|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm:
  377|  6.54M|    {
  378|  6.54M|        std::size_t len = 0;
  379|  6.54M|        if (remaining_ > 0)
  ------------------
  |  Branch (379:13): [True: 6.54M, False: 432]
  ------------------
  380|  6.54M|        {
  381|  6.54M|            len = (std::min)(remaining_, length);
  382|  6.54M|            std::memcpy(p, data_end_, len*sizeof(value_type));
  383|  6.54M|            data_end_ += len;
  384|  6.54M|            remaining_ -= len;
  385|  6.54M|            position_ += len;
  386|  6.54M|        }
  387|  6.54M|        if (length - len == 0)
  ------------------
  |  Branch (387:13): [True: 6.54M, False: 1.78k]
  ------------------
  388|  6.54M|        {
  389|  6.54M|            return len;
  390|  6.54M|        }
  391|  1.78k|        else if (length - len < chunk_size_)
  ------------------
  |  Branch (391:18): [True: 1.78k, False: 0]
  ------------------
  392|  1.78k|        {
  393|  1.78k|            data_end_ = chunk_;
  394|  1.78k|            remaining_ = fill_buffer(chunk_, chunk_size_);
  395|  1.78k|            if (remaining_ > 0)
  ------------------
  |  Branch (395:17): [True: 1.69k, False: 83]
  ------------------
  396|  1.69k|            {
  397|  1.69k|                std::size_t len2 = (std::min)(remaining_, length-len);
  398|  1.69k|                std::memcpy(p+len, data_end_, len2*sizeof(value_type));
  399|  1.69k|                data_end_ += len2;
  400|  1.69k|                remaining_ -= len2;
  401|  1.69k|                position_ += len2;
  402|  1.69k|                len += len2;
  403|  1.69k|            }
  404|  1.78k|            return len;
  405|  1.78k|        }
  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|  6.54M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEPhm:
  442|  3.30k|    {
  443|  3.30k|        if (stream_ptr_->eof())
  ------------------
  |  Branch (443:13): [True: 98, False: 3.20k]
  ------------------
  444|     98|        {
  445|     98|            return 0;
  446|     98|        }
  447|       |
  448|  3.20k|        JSONCONS_TRY
  ------------------
  |  |   37|  3.20k|    #define JSONCONS_TRY try
  ------------------
  449|  3.20k|        {
  450|  3.20k|            std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(chunk), chunk_size);
  451|  3.20k|            std::size_t length = static_cast<std::size_t>(count);
  452|       |
  453|  3.20k|            if (length < chunk_size)
  ------------------
  |  Branch (453:17): [True: 311, False: 2.89k]
  ------------------
  454|    311|            {
  455|    311|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  456|    311|            }
  457|  3.20k|            return length;
  458|  3.20k|        }
  459|  3.20k|        JSONCONS_CATCH(const std::exception&)     
  460|  3.20k|        {
  461|      0|            stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  462|      0|            return 0;
  463|      0|        }
  464|  3.20k|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_6vectorIhS4_EEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr6nonstd7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSD_m:
  746|  1.17M|    {
  747|  1.17M|        std::size_t unread = length;
  748|       |
  749|  2.34M|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (749:16): [True: 1.17M, False: 1.17M]
  |  Branch (749:30): [True: 1.17M, False: 119]
  ------------------
  750|  1.17M|        {
  751|  1.17M|            if (source.remaining() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (751:17): [True: 469, False: 1.17M]
  |  Branch (751:44): [True: 387, False: 82]
  ------------------
  752|    387|            {
  753|    387|                std::size_t n = source.chunk_size();
  754|    387|                std::size_t offset = buffer.size();
  755|    387|                buffer.resize(offset+n);
  756|    387|                std::size_t actual = source.read_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  757|    387|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|    387|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 46, False: 341]
  |  |  ------------------
  ------------------
  758|     46|                {
  759|     46|                    buffer.resize(offset+actual);
  760|     46|                }
  761|    387|                unread -= actual;
  762|    387|            }
  763|  1.17M|            else
  764|  1.17M|            {
  765|  1.17M|                std::size_t n = (std::min)(source.chunk_size(), unread);
  766|  1.17M|                std::size_t offset = buffer.size();
  767|  1.17M|                buffer.resize(offset+n);
  768|  1.17M|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  769|  1.17M|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|  1.17M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 69, False: 1.17M]
  |  |  ------------------
  ------------------
  770|     69|                {
  771|     69|                    buffer.resize(offset + actual);
  772|     69|                }
  773|  1.17M|                unread -= actual;
  774|  1.17M|            }
  775|  1.17M|        }
  776|  1.17M|        return length - unread;
  777|  1.17M|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv:
  271|  3.12M|    {
  272|  3.12M|        return remaining_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:16): [True: 1.11k, False: 3.12M]
  |  Branch (272:35): [True: 179, False: 934]
  ------------------
  273|  3.12M|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9remainingEv:
  346|  3.12M|    {
  347|  3.12M|        return remaining_;
  348|  3.12M|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE10chunk_sizeEv:
  261|  3.13M|    {
  262|  3.13M|        return chunk_size_;
  263|  3.13M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11read_bufferEPhm:
  435|    717|    {
  436|    717|        auto len = fill_buffer(chunk, chunk_size);
  437|    717|        position_ += len;
  438|    717|        return len;
  439|    717|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_6vectorIhS3_EEEENS_6nonstd4spanIKhLm18446744073709551615EEEmOT_:
  352|     31|    {
  353|     31|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   79|     31|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 31]
  |  |  ------------------
  ------------------
  354|      0|        {
  355|      0|            return span<const value_type>{};
  356|      0|        }
  357|     31|        if (remaining_ == 0 && length <= chunk_size_)
  ------------------
  |  Branch (357:13): [True: 0, False: 31]
  |  Branch (357:32): [True: 0, False: 0]
  ------------------
  358|      0|        {
  359|      0|            remaining_ = fill_buffer(chunk_, chunk_size_);
  360|      0|            data_end_ = chunk_;
  361|      0|        }
  362|     31|        if (length > remaining_)
  ------------------
  |  Branch (362:13): [True: 24, False: 7]
  ------------------
  363|     24|        {
  364|     24|            buffer.clear();
  365|     24|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  366|     24|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  367|     24|        }
  368|       |
  369|      7|        const value_type* data = data_end_;
  370|      7|        data_end_ += length;
  371|      7|        remaining_ -= length;
  372|      7|        position_ += length;
  373|      7|        return span<const value_type>(data, length);
  374|     31|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_12basic_stringIcNS2_11char_traitsIcEENS3_IcEEEEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr6nonstd7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSG_m:
  746|  1.96M|    {
  747|  1.96M|        std::size_t unread = length;
  748|       |
  749|  3.91M|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (749:16): [True: 1.95M, False: 1.96M]
  |  Branch (749:30): [True: 1.95M, False: 60]
  ------------------
  750|  1.95M|        {
  751|  1.95M|            if (source.remaining() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (751:17): [True: 465, False: 1.95M]
  |  Branch (751:44): [True: 330, False: 135]
  ------------------
  752|    330|            {
  753|    330|                std::size_t n = source.chunk_size();
  754|    330|                std::size_t offset = buffer.size();
  755|    330|                buffer.resize(offset+n);
  756|    330|                std::size_t actual = source.read_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  757|    330|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|    330|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 34, False: 296]
  |  |  ------------------
  ------------------
  758|     34|                {
  759|     34|                    buffer.resize(offset+actual);
  760|     34|                }
  761|    330|                unread -= actual;
  762|    330|            }
  763|  1.95M|            else
  764|  1.95M|            {
  765|  1.95M|                std::size_t n = (std::min)(source.chunk_size(), unread);
  766|  1.95M|                std::size_t offset = buffer.size();
  767|  1.95M|                buffer.resize(offset+n);
  768|  1.95M|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  769|  1.95M|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|  1.95M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 22, False: 1.95M]
  |  |  ------------------
  ------------------
  770|     22|                {
  771|     22|                    buffer.resize(offset + actual);
  772|     22|                }
  773|  1.95M|                unread -= actual;
  774|  1.95M|            }
  775|  1.95M|        }
  776|  1.96M|        return length - unread;
  777|  1.96M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_12basic_stringIcNS1_11char_traitsIcEENS2_IcEEEEEENS_6nonstd4spanIKhLm18446744073709551615EEEmOT_:
  352|     20|    {
  353|     20|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   79|     20|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 20]
  |  |  ------------------
  ------------------
  354|      0|        {
  355|      0|            return span<const value_type>{};
  356|      0|        }
  357|     20|        if (remaining_ == 0 && length <= chunk_size_)
  ------------------
  |  Branch (357:13): [True: 0, False: 20]
  |  Branch (357:32): [True: 0, False: 0]
  ------------------
  358|      0|        {
  359|      0|            remaining_ = fill_buffer(chunk_, chunk_size_);
  360|      0|            data_end_ = chunk_;
  361|      0|        }
  362|     20|        if (length > remaining_)
  ------------------
  |  Branch (362:13): [True: 19, False: 1]
  ------------------
  363|     19|        {
  364|     19|            buffer.clear();
  365|     19|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  366|     19|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  367|     19|        }
  368|       |
  369|      1|        const value_type* data = data_end_;
  370|      1|        data_end_ += length;
  371|      1|        remaining_ -= length;
  372|      1|        position_ += length;
  373|      1|        return span<const value_type>(data, length);
  374|     20|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4peekEv:
  312|  7.36M|    {
  313|  7.36M|        if (remaining_ == 0)
  ------------------
  |  Branch (313:13): [True: 808, False: 7.36M]
  ------------------
  314|    808|        {
  315|    808|            data_end_ = chunk_;
  316|    808|            remaining_ = fill_buffer(chunk_, chunk_size_);
  317|    808|        }
  318|  7.36M|        if (remaining_ > 0)
  ------------------
  |  Branch (318:13): [True: 7.36M, False: 36]
  ------------------
  319|  7.36M|        {
  320|  7.36M|            value_type c = *data_end_;
  321|  7.36M|            return char_result<value_type>{c, false};
  322|  7.36M|        }
  323|     36|        else
  324|     36|        {
  325|     36|            return char_result<value_type>{0, true};
  326|     36|        }
  327|  7.36M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE6ignoreEm:
  286|  7.36M|    {
  287|  7.36M|        std::size_t len = 0;
  288|  7.36M|        if (remaining_ > 0)
  ------------------
  |  Branch (288:13): [True: 7.36M, False: 0]
  ------------------
  289|  7.36M|        {
  290|  7.36M|            len = (std::min)(remaining_, length);
  291|  7.36M|            position_ += len;
  292|  7.36M|            data_end_ += len;
  293|  7.36M|            remaining_ -= len;
  294|  7.36M|        }
  295|  7.36M|        while (len < length)
  ------------------
  |  Branch (295:16): [True: 0, False: 7.36M]
  ------------------
  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.36M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  176|    348|        : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  177|    348|          chunk_size_(default_max_chunk_size)
  178|    348|    {
  179|    348|        chunk_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, chunk_size_);
  180|    348|        data_end_ = chunk_;
  181|    348|    }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   57|    348|      : std::basic_istream<CharT>(&nb_)
   58|    348|    {
   59|    348|    }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   43|    348|        null_buffer() = default;

_ZN8jsoncons17basic_staj_cursorIcED2Ev:
  558|    348|    virtual ~basic_staj_cursor() = default;
_ZNK8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE5eventEv:
   73|     89|    {
   74|     89|        return event_;
   75|     89|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEEC2ERKS3_:
   67|    348|        : event_(staj_events::null_value), structure_stack_(temp_alloc)
   68|    348|    {
   69|    348|        structure_stack_.emplace_back(json_structure_kind::root_kind);
   70|    348|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE14json_structureC2ENS4_19json_structure_kindE:
   53|    370|            : structure_kind(type)
   54|    370|        {
   55|    370|        }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  174|     21|    {
  175|     21|        auto& structure = structure_stack_.back();
  176|     21|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (176:13): [True: 0, False: 21]
  ------------------
  177|      0|        {
  178|      0|            structure.is_key = !structure_stack_.back().is_key;
  179|      0|        }
  180|     21|        if (structure.is_key)
  ------------------
  |  Branch (180:13): [True: 0, False: 21]
  ------------------
  181|      0|        {
  182|      0|            event_ = staj_event_type(staj_events::begin_array, length, tag, staj_events::key_flag);
  183|      0|        }
  184|     21|        else
  185|     21|        {
  186|     21|            event_ = staj_event_type(staj_events::begin_array, length, tag);
  187|     21|        }
  188|     21|        structure_stack_.emplace_back(json_structure_kind::array_kind);
  189|     21|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     21|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  190|     21|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  295|      2|    {
  296|      2|        auto& structure = structure_stack_.back();
  297|      2|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (297:13): [True: 0, False: 2]
  ------------------
  298|      0|        {
  299|      0|            structure.is_key = !structure.is_key;
  300|      0|        }
  301|      2|        if (structure.is_key)
  ------------------
  |  Branch (301:13): [True: 0, False: 2]
  ------------------
  302|      0|        {
  303|      0|            event_ = staj_event_type(value, tag, staj_events::key_flag);
  304|      0|        }
  305|      2|        else
  306|      2|        {
  307|      2|            event_ = staj_event_type(value, tag);
  308|      2|        }
  309|      2|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  310|      2|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  274|      1|    {
  275|      1|        auto& structure = structure_stack_.back();
  276|      1|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (276:13): [True: 0, False: 1]
  ------------------
  277|      0|        {
  278|      0|            structure.is_key = !structure.is_key;
  279|      0|        }
  280|      1|        if (structure.is_key)
  ------------------
  |  Branch (280:13): [True: 0, False: 1]
  ------------------
  281|      0|        {
  282|      0|            event_ = staj_event_type(value, tag, staj_events::key_flag);
  283|      0|        }
  284|      1|        else
  285|      1|        {
  286|      1|            event_ = staj_event_type(value, tag);
  287|      1|        }
  288|      1|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      1|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  289|      1|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  337|      2|    {
  338|      2|        auto& structure = structure_stack_.back();
  339|      2|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (339:13): [True: 0, False: 2]
  ------------------
  340|      0|        {
  341|      0|            structure.is_key = !structure.is_key;
  342|      0|        }
  343|      2|        if (structure.is_key)
  ------------------
  |  Branch (343:13): [True: 0, False: 2]
  ------------------
  344|      0|        {
  345|      0|            event_ = staj_event_type(value, tag, staj_events::key_flag);
  346|      0|        }
  347|      2|        else
  348|      2|        {
  349|      2|            event_ = staj_event_type(value, tag);
  350|      2|        }
  351|      2|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  352|      2|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE11visit_flushEv:
   94|     67|    {
   95|     67|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
   98|      1|    {
   99|      1|        auto& structure = structure_stack_.back();
  100|      1|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (100:13): [True: 0, False: 1]
  ------------------
  101|      0|        {
  102|      0|            structure_stack_.back().is_key = !structure_stack_.back().is_key;
  103|      0|        }
  104|      1|        if (structure.is_key)
  ------------------
  |  Branch (104:13): [True: 0, False: 1]
  ------------------
  105|      0|        {
  106|      0|            event_ = staj_event_type(staj_events::begin_object, length, tag, staj_events::key_flag);
  107|      0|        }
  108|      1|        else 
  109|      1|        {
  110|      1|            event_ = staj_event_type(staj_events::begin_object, length, tag);
  111|      1|        }
  112|      1|        structure_stack_.emplace_back(json_structure_kind::object_kind);
  113|      1|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      1|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  114|      1|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE12visit_stringERKNS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  211|     58|    {
  212|     58|        auto& structure = structure_stack_.back();
  213|     58|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (213:13): [True: 0, False: 58]
  ------------------
  214|      0|        {
  215|      0|            structure.is_key = !structure.is_key;
  216|      0|        }
  217|     58|        if (structure.is_key)
  ------------------
  |  Branch (217:13): [True: 0, False: 58]
  ------------------
  218|      0|        {
  219|      0|            event_ = staj_event_type(sv, staj_events::string_value, tag, staj_events::key_flag);
  220|      0|        }
  221|     58|        else
  222|     58|        {
  223|     58|            event_ = staj_event_type(sv, staj_events::string_value, tag);
  224|     58|        }
  225|     58|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     58|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  226|     58|    }
_ZN8jsoncons33basic_generic_staj_event_receiverIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  232|      4|    {
  233|      4|        auto& structure = structure_stack_.back();
  234|      4|        if (structure.structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (234:13): [True: 0, False: 4]
  ------------------
  235|      0|        {
  236|      0|            structure.is_key = !structure.is_key;
  237|      0|        }
  238|      4|        if (structure.is_key)
  ------------------
  |  Branch (238:13): [True: 0, False: 4]
  ------------------
  239|      0|        {
  240|      0|            event_ = staj_event_type(value, staj_events::byte_string_value, tag, staj_events::key_flag);
  241|      0|        }
  242|      4|        else
  243|      4|        {
  244|      4|            event_ = staj_event_type(value, staj_events::byte_string_value, tag);
  245|      4|        }
  246|      4|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      4|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  247|      4|    }

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

_ZN8jsoncons16typed_array_castItEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   87|      4|{
   88|      4|    return jsoncons::span<uint16_t>{reinterpret_cast<uint16_t*>(bytes.data()), bytes.size()/sizeof(uint16_t)};
   89|      4|}
_ZN8jsoncons16typed_array_castIjEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   93|      2|{
   94|      2|    return jsoncons::span<uint32_t>{reinterpret_cast<uint32_t*>(bytes.data()), bytes.size()/sizeof(uint32_t)};
   95|      2|}
_ZN8jsoncons16typed_array_castImEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   99|      6|{
  100|      6|    return jsoncons::span<uint64_t>{reinterpret_cast<uint64_t*>(bytes.data()), bytes.size()/sizeof(uint64_t)};
  101|      6|}
_ZN8jsoncons16typed_array_castIsEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  111|      8|{
  112|      8|    return jsoncons::span<int16_t>{reinterpret_cast<int16_t*>(bytes.data()), bytes.size()/sizeof(int16_t)};
  113|      8|}
_ZN8jsoncons16typed_array_castIiEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  117|     14|{
  118|     14|    return jsoncons::span<int32_t>{reinterpret_cast<int32_t*>(bytes.data()), bytes.size()/sizeof(int32_t)};
  119|     14|}
_ZN8jsoncons16typed_array_castIfEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  129|      2|{
  130|      2|    return jsoncons::span<float>{reinterpret_cast<float*>(bytes.data()), bytes.size()/sizeof(float)};
  131|      2|}
_ZN8jsoncons16typed_array_castIdEENS_6nonstd4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  135|      2|{
  136|      2|    return jsoncons::span<double>{reinterpret_cast<double*>(bytes.data()), bytes.size()/sizeof(double)};
  137|      2|}
_ZN8jsoncons22calculate_mdarray_sizeENS_6nonstd4spanIKmLm18446744073709551615EEE:
  247|      8|{
  248|      8|    using result_type = jsoncons::expected<std::size_t,std::errc>;
  249|       |
  250|      8|    if (extents.empty())
  ------------------
  |  Branch (250:9): [True: 0, False: 8]
  ------------------
  251|      0|    {
  252|      0|        return result_type(0);
  253|      0|    }
  254|      8|    std::size_t n = extents[0];
  255|  27.7k|    for (std::size_t i = 1; i < extents.size(); ++i)
  ------------------
  |  Branch (255:29): [True: 27.7k, False: 1]
  ------------------
  256|  27.7k|    {
  257|  27.7k|        if (extents[i] == 0 || JSONCONS_UNLIKELY(n > (std::numeric_limits<std::size_t>::max)()/extents[i]))
  ------------------
  |  |   79|  27.7k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 4, False: 27.7k]
  |  |  ------------------
  ------------------
  |  Branch (257:13): [True: 3, False: 27.7k]
  ------------------
  258|      7|        {
  259|      7|            return result_type(jsoncons::unexpect, std::errc::value_too_large);
  260|      7|        }
  261|  27.7k|        n *= extents[i];
  262|  27.7k|    }
  263|      1|    return n;
  264|      8|}

_ZN8jsoncons12basic_bigdecINSt3__19allocatorImEEEC2EONS_12basic_bigintIS3_EEl:
   42|     27|        : unscaled_{significand}, scale_{scale}
   43|     27|    {
   44|     27|    }
_ZN8jsoncons16append_to_bufferINSt3__19allocatorImEEcNS2_IcEEEEvRKNS_12basic_bigdecIT_EERNS1_12basic_stringIT0_NS1_11char_traitsISB_EET1_EE:
  408|     27|{
  409|     27|    if (value.scale() == 0)
  ------------------
  |  Branch (409:9): [True: 1, False: 26]
  ------------------
  410|      1|    {
  411|      1|        append_to_buffer(value.unscaled(), buf);
  412|      1|        return;
  413|      1|    }
  414|     26|    if (value.unscaled().is_negative())
  ------------------
  |  Branch (414:9): [True: 20, False: 6]
  ------------------
  415|     20|    {
  416|     20|        buf.push_back('-');
  417|     20|    }
  418|     26|    std::basic_string<CharT> coeff;
  419|     26|    append_to_buffer(value.unscaled().is_negative() ? -value.unscaled() : value.unscaled(), coeff);
  ------------------
  |  Branch (419:22): [True: 20, False: 6]
  ------------------
  420|     26|    std::size_t coeffLen = coeff.size();
  421|     26|    if ((value.scale() >= 0) && (value.scale() <= static_cast<int64_t>(coeffLen) + 5)) 
  ------------------
  |  Branch (421:9): [True: 25, False: 1]
  |  Branch (421:33): [True: 23, False: 2]
  ------------------
  422|     23|    { 
  423|     23|        int64_t pad = value.scale() - coeffLen;         // padding zeros
  424|     23|        if (pad >= 0) {                                 // 0.xxx form
  ------------------
  |  Branch (424:13): [True: 0, False: 23]
  ------------------
  425|      0|            buf.push_back('0');
  426|      0|            buf.push_back('.');
  427|      0|            for (; pad>0; pad--) {
  ------------------
  |  Branch (427:20): [True: 0, False: 0]
  ------------------
  428|      0|                buf.push_back('0');
  429|      0|            }
  430|      0|            buf.append(coeff.data(), coeffLen);
  431|      0|        } 
  432|     23|        else 
  433|     23|        {
  434|     23|            buf.append(coeff.data(), -pad);
  435|     23|            buf.push_back('.');
  436|     23|            buf.append(coeff.data() -pad, value.scale());
  437|     23|        }
  438|     23|    }
  439|      3|    else
  440|      3|    {
  441|      3|        buf.push_back(coeff[0]);   // first character
  442|      3|        if (coeffLen > 1) 
  ------------------
  |  Branch (442:13): [True: 0, False: 3]
  ------------------
  443|      0|        {
  444|      0|            buf.push_back('.');
  445|      0|            buf.append(coeff.data() + 1, coeffLen - 1);
  446|      0|        }
  447|      3|        int64_t digits = static_cast<int64_t>(coeffLen) - 1;
  448|      3|        if (value.scale() != digits) 
  ------------------
  |  Branch (448:13): [True: 3, False: 0]
  ------------------
  449|      3|        {             
  450|      3|            buf.push_back('e');
  451|      3|            if (value.scale() < digits)
  ------------------
  |  Branch (451:17): [True: 1, False: 2]
  ------------------
  452|      1|            {
  453|      1|                from_integer(static_cast<uint64_t>(digits) - static_cast<uint64_t>(value.scale()), buf);
  454|      1|            }
  455|      2|            else
  456|      2|            {
  457|      2|                from_integer(digits - value.scale(), buf);
  458|      2|            }
  459|      3|        }
  460|      3|    }
  461|     26|}
_ZNK8jsoncons12basic_bigdecINSt3__19allocatorImEEE5scaleEv:
   78|    133|    {
   79|    133|        return scale_;
   80|    133|    }
_ZNK8jsoncons12basic_bigdecINSt3__19allocatorImEEE8unscaledEv:
   73|     79|    {
   74|     79|        return unscaled_;
   75|     79|    }
_ZN8jsoncons12basic_bigdecINSt3__19allocatorImEEEC2Ev:
   35|      8|    basic_bigdec() = default;
_ZN8jsoncons12basic_bigdecINSt3__19allocatorImEEEaSEOS4_:
   70|      8|    basic_bigdec& operator=(basic_bigdec&&) = default;

_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE13from_bytes_beEiPKhm:
  824|     38|    {
  825|     38|        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|     38|        double bits = radix_log2 * n;
  828|     38|        double big_digits = std::ceil(bits / 64.0);
  829|       |        //std::cout << "ESTIMATED: " << big_digits << "\n";
  830|       |
  831|     38|        basic_bigint<Allocator> v = 0;
  832|     38|        v.reserve(static_cast<size_type>(big_digits));
  833|       |
  834|   828k|        for (size_type i = 0; i < n; i++)
  ------------------
  |  Branch (834:31): [True: 828k, False: 38]
  ------------------
  835|   828k|        {
  836|   828k|            v *= 256;
  837|   828k|            v += (word_type)(bytes[i]);
  838|   828k|        }
  839|       |        //std::cout << "ACTUAL: " << v.size() << "\n";
  840|       |
  841|     38|        if (signum < 0)
  ------------------
  |  Branch (841:13): [True: 0, False: 38]
  ------------------
  842|      0|        {
  843|      0|            v.set_negative(true);
  844|      0|        }
  845|       |
  846|     38|        return v;
  847|     38|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE17next_power_of_twoEm:
 2062|      1|    static word_type next_power_of_two(word_type n) {
 2063|      1|        n = n - 1;
 2064|      1|        n |= n >> 1u;
 2065|      1|        n |= n >> 2u;
 2066|      1|        n |= n >> 4u;
 2067|      1|        n |= n >> 8u;
 2068|      1|        n |= n >> 16u;
 2069|      1|        n |= n >> 32u;
 2070|      1|        return n + 1;
 2071|      1|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE7reserveEm:
  855|     38|    {
  856|     38|        storage_.reserve(n);
  857|     38|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7reserveEm:
  455|  1.13M|    {
  456|  1.13M|       if (capacity() < n)
  ------------------
  |  Branch (456:12): [True: 142, False: 1.13M]
  ------------------
  457|    142|       {
  458|    142|           if (!is_allocated())
  ------------------
  |  Branch (458:16): [True: 140, False: 2]
  ------------------
  459|    140|           {
  460|    140|               size_type size = inlined_.size_;
  461|    140|               size_type is_neg = inlined_.is_negative_;
  462|    140|               word_type values[inlined_capacity] = {inlined_.values_[0], inlined_.values_[1]};
  463|       |
  464|    140|               ::new (&allocated_) allocated_storage();
  465|    140|               allocated_.reserve(n, get_allocator());
  466|    140|               allocated_.size_ = size;
  467|    140|               allocated_.is_negative_ = is_neg;
  468|    140|               if (n >= 1)
  ------------------
  |  Branch (468:20): [True: 140, False: 0]
  ------------------
  469|    140|               {
  470|    140|                   allocated_.data_[0] = values[0];
  471|    140|               }
  472|    140|               if (n >= 2)
  ------------------
  |  Branch (472:20): [True: 140, False: 0]
  ------------------
  473|    140|               {
  474|    140|                   allocated_.data_[1] = values[1];
  475|    140|               }
  476|    140|           }
  477|      2|           else
  478|      2|           {
  479|      2|               allocated_.reserve(n, get_allocator());
  480|      2|           }
  481|    142|       }
  482|  1.13M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE8capacityEv:
  508|  1.13M|    {
  509|  1.13M|        return is_allocated() ? allocated_.capacity_ : inlined_capacity;
  ------------------
  |  Branch (509:16): [True: 1.13M, False: 153]
  ------------------
  510|  1.13M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12is_allocatedEv:
  503|  2.99M|    {
  504|  2.99M|        return common_.is_allocated_;
  505|  2.99M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2Ev:
  206|    140|            : is_allocated_(true),
  207|    140|            is_negative_(false)
  208|    140|        {
  209|    140|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7reserveEmRKS4_:
  258|    142|        {
  259|    142|            JSONCONS_ASSERT(n < max_size);
  ------------------
  |  |   54|    142|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 142]
  |  |  ------------------
  |  |   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|    142|            size_type capacity_new = round_up(n);
  261|       |
  262|    142|            real_allocator_type alloc(a);
  263|    142|            word_type* data_new = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_new);
  264|    142|            if (size_ > 0)
  ------------------
  |  Branch (264:17): [True: 2, False: 140]
  ------------------
  265|      2|            {
  266|      2|                std::memcpy(data_new, data_, size_type(size_ * sizeof(word_type)));
  267|      2|            }
  268|    142|            if (data_ != nullptr)
  ------------------
  |  Branch (268:17): [True: 2, False: 140]
  ------------------
  269|      2|            {
  270|      2|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  271|      2|            }
  272|    142|            capacity_ = capacity_new;
  273|    142|            data_ = data_new;
  274|    142|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage8round_upEm:
  278|    142|        {
  279|    142|            size_type remainder = i % mem_unit;
  280|    142|            size_type off = mem_unit - remainder;
  281|    142|            bool testoff = i < max_size - off;
  282|    142|            JSONCONS_ASSERT(testoff);
  ------------------
  |  |   54|    142|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 142]
  |  |  ------------------
  |  |   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|    142|            return i + off;
  285|    142|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE13get_allocatorEv:
  485|   612k|    {
  486|   612k|        return static_cast<const word_allocator_type&>(*this);
  487|   612k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLIiEENS1_9enable_ifIXsr6nonstd17is_signed_integerIT_EE5valueERS4_E4typeES7_:
 1020|   828k|    {
 1021|   828k|        *this *= word_type(y < 0 ? -y : y);
  ------------------
  |  Branch (1021:28): [True: 0, False: 828k]
  ------------------
 1022|   828k|        if ( y < 0 )
  ------------------
  |  Branch (1022:14): [True: 0, False: 828k]
  ------------------
 1023|      0|            set_negative(!is_negative());
 1024|   828k|        return *this;
 1025|   828k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLImEENS1_9enable_ifIXsr6nonstd19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
 1030|   828k|    {
 1031|   828k|        auto words = get_words();
 1032|   828k|        size_type len = words.size();
 1033|   828k|        if (len == 0 || m == 0)
  ------------------
  |  Branch (1033:13): [True: 39, False: 828k]
  |  Branch (1033:25): [True: 0, False: 828k]
  ------------------
 1034|     39|        {
 1035|     39|            resize(0);
 1036|     39|            return *this;
 1037|     39|        }
 1038|       |
 1039|   828k|        dword_type carry = 0;
 1040|   828k|        size_t i = 0;
 1041|  1.56G|        for (; i < len; ++i) {
  ------------------
  |  Branch (1041:16): [True: 1.56G, False: 828k]
  ------------------
 1042|  1.56G|            dword_type x = dword_type(words[i]) * m + carry;
 1043|  1.56G|            words[i] = static_cast<word_type>(x);
 1044|  1.56G|            carry = x >> 64;
 1045|  1.56G|        }
 1046|       |
 1047|   828k|        if (carry)
  ------------------
  |  Branch (1047:13): [True: 103k, False: 724k]
  ------------------
 1048|   103k|        {
 1049|   103k|            resize(len+1);
 1050|   103k|            words = get_words();
 1051|   103k|            words[i] = static_cast<word_type>(carry);
 1052|   103k|        }
 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|   828k|        return *this;
 1075|   828k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE9get_wordsEv:
  697|  3.91M|    {
  698|  3.91M|        return storage_.get_words();
  699|  3.91M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE9get_wordsEv:
  523|  5.25M|    {
  524|  5.25M|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (524:16): [True: 4.64M, False: 611k]
  ------------------
  525|  4.64M|            storage_view<word_type>{allocated_.data_, allocated_.size_} :
  526|  5.25M|            storage_view<word_type>{inlined_.values_, inlined_.size_};
  527|  5.25M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEC2EPmm:
   67|  5.25M|            : data_(data), size_(size)
   68|  5.25M|        {
   69|  5.25M|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4sizeEv:
   87|  51.2M|        {
   88|  51.2M|            return size_;
   89|  51.2M|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6resizeEm:
  850|  1.03M|    {
  851|  1.03M|        storage_.resize(new_length);
  852|  1.03M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6resizeEm:
  537|  1.13M|    {
  538|  1.13M|        size_type old_length = common_.size_;
  539|  1.13M|        reserve(new_length);
  540|  1.13M|        common_.size_ = new_length;
  541|       |
  542|  1.13M|        if (old_length < new_length)
  ------------------
  |  Branch (542:13): [True: 1.03M, False: 102k]
  ------------------
  543|  1.03M|        {
  544|  1.03M|            if (is_allocated())
  ------------------
  |  Branch (544:17): [True: 1.03M, False: 10]
  ------------------
  545|  1.03M|            {
  546|  1.03M|                std::memset(allocated_.data_+old_length, 0, size_type((new_length-old_length)*sizeof(word_type)));
  547|  1.03M|            }
  548|     10|            else
  549|     10|            {
  550|     10|                JSONCONS_ASSERT(new_length <= inlined_capacity);
  ------------------
  |  |   54|     10|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 10]
  |  |  ------------------
  |  |   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|     22|                for (size_type i = old_length; i < inlined_capacity; ++i)
  ------------------
  |  Branch (551:48): [True: 12, False: 10]
  ------------------
  552|     12|                {
  553|     12|                    inlined_.values_[i] = 0;
  554|     12|                }
  555|     10|            }
  556|  1.03M|        }
  557|  1.13M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEixEm:
   72|  3.90G|        {
   73|  3.90G|            return data_[i];
   74|  3.90G|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11is_negativeEv:
  707|  1.44M|    {
  708|  1.44M|        return storage_.is_negative();
  709|  1.44M|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE11is_negativeEv:
  513|  1.44M|    {
  514|  1.44M|        return common_.is_negative_;
  515|  1.44M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLImEENS1_9enable_ifIXaasr6nonstd19is_unsigned_integerIT_EE5valuelestS7_Lm8EERS4_E4typeES7_:
  921|   828k|    {
  922|   828k|        if ( is_negative())
  ------------------
  |  Branch (922:14): [True: 0, False: 828k]
  ------------------
  923|      0|            return *this -= -basic_bigint<Allocator>(y);
  924|       |
  925|   828k|        word_type d;
  926|   828k|        word_type carry = 0;
  927|       |
  928|   828k|        auto words = get_words();
  929|   828k|        resize(words.size() + 1);
  930|       |
  931|   828k|        words = get_words();
  932|   828k|        const size_type this_size = words.size();
  933|   828k|        size_type y_size = 1;
  934|       |
  935|   828k|        d = words[0] + carry;
  936|   828k|        carry = d < carry;
  937|   828k|        words[0] = d + y;
  938|   828k|        if (words[0] < d)
  ------------------
  |  Branch (938:13): [True: 0, False: 828k]
  ------------------
  939|      0|            carry = 1;
  940|       |
  941|   828k|        for (size_type i = y_size; i < this_size && carry != 0; ++i)
  ------------------
  |  Branch (941:36): [True: 828k, False: 39]
  |  Branch (941:53): [True: 0, False: 828k]
  ------------------
  942|      0|        {
  943|      0|            d = words[i] + carry;
  944|      0|            carry = d < carry;
  945|      0|            words[i] = d;
  946|      0|        }
  947|   828k|        reduce();
  948|   828k|        return *this;
  949|   828k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ImEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  672|     75|        : storage_(n, alloc)
  673|     75|    {
  674|     75|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ImEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  363|     75|        : word_allocator_type(alloc)
  364|     75|    {
  365|     75|        ::new (&inlined_) inlined_storage(n);
  366|     75|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ImEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  141|     75|            : is_allocated_(false),
  142|     75|            is_negative_(false),
  143|     75|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (143:19): [True: 37, False: 38]
  ------------------
  144|     75|        {
  145|     75|            values_[0] = n;
  146|     75|            values_[1] = 0;
  147|     75|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEEngEv:
  867|     64|    {
  868|     64|        basic_bigint<Allocator> v(*this);
  869|     64|        v.set_negative(!v.is_negative());
  870|     64|        return v;
  871|     64|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_:
  650|    282|        : storage_(other.storage_)
  651|    282|    {
  652|    282|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_:
  302|    282|        : word_allocator_type(other.get_allocator())
  303|    282|    {
  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|    282|        if (!other.is_allocated())
  ------------------
  |  Branch (308:13): [True: 46, False: 236]
  ------------------
  309|     46|        {
  310|     46|            ::new (&inlined_) inlined_storage(other.inlined_);
  311|     46|        }
  312|    236|        else
  313|    236|        {
  314|    236|            ::new (&allocated_) allocated_storage(other.allocated_, get_allocator());
  315|    236|        }
  316|       |#if defined(__GNUC__) && JSONCONS_GCC_AVAILABLE(12,0,0)
  317|       |# pragma GCC diagnostic pop
  318|       |#endif
  319|    282|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ERKS6_:
  181|   203k|            : is_allocated_(false),
  182|   203k|            is_negative_(stor.is_negative_),
  183|   203k|            size_(stor.size_)
  184|   203k|        {
  185|   203k|            values_[0] = stor.values_[0];
  186|   203k|            values_[1] = stor.values_[1];
  187|   203k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2ERKS6_RKS4_:
  212|   204k|            : is_allocated_(true),
  213|   204k|              is_negative_(stor.is_negative_),
  214|   204k|              size_(stor.size_),
  215|   204k|              capacity_(stor.capacity_)
  216|   204k|        {
  217|   204k|            real_allocator_type alloc(a);
  218|       |
  219|   204k|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_);
  220|   204k|            JSONCONS_TRY
  ------------------
  |  |   37|   204k|    #define JSONCONS_TRY try
  ------------------
  221|   204k|            {
  222|   204k|                std::allocator_traits<real_allocator_type>::construct(alloc, nonstd::to_plain_pointer(data_));
  223|   204k|            }
  224|   204k|            JSONCONS_CATCH(...)
  225|   204k|            {
  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|   204k|            JSONCONS_ASSERT(stor.data_ != nullptr);
  ------------------
  |  |   54|   204k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 204k]
  |  |  ------------------
  |  |   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|   204k|            std::memcpy(data_, stor.data_, size_type(stor.size_ * sizeof(word_type)));
  232|   204k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmIERKS4_:
  986|     34|    {
  987|     34|        auto y_words = y.get_words();
  988|       |
  989|     34|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (989:14): [True: 34, False: 0]
  ------------------
  990|     34|            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|   306k|    {
  703|   306k|        return storage_.get_words();
  704|   306k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE9get_wordsEv:
  530|   408k|    {
  531|   408k|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (531:16): [True: 306k, False: 102k]
  ------------------
  532|   306k|            storage_view<const word_type>{allocated_.data_, allocated_.size_} :
  533|   408k|            storage_view<const word_type>{inlined_.values_, inlined_.size_};
  534|   408k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEC2EPS7_m:
   67|   408k|            : data_(data), size_(size)
   68|   408k|        {
   69|   408k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLERKS4_:
  952|     37|    {
  953|     37|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (953:14): [True: 0, False: 37]
  ------------------
  954|      0|            return *this -= -y;
  955|       |
  956|     37|        auto y_words = y.get_words();
  957|       |        
  958|     37|        word_type d;
  959|     37|        word_type carry = 0;
  960|       |
  961|     37|        auto words = get_words();
  962|     37|        resize( (std::max)(y_words.size(), words.size()) + 1 );
  963|     37|        words = get_words();
  964|       |
  965|     37|        const size_t this_size = words.size();
  966|     37|        const size_t y_size = y_words.size();
  967|  81.3k|        for (size_type i = 0; i < y_size; i++ )
  ------------------
  |  Branch (967:31): [True: 81.3k, False: 37]
  ------------------
  968|  81.3k|        {
  969|  81.3k|            d = words[i] + carry;
  970|  81.3k|            carry = d < carry;
  971|  81.3k|            words[i] = d + y_words[i];
  972|  81.3k|            if (words[i] < d)
  ------------------
  |  Branch (972:17): [True: 211, False: 81.1k]
  ------------------
  973|    211|                carry = 1;
  974|  81.3k|        }
  975|     37|        for (size_type i = y_size; i < this_size && carry != 0; i++ )
  ------------------
  |  Branch (975:36): [True: 37, False: 0]
  |  Branch (975:53): [True: 0, False: 37]
  ------------------
  976|      0|        {
  977|      0|            d = words[i] + carry;
  978|      0|            carry = d < carry;
  979|      0|            words[i] = d;
  980|      0|        }
  981|     37|        reduce();
  982|     37|        return *this;
  983|     37|    }
_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: 6, False: 101k]
  ------------------
 1710|      6|            return y.is_negative() - is_negative();
 1711|   101k|        int code = 0;
 1712|   101k|        if ( words.size() < y_size)
  ------------------
  |  Branch (1712:14): [True: 0, False: 101k]
  ------------------
 1713|      0|            code = -1;
 1714|   101k|        else if ( words.size() > y_size)
  ------------------
  |  Branch (1714:19): [True: 101k, False: 37]
  ------------------
 1715|   101k|            code = +1;
 1716|     37|        else
 1717|     37|        {
 1718|     37|            for (size_type i = words.size(); i-- > 0; )
  ------------------
  |  Branch (1718:46): [True: 37, False: 0]
  ------------------
 1719|     37|            {
 1720|     37|                if (words[i] > y_words[i])
  ------------------
  |  Branch (1720:21): [True: 0, False: 37]
  ------------------
 1721|      0|                {
 1722|      0|                    code = 1;
 1723|      0|                    break;
 1724|      0|                }
 1725|     37|                else if (words[i] < y_words[i])
  ------------------
  |  Branch (1725:26): [True: 37, False: 0]
  ------------------
 1726|     37|                {
 1727|     37|                    code = -1;
 1728|     37|                    break;
 1729|     37|                }
 1730|     37|            }
 1731|     37|        }
 1732|   101k|        return is_negative() ? -code : code;
  ------------------
  |  Branch (1732:16): [True: 0, False: 101k]
  ------------------
 1733|   102k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEES6_:
 1537|   102k|    {
 1538|   102k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1538:15): [True: 43, False: 101k]
  ------------------
 1539|   102k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4sizeEv:
   87|   714k|        {
   88|   714k|            return size_;
   89|   714k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEixEm:
   72|  81.5k|        {
   73|  81.5k|            return data_[i];
   74|  81.5k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6reduceEv:
 2058|  1.23M|    {
 2059|  1.23M|        storage_.reduce();
 2060|  1.23M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6reduceEv:
  432|  1.23M|    {
  433|  1.23M|        if (common_.size_ > 0)
  ------------------
  |  Branch (433:13): [True: 1.23M, False: 0]
  ------------------
  434|  1.23M|        {
  435|  1.23M|            auto words = get_words();
  436|  1.23M|            word_type* p = words.end() - 1;
  437|  1.23M|            word_type* first = words.begin();
  438|   196M|            while ( p >= first )
  ------------------
  |  Branch (438:21): [True: 196M, False: 1]
  ------------------
  439|   196M|            {
  440|   196M|                if ( *p )
  ------------------
  |  Branch (440:22): [True: 1.23M, False: 195M]
  ------------------
  441|  1.23M|                {
  442|  1.23M|                    break;
  443|  1.23M|                }
  444|   195M|                --common_.size_;
  445|   195M|                --p;
  446|   195M|            }
  447|  1.23M|        }
  448|  1.23M|        if (common_.size_ == 0)
  ------------------
  |  Branch (448:13): [True: 1, False: 1.23M]
  ------------------
  449|      1|        {
  450|      1|            common_.is_negative_ = false;
  451|      1|        }
  452|  1.23M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE3endEv:
   96|  1.23M|        {
   97|  1.23M|            return data_ + size_;
   98|  1.23M|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE5beginEv:
   91|  1.23M|        {
   92|  1.23M|            return data_;
   93|  1.23M|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE12set_negativeEb:
  728|   408k|    {
  729|   408k|        storage_.set_negative(value);
  730|   408k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12set_negativeEb:
  518|   408k|    {
  519|   408k|        common_.is_negative_ = value;
  520|   408k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16append_to_bufferIcNS1_11char_traitsIcEENS2_IcEEEEvRNS1_12basic_stringIT_T0_T1_EE:
 1414|     12|    {
 1415|     12|        if (is_zero())
  ------------------
  |  Branch (1415:13): [True: 0, False: 12]
  ------------------
 1416|      0|        {
 1417|      0|            buf.push_back('0');
 1418|      0|            return;
 1419|      0|        }
 1420|     12|        if (is_negative())
  ------------------
  |  Branch (1420:13): [True: 11, False: 1]
  ------------------
 1421|     11|        {
 1422|     11|            buf.push_back('-');
 1423|     11|        }
 1424|     12|        std::size_t pos = buf.size();
 1425|     12|        basic_bigint<Allocator> v(*this);
 1426|     12|        auto v_words = v.get_words();
 1427|       |
 1428|     12|        size_type len = (v_words.size() * word_bits / 3) + 2;
 1429|     12|        buf.reserve(len);
 1430|       |
 1431|     12|        if ( v_words.size() == 0 )
  ------------------
  |  Branch (1431:14): [True: 0, False: 12]
  ------------------
 1432|      0|        {
 1433|      0|            buf.push_back('0');
 1434|      0|        }
 1435|     12|        else
 1436|     12|        {
 1437|     12|            word_type r;
 1438|     12|            basic_bigint<Allocator> R(get_allocator());
 1439|     12|            basic_bigint<Allocator> LP10(max_unsigned_power_10, get_allocator()); 
 1440|       |
 1441|     12|            do
 1442|  36.4k|            {
 1443|  36.4k|                v.divide( LP10, v, R, true );
 1444|  36.4k|                v_words = v.get_words();
 1445|       |
 1446|  36.4k|                auto R_words = R.get_words();
 1447|  36.4k|                r = (R_words.size() ? R_words[0] : 0);
  ------------------
  |  Branch (1447:22): [True: 36.4k, False: 0]
  ------------------
 1448|   728k|                for ( size_type j=0; j < imax_unsigned_power_10; j++ )
  ------------------
  |  Branch (1448:38): [True: 692k, False: 36.4k]
  ------------------
 1449|   692k|                {
 1450|   692k|                    buf.push_back(char(r % 10u + '0'));
 1451|   692k|                    r /= 10u;
 1452|   692k|                    if ( r + v_words.size() == 0 )
  ------------------
  |  Branch (1452:26): [True: 12, False: 692k]
  ------------------
 1453|     12|                        break;
 1454|   692k|                }
 1455|  36.4k|            } 
 1456|  36.4k|            while ( v_words.size() > 0);
  ------------------
  |  Branch (1456:21): [True: 36.4k, False: 12]
  ------------------
 1457|       |
 1458|     12|            std::reverse(buf.begin()+pos,buf.end());
 1459|     12|        }
 1460|     12|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7is_zeroEv:
 2179|     51|    bool is_zero() const {
 2180|     51|        return get_words().size() == 0;
 2181|     51|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE13get_allocatorEv:
  692|   407k|    {
  693|   407k|        return storage_.get_allocator();
  694|   407k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS3_:
  623|     37|        : storage_(alloc)
  624|     37|    {
  625|     37|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS4_:
  296|     79|        : word_allocator_type(alloc)
  297|     79|    {
  298|     79|        ::new (&inlined_) inlined_storage();
  299|     79|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2Ev:
  116|     79|            : is_allocated_(false),
  117|     79|            is_negative_(false),
  118|     79|            size_(0),
  119|     79|            values_{0, 0}
  120|     79|        {
  121|     79|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE6divideERKS4_RS4_S7_b:
 1815|   101k|    {
 1816|   101k|        basic_bigint<Allocator> denom(denom_, get_allocator());
 1817|   101k|        auto denom_words = denom.get_words();
 1818|       |
 1819|   101k|        if (denom_words.size() == 0)
  ------------------
  |  Branch (1819:13): [True: 0, False: 101k]
  ------------------
 1820|      0|        {
 1821|      0|            JSONCONS_THROW(std::runtime_error( "Zero divide." ));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1822|      0|        }
 1823|   101k|        bool quot_neg = is_negative() ^ denom.is_negative();
 1824|   101k|        bool rem_neg = is_negative();
 1825|   101k|        basic_bigint<Allocator> num(*this, get_allocator());
 1826|   101k|        num.set_negative(false);
 1827|   101k|        denom.set_negative(false);
 1828|   101k|        if ( num < denom )
  ------------------
  |  Branch (1828:14): [True: 37, False: 101k]
  ------------------
 1829|     37|        {
 1830|     37|            quot = word_type(0);
 1831|     37|            quot.set_negative(quot_neg);
 1832|     37|            rem = num;
 1833|     37|            rem.set_negative(rem_neg);
 1834|     37|            return;
 1835|     37|        }
 1836|       |
 1837|   101k|        auto num_words = num.get_words();
 1838|   101k|        auto quot_words = quot.get_words();
 1839|   101k|        auto words = get_words();
 1840|       |
 1841|   101k|        if ( denom_words.size() == 1 && num_words.size() == 1 )
  ------------------
  |  Branch (1841:14): [True: 101k, False: 0]
  |  Branch (1841:41): [True: 0, False: 101k]
  ------------------
 1842|      0|        {
 1843|      0|            quot = word_type( num_words[0]/denom_words[0] );
 1844|      0|            rem = word_type( num_words[0]%denom_words[0] );
 1845|      0|            quot.set_negative(quot_neg);
 1846|      0|            rem.set_negative(rem_neg);
 1847|      0|            return;
 1848|      0|        }
 1849|   101k|        if (denom_words.size() == 1 && (denom_words[0] & l_mask) == 0 )
  ------------------
  |  Branch (1849:13): [True: 101k, False: 0]
  |  Branch (1849:40): [True: 0, False: 101k]
  ------------------
 1850|      0|        {
 1851|       |            // Denominator fits into a half word
 1852|      0|            word_type divisor = denom_words[0], dHi = 0, q1, r, q2, dividend;
 1853|      0|            quot.resize(words.size());
 1854|      0|            quot_words = quot.get_words();
 1855|      0|            for (size_type i=words.size(); i-- > 0; )
  ------------------
  |  Branch (1855:44): [True: 0, False: 0]
  ------------------
 1856|      0|            {
 1857|      0|                dividend = (dHi << word_half_bits) | (words[i] >> word_half_bits);
 1858|      0|                q1 = dividend/divisor;
 1859|      0|                r = dividend % divisor;
 1860|      0|                dividend = (r << word_half_bits) | (words[i] & r_mask);
 1861|      0|                q2 = dividend/divisor;
 1862|      0|                dHi = dividend % divisor;
 1863|      0|                quot_words[i] = (q1 << word_half_bits) | q2;
 1864|      0|            }
 1865|      0|            quot.reduce();
 1866|      0|            rem = dHi;
 1867|      0|            quot.set_negative(quot_neg);
 1868|      0|            rem.set_negative(rem_neg);
 1869|      0|            return;
 1870|      0|        }
 1871|   101k|        basic_bigint<Allocator> num0(num, get_allocator());
 1872|   101k|        basic_bigint<Allocator> denom0(denom, get_allocator());
 1873|   101k|        int x = 0;
 1874|   101k|        bool second_done = normalize(denom, num, x);
 1875|   101k|        denom_words = denom.get_words();
 1876|   101k|        num_words = num.get_words();
 1877|       |
 1878|   101k|        size_type l = denom_words.size() - 1;
 1879|   101k|        size_type n = num_words.size() - 1;
 1880|   101k|        quot.resize(n - l);
 1881|   101k|        quot_words = quot.get_words();
 1882|   194M|        for (size_type i = quot_words.size(); i-- > 0; )
  ------------------
  |  Branch (1882:47): [True: 194M, False: 101k]
  ------------------
 1883|   194M|        {
 1884|   194M|            quot_words[i] = 0;
 1885|   194M|        }
 1886|   101k|        rem = num;
 1887|   101k|        auto rem_words = rem.get_words();
 1888|   101k|        if ( rem_words[n] >= denom_words[l] )
  ------------------
  |  Branch (1888:14): [True: 1.41k, False: 100k]
  ------------------
 1889|  1.41k|        {
 1890|  1.41k|            rem.resize(rem_words.size() + 1);
 1891|  1.41k|            rem_words = rem.get_words();
 1892|  1.41k|            n++;
 1893|  1.41k|            quot.resize(quot_words.size() + 1);
 1894|  1.41k|            quot_words = quot.get_words();
 1895|  1.41k|        }
 1896|   101k|        word_type d = denom_words[l];
 1897|       |
 1898|   194M|        for ( size_type k = n; k > l; k-- )
  ------------------
  |  Branch (1898:32): [True: 194M, False: 101k]
  ------------------
 1899|   194M|        {
 1900|   194M|            word_type q = DDquotient(rem_words[k], rem_words[k-1], d);
 1901|   194M|            subtractmul( rem_words.data() + (k - l - 1), denom_words.data(), l + 1, q );
 1902|   194M|            quot_words[k - l - 1] = q;
 1903|   194M|        }
 1904|   101k|        quot.reduce();
 1905|   101k|        quot.set_negative(quot_neg);
 1906|   101k|        if (remDesired)
  ------------------
  |  Branch (1906:13): [True: 101k, False: 0]
  ------------------
 1907|   101k|        {
 1908|   101k|            unnormalize(rem, x, second_done);
 1909|   101k|            rem.set_negative(rem_neg);
 1910|   101k|        }
 1911|   101k|    }
_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: 203k, False: 203k]
  ------------------
  325|   203k|        {
  326|   203k|            ::new (&inlined_) inlined_storage(other.inlined_);
  327|   203k|        }
  328|   203k|        else
  329|   203k|        {
  330|   203k|            ::new (&allocated_) allocated_storage(other.allocated_, alloc);
  331|   203k|        }
  332|   407k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9normalizeERS4_S5_Ri:
 2013|   101k|    {
 2014|   101k|        auto denom_words = denom.get_words();
 2015|   101k|        if (denom_words.size() == 0)
  ------------------
  |  Branch (2015:13): [True: 0, False: 101k]
  ------------------
 2016|      0|        {
 2017|      0|            return false;
 2018|      0|        }
 2019|   101k|        size_type r = denom_words.size() - 1;
 2020|   101k|        word_type y = denom_words[r];
 2021|       |
 2022|   101k|        x = 0;
 2023|   101k|        while ( (y & l_bit) == 0 )
  ------------------
  |  Branch (2023:17): [True: 0, False: 101k]
  ------------------
 2024|      0|        {
 2025|      0|            y <<= 1;
 2026|      0|            x++;
 2027|      0|        }
 2028|   101k|        denom <<= x;
 2029|   101k|        num <<= x;
 2030|       |
 2031|   101k|        denom_words = denom.get_words();
 2032|   101k|        if ( r > 0 && denom_words[r] < denom_words[r-1] )
  ------------------
  |  Branch (2032:14): [True: 0, False: 101k]
  |  Branch (2032:23): [True: 0, False: 0]
  ------------------
 2033|      0|        {
 2034|      0|            denom *= max_word;
 2035|      0|            num *= max_word;
 2036|      0|            return true;
 2037|      0|        }
 2038|   101k|        return false;
 2039|   101k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEElSEm:
 1172|   203k|    {
 1173|   203k|        auto words = get_words();
 1174|   203k|        size_type q = k / word_bits;
 1175|   203k|        if ( q ) // Increase storage_.size() by q:
  ------------------
  |  Branch (1175:14): [True: 0, False: 203k]
  ------------------
 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|   203k|        if ( k )  // 0 < k < word_bits:
  ------------------
  |  Branch (1183:14): [True: 1, False: 203k]
  ------------------
 1184|      1|        {
 1185|      1|            size_type k1 = word_bits - k;
 1186|      1|            word_type mask = (word_type(1) << k) - word_type(1);
 1187|      1|            resize( words.size() + 1 );
 1188|      1|            words = get_words();
 1189|  2.05k|            for (size_type i = words.size(); i-- > 0; )
  ------------------
  |  Branch (1189:46): [True: 2.04k, False: 1]
  ------------------
 1190|  2.04k|            {
 1191|  2.04k|                words[i] <<= k;
 1192|  2.04k|                if ( i > 0 )
  ------------------
  |  Branch (1192:22): [True: 2.04k, False: 1]
  ------------------
 1193|  2.04k|                    words[i] |= (words[i-1] >> k1) & mask;
 1194|  2.04k|            }
 1195|      1|        }
 1196|   203k|        reduce();
 1197|   203k|        return *this;
 1198|   203k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE10DDquotientEmmm:
 1940|   194M|    {
 1941|   194M|        word_type left, middle, right, qHi, qLo, x, dLo1,
 1942|   194M|                   dHi = d >> word_half_bits, dLo = d & r_mask;
 1943|   194M|        qHi = A/(dHi + 1);
 1944|       |        // This initial guess of qHi may be too small.
 1945|   194M|        middle = qHi * dLo;
 1946|   194M|        left = qHi * dHi;
 1947|   194M|        x = B - (middle << word_half_bits);
 1948|   194M|        A -= (middle >> word_half_bits) + left + (x > B);
 1949|   194M|        B = x;
 1950|   194M|        dLo1 = dLo << word_half_bits;
 1951|       |        // Increase qHi if necessary:
 1952|   277M|        while ( A > dHi || (A == dHi && B >= dLo1) )
  ------------------
  |  Branch (1952:17): [True: 82.7M, False: 194M]
  |  Branch (1952:29): [True: 1, False: 194M]
  |  Branch (1952:41): [True: 0, False: 1]
  ------------------
 1953|  82.7M|        {
 1954|  82.7M|            x = B - dLo1;
 1955|  82.7M|            A -= dHi + (x > B);
 1956|  82.7M|            B = x;
 1957|  82.7M|            qHi++;
 1958|  82.7M|        }
 1959|   194M|        qLo = ((A << word_half_bits) | (B >> word_half_bits))/(dHi + 1);
 1960|       |        // This initial guess of qLo may be too small.
 1961|   194M|        right = qLo * dLo;
 1962|   194M|        middle = qLo * dHi;
 1963|   194M|        x = B - right;
 1964|   194M|        A -= (x > B);
 1965|   194M|        B = x;
 1966|   194M|        x = B - (middle << word_half_bits);
 1967|   194M|            A -= (middle >> word_half_bits) + (x > B);
 1968|   194M|        B = x;
 1969|       |        // Increase qLo if necessary:
 1970|   277M|        while ( A || B >= d )
  ------------------
  |  Branch (1970:17): [True: 4.52k, False: 277M]
  |  Branch (1970:22): [True: 82.7M, False: 194M]
  ------------------
 1971|  82.7M|        {
 1972|  82.7M|            x = B - d;
 1973|  82.7M|            A -= (x > B);
 1974|  82.7M|            B = x;
 1975|  82.7M|            qLo++;
 1976|  82.7M|        }
 1977|   194M|        return (qHi << word_half_bits) + qLo;
 1978|   194M|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11subtractmulEPmS5_mRm:
 1982|   194M|    {
 1983|   194M|        word_type hi, lo, d, carry = 0;
 1984|   194M|        size_type i;
 1985|   388M|        for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1985:22): [True: 194M, False: 194M]
  ------------------
 1986|   194M|        {
 1987|   194M|            DDproduct( b[i], q, hi, lo );
 1988|   194M|            d = a[i];
 1989|   194M|            a[i] -= lo;
 1990|   194M|            if ( a[i] > d )
  ------------------
  |  Branch (1990:18): [True: 52.7M, False: 141M]
  ------------------
 1991|  52.7M|                carry++;
 1992|   194M|            d = a[i + 1];
 1993|   194M|            a[i + 1] -= hi + carry;
 1994|   194M|            carry = a[i + 1] > d;
 1995|   194M|        }
 1996|   194M|        if ( carry ) // q was too large
  ------------------
  |  Branch (1996:14): [True: 0, False: 194M]
  ------------------
 1997|      0|        {
 1998|      0|            q--;
 1999|      0|            carry = 0;
 2000|      0|            for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (2000:26): [True: 0, False: 0]
  ------------------
 2001|      0|            {
 2002|      0|                d = a[i] + carry;
 2003|      0|                carry = d < carry;
 2004|      0|                a[i] = d + b[i];
 2005|      0|                if ( a[i] < d )
  ------------------
  |  Branch (2005:22): [True: 0, False: 0]
  ------------------
 2006|      0|                    carry = 1;
 2007|      0|            }
 2008|      0|            a[n] = 0;
 2009|      0|        }
 2010|   194M|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9DDproductEmmRmS5_:
 1922|   194M|    {
 1923|   194M|        word_type hiA = A >> word_half_bits, loA = A & r_mask,
 1924|   194M|                   hiB = B >> word_half_bits, loB = B & r_mask;
 1925|       |
 1926|   194M|        lo = loA * loB;
 1927|   194M|        hi = hiA * hiB;
 1928|   194M|        word_type mid1 = loA * hiB;
 1929|   194M|        word_type mid2 = hiA * loB;
 1930|   194M|        word_type old = lo;
 1931|   194M|        lo += mid1 << word_half_bits;
 1932|   194M|            hi += (lo < old) + (mid1 >> word_half_bits);
 1933|   194M|        old = lo;
 1934|   194M|        lo += mid2 << word_half_bits;
 1935|   194M|            hi += (lo < old) + (mid2 >> word_half_bits);
 1936|   194M|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4dataEv:
   82|   389M|        {
   83|   389M|            return data_;
   84|   389M|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11unnormalizeERS4_ib:
 2042|   101k|    {
 2043|   101k|        if (secondDone)
  ------------------
  |  Branch (2043:13): [True: 0, False: 101k]
  ------------------
 2044|      0|        {
 2045|      0|            rem /= max_word;
 2046|      0|        }
 2047|   101k|        if ( x > 0 )
  ------------------
  |  Branch (2047:14): [True: 0, False: 101k]
  ------------------
 2048|      0|        {
 2049|      0|            rem >>= x;
 2050|      0|        }
 2051|   101k|        else
 2052|   101k|        {
 2053|   101k|            rem.reduce();
 2054|   101k|        }
 2055|   101k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2Ev:
  620|     42|    basic_bigint() = default;
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEErSEm:
 1201|      6|    {
 1202|      6|        auto words = get_words();
 1203|      6|        size_type q = k / word_bits;
 1204|      6|        if ( q >= words.size())
  ------------------
  |  Branch (1204:14): [True: 0, False: 6]
  ------------------
 1205|      0|        {
 1206|      0|            resize( 0 );
 1207|      0|            return *this;
 1208|      0|        }
 1209|      6|        if (q > 0)
  ------------------
  |  Branch (1209:13): [True: 4, False: 2]
  ------------------
 1210|      4|        {
 1211|      4|            memmove( words.data(), words.data()+q, size_type((words.size() - q)*sizeof(word_type)) );
 1212|      4|            resize( size_type(words.size() - q) );
 1213|      4|            k %= word_bits;
 1214|      4|            if ( k == 0 )
  ------------------
  |  Branch (1214:18): [True: 0, False: 4]
  ------------------
 1215|      0|            {
 1216|      0|                reduce();
 1217|      0|                return *this;
 1218|      0|            }
 1219|      4|        }
 1220|       |
 1221|      6|        words = get_words();
 1222|      6|        size_type n = size_type(words.size() - 1);
 1223|      6|        ssize_type k1 = word_bits - k;
 1224|      6|        word_type mask = (word_type(1) << k) - 1;
 1225|  12.7k|        for (size_type i = 0; i <= n; i++)
  ------------------
  |  Branch (1225:31): [True: 12.7k, False: 6]
  ------------------
 1226|  12.7k|        {
 1227|  12.7k|            words[i] >>= k;
 1228|  12.7k|            if ( i < n )
  ------------------
  |  Branch (1228:18): [True: 12.7k, False: 6]
  ------------------
 1229|  12.7k|                words[i] |= ((words[i+1] & mask) << k1);
 1230|  12.7k|        }
 1231|      6|        reduce();
 1232|      6|        return *this;
 1233|      6|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEED2Ev:
  687|   408k|    {
  688|   408k|        storage_.destroy();
  689|   408k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7destroyEv:
  490|   408k|    {
  491|   408k|        if (is_allocated())
  ------------------
  |  Branch (491:13): [True: 204k, False: 204k]
  ------------------
  492|   204k|        {
  493|   204k|            allocated_.destroy(get_allocator());
  494|   204k|            allocated_.~allocated_storage();
  495|   204k|        }
  496|   204k|        else
  497|   204k|        {
  498|   204k|            inlined_.~inlined_storage();
  499|   204k|        }
  500|   408k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7destroyERKS4_:
  249|   204k|        {
  250|   204k|            if (data_ != nullptr)
  ------------------
  |  Branch (250:17): [True: 204k, False: 0]
  ------------------
  251|   204k|            {
  252|   204k|                real_allocator_type alloc(a);
  253|   204k|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  254|   204k|            }
  255|   204k|        }
_ZN8jsonconsmiENS_12basic_bigintINSt3__19allocatorImEEEERKS4_:
 1587|     34|    {
 1588|     34|        return x -= y;
 1589|     34|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IiEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  672|     94|        : storage_(n, alloc)
  673|     94|    {
  674|     94|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IiEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  363|     94|        : word_allocator_type(alloc)
  364|     94|    {
  365|     94|        ::new (&inlined_) inlined_storage(n);
  366|     94|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IiEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  128|     94|            : is_allocated_(false),
  129|     94|            is_negative_(n < 0),
  130|     94|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (130:19): [True: 47, False: 47]
  ------------------
  131|     94|        {
  132|     94|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (132:26): [True: 34, False: 60]
  ------------------
  133|     94|            values_[1] = 0;
  134|     94|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEaSERKS4_:
  874|   102k|    {
  875|   102k|        storage_ = y.storage_;
  876|   102k|        return *this;
  877|   102k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEaSERKS5_:
  369|   102k|    {
  370|   102k|        if (this != &other)
  ------------------
  |  Branch (370:13): [True: 102k, False: 0]
  ------------------
  371|   102k|        {
  372|   102k|            auto other_words = other.get_words();
  373|   102k|            resize(other_words.size());
  374|   102k|            auto words = get_words();
  375|   102k|            if (other_words.size() > 0)
  ------------------
  |  Branch (375:17): [True: 102k, False: 39]
  ------------------
  376|   102k|            {
  377|   102k|                common_.is_negative_ = other.common_.is_negative_;
  378|   102k|                std::memcpy(words.data(), other_words.data(), size_type(other_words.size()*sizeof(word_type)));
  379|   102k|            }
  380|   102k|        }
  381|   102k|        return *this;
  382|   102k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4dataEv:
   82|   102k|        {
   83|   102k|            return data_;
   84|   102k|        }
_ZN8jsoncons16append_to_bufferIcNSt3__19allocatorIcEEEEvRKNS_12basic_bigintINS2_ImEEEERNS1_12basic_stringIT_NS1_11char_traitsISA_EET0_EE:
 2137|     27|    {
 2138|     27|        if (value.is_zero())
  ------------------
  |  Branch (2138:13): [True: 2, False: 25]
  ------------------
 2139|      2|        {
 2140|      2|            buf.push_back('0');
 2141|      2|            return;
 2142|      2|        }
 2143|     25|        if (value.is_negative())
  ------------------
  |  Branch (2143:13): [True: 1, False: 24]
  ------------------
 2144|      1|        {
 2145|      1|            buf.push_back('-');
 2146|      1|        }
 2147|       |
 2148|     25|        size_type start = buf.size();
 2149|     25|        basic_bigint v(value);
 2150|     25|        auto v_words = v.get_words();
 2151|       |
 2152|     25|        size_type len = (v_words.size() * word_bits / 3) + 2;
 2153|     25|        buf.reserve(start+len);
 2154|       |
 2155|     25|        word_type r;
 2156|     25|        basic_bigint R(value.get_allocator());
 2157|     25|        basic_bigint LP10(max_unsigned_power_10, value.get_allocator());
 2158|       |
 2159|     25|        do
 2160|  65.5k|        {
 2161|  65.5k|            v.divide(LP10, v, R, true);
 2162|  65.5k|            v_words = v.get_words();
 2163|       |
 2164|  65.5k|            auto R_words = R.get_words();
 2165|  65.5k|            r = (R_words.size() ? R_words[0] : 0);
  ------------------
  |  Branch (2165:18): [True: 65.5k, False: 0]
  ------------------
 2166|  1.31M|            for (size_type j = 0; j < imax_unsigned_power_10; j++)
  ------------------
  |  Branch (2166:35): [True: 1.24M, False: 65.5k]
  ------------------
 2167|  1.24M|            {
 2168|  1.24M|                buf.push_back(CharT(r % 10u + '0'));
 2169|  1.24M|                r /= 10u;
 2170|  1.24M|                if (r + v_words.size() == 0)
  ------------------
  |  Branch (2170:21): [True: 25, False: 1.24M]
  ------------------
 2171|     25|                    break;
 2172|  1.24M|            }
 2173|  65.5k|        } while (v_words.size() > 0);
  ------------------
  |  Branch (2173:18): [True: 65.5k, False: 25]
  ------------------
 2174|       |
 2175|     25|        std::reverse(buf.begin()+start, buf.end());
 2176|       |        
 2177|     25|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE18trailing_zero_bitsEv:
 1736|      7|    {
 1737|       |        // Assumes words contains the absolute magnitude,
 1738|       |        // even when BigInt is negative.
 1739|       |
 1740|      7|        auto words = get_words();
 1741|      7|        for (size_t i = 0; i < words.size(); ++i) {
  ------------------
  |  Branch (1741:28): [True: 7, False: 0]
  ------------------
 1742|      7|            const uint64_t w = words[i];
 1743|       |
 1744|      7|            if (w != 0) {
  ------------------
  |  Branch (1744:17): [True: 7, False: 0]
  ------------------
 1745|      7|                return static_cast<u128>(i) * 64
 1746|      7|                     + jsoncons::countr_zero(w);
 1747|      7|            }
 1748|      7|        }
 1749|       |
 1750|       |        // Zero has no finite number of trailing zero bits.
 1751|      0|        return (jsoncons::nonstd::integer_limits<u128>::max)();
 1752|      7|    }
_ZN8jsoncons4powbINSt3__19allocatorImEEEENS_12basic_bigintIT_EES6_m:
 2261|      5|{
 2262|      5|    basic_bigint<Allocator> result{1};
 2263|       |
 2264|     34|    while ( n )
  ------------------
  |  Branch (2264:13): [True: 29, False: 5]
  ------------------
 2265|     29|    {
 2266|     29|        if ( n & 1 )
  ------------------
  |  Branch (2266:14): [True: 9, False: 20]
  ------------------
 2267|      9|        {
 2268|      9|            result *= base;
 2269|      9|        }
 2270|     29|        n >>= 1;
 2271|       |
 2272|     29|        if (n)
  ------------------
  |  Branch (2272:13): [True: 24, False: 5]
  ------------------
 2273|     24|        {
 2274|     24|            base *= base;
 2275|     24|        }
 2276|     29|    }
 2277|       |
 2278|      5|    return result;
 2279|      5|}
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLES4_:
 1078|     38|    {
 1079|     38|        auto words = get_words();
 1080|     38|        auto y_words = y.get_words();
 1081|       |
 1082|     38|        if (words.size() == 0 || y_words.size() == 0)
  ------------------
  |  Branch (1082:13): [True: 0, False: 38]
  |  Branch (1082:34): [True: 0, False: 38]
  ------------------
 1083|      0|        {
 1084|      0|            return *this = 0;
 1085|      0|        }
 1086|       |
 1087|     38|        bool difSigns = is_negative() != y.is_negative();
 1088|     38|        const size_type y_size = y_words.size();
 1089|     38|        if ( words.size() + y_size == 2 ) // size() = y.size() = 1
  ------------------
  |  Branch (1089:14): [True: 29, False: 9]
  ------------------
 1090|     29|        {
 1091|     29|            word_type a = words[0], b = y_words[0];
 1092|     29|            words[0] = a * b;
 1093|     29|            if ( words[0] / a != b )
  ------------------
  |  Branch (1093:18): [True: 4, False: 25]
  ------------------
 1094|      4|            {
 1095|      4|                resize(2);
 1096|      4|                words = get_words();
 1097|      4|                DDproduct( a, b, words[1], words[0] );
 1098|      4|            }
 1099|     29|            set_negative(difSigns);
 1100|     29|            return *this;
 1101|     29|        }
 1102|       |
 1103|      9|        if ( words.size() == 1 )  //  && y.size() > 1
  ------------------
  |  Branch (1103:14): [True: 4, False: 5]
  ------------------
 1104|      4|        {
 1105|      4|            word_type digit = words[0];
 1106|      4|            *this = y;
 1107|      4|            *this *= digit;
 1108|      4|        }
 1109|      5|        else
 1110|      5|        {
 1111|      5|            if (y_words.size() == 1)
  ------------------
  |  Branch (1111:17): [True: 1, False: 4]
  ------------------
 1112|      1|            {
 1113|      1|                *this *= y_words[0];
 1114|      1|            }
 1115|      4|            else
 1116|      4|            {
 1117|      4|                size_type lenProd = words.size() + y_words.size();
 1118|      4|                word_type sumHi = 0, sumLo, hi, lo,
 1119|      4|                sumLo_old, sumHi_old, carry=0;
 1120|      4|                basic_bigint<Allocator> x = *this;
 1121|      4|                auto x_words = x.get_words();
 1122|      4|                resize( lenProd ); // Give *this length lenProd
 1123|      4|                words = get_words();
 1124|       |
 1125|  9.64k|                for (size_type i = 0; i < lenProd; i++ )
  ------------------
  |  Branch (1125:39): [True: 9.63k, False: 4]
  ------------------
 1126|  9.63k|                {
 1127|  9.63k|                    sumLo = sumHi;
 1128|  9.63k|                    sumHi = carry;
 1129|  9.63k|                    carry = 0;
 1130|  30.4M|                    for (size_type jA=0; jA < x_words.size(); jA++)
  ------------------
  |  Branch (1130:42): [True: 30.4M, False: 9.63k]
  ------------------
 1131|  30.4M|                    {
 1132|  30.4M|                        if (JSONCONS_LIKELY(i >= jA))
  ------------------
  |  |   78|  30.4M|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 15.2M, False: 15.2M]
  |  |  ------------------
  ------------------
 1133|  15.2M|                        {
 1134|  15.2M|                            size_type jB = i - jA;
 1135|  15.2M|                            if (jB < y_words.size())
  ------------------
  |  Branch (1135:33): [True: 19.2k, False: 15.2M]
  ------------------
 1136|  19.2k|                            {
 1137|  19.2k|                                DDproduct( x_words[jA], y_words[jB], hi, lo );
 1138|  19.2k|                                sumLo_old = sumLo;
 1139|  19.2k|                                sumHi_old = sumHi;
 1140|  19.2k|                                sumLo += lo;
 1141|  19.2k|                                if ( sumLo < sumLo_old )
  ------------------
  |  Branch (1141:38): [True: 9.36k, False: 9.89k]
  ------------------
 1142|  9.36k|                                    sumHi++;
 1143|  19.2k|                                sumHi += hi;
 1144|  19.2k|                                carry += (sumHi < sumHi_old);
 1145|  19.2k|                            }
 1146|  15.2M|                        }
 1147|  30.4M|                    }
 1148|  9.63k|                    words[i] = sumLo;
 1149|  9.63k|                }
 1150|      4|            }
 1151|      5|        }
 1152|      9|       reduce();
 1153|      9|       set_negative(difSigns);
 1154|      9|       return *this;
 1155|     38|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE10bit_lengthEv:
 2230|      6|    {
 2231|       |        // Assumes words stores the absolute magnitude,
 2232|       |        // even when BigInt is negative.
 2233|       |
 2234|      6|        auto words = get_words();
 2235|       |
 2236|      6|        for (size_t i = words.size(); i-- > 0;) {
  ------------------
  |  Branch (2236:39): [True: 6, False: 0]
  ------------------
 2237|      6|            const uint64_t w = words[i];
 2238|       |
 2239|      6|            if (w != 0) {
  ------------------
  |  Branch (2239:17): [True: 6, False: 0]
  ------------------
 2240|      6|                return static_cast<uint64_t>(i) * 64
 2241|      6|                     + 64 - jsoncons::countl_zero(w);
 2242|      6|            }
 2243|      6|        }
 2244|       |
 2245|      0|        return 0;
 2246|      6|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE8test_bitEm:
 2184|      8|    {
 2185|      8|        auto words = get_words();
 2186|       |
 2187|      8|        const uint64_t wordIndex = bitIndex / 64;
 2188|      8|        const unsigned bit = static_cast<unsigned>(bitIndex % 64);
 2189|       |
 2190|      8|        if (wordIndex >= words.size())
  ------------------
  |  Branch (2190:13): [True: 0, False: 8]
  ------------------
 2191|      0|            return false;
 2192|       |
 2193|      8|        return ((words[static_cast<size_t>(wordIndex)] >> bit) & 1ULL) != 0;
 2194|      8|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE12any_low_bitsEm:
 2197|      4|    {
 2198|      4|        auto words = get_words();
 2199|       |
 2200|       |        // Check whether any of bits [0, count) are set.
 2201|      4|        if (words.size() == 0)
  ------------------
  |  Branch (2201:13): [True: 0, False: 4]
  ------------------
 2202|      0|            return false;
 2203|       |
 2204|      4|        const uint64_t wholeWords = count / 64;
 2205|      4|        const unsigned remainingBits = static_cast<unsigned>(count % 64);
 2206|       |
 2207|       |        // Check complete 64-bit limbs.
 2208|      4|        const size_t limit =
 2209|      4|            wholeWords >= words.size()
  ------------------
  |  Branch (2209:13): [True: 0, False: 4]
  ------------------
 2210|      4|                ? words.size()
 2211|      4|                : static_cast<size_t>(wholeWords);
 2212|       |
 2213|      4|        for (size_t i = 0; i < limit; ++i) {
  ------------------
  |  Branch (2213:28): [True: 4, False: 0]
  ------------------
 2214|      4|            if (words[i] != 0)
  ------------------
  |  Branch (2214:17): [True: 4, False: 0]
  ------------------
 2215|      4|                return true;
 2216|      4|        }
 2217|       |
 2218|       |        // Check remaining low bits of the next limb.
 2219|      0|        if (remainingBits != 0 && wholeWords < words.size()) {
  ------------------
  |  Branch (2219:13): [True: 0, False: 0]
  |  Branch (2219:35): [True: 0, False: 0]
  ------------------
 2220|      0|            const uint64_t mask = (1ULL << remainingBits) - 1;
 2221|       |
 2222|      0|            if ((words[static_cast<size_t>(wholeWords)] & mask) != 0)
  ------------------
  |  Branch (2222:17): [True: 0, False: 0]
  ------------------
 2223|      0|                return true;
 2224|      0|        }
 2225|       |
 2226|      0|        return false;
 2227|      0|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2EOS4_:
  660|      8|        : storage_(std::move(other.storage_))
  661|      8|    {
  662|      8|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2EOS5_:
  335|      8|        : word_allocator_type(other.get_allocator())
  336|      8|    {
  337|      8|        if (!other.is_allocated())
  ------------------
  |  Branch (337:13): [True: 0, False: 8]
  ------------------
  338|      0|        {
  339|      0|            ::new (&inlined_) inlined_storage(other.inlined_);
  340|      0|        }
  341|      8|        else
  342|      8|        {
  343|      8|            ::new (&allocated_) allocated_storage(std::move(other.allocated_));
  344|      8|        }
  345|      8|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2EOS6_:
  235|      8|            : is_allocated_(stor.is_allocated_),
  236|      8|            is_negative_(stor.is_negative_),
  237|      8|            size_(stor.size_),
  238|      8|            capacity_(stor.capacity_),
  239|      8|            data_(stor.data_)
  240|      8|        {
  241|      8|            stor.is_allocated_ = false;
  242|      8|            stor.is_negative_ = false;
  243|      8|            stor.size_ = 0;
  244|      8|            stor.capacity_ = 0;
  245|      8|            stor.data_ = nullptr;
  246|      8|        }

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

_ZN8jsoncons6detail23bytes_to_base64_genericIPKhNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS4_9enable_ifIXsr3std7is_sameINS4_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESD_SD_PKcRT0_:
   44|      4|    {
   45|      4|        std::size_t count = 0;
   46|      4|        unsigned char a3[3];
   47|      4|        unsigned char a4[4];
   48|      4|        unsigned char fill = alphabet[64];
   49|      4|        int i = 0;
   50|      4|        int j = 0;
   51|       |
   52|     41|        while (first != last)
  ------------------
  |  Branch (52:16): [True: 37, False: 4]
  ------------------
   53|     37|        {
   54|     37|            a3[i++] = *first++;
   55|     37|            if (i == 3)
  ------------------
  |  Branch (55:17): [True: 11, False: 26]
  ------------------
   56|     11|            {
   57|     11|                a4[0] = (a3[0] & 0xfc) >> 2;
   58|     11|                a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   59|     11|                a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   60|     11|                a4[3] = a3[2] & 0x3f;
   61|       |
   62|     55|                for (i = 0; i < 4; i++) 
  ------------------
  |  Branch (62:29): [True: 44, False: 11]
  ------------------
   63|     44|                {
   64|     44|                    result.push_back(alphabet[a4[i]]);
   65|     44|                    ++count;
   66|     44|                }
   67|     11|                i = 0;
   68|     11|            }
   69|     37|        }
   70|       |
   71|      4|        if (i > 0)
  ------------------
  |  Branch (71:13): [True: 3, False: 1]
  ------------------
   72|      3|        {
   73|      8|            for (j = i; j < 3; ++j) 
  ------------------
  |  Branch (73:25): [True: 5, False: 3]
  ------------------
   74|      5|            {
   75|      5|                a3[j] = 0;
   76|      5|            }
   77|       |
   78|      3|            a4[0] = (a3[0] & 0xfc) >> 2;
   79|      3|            a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   80|      3|            a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   81|       |
   82|     10|            for (j = 0; j < i + 1; ++j) 
  ------------------
  |  Branch (82:25): [True: 7, False: 3]
  ------------------
   83|      7|            {
   84|      7|                result.push_back(alphabet[a4[j]]);
   85|      7|                ++count;
   86|      7|            }
   87|       |
   88|      3|            if (fill != 0)
  ------------------
  |  Branch (88:17): [True: 0, False: 3]
  ------------------
   89|      0|            {
   90|      0|                while (i++ < 3) 
  ------------------
  |  Branch (90:24): [True: 0, False: 0]
  ------------------
   91|      0|                {
   92|      0|                    result.push_back(fill);
   93|      0|                    ++count;
   94|      0|                }
   95|      0|            }
   96|      3|        }
   97|       |
   98|      4|        return count;
   99|      4|    }
_ZN8jsoncons18bytes_to_base64urlIPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  177|      4|    {
  178|      4|        static constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  179|      4|                                                      "abcdefghijklmnopqrstuvwxyz"
  180|      4|                                                      "0123456789-_"
  181|      4|                                                      "\0";
  182|      4|        return detail::bytes_to_base64_generic(first, last, alphabet, result);
  183|      4|    }
_ZNK8jsoncons16byte_string_view4dataEv:
  399|     20|        {
  400|     20|            return data_;
  401|     20|        }
_ZNK8jsoncons16byte_string_view4sizeEv:
  403|     20|        {
  404|     20|            return size_;
  405|     20|        }
_ZN8jsoncons16byte_string_viewC2EPKhm:
  362|     20|            : data_(data), size_(length)
  363|     20|        {
  364|     20|        }
_ZN8jsoncons16byte_string_viewC2Ev:
  358|    122|        {
  359|    122|        }

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

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

_ZN8jsoncons12from_integerImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr6nonstd10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|      3|{
   43|      3|    using char_type = typename Result::value_type;
   44|       |
   45|      3|    char_type buf[255];
   46|      3|    char_type *p = buf;
   47|      3|    const char_type* last = buf+255;
   48|       |
   49|      3|    bool is_negative = value < 0;
   50|       |
   51|      3|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 3]
  ------------------
   52|      0|    {
   53|      0|        do
   54|      0|        {
   55|      0|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|      0|        }
   57|      0|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 0, False: 0]
  |  Branch (57:33): [True: 0, False: 0]
  ------------------
   58|      0|    }
   59|      3|    else
   60|      3|    {
   61|       |
   62|      3|        do
   63|     21|        {
   64|     21|            *p++ = static_cast<char_type>(48 + value % 10);
   65|     21|        }
   66|     21|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 18, False: 3]
  |  Branch (66:33): [True: 18, False: 0]
  ------------------
   67|      3|    }
   68|      3|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   54|      3|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 3]
  |  |  ------------------
  |  |   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|      3|    std::size_t count = (p - buf);
   71|      3|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 3]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|     24|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 21, False: 3]
  ------------------
   77|     21|    {
   78|     21|        result.push_back(*p);
   79|     21|    }
   80|       |
   81|      3|    return count;
   82|      3|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr6nonstd10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|      3|{
   43|      3|    using char_type = typename Result::value_type;
   44|       |
   45|      3|    char_type buf[255];
   46|      3|    char_type *p = buf;
   47|      3|    const char_type* last = buf+255;
   48|       |
   49|      3|    bool is_negative = value < 0;
   50|       |
   51|      3|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 3, False: 0]
  ------------------
   52|      3|    {
   53|      3|        do
   54|      5|        {
   55|      5|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|      5|        }
   57|      5|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 2, False: 3]
  |  Branch (57:33): [True: 2, False: 0]
  ------------------
   58|      3|    }
   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|      3|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   54|      3|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 3]
  |  |  ------------------
  |  |   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|      3|    std::size_t count = (p - buf);
   71|      3|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 3, False: 0]
  ------------------
   72|      3|    {
   73|      3|        result.push_back('-');
   74|      3|        ++count;
   75|      3|    }
   76|      8|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 5, False: 3]
  ------------------
   77|      5|    {
   78|      5|        result.push_back(*p);
   79|      5|    }
   80|       |
   81|      3|    return count;
   82|      3|}
_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|      2|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|      2|    {
  489|      2|#if !defined(JSONCONS_NO_LOCALECONV)
  490|      2|        struct lconv *lc = localeconv();
  491|      2|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 2, False: 0]
  |  Branch (491:30): [True: 2, False: 0]
  ------------------
  492|      2|        {
  493|      2|            decimal_point_ = lc->decimal_point[0];
  494|      2|        }
  495|      2|#endif
  496|      2|    }
_ZN8jsoncons12write_doubleclINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEmdRT_:
  503|      2|    {
  504|      2|        std::size_t count = 0;
  505|       |
  506|      2|        char number_buffer[200];
  507|      2|        int length = 0;
  508|       |
  509|      2|        switch (float_format_)
  510|      2|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 2]
  ------------------
  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: 2]
  ------------------
  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|      2|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 2, False: 0]
  ------------------
  552|      2|            {
  553|      2|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 2]
  ------------------
  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|      2|                else
  563|      2|                {
  564|      2|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 2]
  ------------------
  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|      2|                }             
  569|      2|                break;
  570|      2|            }
  571|      2|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 2]
  ------------------
  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|      2|        }
  575|      2|        return count;
  576|      2|    }
_ZN8jsoncons15prettify_stringINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKciiiiRT_:
  171|      2|{
  172|      2|    int nb_digits = length;
  173|      2|    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|      2|    int kk = nb_digits + k;
  179|       |
  180|      2|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 1, False: 1]
  |  Branch (180:28): [True: 0, False: 1]
  ------------------
  181|      0|    {
  182|       |        /* the first digits are already in. Add some 0s and call it a day. */
  183|       |        /* the max_exp is a personal choice. Only 16 digits could possibly be relevant.
  184|       |         * Basically we want to print 12340000000 rather than 1234.0e7 or 1.234e10 */
  185|      0|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 0, False: 0]
  ------------------
  186|      0|        {
  187|      0|            result.push_back(buffer[i]);
  188|      0|        }
  189|      0|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 0, False: 0]
  ------------------
  190|      0|        {
  191|      0|            result.push_back('0');
  192|      0|        }
  193|      0|        result.push_back('.');
  194|      0|        result.push_back('0');
  195|      0|    } 
  196|      2|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 1, False: 1]
  |  Branch (196:24): [True: 0, False: 1]
  ------------------
  197|      0|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|      0|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 0, False: 0]
  ------------------
  200|      0|        {
  201|      0|            result.push_back(buffer[i]);
  202|      0|        }
  203|      0|        result.push_back('.');
  204|      0|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 0, False: 0]
  ------------------
  205|      0|        {
  206|      0|            result.push_back(buffer[i]);
  207|      0|        }
  208|      0|    } 
  209|      2|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 2, False: 0]
  |  Branch (209:30): [True: 1, False: 1]
  ------------------
  210|      1|    {
  211|      1|        offset = 2 - kk;
  212|       |
  213|      1|        result.push_back('0');
  214|      1|        result.push_back('.');
  215|      3|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 2, False: 1]
  ------------------
  216|      2|            result.push_back('0');
  217|     18|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 17, False: 1]
  ------------------
  218|     17|        {
  219|     17|            result.push_back(buffer[i]);
  220|     17|        }
  221|      1|    } 
  222|      1|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 0, False: 1]
  ------------------
  223|      0|    {
  224|      0|        result.push_back(buffer[0]);
  225|      0|        result.push_back('e');
  226|      0|        fill_exponent(kk - 1, result);
  227|      0|    } 
  228|      1|    else
  229|      1|    {
  230|      1|        result.push_back(buffer[0]);
  231|      1|        result.push_back('.');
  232|     15|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 14, False: 1]
  ------------------
  233|     14|        {
  234|     14|            result.push_back(buffer[i]);
  235|     14|        }
  236|      1|        result.push_back('e');
  237|      1|        fill_exponent(kk - 1, result);
  238|      1|    }
  239|      2|}
_ZN8jsoncons13fill_exponentINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEviRT_:
  136|      1|{
  137|      1|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 0, False: 1]
  ------------------
  138|      0|    {
  139|      0|        result.push_back('-');
  140|      0|        K = -K;
  141|      0|    }
  142|      1|    else
  143|      1|    {
  144|      1|        result.push_back('+'); // compatibility with sprintf
  145|      1|    }
  146|       |
  147|      1|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 0, False: 1]
  ------------------
  148|      0|    {
  149|      0|        result.push_back('0'); // compatibility with sprintf
  150|      0|        result.push_back((char)('0' + K));
  151|      0|    }
  152|      1|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 0, False: 1]
  ------------------
  153|      0|    {
  154|      0|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|      0|        result.push_back((char)('0' + K));
  156|      0|    }
  157|      1|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 1, False: 0]
  ------------------
  158|      1|    {
  159|      1|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|      1|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|      1|        result.push_back((char)('0' + K));
  162|      1|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|      1|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_:
  475|      2|{
  476|      2|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|      2|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_NS1_17integral_constantIbLb1EEE:
  366|      2|{
  367|      2|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 0, False: 2]
  ------------------
  368|      0|    {
  369|      0|        result.push_back('0');
  370|      0|        result.push_back('.');
  371|      0|        result.push_back('0');
  372|      0|        return true;
  373|      0|    }
  374|       |
  375|      2|    int length = 0;
  376|      2|    int k;
  377|       |
  378|      2|    char buffer[100];
  379|       |
  380|      2|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 0, False: 2]
  ------------------
  381|      2|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 2, False: 0]
  ------------------
  382|      2|    {
  383|      2|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 0, False: 2]
  ------------------
  384|      0|        {
  385|      0|            result.push_back('-');
  386|      0|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|      2|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|      2|        return true;
  391|      2|    }
  392|      0|    else
  393|      0|    {
  394|      0|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|      0|    }
  396|      2|}

_ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr6nonstd8is_char8IT_EE5valueENS0_14unicode_resultIS4_EEE4typeEPKS4_m:
 1147|  1.96M|    {
 1148|  1.96M|        const uint8_t* it = reinterpret_cast<const uint8_t*>(data);
 1149|  1.96M|        const uint8_t* end = it + length;
 1150|       |
 1151|  1.96M|        unicode_errc  result{};
 1152|  5.08M|        while (it != end) 
  ------------------
  |  Branch (1152:16): [True: 3.12M, False: 1.96M]
  ------------------
 1153|  3.12M|        {
 1154|  3.12M|            if ((end - it) >= 8)
  ------------------
  |  Branch (1154:17): [True: 758k, False: 2.36M]
  ------------------
 1155|   758k|            {
 1156|  4.68M|                JSONCONS_REPEAT8({if (JSONCONS_LIKELY((*it & 0x80) == 0)) ++it; else goto non_ascii;})
  ------------------
  |  |  326|  1.51M|#define JSONCONS_REPEAT8(x)  { x x x x x x x x }
  |  |  ------------------
  |  |  |  Branch (326:32): [True: 749k, False: 8.99k]
  |  |  |  Branch (326:34): [True: 713k, False: 35.7k]
  |  |  |  Branch (326:36): [True: 672k, False: 41.4k]
  |  |  |  Branch (326:38): [True: 660k, False: 11.7k]
  |  |  |  Branch (326:40): [True: 639k, False: 20.8k]
  |  |  |  Branch (326:42): [True: 631k, False: 7.95k]
  |  |  |  Branch (326:44): [True: 619k, False: 12.4k]
  |  |  |  Branch (326:46): [True: 596k, False: 22.9k]
  |  |  ------------------
  ------------------
 1157|   596k|                continue;
 1158|  4.68M|            }
 1159|  2.53M|    non_ascii:
 1160|  2.53M|            const std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[*it]) + 1;
 1161|  2.53M|            if (len > (std::size_t)(end - it))
  ------------------
  |  Branch (1161:17): [True: 1, False: 2.53M]
  ------------------
 1162|      1|            {
 1163|      1|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), unicode_errc::source_exhausted};
 1164|      1|            }
 1165|  2.53M|            if ((result=is_legal_utf8(it, len)) != unicode_errc())
  ------------------
  |  Branch (1165:17): [True: 7, False: 2.53M]
  ------------------
 1166|      7|            {
 1167|      7|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1168|      7|            }
 1169|  2.53M|            it += len;
 1170|  2.53M|        }
 1171|  1.96M|        return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1172|  1.96M|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8EPKhm:
  305|  2.53M|    {
  306|  2.53M|        const uint8_t* it = reinterpret_cast<const uint8_t*>(bytes);
  307|  2.53M|        const uint8_t* end = it+length;
  308|       |
  309|  2.53M|        uint8_t byte;
  310|  2.53M|        switch (length) {
  311|      1|        default:
  ------------------
  |  Branch (311:9): [True: 1, False: 2.53M]
  ------------------
  312|      1|            return unicode_errc::over_long_utf8_sequence;
  313|      0|        case 4:
  ------------------
  |  Branch (313:9): [True: 0, False: 2.53M]
  ------------------
  314|      0|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 0, False: 0]
  ------------------
  315|      0|                return unicode_errc::bad_continuation_byte;
  316|      0|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  565|      0|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  317|      0|        case 3:
  ------------------
  |  Branch (317:9): [True: 0, False: 2.53M]
  ------------------
  318|      0|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (318:17): [True: 0, False: 0]
  ------------------
  319|      0|                return unicode_errc::bad_continuation_byte;
  320|      0|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  565|      0|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  321|   162k|        case 2:
  ------------------
  |  Branch (321:9): [True: 162k, False: 2.36M]
  ------------------
  322|   162k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (322:17): [True: 5, False: 162k]
  ------------------
  323|      5|                return unicode_errc::bad_continuation_byte;
  324|       |
  325|   162k|            switch (*it) 
  326|   162k|            {
  327|       |                // no fall-through in this inner switch
  328|      0|                case 0xE0: if (byte < 0xA0) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (328:17): [True: 0, False: 162k]
  |  Branch (328:32): [True: 0, False: 0]
  ------------------
  329|      0|                case 0xED: if (byte > 0x9F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (329:17): [True: 0, False: 162k]
  |  Branch (329:32): [True: 0, False: 0]
  ------------------
  330|      0|                case 0xF0: if (byte < 0x90) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (330:17): [True: 0, False: 162k]
  |  Branch (330:32): [True: 0, False: 0]
  ------------------
  331|      0|                case 0xF4: if (byte > 0x8F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (331:17): [True: 0, False: 162k]
  |  Branch (331:32): [True: 0, False: 0]
  ------------------
  332|   162k|                default:   if (byte < 0x80) return unicode_errc::source_illegal;
  ------------------
  |  Branch (332:17): [True: 162k, False: 0]
  |  Branch (332:32): [True: 0, False: 162k]
  ------------------
  333|   162k|            }
  334|       |
  335|   162k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  565|   162k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  336|  2.53M|        case 1:
  ------------------
  |  Branch (336:9): [True: 2.36M, False: 162k]
  ------------------
  337|  2.53M|            if (*it >= 0x80 && *it < 0xC2)
  ------------------
  |  Branch (337:17): [True: 162k, False: 2.36M]
  |  Branch (337:32): [True: 1, False: 162k]
  ------------------
  338|      1|                return unicode_errc::source_illegal;
  339|  2.53M|            break;
  340|  2.53M|        }
  341|  2.53M|        if (*it > 0xF4) 
  ------------------
  |  Branch (341:13): [True: 0, False: 2.53M]
  ------------------
  342|      0|            return unicode_errc::source_illegal;
  343|       |
  344|  2.53M|        return unicode_errc();
  345|  2.53M|    }

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

_ZN8jsoncons4cbor15make_error_codeENS0_9cbor_errcE:
  111|    259|{
  112|    259|    return std::error_code(static_cast<int>(e),cbor_error_category());
  113|    259|}
_ZN8jsoncons4cbor19cbor_error_categoryEv:
  104|    259|{
  105|    259|  static cbor_error_category_impl instance;
  106|    259|  return instance;
  107|    259|}

_ZN8jsoncons4cbor19cbor_decode_optionsC1Ev:
   43|    348|    cbor_decode_options() = default;
_ZN8jsoncons4cbor19cbor_options_commonC2Ev:
   25|    348|    cbor_options_common() = default;
_ZN8jsoncons4cbor19cbor_options_commonD2Ev:
   27|    348|    virtual ~cbor_options_common() = default;
_ZNK8jsoncons4cbor19cbor_options_common17max_nesting_depthEv:
   33|    348|    {
   34|    348|        return max_nesting_depth_;
   35|    348|    }
_ZNK8jsoncons4cbor19cbor_decode_options18bigfloat_precisionEv:
   49|    348|    {
   50|    348|        return bigfloat_precision_;
   51|    348|    }

_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEED2Ev:
  354|    348|    ~basic_cbor_parser() = default;
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11cursor_modeEb:
  415|    348|    {
  416|    348|        cursor_mode_ = value;
  417|    348|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE7restartEv:
  357|    415|    {
  358|    415|        more_ = !done_;
  359|    415|    }
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE7stoppedEv:
  440|    571|    {
  441|    571|        return !more_;
  442|    571|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  465|    415|    {
  466|    571|        while (!done_ && more_)
  ------------------
  |  Branch (466:16): [True: 504, False: 67]
  |  Branch (466:26): [True: 415, False: 89]
  ------------------
  467|    415|        {
  468|    415|            switch (state_stack_.back().mode)
  ------------------
  |  Branch (468:21): [True: 415, False: 0]
  ------------------
  469|    415|            {
  470|      0|                case parse_mode::multi_dim:
  ------------------
  |  Branch (470:17): [True: 0, False: 415]
  ------------------
  471|      0|                {
  472|      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 ))); }
  ------------------
  473|      0|                    typed_array_stack_.pop_back();
  474|      0|                    state_stack_.pop_back();
  475|      0|                    break;
  476|      0|                }
  477|      0|                case parse_mode::typed_array:
  ------------------
  |  Branch (477:17): [True: 0, False: 415]
  ------------------
  478|      0|                {
  479|      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 ))); }
  ------------------
  480|      0|                    read_typed_array_item(visitor, ec);
  481|      0|                    auto iter = typed_array_stack_.back();
  482|      0|                    if (iter->done())
  ------------------
  |  Branch (482:25): [True: 0, False: 0]
  ------------------
  483|      0|                    {
  484|      0|                        if (level() == mark_level_)
  ------------------
  |  Branch (484:29): [True: 0, False: 0]
  ------------------
  485|      0|                        {
  486|      0|                            more_ = false;
  487|      0|                        }
  488|      0|                        if (!is_multi_dim())
  ------------------
  |  Branch (488:29): [True: 0, False: 0]
  ------------------
  489|      0|                        {
  490|      0|                            typed_array_stack_.pop_back();
  491|      0|                        }
  492|      0|                        state_stack_.pop_back();
  493|      0|                    }
  494|      0|                    break;
  495|      0|                }
  496|      0|                case parse_mode::array:
  ------------------
  |  Branch (496:17): [True: 0, False: 415]
  ------------------
  497|      0|                {
  498|      0|                    if (is_multi_dim())
  ------------------
  |  Branch (498:25): [True: 0, False: 0]
  ------------------
  499|      0|                    {
  500|      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 ))); }
  ------------------
  501|      0|                        auto iter = typed_array_stack_.back();
  502|      0|                        if (!iter->done())
  ------------------
  |  Branch (502:29): [True: 0, False: 0]
  ------------------
  503|      0|                        {
  504|      0|                            iter->next(visitor, *this, 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|                            if (iter->count() != state_stack_.back().length)
  ------------------
  |  Branch (512:33): [True: 0, False: 0]
  ------------------
  513|      0|                            {
  514|       |                                //std::cout << state_stack_.back().index << "!=" << state_stack_.back().length << "\n";
  515|      0|                                ec = cbor_errc::bad_mdarray;
  516|      0|                                return;
  517|      0|                            }
  518|      0|                            end_classical_array_storage(ec);
  519|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  520|      0|                            {
  521|      0|                                return;
  522|      0|                            }
  523|      0|                        }
  524|      0|                    }
  525|      0|                    else
  526|      0|                    {
  527|      0|                        if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (527:29): [True: 0, False: 0]
  ------------------
  528|      0|                        {
  529|      0|                            ++state_stack_.back().index;
  530|      0|                            read_item(visitor, ec);
  531|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  532|      0|                            {
  533|      0|                                return;
  534|      0|                            }
  535|      0|                        }
  536|      0|                        else
  537|      0|                        {
  538|      0|                            end_array(visitor, ec);
  539|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  540|      0|                            {
  541|      0|                                return;
  542|      0|                            }
  543|      0|                        }
  544|      0|                    }
  545|      0|                    break;
  546|      0|                }
  547|      0|                case parse_mode::indefinite_array:
  ------------------
  |  Branch (547:17): [True: 0, False: 415]
  ------------------
  548|      0|                {
  549|      0|                    if (is_multi_dim()) 
  ------------------
  |  Branch (549:25): [True: 0, False: 0]
  ------------------
  550|      0|                    {
  551|      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 ))); }
  ------------------
  552|      0|                        auto iter = typed_array_stack_.back();
  553|      0|                        if (!iter->done())
  ------------------
  |  Branch (553:29): [True: 0, False: 0]
  ------------------
  554|      0|                        {
  555|      0|                            iter->next(visitor, *this, ec);
  556|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  557|      0|                            {
  558|      0|                                return;
  559|      0|                            }
  560|      0|                        }
  561|      0|                        else
  562|      0|                        {
  563|      0|                            auto c = source_.peek();
  564|      0|                            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  565|      0|                            {
  566|      0|                                ec = cbor_errc::unexpected_eof;
  567|      0|                                more_ = false;
  568|      0|                                return;
  569|      0|                            }
  570|      0|                            if (c.value == 0xff)
  ------------------
  |  Branch (570:33): [True: 0, False: 0]
  ------------------
  571|      0|                            {
  572|      0|                                source_.ignore(1);
  573|      0|                            }
  574|      0|                            else
  575|      0|                            {
  576|      0|                                ec = cbor_errc::bad_mdarray;
  577|      0|                                return;
  578|      0|                            }
  579|      0|                            end_classical_array_storage(ec);
  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|                        }
  585|      0|                    }
  586|      0|                    else
  587|      0|                    {
  588|      0|                        auto c = source_.peek();
  589|      0|                        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  590|      0|                        {
  591|      0|                            ec = cbor_errc::unexpected_eof;
  592|      0|                            more_ = false;
  593|      0|                            return;
  594|      0|                        }
  595|      0|                        if (c.value == 0xff)
  ------------------
  |  Branch (595:29): [True: 0, False: 0]
  ------------------
  596|      0|                        {
  597|      0|                            source_.ignore(1);
  598|      0|                            end_array(visitor, ec);
  599|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  600|      0|                            {
  601|      0|                                return;
  602|      0|                            }
  603|      0|                        }
  604|      0|                        else
  605|      0|                        {
  606|      0|                            read_item(visitor, ec);
  607|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  608|      0|                            {
  609|      0|                                return;
  610|      0|                            }
  611|      0|                        }
  612|      0|                    }
  613|      0|                    break;
  614|      0|                }
  615|      0|                case parse_mode::map_key:
  ------------------
  |  Branch (615:17): [True: 0, False: 415]
  ------------------
  616|      0|                {
  617|      0|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (617:25): [True: 0, False: 0]
  ------------------
  618|      0|                    {
  619|      0|                        ++state_stack_.back().index;
  620|      0|                        state_stack_.back().mode = parse_mode::map_value;
  621|      0|                        read_item(visitor, ec);
  622|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  623|      0|                        {
  624|      0|                            return;
  625|      0|                        }
  626|      0|                    }
  627|      0|                    else
  628|      0|                    {
  629|      0|                        end_object(visitor, ec);
  630|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  631|      0|                        {
  632|      0|                            return;
  633|      0|                        }
  634|      0|                    }
  635|      0|                    break;
  636|      0|                }
  637|      0|                case parse_mode::map_value:
  ------------------
  |  Branch (637:17): [True: 0, False: 415]
  ------------------
  638|      0|                {
  639|      0|                    state_stack_.back().mode = parse_mode::map_key;
  640|      0|                    read_item(visitor, ec);
  641|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  642|      0|                    {
  643|      0|                        return;
  644|      0|                    }
  645|      0|                    break;
  646|      0|                }
  647|      0|                case parse_mode::indefinite_map_key:
  ------------------
  |  Branch (647:17): [True: 0, False: 415]
  ------------------
  648|      0|                {
  649|      0|                    auto c = source_.peek();
  650|      0|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  651|      0|                    {
  652|      0|                        ec = cbor_errc::unexpected_eof;
  653|      0|                        more_ = false;
  654|      0|                        return;
  655|      0|                    }
  656|      0|                    if (c.value == 0xff)
  ------------------
  |  Branch (656:25): [True: 0, False: 0]
  ------------------
  657|      0|                    {
  658|      0|                        source_.ignore(1);
  659|      0|                        end_object(visitor, ec);
  660|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  661|      0|                        {
  662|      0|                            return;
  663|      0|                        }
  664|      0|                    }
  665|      0|                    else
  666|      0|                    {
  667|      0|                        state_stack_.back().mode = parse_mode::indefinite_map_value;
  668|      0|                        read_item(visitor, ec);
  669|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  670|      0|                        {
  671|      0|                            return;
  672|      0|                        }
  673|      0|                    }
  674|      0|                    break;
  675|      0|                }
  676|      0|                case parse_mode::indefinite_map_value:
  ------------------
  |  Branch (676:17): [True: 0, False: 415]
  ------------------
  677|      0|                {
  678|      0|                    state_stack_.back().mode = parse_mode::indefinite_map_key;
  679|      0|                    read_item(visitor, ec);
  680|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  681|      0|                    {
  682|      0|                        return;
  683|      0|                    }
  684|      0|                    break;
  685|      0|                }
  686|    348|                case parse_mode::root:
  ------------------
  |  Branch (686:17): [True: 348, False: 67]
  ------------------
  687|    348|                {
  688|    348|                    state_stack_.back().mode = parse_mode::accept;
  689|    348|                    read_item(visitor, ec);
  690|    348|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    348|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 259, False: 89]
  |  |  ------------------
  ------------------
  691|    259|                    {
  692|    259|                        return;
  693|    259|                    }
  694|     89|                    break;
  695|    348|                }
  696|     89|                case parse_mode::accept:
  ------------------
  |  Branch (696:17): [True: 67, False: 348]
  ------------------
  697|     67|                {
  698|     67|                    JSONCONS_ASSERT(state_stack_.size() == 1);
  ------------------
  |  |   54|     67|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 67]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  699|     67|                    state_stack_.clear();
  700|     67|                    more_ = false;
  701|     67|                    done_ = true;
  702|     67|                    visitor.flush();
  703|     67|                    break;
  704|     67|                }
  705|    415|            }
  706|    415|        }
  707|    415|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_itemERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  725|    348|    {
  726|    348|        read_tags(ec);
  727|    348|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    348|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 8, False: 340]
  |  |  ------------------
  ------------------
  728|      8|        {
  729|      8|            return;
  730|      8|        }
  731|    340|        auto c = source_.peek();
  732|    340|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|    340|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 340]
  |  |  ------------------
  ------------------
  733|      0|        {
  734|      0|            ec = cbor_errc::unexpected_eof;
  735|      0|            more_ = false;
  736|      0|            return;
  737|      0|        }
  738|    340|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
  739|    340|        uint8_t info = get_additional_information(c.value);
  740|    340|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|    545|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 340]
  |  |  |  Branch (79:50): [True: 205, False: 135]
  |  |  |  Branch (79:50): [True: 0, False: 205]
  |  |  ------------------
  ------------------
  741|      0|        {
  742|      0|            ec = cbor_errc::reserved_additional_info;
  743|      0|            more_ = false;
  744|      0|            return;
  745|      0|        }
  746|       |
  747|    340|        switch (major_type)
  748|    340|        {
  749|      2|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (749:13): [True: 2, False: 338]
  ------------------
  750|      2|            {
  751|      2|                source_.ignore(1);
  752|      2|                uint64_t val = read_unsigned_integer(info, ec);
  753|      2|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  754|      0|                {
  755|      0|                    return;
  756|      0|                }
  757|      2|                if (!stringref_map_stack_.empty() && other_tags_[stringref_tag])
  ------------------
  |  Branch (757:21): [True: 0, False: 2]
  |  Branch (757:21): [True: 0, False: 2]
  |  Branch (757:54): [True: 0, False: 0]
  ------------------
  758|      0|                {
  759|      0|                    other_tags_[stringref_tag] = false;
  760|      0|                    if (val >= stringref_map_stack_.back().size())
  ------------------
  |  Branch (760:25): [True: 0, False: 0]
  ------------------
  761|      0|                    {
  762|      0|                        ec = cbor_errc::stringref_too_large;
  763|      0|                        more_ = false;
  764|      0|                        return;
  765|      0|                    }
  766|      0|                    auto index = static_cast<typename stringref_map::size_type>(val);
  767|      0|                    if (index != val)
  ------------------
  |  Branch (767:25): [True: 0, False: 0]
  ------------------
  768|      0|                    {
  769|      0|                        ec = cbor_errc::number_too_large;
  770|      0|                        more_ = false;
  771|      0|                        return;
  772|      0|                    }
  773|      0|                    auto& str = stringref_map_stack_.back().at(index);
  774|      0|                    switch (str.type)
  775|      0|                    {
  776|      0|                        case jsoncons::cbor::detail::cbor_major_type::text_string:
  ------------------
  |  Branch (776:25): [True: 0, False: 0]
  ------------------
  777|      0|                        {
  778|      0|                            handle_string(visitor, jsoncons::string_view(str.str.data(),str.str.length()),ec);
  779|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  780|      0|                            {
  781|      0|                                return;
  782|      0|                            }
  783|      0|                            break;
  784|      0|                        }
  785|      0|                        case jsoncons::cbor::detail::cbor_major_type::byte_string:
  ------------------
  |  Branch (785:25): [True: 0, False: 0]
  ------------------
  786|      0|                        {
  787|      0|                            read_byte_string_from_buffer read(byte_string_view(str.bytes));
  788|      0|                            read_byte_string(read, visitor, ec);
  789|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  790|      0|                            {
  791|      0|                                return;
  792|      0|                            }
  793|      0|                            break;
  794|      0|                        }
  795|      0|                        default:
  ------------------
  |  Branch (795:25): [True: 0, False: 0]
  ------------------
  796|      0|                        {
  797|      0|                            ec = cbor_errc::invalid_major_type;
  798|      0|                            more_ = false;
  799|      0|                            return;
  800|      0|                        }
  801|      0|                    }
  802|      0|                }
  803|      2|                else
  804|      2|                {
  805|      2|                    semantic_tag tag = semantic_tag::none;
  806|      2|                    if (other_tags_[item_tag])
  ------------------
  |  Branch (806:25): [True: 1, False: 1]
  ------------------
  807|      1|                    {
  808|      1|                        if (raw_tag_ == 1)
  ------------------
  |  Branch (808:29): [True: 1, False: 0]
  ------------------
  809|      1|                        {
  810|      1|                            tag = semantic_tag::epoch_second;
  811|      1|                        }
  812|      1|                        other_tags_[item_tag] = false;
  813|      1|                    }
  814|      2|                    visitor.uint64_value(val, tag, *this, ec);
  815|      2|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  816|      0|                    {
  817|      0|                        return;
  818|      0|                    }
  819|      2|                    more_ = !cursor_mode_;
  820|      2|                }
  821|      2|                break;
  822|      2|            }
  823|      2|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (823:13): [True: 1, False: 339]
  ------------------
  824|      1|            {
  825|      1|                source_.ignore(1);
  826|      1|                read_negative_integer (info, visitor, ec);
  827|      1|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  828|      0|                {
  829|      0|                    return;
  830|      0|                }
  831|      1|                break;
  832|      1|            }
  833|    164|            case jsoncons::cbor::detail::cbor_major_type::byte_string:
  ------------------
  |  Branch (833:13): [True: 164, False: 176]
  ------------------
  834|    164|            {
  835|    164|                read_byte_string_from_source read(this);
  836|    164|                read_byte_string(read, visitor, ec);
  837|    164|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    164|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 129, False: 35]
  |  |  ------------------
  ------------------
  838|    129|                {
  839|    129|                    return;
  840|    129|                }
  841|     35|                break;
  842|    164|            }
  843|     95|            case jsoncons::cbor::detail::cbor_major_type::text_string:
  ------------------
  |  Branch (843:13): [True: 95, False: 245]
  ------------------
  844|     95|            {
  845|     95|                source_.ignore(1);
  846|     95|                auto sv = read_text_string_view(info, ec);
  847|     95|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     95|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 72, False: 23]
  |  |  ------------------
  ------------------
  848|     72|                {
  849|     72|                    return;
  850|     72|                }
  851|     23|                auto result = unicode_traits::validate(sv.data(),sv.size());
  852|     23|                if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (852:21): [True: 4, False: 19]
  ------------------
  853|      4|                {
  854|      4|                    ec = cbor_errc::invalid_utf8_text_string;
  855|      4|                    more_ = false;
  856|      4|                    return;
  857|      4|                }
  858|     19|                handle_string(visitor, sv, ec);
  859|     19|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     19|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 19]
  |  |  ------------------
  ------------------
  860|      0|                {
  861|      0|                    return;
  862|      0|                }
  863|     19|                break;
  864|     19|            }
  865|     19|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (865:13): [True: 0, False: 340]
  ------------------
  866|      0|            {
  867|      0|                JSONCONS_UNREACHABLE();
  ------------------
  |  |   80|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
  868|      0|                break;
  869|     19|            }
  870|      7|            case jsoncons::cbor::detail::cbor_major_type::simple:
  ------------------
  |  Branch (870:13): [True: 7, False: 333]
  ------------------
  871|      7|            {
  872|      7|                switch (info)
  873|      7|                {
  874|      0|                    case 0x14:
  ------------------
  |  Branch (874:21): [True: 0, False: 7]
  ------------------
  875|      0|                        source_.ignore(1);
  876|      0|                        visitor.bool_value(false, semantic_tag::none, *this, ec);
  877|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  878|      0|                        {
  879|      0|                            return;
  880|      0|                        }
  881|      0|                        more_ = !cursor_mode_;
  882|      0|                        break;
  883|      0|                    case 0x15:
  ------------------
  |  Branch (883:21): [True: 0, False: 7]
  ------------------
  884|      0|                        source_.ignore(1);
  885|      0|                        visitor.bool_value(true, semantic_tag::none, *this, ec);
  886|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  887|      0|                        {
  888|      0|                            return;
  889|      0|                        }
  890|      0|                        more_ = !cursor_mode_;
  891|      0|                        break;
  892|      0|                    case 0x16:
  ------------------
  |  Branch (892:21): [True: 0, False: 7]
  ------------------
  893|      0|                        source_.ignore(1);
  894|      0|                        visitor.null_value(semantic_tag::none, *this, ec);
  895|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  896|      0|                        {
  897|      0|                            return;
  898|      0|                        }
  899|      0|                        more_ = !cursor_mode_;
  900|      0|                        break;
  901|      0|                    case 0x17:
  ------------------
  |  Branch (901:21): [True: 0, False: 7]
  ------------------
  902|      0|                        source_.ignore(1);
  903|      0|                        visitor.null_value(semantic_tag::undefined, *this, ec);
  904|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  905|      0|                        {
  906|      0|                            return;
  907|      0|                        }
  908|      0|                        more_ = !cursor_mode_;
  909|      0|                        break;
  910|      0|                    case 0x19: // Half-Precision Float (two-byte IEEE 754)
  ------------------
  |  Branch (910:21): [True: 0, False: 7]
  ------------------
  911|      0|                    {
  912|      0|                        source_.ignore(1);
  913|      0|                        uint64_t val = read_unsigned_integer(info, ec);
  914|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  915|      0|                        {
  916|      0|                            return;
  917|      0|                        }
  918|      0|                        visitor.half_value(static_cast<uint16_t>(val), semantic_tag::none, *this, ec);
  919|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  920|      0|                        {
  921|      0|                            return;
  922|      0|                        }
  923|      0|                        more_ = !cursor_mode_;
  924|      0|                        break;
  925|      0|                    }
  926|      1|                    case 0x1a: // Single-Precision Float (four-byte IEEE 754)
  ------------------
  |  Branch (926:21): [True: 1, False: 6]
  ------------------
  927|      2|                    case 0x1b: // Double-Precision Float (eight-byte IEEE 754)
  ------------------
  |  Branch (927:21): [True: 1, False: 6]
  ------------------
  928|      2|                    {
  929|      2|                        source_.ignore(1);
  930|      2|                        double val = read_double(info, ec);
  931|      2|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  932|      0|                        {
  933|      0|                            return;
  934|      0|                        }
  935|      2|                        semantic_tag tag = semantic_tag::none;
  936|      2|                        if (other_tags_[item_tag])
  ------------------
  |  Branch (936:29): [True: 0, False: 2]
  ------------------
  937|      0|                        {
  938|      0|                            if (raw_tag_ == 1)
  ------------------
  |  Branch (938:33): [True: 0, False: 0]
  ------------------
  939|      0|                            {
  940|      0|                                tag = semantic_tag::epoch_second;
  941|      0|                            }
  942|      0|                            other_tags_[item_tag] = false;
  943|      0|                        }
  944|      2|                        visitor.double_value(val, tag, *this, ec);
  945|      2|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  946|      0|                        {
  947|      0|                            return;
  948|      0|                        }
  949|      2|                        more_ = !cursor_mode_;
  950|      2|                        break;
  951|      2|                    }
  952|      5|                    default:
  ------------------
  |  Branch (952:21): [True: 5, False: 2]
  ------------------
  953|      5|                    {
  954|      5|                        ec = cbor_errc::unknown_type;
  955|      5|                        more_ = false;
  956|      5|                        return;
  957|      2|                    }
  958|      7|                }
  959|      2|                break;
  960|      7|            }
  961|     70|            case jsoncons::cbor::detail::cbor_major_type::array:
  ------------------
  |  Branch (961:13): [True: 70, False: 270]
  ------------------
  962|     70|            {
  963|     70|                if (other_tags_[item_tag])
  ------------------
  |  Branch (963:21): [True: 69, False: 1]
  ------------------
  964|     69|                {
  965|     69|                    switch (raw_tag_)
  966|     69|                    {
  967|     21|                        case 0x04:
  ------------------
  |  Branch (967:25): [True: 21, False: 48]
  ------------------
  968|     21|                            source_.ignore(1);
  969|     21|                            text_buffer_.clear();
  970|     21|                            read_bigdecimal(info, text_buffer_, ec);
  971|     21|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     21|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 19]
  |  |  ------------------
  ------------------
  972|      2|                            {
  973|      2|                                return;
  974|      2|                            }
  975|     19|                            visitor.string_value(text_buffer_, semantic_tag::bigdec, *this, ec);
  976|     19|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     19|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 19]
  |  |  ------------------
  ------------------
  977|      0|                            {
  978|      0|                                return;
  979|      0|                            }
  980|     19|                            more_ = !cursor_mode_;
  981|     19|                            break;
  982|     13|                        case 0x05:
  ------------------
  |  Branch (982:25): [True: 13, False: 56]
  ------------------
  983|     13|                            source_.ignore(1);
  984|     13|                            text_buffer_.clear();
  985|     13|                            read_bigfloat(info, text_buffer_, ec);
  986|     13|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     13|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 5, False: 8]
  |  |  ------------------
  ------------------
  987|      5|                            {
  988|      5|                                return;
  989|      5|                            }
  990|      8|                            visitor.string_value(text_buffer_, semantic_tag::bigdec, *this, ec);
  991|      8|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      8|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 8]
  |  |  ------------------
  ------------------
  992|      0|                            {
  993|      0|                                return;
  994|      0|                            }
  995|      8|                            more_ = !cursor_mode_;
  996|      8|                            break;
  997|     30|                        case 40: // row-major storage
  ------------------
  |  Branch (997:25): [True: 30, False: 39]
  ------------------
  998|     30|                            order_ = mdarray_order::row_major;
  999|     30|                            read_mdarray_header(visitor, ec);
 1000|     30|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     30|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 30, False: 0]
  |  |  ------------------
  ------------------
 1001|     30|                            {
 1002|     30|                                return;
 1003|     30|                            }
 1004|      0|                            break;
 1005|      5|                        case 1040: // column-major storage
  ------------------
  |  Branch (1005:25): [True: 5, False: 64]
  ------------------
 1006|      5|                            order_ = mdarray_order::column_major;
 1007|      5|                            read_mdarray_header(visitor, ec);
 1008|      5|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 4, False: 1]
  |  |  ------------------
  ------------------
 1009|      4|                            {
 1010|      4|                                return;
 1011|      4|                            }
 1012|      1|                            break;
 1013|      1|                        default:
  ------------------
  |  Branch (1013:25): [True: 0, False: 69]
  ------------------
 1014|      0|                            source_.ignore(1);
 1015|      0|                            begin_array(info, visitor, ec);
 1016|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1017|      0|                            {
 1018|      0|                                return;
 1019|      0|                            }
 1020|      0|                            break;
 1021|     69|                    }
 1022|     28|                    other_tags_[item_tag] = false;
 1023|     28|                }
 1024|      1|                else
 1025|      1|                {
 1026|      1|                    source_.ignore(1);
 1027|      1|                    begin_array(info, visitor, ec);
 1028|      1|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1029|      0|                    {
 1030|      0|                        return;
 1031|      0|                    }
 1032|      1|                }
 1033|     29|                break;
 1034|     70|            }
 1035|     29|            case jsoncons::cbor::detail::cbor_major_type::map:
  ------------------
  |  Branch (1035:13): [True: 1, False: 339]
  ------------------
 1036|      1|            {
 1037|      1|                source_.ignore(1);
 1038|      1|                begin_object(info, visitor, ec);
 1039|      1|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1040|      0|                {
 1041|      0|                    return;
 1042|      0|                }
 1043|      1|                break;
 1044|      1|            }
 1045|      1|            default:
  ------------------
  |  Branch (1045:13): [True: 0, False: 340]
  ------------------
 1046|      0|                ec = cbor_errc::invalid_major_type;
 1047|      0|                more_ = false;
 1048|      0|                return;
 1049|    340|        }
 1050|     89|        other_tags_[item_tag] = false;
 1051|     89|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_tagsERNS3_10error_codeE:
 2212|    349|    {
 2213|    349|        auto c = source_.peek();
 2214|    349|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|    349|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 349]
  |  |  ------------------
  ------------------
 2215|      0|        {
 2216|      0|            ec = cbor_errc::unexpected_eof;
 2217|      0|            more_ = false;
 2218|      0|            return;
 2219|      0|        }
 2220|    349|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 2221|    349|        uint8_t info = get_additional_information(c.value);
 2222|    349|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|    510|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 349]
  |  |  |  Branch (79:50): [True: 161, False: 188]
  |  |  |  Branch (79:50): [True: 0, False: 161]
  |  |  ------------------
  ------------------
 2223|      0|        {
 2224|      0|            ec = cbor_errc::reserved_additional_info;
 2225|      0|            more_ = false;
 2226|      0|            return;
 2227|      0|        }
 2228|       |
 2229|  1.02M|        while (major_type == jsoncons::cbor::detail::cbor_major_type::semantic_tag)
  ------------------
  |  Branch (2229:16): [True: 1.02M, False: 341]
  ------------------
 2230|  1.02M|        {
 2231|  1.02M|            source_.ignore(1);
 2232|  1.02M|            uint64_t val = read_unsigned_integer(info, ec);
 2233|  1.02M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  1.02M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 1.02M]
  |  |  ------------------
  ------------------
 2234|      1|            {
 2235|      1|                return;
 2236|      1|            }
 2237|  1.02M|            switch(val)
 2238|  1.02M|            {
 2239|      1|                case 25: // stringref
  ------------------
  |  Branch (2239:17): [True: 1, False: 1.02M]
  ------------------
 2240|      1|                    other_tags_[stringref_tag] = true;
 2241|      1|                    break;
 2242|      1|                case 256: // stringref-namespace
  ------------------
  |  Branch (2242:17): [True: 1, False: 1.02M]
  ------------------
 2243|      1|                    other_tags_[stringref_namespace_tag] = true;
 2244|      1|                    break;
 2245|  1.02M|                default:
  ------------------
  |  Branch (2245:17): [True: 1.02M, False: 2]
  ------------------
 2246|  1.02M|                    other_tags_[item_tag] = true;
 2247|  1.02M|                    raw_tag_ = val;
 2248|  1.02M|                    break;
 2249|  1.02M|            }
 2250|  1.02M|            c = source_.peek();
 2251|  1.02M|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|  1.02M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 7, False: 1.02M]
  |  |  ------------------
  ------------------
 2252|      7|            {
 2253|      7|                ec = cbor_errc::unexpected_eof;
 2254|      7|                more_ = false;
 2255|      7|                return;
 2256|      7|            }
 2257|  1.02M|            major_type = get_major_type(c.value);
 2258|  1.02M|        }
 2259|    349|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE14get_major_typeEh:
 2198|  7.21M|    {
 2199|  7.21M|        static constexpr uint8_t major_type_shift = 0x05;
 2200|  7.21M|        uint8_t value = type >> major_type_shift;
 2201|  7.21M|        return static_cast<jsoncons::cbor::detail::cbor_major_type>(value);
 2202|  7.21M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE26get_additional_informationEh:
 2205|  9.39M|    {
 2206|  9.39M|        static constexpr uint8_t additional_information_mask = (1U << 5) - 1;
 2207|  9.39M|        uint8_t value = type & additional_information_mask;
 2208|  9.39M|        return value;
 2209|  9.39M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_unsigned_integerEhRNS3_10error_codeE:
 1728|  10.4M|    {
 1729|  10.4M|        switch (info)
 1730|  10.4M|        {
 1731|  10.0M|            case JSONCONS_EXT_CBOR_0x00_0x17: // 0x00..0x17 (0..23)
  ------------------
  |  |   18|  10.0M|    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.81M, False: 8.60M]
  |  |  |  Branch (18:20): [True: 1.10M, False: 9.32M]
  |  |  |  Branch (18:30): [True: 53.5k, False: 10.3M]
  |  |  |  Branch (18:40): [True: 8.62k, False: 10.4M]
  |  |  |  Branch (18:50): [True: 2.01M, False: 8.40M]
  |  |  |  Branch (18:60): [True: 2.79k, False: 10.4M]
  |  |  |  Branch (18:70): [True: 55.1k, False: 10.3M]
  |  |  |  Branch (18:80): [True: 2.74k, False: 10.4M]
  |  |  |  Branch (18:90): [True: 80.2k, False: 10.3M]
  |  |  |  Branch (18:100): [True: 4.41k, False: 10.4M]
  |  |  |  Branch (18:110): [True: 46.1k, False: 10.3M]
  |  |  |  Branch (18:120): [True: 315, False: 10.4M]
  |  |  |  Branch (18:130): [True: 1.16k, False: 10.4M]
  |  |  |  Branch (18:140): [True: 19.2k, False: 10.4M]
  |  |  |  Branch (18:150): [True: 11.5k, False: 10.4M]
  |  |  |  Branch (18:160): [True: 15.6k, False: 10.4M]
  |  |  |  Branch (18:170): [True: 7.97k, False: 10.4M]
  |  |  |  Branch (18:180): [True: 1.97k, False: 10.4M]
  |  |  |  Branch (18:190): [True: 45.1k, False: 10.3M]
  |  |  |  Branch (18:200): [True: 331, False: 10.4M]
  |  |  |  Branch (18:210): [True: 852, False: 10.4M]
  |  |  |  Branch (18:220): [True: 65.8k, False: 10.3M]
  |  |  ------------------
  ------------------
  |  Branch (1731:13): [True: 4.70M, False: 5.71M]
  ------------------
 1732|  10.0M|            {
 1733|  10.0M|                return info;
 1734|   207M|            }
 1735|   345k|            case 0x18: // Unsigned integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1735:13): [True: 345k, False: 10.0M]
  ------------------
 1736|   345k|            {
 1737|   345k|                uint8_t b;
 1738|   345k|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1738:21): [True: 0, False: 345k]
  ------------------
 1739|      0|                {
 1740|      0|                    ec = cbor_errc::unexpected_eof;
 1741|      0|                    return uint64_t{};
 1742|      0|                }
 1743|   345k|                return b;
 1744|   345k|            }
 1745|  4.82k|            case 0x19: // Unsigned integer (two-byte uint16_t follows)
  ------------------
  |  Branch (1745:13): [True: 4.82k, False: 10.4M]
  ------------------
 1746|  4.82k|            {
 1747|  4.82k|                uint8_t buf[sizeof(uint16_t)];
 1748|  4.82k|                if (source_.read(buf, sizeof(uint16_t)) != sizeof(uint16_t))
  ------------------
  |  Branch (1748:21): [True: 2, False: 4.82k]
  ------------------
 1749|      2|                {
 1750|      2|                    ec = cbor_errc::unexpected_eof;
 1751|      2|                    return uint64_t{};
 1752|      2|                }
 1753|  4.82k|                auto u = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1754|  4.82k|                return u;
 1755|  4.82k|            }
 1756|    907|            case 0x1a: // Unsigned integer (four-byte uint32_t follows)
  ------------------
  |  Branch (1756:13): [True: 907, False: 10.4M]
  ------------------
 1757|    907|            {
 1758|    907|                uint8_t buf[sizeof(uint32_t)];
 1759|    907|                if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (1759:21): [True: 1, False: 906]
  ------------------
 1760|      1|                {
 1761|      1|                    ec = cbor_errc::unexpected_eof;
 1762|      1|                    return uint64_t{};
 1763|      1|                }
 1764|    906|                auto u = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1765|    906|                return u;
 1766|    907|            }
 1767|  8.43k|            case 0x1b: // Unsigned integer (eight-byte uint64_t follows)
  ------------------
  |  Branch (1767:13): [True: 8.43k, False: 10.4M]
  ------------------
 1768|  8.43k|            {
 1769|  8.43k|                uint8_t buf[sizeof(uint64_t)];
 1770|  8.43k|                if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (1770:21): [True: 2, False: 8.43k]
  ------------------
 1771|      2|                {
 1772|      2|                    ec = cbor_errc::unexpected_eof;
 1773|      2|                    return uint64_t{};
 1774|      2|                }
 1775|  8.43k|                auto u = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1776|  8.43k|                return u;
 1777|  8.43k|            }
 1778|      2|            default:
  ------------------
  |  Branch (1778:13): [True: 2, False: 10.4M]
  ------------------
 1779|      2|                ec = info == jsoncons::cbor::detail::additional_info::indefinite_length ? cbor_errc::unknown_type : cbor_errc::reserved_additional_info;
  ------------------
  |  Branch (1779:22): [True: 2, False: 0]
  ------------------
 1780|      2|                return uint64_t{};
 1781|  10.4M|        }
 1782|  10.4M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13handle_stringERNS_21basic_generic_visitorIcEERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERNS3_10error_codeE:
 2262|     19|    {
 2263|     19|        semantic_tag tag = semantic_tag::none;
 2264|     19|        if (other_tags_[item_tag])
  ------------------
  |  Branch (2264:13): [True: 5, False: 14]
  ------------------
 2265|      5|        {
 2266|      5|            switch (raw_tag_)
 2267|      5|            {
 2268|      0|                case 0:
  ------------------
  |  Branch (2268:17): [True: 0, False: 5]
  ------------------
 2269|      0|                    tag = semantic_tag::datetime;
 2270|      0|                    break;
 2271|      0|                case 32:
  ------------------
  |  Branch (2271:17): [True: 0, False: 5]
  ------------------
 2272|      0|                    tag = semantic_tag::uri;
 2273|      0|                    break;
 2274|      0|                case 33:
  ------------------
  |  Branch (2274:17): [True: 0, False: 5]
  ------------------
 2275|      0|                    tag = semantic_tag::base64url;
 2276|      0|                    break;
 2277|      0|                case 34:
  ------------------
  |  Branch (2277:17): [True: 0, False: 5]
  ------------------
 2278|      0|                    tag = semantic_tag::base64;
 2279|      0|                    break;
 2280|      5|                default:
  ------------------
  |  Branch (2280:17): [True: 5, False: 0]
  ------------------
 2281|      5|                    break;
 2282|      5|            }
 2283|      5|            other_tags_[item_tag] = false;
 2284|      5|        }
 2285|     19|        visitor.string_value(v, tag, *this, ec);
 2286|     19|        more_ = !cursor_mode_;
 2287|     19|    }
_ZN8jsoncons4cbor11parse_stateC2ENS0_10parse_modeEmb:
  167|    371|        : mode(mode), length(length), pop_stringref_map_stack(pop_stringref_map_stack)
  168|    371|    {
  169|    371|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE26get_typed_array_endiannessEh:
 2290|     19|    {
 2291|     19|        return ((tag & detail::cbor_array_tags_e_mask) >> detail::cbor_array_tags_e_shift) == 0 ? jsoncons::endian::big : jsoncons::endian::little; 
  ------------------
  |  Branch (2291:16): [True: 18, False: 1]
  ------------------
 2292|     19|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_negative_integerEhRNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 1623|      1|    {
 1624|      1|        semantic_tag tag = semantic_tag::none;
 1625|      1|        if (other_tags_[item_tag])
  ------------------
  |  Branch (1625:13): [True: 1, False: 0]
  ------------------
 1626|      1|        {
 1627|      1|            if (raw_tag_ == 1)
  ------------------
  |  Branch (1627:17): [True: 0, False: 1]
  ------------------
 1628|      0|            {
 1629|      0|                tag = semantic_tag::epoch_second;
 1630|      0|            }
 1631|      1|            other_tags_[item_tag] = false;
 1632|      1|        }
 1633|       |
 1634|      1|        switch (info)
 1635|      1|        {
 1636|      1|            case JSONCONS_EXT_CBOR_0x00_0x17: // 0x00..0x17 (0..23)
  ------------------
  |  |   18|      1|    0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x09:case 0x0a:case 0x0b:case 0x0c:case 0x0d:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16:case 0x17
  |  |  ------------------
  |  |  |  Branch (18:10): [True: 0, False: 1]
  |  |  |  Branch (18:20): [True: 0, False: 1]
  |  |  |  Branch (18:30): [True: 0, False: 1]
  |  |  |  Branch (18:40): [True: 0, False: 1]
  |  |  |  Branch (18:50): [True: 0, False: 1]
  |  |  |  Branch (18:60): [True: 0, False: 1]
  |  |  |  Branch (18:70): [True: 0, False: 1]
  |  |  |  Branch (18:80): [True: 1, False: 0]
  |  |  |  Branch (18:90): [True: 0, False: 1]
  |  |  |  Branch (18:100): [True: 0, False: 1]
  |  |  |  Branch (18:110): [True: 0, False: 1]
  |  |  |  Branch (18:120): [True: 0, False: 1]
  |  |  |  Branch (18:130): [True: 0, False: 1]
  |  |  |  Branch (18:140): [True: 0, False: 1]
  |  |  |  Branch (18:150): [True: 0, False: 1]
  |  |  |  Branch (18:160): [True: 0, False: 1]
  |  |  |  Branch (18:170): [True: 0, False: 1]
  |  |  |  Branch (18:180): [True: 0, False: 1]
  |  |  |  Branch (18:190): [True: 0, False: 1]
  |  |  |  Branch (18:200): [True: 0, False: 1]
  |  |  |  Branch (18:210): [True: 0, False: 1]
  |  |  |  Branch (18:220): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  |  Branch (1636:13): [True: 0, False: 1]
  ------------------
 1637|      1|            {
 1638|      1|                int64_t val = static_cast<int8_t>(- 1 - info);
 1639|      1|                visitor.int64_value(val, tag, *this, ec);
 1640|      1|                more_ = !cursor_mode_;
 1641|      1|                break;
 1642|     15|            }
 1643|      0|            case 0x18: // Negative integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1643:13): [True: 0, False: 1]
  ------------------
 1644|      0|            {
 1645|      0|                uint8_t b;
 1646|      0|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1646:21): [True: 0, False: 0]
  ------------------
 1647|      0|                {
 1648|      0|                    ec = cbor_errc::unexpected_eof;
 1649|      0|                    more_ = false;
 1650|      0|                    return;
 1651|      0|                }
 1652|      0|                int64_t val = static_cast<int64_t>(-1) - static_cast<int64_t>(b);
 1653|      0|                visitor.int64_value(val, tag, *this, ec);
 1654|      0|                more_ = !cursor_mode_;
 1655|      0|                break;
 1656|      0|            }
 1657|      0|            case 0x19: // Negative integer -1-n (two-byte uint16_t follows)
  ------------------
  |  Branch (1657:13): [True: 0, False: 1]
  ------------------
 1658|      0|            {
 1659|      0|                uint8_t buf[sizeof(uint16_t)];
 1660|      0|                if (source_.read(buf, sizeof(uint16_t)) != sizeof(uint16_t))
  ------------------
  |  Branch (1660:21): [True: 0, False: 0]
  ------------------
 1661|      0|                {
 1662|      0|                    ec = cbor_errc::unexpected_eof;
 1663|      0|                    more_ = false;
 1664|      0|                    return;
 1665|      0|                }
 1666|      0|                auto u = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1667|      0|                int64_t val = static_cast<int64_t>(-1)- u;
 1668|      0|                visitor.int64_value(val, tag, *this, ec);
 1669|      0|                more_ = !cursor_mode_;
 1670|      0|                break;
 1671|      0|            }
 1672|      0|            case 0x1a: // Negative integer -1-n (four-byte uint32_t follows)
  ------------------
  |  Branch (1672:13): [True: 0, False: 1]
  ------------------
 1673|      0|            {
 1674|      0|                uint8_t buf[sizeof(uint32_t)];
 1675|      0|                if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (1675:21): [True: 0, False: 0]
  ------------------
 1676|      0|                {
 1677|      0|                    ec = cbor_errc::unexpected_eof;
 1678|      0|                    more_ = false;
 1679|      0|                    return;
 1680|      0|                }
 1681|      0|                auto u = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1682|      0|                int64_t val = static_cast<int64_t>(-1)- u;
 1683|      0|                visitor.int64_value(val, tag, *this, ec);
 1684|      0|                more_ = !cursor_mode_;
 1685|      0|                break;
 1686|      0|            }
 1687|      0|            case 0x1b: // Negative integer -1-n (eight-byte uint64_t follows)
  ------------------
  |  Branch (1687:13): [True: 0, False: 1]
  ------------------
 1688|      0|            {
 1689|      0|                uint8_t buf[sizeof(uint64_t)];
 1690|      0|                if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (1690:21): [True: 0, False: 0]
  ------------------
 1691|      0|                {
 1692|      0|                    ec = cbor_errc::unexpected_eof;
 1693|      0|                    more_ = false;
 1694|      0|                    return;
 1695|      0|                }
 1696|      0|                auto u = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1697|      0|                if (u > static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1697:21): [True: 0, False: 0]
  ------------------
 1698|      0|                {
 1699|       |                    //ec = cbor_errc::invalid_negative_integer;
 1700|       |                    //more_ = false;
 1701|       |                    //return;
 1702|      0|                    bigint b(u);
 1703|      0|                    bigint b2 = -1 - b;
 1704|      0|                    text_buffer_.clear();
 1705|      0|                    b2.append_to_buffer(text_buffer_);
 1706|      0|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 1707|      0|                }
 1708|      0|                else if (JSONCONS_UNLIKELY(u == static_cast<uint64_t>((std::numeric_limits<int64_t>::max)())))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1709|      0|                {
 1710|      0|                    visitor.int64_value((std::numeric_limits<int64_t>::min)(), tag, *this, ec);
 1711|      0|                }
 1712|      0|                else
 1713|      0|                {
 1714|      0|                    int64_t val = static_cast<int64_t>(-1) - static_cast<int64_t>(u);
 1715|      0|                    visitor.int64_value(val, tag, *this, ec);
 1716|      0|                }
 1717|      0|                more_ = !cursor_mode_;
 1718|      0|                break;
 1719|      0|            }
 1720|      0|            default:
  ------------------
  |  Branch (1720:13): [True: 0, False: 1]
  ------------------
 1721|      0|                ec = info == jsoncons::cbor::detail::additional_info::indefinite_length ? cbor_errc::unknown_type : cbor_errc::reserved_additional_info;
  ------------------
  |  Branch (1721:22): [True: 0, False: 0]
  ------------------
 1722|      0|                more_ = false;
 1723|      0|                return;
 1724|      1|        }
 1725|      1|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_sourceC2EPS8_:
  316|    164|            : source(source)
  317|    164|        {
  318|    164|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringINS8_28read_byte_string_from_sourceEEEvT_RNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 2304|    164|    {
 2305|    164|        if (other_tags_[item_tag])
  ------------------
  |  Branch (2305:13): [True: 48, False: 116]
  ------------------
 2306|     48|        {
 2307|     48|            switch (raw_tag_)
 2308|     48|            {
 2309|      1|                case 0x2:
  ------------------
  |  Branch (2309:17): [True: 1, False: 47]
  ------------------
 2310|      1|                {
 2311|      1|                    auto bytes = read.view(ec);
 2312|      1|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2313|      0|                    {
 2314|      0|                        more_ = false;
 2315|      0|                        return;
 2316|      0|                    }
 2317|      1|                    bigint b = bigint::from_bytes_be(1, bytes.data(), bytes.size());
 2318|      1|                    text_buffer_.clear();
 2319|      1|                    b.append_to_buffer(text_buffer_);
 2320|      1|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2321|      1|                    more_ = !cursor_mode_;
 2322|      1|                    break;
 2323|      1|                }
 2324|     16|                case 0x3:
  ------------------
  |  Branch (2324:17): [True: 16, False: 32]
  ------------------
 2325|     16|                {
 2326|     16|                    auto bytes = read.view(ec);
 2327|     16|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     16|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 5, False: 11]
  |  |  ------------------
  ------------------
 2328|      5|                    {
 2329|      5|                        more_ = false;
 2330|      5|                        return;
 2331|      5|                    }
 2332|     11|                    bigint b = bigint::from_bytes_be(1, bytes.data(), bytes.size());
 2333|     11|                    b = -1 - b;
 2334|     11|                    text_buffer_.clear();
 2335|     11|                    b.append_to_buffer(text_buffer_);
 2336|     11|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2337|     11|                    more_ = !cursor_mode_;
 2338|     11|                    break;
 2339|     16|                }
 2340|      0|                case 0x15:
  ------------------
  |  Branch (2340:17): [True: 0, False: 48]
  ------------------
 2341|      0|                case 0x16:
  ------------------
  |  Branch (2341:17): [True: 0, False: 48]
  ------------------
 2342|      0|                case 0x17:
  ------------------
  |  Branch (2342:17): [True: 0, False: 48]
  ------------------
 2343|      0|                {
 2344|      0|                    auto bytes = read.view(ec);
 2345|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2346|      0|                    {
 2347|      0|                        more_ = false;
 2348|      0|                        return;
 2349|      0|                    }
 2350|      0|                    const semantic_tag tag = raw_tag_ == 0x15 ? semantic_tag::base64url
  ------------------
  |  Branch (2350:46): [True: 0, False: 0]
  ------------------
 2351|      0|                        : raw_tag_ == 0x16 ? semantic_tag::base64
  ------------------
  |  Branch (2351:27): [True: 0, False: 0]
  ------------------
 2352|      0|                        : semantic_tag::base16;
 2353|      0|                    visitor.byte_string_value(bytes, tag, *this, ec);
 2354|      0|                    more_ = !cursor_mode_;
 2355|      0|                    break;
 2356|      0|                }
 2357|      0|                case 0x40:
  ------------------
  |  Branch (2357:17): [True: 0, False: 48]
  ------------------
 2358|      0|                {
 2359|      0|                    array_tag_ = typed_array_tags::uint8;
 2360|      0|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2361|      0|                    read(array_buffer, ec);
 2362|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2363|      0|                    {
 2364|      0|                        more_ = false;
 2365|      0|                        return;
 2366|      0|                    }
 2367|      0|                    auto ta = typed_array_cast<const uint8_t>(array_buffer);
 2368|      0|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2368:25): [True: 0, False: 0]
  |  Branch (2368:42): [True: 0, False: 0]
  ------------------
 2369|      0|                    {
 2370|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2370:29): [True: 0, False: 0]
  ------------------
 2371|      0|                        {
 2372|      0|                            ec = cbor_errc::bad_extents;
 2373|      0|                            more_ = false;
 2374|      0|                            return;
 2375|      0|                        }
 2376|      0|                        auto iter = std::make_shared<mdarray_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2377|      0|                            typed_array_tags::uint8, extents_, order_, alloc_);
 2378|      0|                        typed_array_stack_.push_back(iter);
 2379|      0|                        iter->next(visitor, *this, ec);
 2380|      0|                    }
 2381|      0|                    else
 2382|      0|                    {
 2383|      0|                        auto iter = std::make_shared<oned_typed_array_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2384|      0|                            typed_array_tags::uint8, semantic_tag::none, alloc_);
 2385|      0|                        typed_array_stack_.push_back(iter);
 2386|      0|                        iter->next(visitor, *this, ec);
 2387|      0|                    }
 2388|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2389|      0|                    more_ = !cursor_mode_;
 2390|      0|                    break;
 2391|      0|                }
 2392|      0|                case 0x44:
  ------------------
  |  Branch (2392:17): [True: 0, False: 48]
  ------------------
 2393|      0|                {
 2394|      0|                    array_tag_ = typed_array_tags::uint8;
 2395|      0|                    typed_array_tag_ = semantic_tag::clamped;
 2396|      0|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2397|      0|                    read(array_buffer, ec);
 2398|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2399|      0|                    {
 2400|      0|                        more_ = false;
 2401|      0|                        return;
 2402|      0|                    }
 2403|      0|                    auto ta = typed_array_cast<const uint8_t>(array_buffer);
 2404|      0|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2404:25): [True: 0, False: 0]
  |  Branch (2404:42): [True: 0, False: 0]
  ------------------
 2405|      0|                    {
 2406|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2406:29): [True: 0, False: 0]
  ------------------
 2407|      0|                        {
 2408|      0|                            ec = cbor_errc::bad_extents;
 2409|      0|                            more_ = false;
 2410|      0|                            return;
 2411|      0|                        }
 2412|      0|                        auto iter = std::make_shared<mdarray_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2413|      0|                            typed_array_tags::uint8, extents_, order_, alloc_);
 2414|      0|                        typed_array_stack_.push_back(iter);
 2415|      0|                        iter->next(visitor, *this, ec);
 2416|      0|                    }
 2417|      0|                    else
 2418|      0|                    {
 2419|      0|                        auto iter = std::make_shared<oned_typed_array_iterator<uint8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2420|      0|                            typed_array_tags::uint8, semantic_tag::clamped, alloc_);
 2421|      0|                        typed_array_stack_.push_back(iter);
 2422|      0|                        iter->next(visitor, *this, ec);
 2423|      0|                    }
 2424|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2425|      0|                    more_ = !cursor_mode_;
 2426|      0|                    break;
 2427|      0|                }
 2428|      1|                case 0x41:
  ------------------
  |  Branch (2428:17): [True: 1, False: 47]
  ------------------
 2429|      1|                case 0x45:
  ------------------
  |  Branch (2429:17): [True: 0, False: 48]
  ------------------
 2430|      1|                {
 2431|      1|                    array_tag_ = typed_array_tags::uint16;
 2432|      1|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2433|      1|                    read(array_buffer, ec);
 2434|      1|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2435|      0|                    {
 2436|      0|                        more_ = false;
 2437|      0|                        return;
 2438|      0|                    }
 2439|      1|                    const uint8_t tag = (uint8_t)raw_tag_;
 2440|      1|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2441|      1|                    auto ta = typed_array_cast<uint16_t>(array_buffer);
 2442|      1|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2442:25): [True: 1, False: 0]
  ------------------
 2443|      1|                    {
 2444|  32.6k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2444:49): [True: 32.6k, False: 1]
  ------------------
 2445|  32.6k|                        {
 2446|  32.6k|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2447|  32.6k|                        }
 2448|      1|                    }
 2449|      1|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2449:25): [True: 0, False: 1]
  |  Branch (2449:42): [True: 0, False: 0]
  ------------------
 2450|      0|                    {
 2451|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2451:29): [True: 0, False: 0]
  ------------------
 2452|      0|                        {
 2453|      0|                            ec = cbor_errc::bad_extents;
 2454|      0|                            more_ = false;
 2455|      0|                            return;
 2456|      0|                        }
 2457|      0|                        auto iter = std::make_shared<mdarray_iterator<uint16_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2458|      0|                            typed_array_tags::uint16, extents_, order_, alloc_);
 2459|      0|                        typed_array_stack_.push_back(iter);
 2460|      0|                        iter->next(visitor, *this, ec);
 2461|      0|                    }
 2462|      1|                    else
 2463|      1|                    {
 2464|      1|                        auto iter = std::make_shared<oned_typed_array_iterator<uint16_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2465|      1|                            typed_array_tags::uint16, semantic_tag::none, alloc_);
 2466|      1|                        typed_array_stack_.push_back(iter);
 2467|      1|                        iter->next(visitor, *this, ec);
 2468|      1|                    }
 2469|      1|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2470|      1|                    more_ = !cursor_mode_;
 2471|      1|                    break;
 2472|      1|                }
 2473|      5|                case 0x42:
  ------------------
  |  Branch (2473:17): [True: 5, False: 43]
  ------------------
 2474|      5|                case 0x46:
  ------------------
  |  Branch (2474:17): [True: 0, False: 48]
  ------------------
 2475|      5|                {
 2476|      5|                    array_tag_ = typed_array_tags::uint32;
 2477|      5|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2478|      5|                    read(array_buffer, ec);
 2479|      5|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 4, False: 1]
  |  |  ------------------
  ------------------
 2480|      4|                    {
 2481|      4|                        more_ = false;
 2482|      4|                        return;
 2483|      4|                    }
 2484|      1|                    const uint8_t tag = (uint8_t)raw_tag_;
 2485|      1|                    jsoncons::endian e = get_typed_array_endianness(tag);
 2486|      1|                    auto ta = typed_array_cast<uint32_t>(array_buffer);
 2487|      1|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2487:25): [True: 1, False: 0]
  ------------------
 2488|      1|                    {
 2489|  15.3k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2489:49): [True: 15.3k, False: 1]
  ------------------
 2490|  15.3k|                        {
 2491|  15.3k|                            ta[i] = binary::byte_swap<uint32_t>(ta[i]);
 2492|  15.3k|                        }
 2493|      1|                    }
 2494|      1|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2494:25): [True: 0, False: 1]
  |  Branch (2494:42): [True: 0, False: 0]
  ------------------
 2495|      0|                    {
 2496|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2496:29): [True: 0, False: 0]
  ------------------
 2497|      0|                        {
 2498|      0|                            ec = cbor_errc::bad_extents;
 2499|      0|                            more_ = false;
 2500|      0|                            return;
 2501|      0|                        }
 2502|      0|                        auto iter = std::make_shared<mdarray_iterator<uint32_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2503|      0|                            typed_array_tags::uint32, extents_, order_, alloc_);
 2504|      0|                        typed_array_stack_.push_back(iter);
 2505|      0|                        iter->next(visitor, *this, ec);
 2506|      0|                    }
 2507|      1|                    else
 2508|      1|                    {
 2509|      1|                        auto iter = std::make_shared<oned_typed_array_iterator<uint32_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2510|      1|                            typed_array_tags::uint32, semantic_tag::none, alloc_);
 2511|      1|                        typed_array_stack_.push_back(iter);
 2512|      1|                        iter->next(visitor, *this, ec);
 2513|      1|                    }
 2514|      1|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2515|      1|                    more_ = !cursor_mode_;
 2516|      1|                    break;
 2517|      1|                }
 2518|      2|                case 0x43:
  ------------------
  |  Branch (2518:17): [True: 2, False: 46]
  ------------------
 2519|      3|                case 0x47:
  ------------------
  |  Branch (2519:17): [True: 1, False: 47]
  ------------------
 2520|      3|                {
 2521|      3|                    array_tag_ = typed_array_tags::uint64;
 2522|      3|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2523|      3|                    read(array_buffer, ec);
 2524|      3|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
 2525|      0|                    {
 2526|      0|                        more_ = false;
 2527|      0|                        return;
 2528|      0|                    }
 2529|      3|                    const uint8_t tag = (uint8_t)raw_tag_;
 2530|      3|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2531|      3|                    auto ta = typed_array_cast<uint64_t>(array_buffer);
 2532|      3|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2532:25): [True: 2, False: 1]
  ------------------
 2533|      2|                    {
 2534|  9.17k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2534:49): [True: 9.17k, False: 2]
  ------------------
 2535|  9.17k|                        {
 2536|  9.17k|                            ta[i] = binary::byte_swap<uint64_t>(ta[i]);
 2537|  9.17k|                        }
 2538|      2|                    }
 2539|      3|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2539:25): [True: 0, False: 3]
  |  Branch (2539:42): [True: 0, False: 0]
  ------------------
 2540|      0|                    {
 2541|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2541:29): [True: 0, False: 0]
  ------------------
 2542|      0|                        {
 2543|      0|                            ec = cbor_errc::bad_extents;
 2544|      0|                            more_ = false;
 2545|      0|                            return;
 2546|      0|                        }
 2547|      0|                        auto iter = std::make_shared<mdarray_iterator<uint64_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2548|      0|                            typed_array_tags::uint64, extents_, order_, alloc_);
 2549|      0|                        typed_array_stack_.push_back(iter);
 2550|      0|                        iter->next(visitor, *this, ec);
 2551|      0|                    }
 2552|      3|                    else
 2553|      3|                    {
 2554|      3|                        auto iter = std::make_shared<oned_typed_array_iterator<uint64_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2555|      3|                            typed_array_tags::uint64, semantic_tag::none, alloc_);
 2556|      3|                        typed_array_stack_.push_back(iter);
 2557|      3|                        iter->next(visitor, *this, ec);
 2558|      3|                    }
 2559|      3|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2560|      3|                    more_ = !cursor_mode_;
 2561|      3|                    break;
 2562|      3|                }
 2563|      0|                case 0x48:
  ------------------
  |  Branch (2563:17): [True: 0, False: 48]
  ------------------
 2564|      0|                {
 2565|      0|                    array_tag_ = typed_array_tags::int8;
 2566|      0|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2567|      0|                    read(array_buffer, ec);
 2568|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2569|      0|                    {
 2570|      0|                        more_ = false;
 2571|      0|                        return;
 2572|      0|                    }
 2573|      0|                    auto ta = typed_array_cast<int8_t>(array_buffer);
 2574|      0|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2574:25): [True: 0, False: 0]
  |  Branch (2574:42): [True: 0, False: 0]
  ------------------
 2575|      0|                    {
 2576|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2576:29): [True: 0, False: 0]
  ------------------
 2577|      0|                        {
 2578|      0|                            ec = cbor_errc::bad_extents;
 2579|      0|                            more_ = false;
 2580|      0|                            return;
 2581|      0|                        }
 2582|      0|                        auto iter = std::make_shared<mdarray_iterator<int8_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2583|      0|                            typed_array_tags::int8, extents_, order_, alloc_);
 2584|      0|                        typed_array_stack_.push_back(iter);
 2585|      0|                        iter->next(visitor, *this, ec);
 2586|      0|                    }
 2587|      0|                    else
 2588|      0|                    {
 2589|      0|                        auto iter = std::make_shared<oned_typed_array_iterator<int8_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2590|      0|                            typed_array_tags::int8, semantic_tag::none, alloc_);
 2591|      0|                        typed_array_stack_.push_back(iter);
 2592|      0|                        iter->next(visitor, *this, ec);
 2593|      0|                    }
 2594|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2595|      0|                    more_ = !cursor_mode_;
 2596|      0|                    break;
 2597|      0|                }
 2598|      4|                case 0x49:
  ------------------
  |  Branch (2598:17): [True: 4, False: 44]
  ------------------
 2599|      4|                case 0x4d:
  ------------------
  |  Branch (2599:17): [True: 0, False: 48]
  ------------------
 2600|      4|                {
 2601|      4|                    array_tag_ = typed_array_tags::int16;
 2602|      4|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2603|      4|                    read(array_buffer, ec);
 2604|      4|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 2605|      0|                    {
 2606|      0|                        more_ = false;
 2607|      0|                        return;
 2608|      0|                    }
 2609|      4|                    const uint8_t tag = (uint8_t)raw_tag_;
 2610|      4|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2611|      4|                    auto ta = typed_array_cast<int16_t>(array_buffer);
 2612|      4|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2612:25): [True: 4, False: 0]
  ------------------
 2613|      4|                    {
 2614|   115k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2614:49): [True: 115k, False: 4]
  ------------------
 2615|   115k|                        {
 2616|   115k|                            ta[i] = binary::byte_swap<int16_t>(ta[i]);
 2617|   115k|                        }
 2618|      4|                    }
 2619|      4|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2619:25): [True: 0, False: 4]
  |  Branch (2619:42): [True: 0, False: 0]
  ------------------
 2620|      0|                    {
 2621|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2621:29): [True: 0, False: 0]
  ------------------
 2622|      0|                        {
 2623|      0|                            ec = cbor_errc::bad_extents;
 2624|      0|                            more_ = false;
 2625|      0|                            return;
 2626|      0|                        }
 2627|      0|                        auto iter = std::make_shared<mdarray_iterator<int16_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2628|      0|                            typed_array_tags::int16, extents_, order_, alloc_);
 2629|      0|                        typed_array_stack_.push_back(iter);
 2630|      0|                        iter->next(visitor, *this, ec);
 2631|      0|                    }
 2632|      4|                    else
 2633|      4|                    {
 2634|      4|                        auto iter = std::make_shared<oned_typed_array_iterator<int16_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2635|      4|                            typed_array_tags::int16, semantic_tag::none, alloc_);
 2636|      4|                        typed_array_stack_.push_back(iter);
 2637|      4|                        iter->next(visitor, *this, ec);
 2638|      4|                    }
 2639|      4|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2640|      4|                    more_ = !cursor_mode_;
 2641|      4|                    break;
 2642|      4|                }
 2643|      9|                case 0x4a:
  ------------------
  |  Branch (2643:17): [True: 9, False: 39]
  ------------------
 2644|      9|                case 0x4e:
  ------------------
  |  Branch (2644:17): [True: 0, False: 48]
  ------------------
 2645|      9|                {
 2646|      9|                    array_tag_ = typed_array_tags::int32;
 2647|      9|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2648|      9|                    read(array_buffer, ec);
 2649|      9|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      9|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 7]
  |  |  ------------------
  ------------------
 2650|      2|                    {
 2651|      2|                        more_ = false;
 2652|      2|                        return;
 2653|      2|                    }
 2654|      7|                    const uint8_t tag = (uint8_t)raw_tag_;
 2655|      7|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2656|      7|                    auto ta = typed_array_cast<int32_t>(array_buffer);
 2657|      7|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2657:25): [True: 7, False: 0]
  ------------------
 2658|      7|                    {
 2659|  80.3k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2659:49): [True: 80.2k, False: 7]
  ------------------
 2660|  80.2k|                        {
 2661|  80.2k|                            ta[i] = binary::byte_swap<int32_t>(ta[i]);
 2662|  80.2k|                        }
 2663|      7|                    }
 2664|      7|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2664:25): [True: 0, False: 7]
  |  Branch (2664:42): [True: 0, False: 0]
  ------------------
 2665|      0|                    {
 2666|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2666:29): [True: 0, False: 0]
  ------------------
 2667|      0|                        {
 2668|      0|                            ec = cbor_errc::bad_extents;
 2669|      0|                            more_ = false;
 2670|      0|                            return;
 2671|      0|                        }
 2672|      0|                        auto iter = std::make_shared<mdarray_iterator<int32_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2673|      0|                            typed_array_tags::int32, extents_, order_, alloc_);
 2674|      0|                        typed_array_stack_.push_back(iter);
 2675|      0|                        iter->next(visitor, *this, ec);
 2676|      0|                    }
 2677|      7|                    else
 2678|      7|                    {
 2679|      7|                        auto iter = std::make_shared<oned_typed_array_iterator<int32_t,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2680|      7|                            typed_array_tags::int32, semantic_tag::none, alloc_);
 2681|      7|                        typed_array_stack_.push_back(iter);
 2682|      7|                        iter->next(visitor, *this, ec);
 2683|      7|                    }
 2684|      7|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2685|      7|                    more_ = !cursor_mode_;
 2686|      7|                    break;
 2687|      7|                }
 2688|      1|                case 0x4b:
  ------------------
  |  Branch (2688:17): [True: 1, False: 47]
  ------------------
 2689|      1|                case 0x4f:
  ------------------
  |  Branch (2689:17): [True: 0, False: 48]
  ------------------
 2690|      1|                {
 2691|      1|                    array_tag_ = typed_array_tags::int64;
 2692|      1|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2693|      1|                    read(array_buffer, ec);
 2694|      1|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 2695|      1|                    {
 2696|      1|                        more_ = false;
 2697|      1|                        return;
 2698|      1|                    }
 2699|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2700|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2701|      0|                    auto ta = typed_array_cast<int64_t>(array_buffer);
 2702|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2702:25): [True: 0, False: 0]
  ------------------
 2703|      0|                    {
 2704|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2704:49): [True: 0, False: 0]
  ------------------
 2705|      0|                        {
 2706|      0|                            ta[i] = binary::byte_swap<int64_t>(ta[i]);
 2707|      0|                        }
 2708|      0|                    }
 2709|      0|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2709:25): [True: 0, False: 0]
  |  Branch (2709:42): [True: 0, False: 0]
  ------------------
 2710|      0|                    {
 2711|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2711:29): [True: 0, False: 0]
  ------------------
 2712|      0|                        {
 2713|      0|                            ec = cbor_errc::bad_extents;
 2714|      0|                            more_ = false;
 2715|      0|                            return;
 2716|      0|                        }
 2717|      0|                        auto iter = std::make_shared<mdarray_iterator<int64_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2718|      0|                            typed_array_tags::int64, extents_, order_, alloc_);
 2719|      0|                        typed_array_stack_.push_back(iter);
 2720|      0|                        iter->next(visitor, *this, ec);
 2721|      0|                    }
 2722|      0|                    else
 2723|      0|                    {
 2724|      0|                        auto iter = std::make_shared<oned_typed_array_iterator<int64_t,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2725|      0|                            typed_array_tags::int64, semantic_tag::none, alloc_);
 2726|      0|                        typed_array_stack_.push_back(iter);
 2727|      0|                        iter->next(visitor, *this, ec);
 2728|      0|                    }
 2729|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2730|      0|                    more_ = !cursor_mode_;
 2731|      0|                    break;
 2732|      0|                }
 2733|      1|                case 0x50:
  ------------------
  |  Branch (2733:17): [True: 1, False: 47]
  ------------------
 2734|      1|                case 0x54:
  ------------------
  |  Branch (2734:17): [True: 0, False: 48]
  ------------------
 2735|      1|                {
 2736|      1|                    array_tag_ = typed_array_tags::half_float;
 2737|      1|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2738|      1|                    read(array_buffer, ec);
 2739|      1|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2740|      0|                    {
 2741|      0|                        more_ = false;
 2742|      0|                        return;
 2743|      0|                    }
 2744|      1|                    const uint8_t tag = (uint8_t)raw_tag_;
 2745|      1|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2746|      1|                    auto ta = typed_array_cast<uint16_t>(array_buffer);
 2747|      1|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2747:25): [True: 1, False: 0]
  ------------------
 2748|      1|                    {
 2749|  32.7k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2749:49): [True: 32.7k, False: 1]
  ------------------
 2750|  32.7k|                        {
 2751|  32.7k|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2752|  32.7k|                        }
 2753|      1|                    }
 2754|      1|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2754:25): [True: 0, False: 1]
  |  Branch (2754:42): [True: 0, False: 0]
  ------------------
 2755|      0|                    {
 2756|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2756:29): [True: 0, False: 0]
  ------------------
 2757|      0|                        {
 2758|      0|                            ec = cbor_errc::bad_extents;
 2759|      0|                            more_ = false;
 2760|      0|                            return;
 2761|      0|                        }
 2762|      0|                        auto iter = std::make_shared<mdarray_iterator<uint16_t,decode_half,Allocator>>(std::move(array_buffer), 
 2763|      0|                            typed_array_tags::half_float, extents_, order_, alloc_);
 2764|      0|                        typed_array_stack_.push_back(iter);
 2765|      0|                        iter->next(visitor, *this, ec);
 2766|      0|                    }
 2767|      1|                    else
 2768|      1|                    {
 2769|      1|                        auto iter = std::make_shared<oned_typed_array_iterator<uint16_t,decode_half,Allocator>>(std::move(array_buffer),
 2770|      1|                            typed_array_tags::half_float, semantic_tag::none, alloc_);
 2771|      1|                        typed_array_stack_.push_back(iter);
 2772|      1|                        iter->next(visitor, *this, ec);
 2773|      1|                    }
 2774|      1|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2775|      1|                    more_ = !cursor_mode_;
 2776|      1|                    break;
 2777|      1|                }
 2778|      1|                case 0x51:
  ------------------
  |  Branch (2778:17): [True: 1, False: 47]
  ------------------
 2779|      1|                case 0x55:
  ------------------
  |  Branch (2779:17): [True: 0, False: 48]
  ------------------
 2780|      1|                {
 2781|      1|                    array_tag_ = typed_array_tags::float32;
 2782|      1|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2783|      1|                    read(array_buffer, ec);
 2784|      1|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2785|      0|                    {
 2786|      0|                        more_ = false;
 2787|      0|                        return;
 2788|      0|                    }
 2789|      1|                    const uint8_t tag = (uint8_t)raw_tag_;
 2790|      1|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2791|      1|                    auto ta = typed_array_cast<float>(array_buffer);
 2792|      1|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2792:25): [True: 1, False: 0]
  ------------------
 2793|      1|                    {
 2794|  1.79k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2794:49): [True: 1.79k, False: 1]
  ------------------
 2795|  1.79k|                        {
 2796|  1.79k|                            ta[i] = binary::byte_swap<float>(ta[i]);
 2797|  1.79k|                        }
 2798|      1|                    }
 2799|      1|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2799:25): [True: 0, False: 1]
  |  Branch (2799:42): [True: 0, False: 0]
  ------------------
 2800|      0|                    {
 2801|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2801:29): [True: 0, False: 0]
  ------------------
 2802|      0|                        {
 2803|      0|                            ec = cbor_errc::bad_extents;
 2804|      0|                            more_ = false;
 2805|      0|                            return;
 2806|      0|                        }
 2807|      0|                        auto iter = std::make_shared<mdarray_iterator<float,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2808|      0|                            typed_array_tags::float32, extents_, order_, alloc_);
 2809|      0|                        typed_array_stack_.push_back(iter);
 2810|      0|                        iter->next(visitor, *this, ec);
 2811|      0|                    }
 2812|      1|                    else
 2813|      1|                    {
 2814|      1|                        auto iter = std::make_shared<oned_typed_array_iterator<float,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2815|      1|                            typed_array_tags::float32, semantic_tag::none, alloc_);
 2816|      1|                        typed_array_stack_.push_back(iter);
 2817|      1|                        iter->next(visitor, *this, ec);
 2818|      1|                    }
 2819|      1|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2820|      1|                    more_ = !cursor_mode_;
 2821|      1|                    break;
 2822|      1|                }
 2823|      1|                case 0x52:
  ------------------
  |  Branch (2823:17): [True: 1, False: 47]
  ------------------
 2824|      1|                case 0x56:
  ------------------
  |  Branch (2824:17): [True: 0, False: 48]
  ------------------
 2825|      1|                {
 2826|      1|                    array_tag_ = typed_array_tags::float64;
 2827|      1|                    std::vector<uint8_t,byte_allocator_type> array_buffer(alloc_);
 2828|      1|                    read(array_buffer, ec);
 2829|      1|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2830|      0|                    {
 2831|      0|                        more_ = false;
 2832|      0|                        return;
 2833|      0|                    }
 2834|      1|                    const uint8_t tag = (uint8_t)raw_tag_;
 2835|      1|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2836|      1|                    auto ta = typed_array_cast<double>(array_buffer);
 2837|      1|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2837:25): [True: 1, False: 0]
  ------------------
 2838|      1|                    {
 2839|  8.17k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2839:49): [True: 8.17k, False: 1]
  ------------------
 2840|  8.17k|                        {
 2841|  8.17k|                            ta[i] = binary::byte_swap<double>(ta[i]);
 2842|  8.17k|                        }
 2843|      1|                    }
 2844|      1|                    if (!cursor_mode_ && state_stack_.back().mode == parse_mode::multi_dim) 
  ------------------
  |  Branch (2844:25): [True: 0, False: 1]
  |  Branch (2844:42): [True: 0, False: 0]
  ------------------
 2845|      0|                    {
 2846|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2846:29): [True: 0, False: 0]
  ------------------
 2847|      0|                        {
 2848|      0|                            ec = cbor_errc::bad_extents;
 2849|      0|                            more_ = false;
 2850|      0|                            return;
 2851|      0|                        }
 2852|      0|                        auto iter = std::make_shared<mdarray_iterator<double,jsoncons::identity,Allocator>>(std::move(array_buffer), 
 2853|      0|                            typed_array_tags::float64, extents_, order_, alloc_);
 2854|      0|                        typed_array_stack_.push_back(iter);
 2855|      0|                        iter->next(visitor, *this, ec);
 2856|      0|                    }
 2857|      1|                    else
 2858|      1|                    {
 2859|      1|                        auto iter = std::make_shared<oned_typed_array_iterator<double,jsoncons::identity,Allocator>>(std::move(array_buffer),
 2860|      1|                            typed_array_tags::float64, semantic_tag::none, alloc_);
 2861|      1|                        typed_array_stack_.push_back(iter);
 2862|      1|                        iter->next(visitor, *this, ec);
 2863|      1|                    }
 2864|      1|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2865|      1|                    more_ = !cursor_mode_;
 2866|      1|                    break;
 2867|      1|                }
 2868|      5|                default:
  ------------------
  |  Branch (2868:17): [True: 5, False: 43]
  ------------------
 2869|      5|                {
 2870|      5|                    auto bytes = read.view(ec);
 2871|      5|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 5, False: 0]
  |  |  ------------------
  ------------------
 2872|      5|                    {
 2873|      5|                        more_ = false;
 2874|      5|                        return;
 2875|      5|                    }
 2876|      0|                    visitor.byte_string_value(bytes, raw_tag_, *this, ec);
 2877|      0|                    more_ = !cursor_mode_;
 2878|      0|                    break;
 2879|      5|                }
 2880|     48|            }
 2881|     31|            other_tags_[item_tag] = false;
 2882|     31|        }
 2883|    116|        else
 2884|    116|        {
 2885|    116|            auto bytes = read.view(ec);
 2886|    116|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    116|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 112, False: 4]
  |  |  ------------------
  ------------------
 2887|    112|            {
 2888|    112|                return;
 2889|    112|            }
 2890|      4|            visitor.byte_string_value(bytes, semantic_tag::none, *this, ec);
 2891|      4|            more_ = !cursor_mode_;
 2892|      4|        }
 2893|    164|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_source4viewERNS3_10error_codeE:
  326|    138|        {
  327|    138|            return source->read_byte_string_view(ec);
  328|    138|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_byte_string_viewERNS3_10error_codeE:
 1260|    138|    {
 1261|    138|        auto c = source_.peek();
 1262|    138|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|    138|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 138]
  |  |  ------------------
  ------------------
 1263|      0|        {
 1264|      0|            ec = cbor_errc::unexpected_eof;
 1265|      0|            more_ = false;
 1266|      0|            return byte_string_view();
 1267|      0|        }
 1268|    138|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1269|    138|        uint8_t info = get_additional_information(c.value);
 1270|    138|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|    245|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 138]
  |  |  |  Branch (79:50): [True: 107, False: 31]
  |  |  |  Branch (79:50): [True: 0, False: 107]
  |  |  ------------------
  ------------------
 1271|      0|        {
 1272|      0|            ec = cbor_errc::reserved_additional_info;
 1273|      0|            more_ = false;
 1274|      0|            return byte_string_view();
 1275|      0|        }
 1276|       |
 1277|    138|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::byte_string);
  ------------------
  |  |   54|    138|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 138]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1278|       |
 1279|    138|        source_.ignore(1);
 1280|    138|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1280:13): [True: 107, False: 31]
  ------------------
 1281|    107|        {
 1282|    107|            bytes_buffer_.clear();
 1283|    107|            iterate_byte_string_chunks(bytes_buffer_, ec);
 1284|    107|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|    107|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 98, False: 9]
  |  |  ------------------
  ------------------
 1285|     98|            {
 1286|     98|                return byte_string_view();
 1287|     98|            }
 1288|      9|            return byte_string_view(bytes_buffer_.data(), bytes_buffer_.size());
 1289|    107|        }
 1290|       |
 1291|     31|        std::size_t length = read_size(info, ec);
 1292|     31|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     31|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 31]
  |  |  ------------------
  ------------------
 1293|      0|        {
 1294|      0|            return byte_string_view();
 1295|      0|        }
 1296|     31|        auto data = source_.read_span(length, bytes_buffer_);
 1297|     31|        if (data.size() != length)
  ------------------
  |  Branch (1297:13): [True: 24, False: 7]
  ------------------
 1298|     24|        {
 1299|     24|            ec = cbor_errc::unexpected_eof;
 1300|     24|            more_ = false;
 1301|     24|            return byte_string_view();
 1302|     24|        }
 1303|       |        
 1304|      7|        byte_string_view bytes(data.data(), data.size());
 1305|      7|        if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1305:13): [True: 0, False: 7]
  ------------------
 1306|      0|            bytes.size() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1306:13): [True: 0, False: 0]
  ------------------
 1307|      0|        {
 1308|      0|            stringref_map_stack_.back().emplace_back(mapped_string(bytes, alloc_));
 1309|      0|        }
 1310|      7|        return bytes;
 1311|     31|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE26iterate_byte_string_chunksINS3_6vectorIhS5_EEEEvRT_RNS3_10error_codeE:
 1444|    147|    {
 1445|    147|        bool done = false;
 1446|  1.17M|        while (!done)
  ------------------
  |  Branch (1446:16): [True: 1.17M, False: 40]
  ------------------
 1447|  1.17M|        {
 1448|  1.17M|            auto c = source_.peek();
 1449|  1.17M|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|  1.17M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 11, False: 1.17M]
  |  |  ------------------
  ------------------
 1450|     11|            {
 1451|     11|                ec = cbor_errc::unexpected_eof;
 1452|     11|                more_ = false;
 1453|     11|                return;
 1454|     11|            }
 1455|  1.17M|            if (c.value == 0xff)
  ------------------
  |  Branch (1455:17): [True: 40, False: 1.17M]
  ------------------
 1456|     40|            {
 1457|     40|                source_.ignore(1);
 1458|     40|                done = true;
 1459|     40|                continue;
 1460|     40|            }
 1461|       |
 1462|  1.17M|            jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1463|  1.17M|            if (major_type != jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (1463:17): [True: 5, False: 1.17M]
  ------------------
 1464|      5|            {
 1465|      5|                ec = cbor_errc::illegal_chunked_string;
 1466|      5|                more_ = false;
 1467|      5|                return;
 1468|      5|            }
 1469|  1.17M|            uint8_t info = get_additional_information(c.value);
 1470|  1.17M|            if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1470:17): [True: 0, False: 1.17M]
  ------------------
 1471|      0|            {
 1472|      0|                ec = cbor_errc::illegal_chunked_string;
 1473|      0|                more_ = false;
 1474|      0|                return;
 1475|      0|            }
 1476|       |
 1477|  1.17M|            source_.ignore(1);
 1478|  1.17M|            std::size_t length = read_size(info, ec);
 1479|  1.17M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  1.17M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1.17M]
  |  |  ------------------
  ------------------
 1480|      0|            {
 1481|      0|                return;
 1482|      0|            }
 1483|  1.17M|            if (source_reader<Source>::read(source_, v, length) != length)
  ------------------
  |  Branch (1483:17): [True: 91, False: 1.17M]
  ------------------
 1484|     91|            {
 1485|     91|                ec = cbor_errc::unexpected_eof;
 1486|     91|            }
 1487|  1.17M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  1.17M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 91, False: 1.17M]
  |  |  ------------------
  ------------------
 1488|     91|            {
 1489|     91|                return;
 1490|     91|            }
 1491|  1.17M|        }
 1492|    147|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_sizeEhRNS3_10error_codeE:
 1314|  9.39M|    {
 1315|  9.39M|        uint64_t u = read_unsigned_integer(info, ec);
 1316|  9.39M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  9.39M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 6, False: 9.39M]
  |  |  ------------------
  ------------------
 1317|      6|        {
 1318|      6|            return 0;
 1319|      6|        }
 1320|  9.39M|        std::size_t len = static_cast<std::size_t>(u);
 1321|  9.39M|        if (len != u)
  ------------------
  |  Branch (1321:13): [True: 0, False: 9.39M]
  ------------------
 1322|      0|        {
 1323|      0|            ec = cbor_errc::number_too_large;
 1324|      0|            more_ = false;
 1325|      0|        }
 1326|  9.39M|        return len;
 1327|  9.39M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_sourceclINS3_6vectorIhS5_EEEEvRT_RNS3_10error_codeE:
  321|     26|        {
  322|     26|            source->read_byte_string(cont,ec);
  323|     26|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringERNS3_6vectorIhS5_EERNS3_10error_codeE:
 1330|     58|    {
 1331|     58|        v.clear();
 1332|     58|        auto c = source_.peek();
 1333|     58|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|     58|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 58]
  |  |  ------------------
  ------------------
 1334|      0|        {
 1335|      0|            ec = cbor_errc::unexpected_eof;
 1336|      0|            return;
 1337|      0|        }
 1338|     58|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1339|     58|        uint8_t info = get_additional_information(c.value);
 1340|     58|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|     98|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 58]
  |  |  |  Branch (79:50): [True: 40, False: 18]
  |  |  |  Branch (79:50): [True: 0, False: 40]
  |  |  ------------------
  ------------------
 1341|      0|        {
 1342|      0|            ec = cbor_errc::reserved_additional_info;
 1343|      0|            more_ = false;
 1344|      0|            return;
 1345|      0|        }
 1346|       |
 1347|     58|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::byte_string);
  ------------------
  |  |   54|     58|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 58]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1348|       |
 1349|     58|        source_.ignore(1);
 1350|     58|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1350:13): [True: 40, False: 18]
  ------------------
 1351|     40|        {
 1352|     40|            iterate_byte_string_chunks(v, ec);
 1353|     40|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     40|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 9, False: 31]
  |  |  ------------------
  ------------------
 1354|      9|            {
 1355|      9|                return;
 1356|      9|            }
 1357|     40|        }
 1358|     18|        else 
 1359|     18|        {
 1360|     18|            std::size_t length = read_size(info, ec);
 1361|     18|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     18|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 18]
  |  |  ------------------
  ------------------
 1362|      0|            {
 1363|      0|                return;
 1364|      0|            }
 1365|     18|            if (source_reader<Source>::read(source_, v, length) != length)
  ------------------
  |  Branch (1365:17): [True: 4, False: 14]
  ------------------
 1366|      4|            {
 1367|      4|                ec = cbor_errc::unexpected_eof;
 1368|      4|                return;
 1369|      4|            }
 1370|     14|            if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1370:17): [True: 0, False: 14]
  ------------------
 1371|      0|                v.size() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1371:17): [True: 0, False: 0]
  ------------------
 1372|      0|            {
 1373|      0|                stringref_map_stack_.back().emplace_back(mapped_string(v, alloc_));
 1374|      0|            }
 1375|     14|        }
 1376|     58|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_text_string_viewEhRNS3_10error_codeE:
 1226|     95|    {
 1227|     95|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1227:13): [True: 75, False: 20]
  ------------------
 1228|     75|        {
 1229|     75|            text_buffer_.clear();
 1230|     75|            iterate_text_string_chunks(text_buffer_, ec);
 1231|     75|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     75|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 57, False: 18]
  |  |  ------------------
  ------------------
 1232|     57|            {
 1233|     57|                return string_view_type();
 1234|     57|            }
 1235|     18|            return string_view_type(text_buffer_.data(), text_buffer_.size());
 1236|     75|        }
 1237|       |
 1238|     20|        std::size_t length = read_size(info, ec);
 1239|     20|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     20|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 20]
  |  |  ------------------
  ------------------
 1240|      0|        {
 1241|      0|            return string_view_type();
 1242|      0|        }
 1243|     20|        auto data = source_.read_span(length, text_buffer_);
 1244|     20|        if (data.size() != length)
  ------------------
  |  Branch (1244:13): [True: 15, False: 5]
  ------------------
 1245|     15|        {
 1246|     15|            ec = cbor_errc::unexpected_eof;
 1247|     15|            more_ = false;
 1248|     15|            return string_view_type();
 1249|     15|        }
 1250|      5|        string_view_type sv(reinterpret_cast<const char_type*>(data.data()), data.size());
 1251|      5|        if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1251:13): [True: 0, False: 5]
  ------------------
 1252|      0|            sv.length() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1252:13): [True: 0, False: 0]
  ------------------
 1253|      0|        {
 1254|      0|            stringref_map_stack_.back().emplace_back(mapped_string(sv,alloc_));
 1255|      0|        }
 1256|      5|        return sv;
 1257|     20|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE26iterate_text_string_chunksINS3_12basic_stringIcNS3_11char_traitsIcEES7_EEEEvRT_RNS3_10error_codeE:
 1380|     75|    {
 1381|     75|        bool done = false;
 1382|  1.96M|        while (!done)
  ------------------
  |  Branch (1382:16): [True: 1.96M, False: 18]
  ------------------
 1383|  1.96M|        {
 1384|  1.96M|            auto c = source_.peek();
 1385|  1.96M|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|  1.96M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 7, False: 1.96M]
  |  |  ------------------
  ------------------
 1386|      7|            {
 1387|      7|                ec = cbor_errc::unexpected_eof;
 1388|      7|                more_ = false;
 1389|      7|                return;
 1390|      7|            }
 1391|  1.96M|            if (c.value == 0xff)
  ------------------
  |  Branch (1391:17): [True: 18, False: 1.96M]
  ------------------
 1392|     18|            {
 1393|     18|                source_.ignore(1);
 1394|     18|                done = true;
 1395|     18|                continue;
 1396|     18|            }
 1397|       |
 1398|  1.96M|            jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1399|  1.96M|            if (major_type != jsoncons::cbor::detail::cbor_major_type::text_string)
  ------------------
  |  Branch (1399:17): [True: 1, False: 1.96M]
  ------------------
 1400|      1|            {
 1401|      1|                ec = cbor_errc::illegal_chunked_string;
 1402|      1|                more_ = false;
 1403|      1|                return;
 1404|      1|            }
 1405|  1.96M|            uint8_t info = get_additional_information(c.value);
 1406|  1.96M|            if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1406:17): [True: 0, False: 1.96M]
  ------------------
 1407|      0|            {
 1408|      0|                ec = cbor_errc::illegal_chunked_string;
 1409|      0|                more_ = false;
 1410|      0|                return;
 1411|      0|            }
 1412|       |
 1413|  1.96M|            source_.ignore(1);
 1414|  1.96M|            std::size_t length = read_size(info, ec);
 1415|  1.96M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  1.96M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1.96M]
  |  |  ------------------
  ------------------
 1416|      0|            {
 1417|      0|                return;
 1418|      0|            }
 1419|  1.96M|            const std::size_t offset = v.size();
 1420|  1.96M|            if (source_reader<Source>::read(source_, v, length) != length)
  ------------------
  |  Branch (1420:17): [True: 45, False: 1.96M]
  ------------------
 1421|     45|            {
 1422|     45|                ec = cbor_errc::unexpected_eof;
 1423|     45|            }
 1424|  1.96M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  1.96M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 45, False: 1.96M]
  |  |  ------------------
  ------------------
 1425|     45|            {
 1426|     45|                return;
 1427|     45|            }
 1428|       |            // RFC 8949 3.2.3: each chunk of an indefinite-length text
 1429|       |            // string must itself be well-formed UTF-8, so a code point
 1430|       |            // may not be split across chunks.
 1431|  1.96M|            auto result = unicode_traits::validate(
 1432|  1.96M|                reinterpret_cast<const char*>(v.data()) + offset, length);
 1433|  1.96M|            if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (1433:17): [True: 4, False: 1.96M]
  ------------------
 1434|      4|            {
 1435|      4|                ec = cbor_errc::invalid_utf8_text_string;
 1436|      4|                more_ = false;
 1437|      4|                return;
 1438|      4|            }
 1439|  1.96M|        }
 1440|     75|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11read_doubleEhRNS3_10error_codeE:
 1785|      2|    {
 1786|      2|        double val = 0;
 1787|       |
 1788|      2|        switch (info)
 1789|      2|        {
 1790|      1|            case 0x1a: // Single-Precision Float (four-byte IEEE 754)
  ------------------
  |  Branch (1790:13): [True: 1, False: 1]
  ------------------
 1791|      1|            {
 1792|      1|                uint8_t buf[sizeof(float)];
 1793|      1|                if (source_.read(buf, sizeof(float)) !=sizeof(float)) 
  ------------------
  |  Branch (1793:21): [True: 0, False: 1]
  ------------------
 1794|      0|                {
 1795|      0|                    ec = cbor_errc::unexpected_eof;
 1796|      0|                    more_ = false;
 1797|      0|                    return 0;
 1798|      0|                }
 1799|      1|                val = binary::big_to_native<float>(buf, sizeof(buf));
 1800|      1|                break;
 1801|      1|            }
 1802|       |
 1803|      1|            case 0x1b: //  Double-Precision Float (eight-byte IEEE 754)
  ------------------
  |  Branch (1803:13): [True: 1, False: 1]
  ------------------
 1804|      1|            {
 1805|      1|                uint8_t buf[sizeof(double)];
 1806|      1|                if (source_.read(buf, sizeof(double)) != sizeof(double))
  ------------------
  |  Branch (1806:21): [True: 0, False: 1]
  ------------------
 1807|      0|                {
 1808|      0|                    ec = cbor_errc::unexpected_eof;
 1809|      0|                    more_ = false;
 1810|      0|                    return 0;
 1811|      0|                }
 1812|      1|                val = binary::big_to_native<double>(buf, sizeof(buf));
 1813|      1|                break;
 1814|      1|            }
 1815|      0|            default:
  ------------------
  |  Branch (1815:13): [True: 0, False: 2]
  ------------------
 1816|      0|            {
 1817|      0|                ec = cbor_errc::unknown_type;
 1818|      0|                more_ = false;
 1819|      0|                return 0;
 1820|      1|            }
 1821|      2|        }
 1822|       |        
 1823|      2|        return val;
 1824|      2|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE15read_bigdecimalEhRNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 1827|     21|    {
 1828|     21|        std::size_t size = read_unsigned_integer(container_info, ec);
 1829|     21|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     21|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 21]
  |  |  ------------------
  ------------------
 1830|      0|        {
 1831|      0|            return;
 1832|      0|        }
 1833|     21|        if (size != 2)
  ------------------
  |  Branch (1833:13): [True: 0, False: 21]
  ------------------
 1834|      0|        {
 1835|      0|            ec = cbor_errc::invalid_bigdecimal;
 1836|      0|            more_ = false;
 1837|      0|            return;
 1838|      0|        }
 1839|       |
 1840|     21|        auto c = source_.peek();
 1841|     21|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|     21|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 21]
  |  |  ------------------
  ------------------
 1842|      0|        {
 1843|      0|            ec = cbor_errc::unexpected_eof;
 1844|      0|            more_ = false;
 1845|      0|            return;
 1846|      0|        }
 1847|     21|        int64_t exponent = 0;
 1848|     21|        auto major_type = get_major_type(c.value);
 1849|     21|        auto info = get_additional_information(c.value);
 1850|     21|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|     21|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 21]
  |  |  |  Branch (79:50): [True: 0, False: 21]
  |  |  |  Branch (79:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1851|      0|        {
 1852|      0|            ec = cbor_errc::reserved_additional_info;
 1853|      0|            more_ = false;
 1854|      0|            return;
 1855|      0|        }
 1856|       |
 1857|     21|        switch (major_type)
 1858|     21|        {
 1859|      1|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1859:13): [True: 1, False: 20]
  ------------------
 1860|      1|            {
 1861|      1|                source_.ignore(1);
 1862|      1|                auto u = read_unsigned_integer(info, ec);
 1863|      1|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1864|      0|                {
 1865|      0|                    return;
 1866|      0|                }
 1867|      1|                if (u > static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1867:21): [True: 0, False: 1]
  ------------------
 1868|      0|                {
 1869|      0|                    ec = cbor_errc::bigdec_scale_overflow;
 1870|      0|                    more_ = false;
 1871|      0|                    return;
 1872|      0|                }
 1873|      1|                exponent = static_cast<int64_t>(u);
 1874|      1|                break;
 1875|      1|            }
 1876|     20|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1876:13): [True: 20, False: 1]
  ------------------
 1877|     20|            {
 1878|     20|                exponent = read_int64(ec);
 1879|     20|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     20|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 20]
  |  |  ------------------
  ------------------
 1880|      0|                {
 1881|      0|                    return;
 1882|      0|                }
 1883|     20|                break;
 1884|     20|            }
 1885|     20|            default:
  ------------------
  |  Branch (1885:13): [True: 0, False: 21]
  ------------------
 1886|      0|            {
 1887|      0|                ec = cbor_errc::invalid_bigdecimal;
 1888|      0|                more_ = false;
 1889|      0|                return;
 1890|     20|            }
 1891|     21|        }
 1892|       |
 1893|     21|        c = source_.peek();
 1894|     21|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|     21|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 21]
  |  |  ------------------
  ------------------
 1895|      0|        {
 1896|      0|            ec = cbor_errc::unexpected_eof;
 1897|      0|            more_ = false;
 1898|      0|            return;
 1899|      0|        }
 1900|       |
 1901|     21|        major_type = get_major_type(c.value);
 1902|     21|        info = get_additional_information(c.value);
 1903|     21|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|     21|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 21]
  |  |  |  Branch (79:50): [True: 0, False: 21]
  |  |  |  Branch (79:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1904|      0|        {
 1905|      0|            ec = cbor_errc::reserved_additional_info;
 1906|      0|            more_ = false;
 1907|      0|            return;
 1908|      0|        }
 1909|       |
 1910|     21|        bigint unscaled;
 1911|     21|        switch (major_type)
 1912|     21|        {
 1913|      1|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1913:13): [True: 1, False: 20]
  ------------------
 1914|      1|            {
 1915|      1|                source_.ignore(1);
 1916|      1|                uint64_t u = read_unsigned_integer(info, ec);
 1917|      1|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1918|      0|                {
 1919|      0|                    return;
 1920|      0|                }
 1921|      1|                unscaled = bigint(u);
 1922|      1|                break;
 1923|      1|            }
 1924|      0|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1924:13): [True: 0, False: 21]
  ------------------
 1925|      0|            {
 1926|      0|                source_.ignore(1);
 1927|      0|                auto u = read_unsigned_integer(info, ec);
 1928|      0|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1929|      0|                {
 1930|      0|                    return;
 1931|      0|                }
 1932|      0|                if (u > static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1932:21): [True: 0, False: 0]
  ------------------
 1933|      0|                {
 1934|      0|                    unscaled = -1 - bigint(u);
 1935|      0|                }
 1936|      0|                else if (JSONCONS_UNLIKELY(u == static_cast<uint64_t>((std::numeric_limits<int64_t>::max)())))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1937|      0|                {
 1938|      0|                    unscaled = bigint((std::numeric_limits<int64_t>::min)());
 1939|      0|                }
 1940|      0|                else
 1941|      0|                {
 1942|      0|                    unscaled = bigint(static_cast<int64_t>(-1) - static_cast<int64_t>(u));
 1943|      0|                }
 1944|      0|                break;
 1945|      0|            }
 1946|     20|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (1946:13): [True: 20, False: 1]
  ------------------
 1947|     20|            {
 1948|     20|                uint8_t b;
 1949|     20|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1949:21): [True: 0, False: 20]
  ------------------
 1950|      0|                {
 1951|      0|                    ec = cbor_errc::unexpected_eof;
 1952|      0|                    more_ = false;
 1953|      0|                    return;
 1954|      0|                }
 1955|     20|                info = get_additional_information(b);
 1956|     20|                if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|     20|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 20]
  |  |  |  Branch (79:50): [True: 0, False: 20]
  |  |  |  Branch (79:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1957|      0|                {
 1958|      0|                    ec = cbor_errc::reserved_additional_info;
 1959|      0|                    more_ = false;
 1960|      0|                    return;
 1961|      0|                }
 1962|     20|                c = source_.peek();
 1963|     20|                if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|     20|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 20]
  |  |  ------------------
  ------------------
 1964|      0|                {
 1965|      0|                    ec = cbor_errc::unexpected_eof;
 1966|      0|                    more_ = false;
 1967|      0|                    return;
 1968|      0|                }
 1969|       |
 1970|     20|                if (get_major_type(c.value) == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (1970:21): [True: 20, False: 0]
  ------------------
 1971|     20|                {
 1972|     20|                    bytes_buffer_.clear();
 1973|     20|                    read_byte_string(bytes_buffer_, ec);
 1974|     20|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     20|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 18]
  |  |  ------------------
  ------------------
 1975|      2|                    {
 1976|      2|                        more_ = false;
 1977|      2|                        return;
 1978|      2|                    }
 1979|     18|                    if (info == 2)
  ------------------
  |  Branch (1979:25): [True: 2, False: 16]
  ------------------
 1980|      2|                    {
 1981|      2|                        unscaled = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1982|      2|                    }
 1983|     16|                    else if (info == 3)
  ------------------
  |  Branch (1983:30): [True: 16, False: 0]
  ------------------
 1984|     16|                    {
 1985|     16|                        unscaled = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1986|     16|                        unscaled = -1 - unscaled;
 1987|     16|                    }
 1988|     18|                }
 1989|     18|                break;
 1990|     20|            }
 1991|     18|            default:
  ------------------
  |  Branch (1991:13): [True: 0, False: 21]
  ------------------
 1992|      0|            {
 1993|      0|                ec = cbor_errc::invalid_bigdecimal;
 1994|      0|                more_ = false;
 1995|      0|                return;
 1996|     20|            }
 1997|     21|        }
 1998|       |
 1999|     19|        bigdec dec(std::move(unscaled), -exponent);
 2000|     19|        append_to_buffer(dec, result);
 2001|     19|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10read_int64ERNS3_10error_codeE:
 1495|     31|    {
 1496|     31|        int64_t val = 0;
 1497|       |
 1498|     31|        auto ch = source_.peek();
 1499|     31|        if (ch.eof)
  ------------------
  |  Branch (1499:13): [True: 0, False: 31]
  ------------------
 1500|      0|        {
 1501|      0|            ec = cbor_errc::unexpected_eof;
 1502|      0|            more_ = false;
 1503|      0|            return val;
 1504|      0|        }
 1505|       |
 1506|     31|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(ch.value);
 1507|     31|        uint8_t info = get_additional_information(ch.value);
 1508|     31|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|     31|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 31]
  |  |  |  Branch (79:50): [True: 0, False: 31]
  |  |  |  Branch (79:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1509|      0|        {
 1510|      0|            ec = cbor_errc::reserved_additional_info;
 1511|      0|            more_ = false;
 1512|      0|            return val;
 1513|      0|        }
 1514|     31|        switch (major_type)
 1515|     31|        {
 1516|     31|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1516:13): [True: 31, False: 0]
  ------------------
 1517|     31|                source_.ignore(1);
 1518|     31|                switch (info)
  ------------------
  |  Branch (1518:25): [True: 31, False: 0]
  ------------------
 1519|     31|                {
 1520|      5|                    case JSONCONS_EXT_CBOR_0x00_0x17: // 0x00..0x17 (0..23)
  ------------------
  |  |   18|      5|    0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:case 0x07:case 0x08:case 0x09:case 0x0a:case 0x0b:case 0x0c:case 0x0d:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16:case 0x17
  |  |  ------------------
  |  |  |  Branch (18:10): [True: 0, False: 31]
  |  |  |  Branch (18:20): [True: 0, False: 31]
  |  |  |  Branch (18:30): [True: 0, False: 31]
  |  |  |  Branch (18:40): [True: 0, False: 31]
  |  |  |  Branch (18:50): [True: 0, False: 31]
  |  |  |  Branch (18:60): [True: 0, False: 31]
  |  |  |  Branch (18:70): [True: 1, False: 30]
  |  |  |  Branch (18:80): [True: 0, False: 31]
  |  |  |  Branch (18:90): [True: 0, False: 31]
  |  |  |  Branch (18:100): [True: 0, False: 31]
  |  |  |  Branch (18:110): [True: 0, False: 31]
  |  |  |  Branch (18:120): [True: 0, False: 31]
  |  |  |  Branch (18:130): [True: 0, False: 31]
  |  |  |  Branch (18:140): [True: 0, False: 31]
  |  |  |  Branch (18:150): [True: 4, False: 27]
  |  |  |  Branch (18:160): [True: 0, False: 31]
  |  |  |  Branch (18:170): [True: 0, False: 31]
  |  |  |  Branch (18:180): [True: 0, False: 31]
  |  |  |  Branch (18:190): [True: 0, False: 31]
  |  |  |  Branch (18:200): [True: 0, False: 31]
  |  |  |  Branch (18:210): [True: 0, False: 31]
  |  |  |  Branch (18:220): [True: 0, False: 31]
  |  |  ------------------
  ------------------
  |  Branch (1520:21): [True: 0, False: 31]
  ------------------
 1521|      5|                    {
 1522|      5|                        val = static_cast<int8_t>(- 1 - info);
 1523|      5|                        break;
 1524|     48|                    }
 1525|      0|                    case 0x18: // Negative integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1525:21): [True: 0, False: 31]
  ------------------
 1526|      0|                        {
 1527|      0|                            uint8_t b;
 1528|      0|                            if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1528:33): [True: 0, False: 0]
  ------------------
 1529|      0|                            {
 1530|      0|                                ec = cbor_errc::unexpected_eof;
 1531|      0|                                more_ = false;
 1532|      0|                                return val;
 1533|      0|                            }
 1534|      0|                            val = static_cast<int64_t>(-1) - static_cast<int64_t>(b);
 1535|      0|                            break;
 1536|      0|                        }
 1537|       |
 1538|     23|                    case 0x19: // Negative integer -1-n (two-byte uint16_t follows)
  ------------------
  |  Branch (1538:21): [True: 23, False: 8]
  ------------------
 1539|     23|                        {
 1540|     23|                            uint8_t buf[sizeof(uint16_t)];
 1541|     23|                            if (source_.read(buf, sizeof(uint16_t)) != sizeof(uint16_t))
  ------------------
  |  Branch (1541:33): [True: 0, False: 23]
  ------------------
 1542|      0|                            {
 1543|      0|                                ec = cbor_errc::unexpected_eof;
 1544|      0|                                more_ = false;
 1545|      0|                                return val;
 1546|      0|                            }
 1547|     23|                            auto u = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1548|     23|                            val = static_cast<int64_t>(-1)- u;
 1549|     23|                            break;
 1550|     23|                        }
 1551|       |
 1552|      0|                    case 0x1a: // Negative integer -1-n (four-byte uint32_t follows)
  ------------------
  |  Branch (1552:21): [True: 0, False: 31]
  ------------------
 1553|      0|                        {
 1554|      0|                            uint8_t buf[sizeof(uint32_t)];
 1555|      0|                            if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (1555:33): [True: 0, False: 0]
  ------------------
 1556|      0|                            {
 1557|      0|                                ec = cbor_errc::unexpected_eof;
 1558|      0|                                more_ = false;
 1559|      0|                                return val;
 1560|      0|                            }
 1561|      0|                            auto u = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1562|      0|                            val = static_cast<int64_t>(-1)- u;
 1563|      0|                            break;
 1564|      0|                        }
 1565|       |
 1566|      3|                    case 0x1b: // Negative integer -1-n (eight-byte uint64_t follows)
  ------------------
  |  Branch (1566:21): [True: 3, False: 28]
  ------------------
 1567|      3|                        {
 1568|      3|                            uint8_t buf[sizeof(uint64_t)];
 1569|      3|                            if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (1569:33): [True: 0, False: 3]
  ------------------
 1570|      0|                            {
 1571|      0|                                ec = cbor_errc::unexpected_eof;
 1572|      0|                                more_ = false;
 1573|      0|                                return val;
 1574|      0|                            }
 1575|      3|                            auto u = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1576|      3|                            if (u > static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1576:33): [True: 0, False: 3]
  ------------------
 1577|      0|                            {
 1578|      0|                                ec = cbor_errc::invalid_bigdecimal;
 1579|      0|                                more_ = false;
 1580|      0|                                return val;
 1581|      0|                            }
 1582|      3|                            if (JSONCONS_UNLIKELY(u == static_cast<uint64_t>((std::numeric_limits<int64_t>::max)())))
  ------------------
  |  |   79|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
 1583|      0|                            {
 1584|      0|                                val = (std::numeric_limits<int64_t>::min)();
 1585|      0|                            }
 1586|      3|                            else
 1587|      3|                            {
 1588|      3|                                val = static_cast<int64_t>(-1)- static_cast<int64_t>(u);
 1589|      3|                            }
 1590|      3|                            break;
 1591|      3|                        }
 1592|     31|                }
 1593|     31|                break;
 1594|       |
 1595|     31|                case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1595:17): [True: 0, False: 31]
  ------------------
 1596|      0|                {
 1597|      0|                    source_.ignore(1);
 1598|      0|                    uint64_t u = read_unsigned_integer(info, ec);
 1599|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1600|      0|                    {
 1601|      0|                        return 0;
 1602|      0|                    }
 1603|      0|                    if (u <= static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1603:25): [True: 0, False: 0]
  ------------------
 1604|      0|                    {
 1605|      0|                        val = u;
 1606|      0|                    }
 1607|      0|                    else
 1608|      0|                    {
 1609|       |                        // error;
 1610|      0|                    }
 1611|       |                    
 1612|      0|                    break;
 1613|      0|                }
 1614|      0|                break;
 1615|      0|            default:
  ------------------
  |  Branch (1615:13): [True: 0, False: 31]
  ------------------
 1616|      0|                break;
 1617|     31|        }
 1618|       |
 1619|     31|        return val;
 1620|     31|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13read_bigfloatEhRNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 2004|     13|    {
 2005|     13|        std::size_t size = read_unsigned_integer(container_info, ec);
 2006|     13|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     13|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 13]
  |  |  ------------------
  ------------------
 2007|      0|        {
 2008|      0|            return;
 2009|      0|        }
 2010|     13|        if (size != 2)
  ------------------
  |  Branch (2010:13): [True: 0, False: 13]
  ------------------
 2011|      0|        {
 2012|      0|            ec = cbor_errc::invalid_bigfloat;
 2013|      0|            more_ = false;
 2014|      0|            return;
 2015|      0|        }
 2016|       |
 2017|     13|        auto c = source_.peek();
 2018|     13|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|     13|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 13]
  |  |  ------------------
  ------------------
 2019|      0|        {
 2020|      0|            ec = cbor_errc::unexpected_eof;
 2021|      0|            more_ = false;
 2022|      0|            return;
 2023|      0|        }
 2024|     13|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 2025|     13|        uint8_t info = get_additional_information(c.value);
 2026|     13|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|     13|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 13]
  |  |  |  Branch (79:50): [True: 0, False: 13]
  |  |  |  Branch (79:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2027|      0|        {
 2028|      0|            ec = cbor_errc::reserved_additional_info;
 2029|      0|            more_ = false;
 2030|      0|            return;
 2031|      0|        }
 2032|       |
 2033|     13|        int64_t exponent = 0;
 2034|     13|        switch (major_type)
 2035|     13|        {
 2036|      2|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (2036:13): [True: 2, False: 11]
  ------------------
 2037|      2|            {
 2038|      2|                source_.ignore(1);
 2039|      2|                auto u = read_unsigned_integer(info, ec);
 2040|      2|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 2041|      0|                {
 2042|      0|                    return;
 2043|      0|                }
 2044|      2|                if (u > static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (2044:21): [True: 0, False: 2]
  ------------------
 2045|      0|                {
 2046|      0|                    ec = cbor_errc::invalid_bigdecimal;
 2047|      0|                    more_ = false;
 2048|      0|                    return;
 2049|      0|                }
 2050|      2|                exponent = static_cast<int64_t>(u);
 2051|      2|                if (exponent == 0)
  ------------------
  |  Branch (2051:21): [True: 0, False: 2]
  ------------------
 2052|      0|                {
 2053|      0|                    str.append("0.0");
 2054|      0|                    return;
 2055|      0|                }
 2056|      2|                break;
 2057|      2|            }
 2058|     11|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (2058:13): [True: 11, False: 2]
  ------------------
 2059|     11|            {
 2060|     11|                exponent = read_int64(ec);
 2061|     11|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     11|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 11]
  |  |  ------------------
  ------------------
 2062|      0|                {
 2063|      0|                    return;
 2064|      0|                }
 2065|     11|                if (exponent == 0)
  ------------------
  |  Branch (2065:21): [True: 0, False: 11]
  ------------------
 2066|      0|                {
 2067|      0|                    str.append("0.0");
 2068|      0|                    return;
 2069|      0|                }
 2070|     11|                break;
 2071|     11|            }
 2072|     11|            default:
  ------------------
  |  Branch (2072:13): [True: 0, False: 13]
  ------------------
 2073|      0|            {
 2074|      0|                ec = cbor_errc::invalid_bigfloat;
 2075|      0|                more_ = false;
 2076|      0|                return;
 2077|     11|            }
 2078|     13|        }
 2079|       |
 2080|     13|        c = source_.peek();
 2081|     13|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|     13|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 13]
  |  |  ------------------
  ------------------
 2082|      0|        {
 2083|      0|            ec = cbor_errc::unexpected_eof;
 2084|      0|            more_ = false;
 2085|      0|            return;
 2086|      0|        }
 2087|     13|        major_type = get_major_type(c.value);
 2088|     13|        info = get_additional_information(c.value);
 2089|     13|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|     13|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 13]
  |  |  |  Branch (79:50): [True: 0, False: 13]
  |  |  |  Branch (79:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2090|      0|        {
 2091|      0|            ec = cbor_errc::reserved_additional_info;
 2092|      0|            more_ = false;
 2093|      0|            return;
 2094|      0|        }
 2095|       |
 2096|     13|        bigint unscaled;
 2097|     13|        switch (major_type)
 2098|     13|        {
 2099|      0|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (2099:13): [True: 0, False: 13]
  ------------------
 2100|      0|            {
 2101|      0|                source_.ignore(1);
 2102|      0|                uint64_t u = read_unsigned_integer(info, ec);
 2103|      0|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2104|      0|                {
 2105|      0|                    return;
 2106|      0|                }
 2107|      0|                unscaled = bigint(u);
 2108|       |                //bigdec dec(std::move(unscaled), -exponent);
 2109|       |                //append_to_buffer(dec, str);
 2110|      0|                break;
 2111|      0|            }
 2112|      0|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (2112:13): [True: 0, False: 13]
  ------------------
 2113|      0|            {
 2114|      0|                source_.ignore(1);
 2115|      0|                auto u = read_unsigned_integer(info, ec);
 2116|      0|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2117|      0|                {
 2118|      0|                    return;
 2119|      0|                }
 2120|      0|                if (u > static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (2120:21): [True: 0, False: 0]
  ------------------
 2121|      0|                {
 2122|      0|                    unscaled = -1 - bigint(u);
 2123|      0|                }
 2124|      0|                else if (JSONCONS_UNLIKELY(u == static_cast<uint64_t>((std::numeric_limits<int64_t>::max)())))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2125|      0|                {
 2126|      0|                    unscaled = bigint((std::numeric_limits<int64_t>::min)());
 2127|      0|                }
 2128|      0|                else
 2129|      0|                {
 2130|      0|                    unscaled = bigint(static_cast<int64_t>(-1) - static_cast<int64_t>(u));
 2131|      0|                }
 2132|       |                //bigdec dec(std::move(unscaled), -exponent);
 2133|       |                //append_to_buffer(dec, str);
 2134|      0|                break;
 2135|      0|            }
 2136|     12|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (2136:13): [True: 12, False: 1]
  ------------------
 2137|     12|            {
 2138|     12|                uint8_t x;
 2139|     12|                if (source_.read(&x, 1) == 0)
  ------------------
  |  Branch (2139:21): [True: 0, False: 12]
  ------------------
 2140|      0|                {
 2141|      0|                    ec = cbor_errc::unexpected_eof;
 2142|      0|                    more_ = false;
 2143|      0|                    return;
 2144|      0|                }
 2145|     12|                uint8_t tag = get_additional_information(x);
 2146|     12|                if (JSONCONS_UNLIKELY(tag >= 0x1C && tag <= 0x1E))
  ------------------
  |  |   79|     12|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 12]
  |  |  |  Branch (79:50): [True: 0, False: 12]
  |  |  |  Branch (79:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2147|      0|                {
 2148|      0|                    ec = cbor_errc::reserved_additional_info;
 2149|      0|                    more_ = false;
 2150|      0|                    return;
 2151|      0|                }
 2152|       |
 2153|     12|                c = source_.peek();
 2154|     12|                if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|     12|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 12]
  |  |  ------------------
  ------------------
 2155|      0|                {
 2156|      0|                    ec = cbor_errc::unexpected_eof;
 2157|      0|                    more_ = false;
 2158|      0|                    return;
 2159|      0|                }
 2160|       |
 2161|     12|                if (get_major_type(c.value) == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (2161:21): [True: 12, False: 0]
  ------------------
 2162|     12|                {
 2163|     12|                    bytes_buffer_.clear();
 2164|     12|                    read_byte_string(bytes_buffer_, ec);
 2165|     12|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     12|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 4, False: 8]
  |  |  ------------------
  ------------------
 2166|      4|                    {
 2167|      4|                        more_ = false;
 2168|      4|                        return;
 2169|      4|                    }
 2170|      8|                    unscaled = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 2171|      8|                    if (tag == 3)
  ------------------
  |  Branch (2171:25): [True: 7, False: 1]
  ------------------
 2172|      7|                    {
 2173|      7|                        unscaled = -1 - unscaled;
 2174|      7|                    }
 2175|      8|                }
 2176|      8|                break;
 2177|     12|            }
 2178|      8|            default:
  ------------------
  |  Branch (2178:13): [True: 1, False: 12]
  ------------------
 2179|      1|            {
 2180|      1|                ec = cbor_errc::invalid_bigfloat;
 2181|      1|                more_ = false;
 2182|      1|                return;
 2183|     12|            }
 2184|     13|        }
 2185|       |
 2186|      8|        bigdec dec;
 2187|      8|        auto result = from_cbor_bigfloat(std::move(unscaled), exponent, dec, bigfloat_precision_);
 2188|      8|        if (result != cbor_errc{})
  ------------------
  |  Branch (2188:13): [True: 0, False: 8]
  ------------------
 2189|      0|        {
 2190|      0|            ec = result;
 2191|      0|            more_ = false;
 2192|      0|            return;
 2193|      0|        }
 2194|      8|        append_to_buffer(dec, str);
 2195|      8|    }
_ZN8jsoncons4cbor18from_cbor_bigfloatINSt3__19allocatorImEEEENS0_9cbor_errcENS_12basic_bigintIT_EElRNS_12basic_bigdecIS7_EEm:
   46|      8|{
   47|      8|    constexpr uint64_t max_scale =
   48|      8|        static_cast<uint64_t>(
   49|      8|            (std::numeric_limits<int64_t>::max)()
   50|      8|        );
   51|       |
   52|      8|    if (max_decimal_places > max_scale)
  ------------------
  |  Branch (52:9): [True: 0, False: 8]
  ------------------
   53|      0|    {
   54|      0|        return cbor_errc::bigdec_scale_overflow;
   55|      0|    }
   56|       |
   57|      8|    if (unscaled.is_zero())
  ------------------
  |  Branch (57:9): [True: 0, False: 8]
  ------------------
   58|      0|    {
   59|      0|        value = basic_bigdec<Allocator>{ basic_bigint<Allocator>(0), 0 };
   60|      0|        return cbor_errc{};
   61|      0|    }
   62|       |
   63|       |    // Positive exponent: exact integer.
   64|      8|    if (exponent >= 0) {
  ------------------
  |  Branch (64:9): [True: 1, False: 7]
  ------------------
   65|      1|        unscaled <<= (static_cast<uint64_t>(exponent));
   66|      1|        value = basic_bigdec<Allocator>{ std::move(unscaled), 0 };
   67|      1|        return cbor_errc{};
   68|      1|    }
   69|       |
   70|      7|    const bool negative = unscaled < basic_bigint<Allocator>(0);
   71|       |
   72|      7|    if (negative)
  ------------------
  |  Branch (72:9): [True: 6, False: 1]
  ------------------
   73|      6|        unscaled = -unscaled;
   74|       |
   75|       |    // Absolute exponent, safe for INT64_MIN.
   76|      7|    uint64_t k =
   77|      7|        static_cast<uint64_t>(-(exponent + 1)) + 1;
   78|       |
   79|       |    // Cancel powers of 2.
   80|      7|    const u128 trailing = unscaled.trailing_zero_bits();
   81|       |
   82|      7|    const uint64_t cancel =
   83|      7|        trailing >= static_cast<u128>(k)
  ------------------
  |  Branch (83:9): [True: 0, False: 7]
  ------------------
   84|      7|            ? k
   85|      7|            : static_cast<uint64_t>(trailing);
   86|       |
   87|      7|    if (cancel != 0)
  ------------------
  |  Branch (87:9): [True: 2, False: 5]
  ------------------
   88|      2|        unscaled >>= (cancel);
   89|       |
   90|      7|    k -= cancel;
   91|       |
   92|       |    // Exact conversion when the scale fits.
   93|      7|    if (k <= max_decimal_places) {
  ------------------
  |  Branch (93:9): [True: 1, False: 6]
  ------------------
   94|      1|        if (k != 0)
  ------------------
  |  Branch (94:13): [True: 1, False: 0]
  ------------------
   95|      1|            unscaled *= jsoncons::powb(basic_bigint<Allocator>(5), k);
   96|       |
   97|      1|        if (negative)
  ------------------
  |  Branch (97:13): [True: 0, False: 1]
  ------------------
   98|      0|            unscaled = -unscaled;
   99|       |
  100|      1|        value = basic_bigdec<Allocator>{
  101|      1|            std::move(unscaled),
  102|      1|            static_cast<int64_t>(k)
  103|      1|        };
  104|      1|        return cbor_errc{};
  105|      1|    }
  106|       |
  107|       |    // Round to max_decimal_places.
  108|       |    //
  109|       |    // m / 2^k * 10^scale
  110|       |    // = m * 5^scale / 2^(k-scale)
  111|       |
  112|      6|    const uint64_t scale = max_decimal_places;
  113|      6|    const uint64_t shift = k - scale;
  114|       |
  115|       |    // Conservative early-zero bound:
  116|       |    // 5^scale < 2^(3*scale).
  117|       |    //
  118|       |    // If shift >= bit_length(m) + 3*scale,
  119|       |    // the rounded result must be zero.
  120|      6|    const u128 bits = unscaled.bit_length();
  121|      6|    const u128 bound =
  122|      6|        bits + static_cast<u128>(3) * scale;
  123|       |
  124|      6|    if (static_cast<u128>(shift) >= bound) {
  ------------------
  |  Branch (124:9): [True: 2, False: 4]
  ------------------
  125|      2|        value = basic_bigdec<Allocator>{
  126|      2|            basic_bigint<Allocator>(0),
  127|      2|            static_cast<int64_t>(scale)
  128|      2|        };
  129|      2|        return cbor_errc{};
  130|      2|    }
  131|       |
  132|       |    // Compute scaled positive magnitude.
  133|      4|    unscaled *= jsoncons::powb(basic_bigint<Allocator>(5), scale);
  134|       |
  135|       |    // Round unscaled / 2^shift using HALF_EVEN.
  136|      4|    basic_bigint<Allocator> quotient = unscaled;
  137|      4|    quotient >>= (shift);
  138|       |
  139|      4|    const bool halfBit = unscaled.test_bit(shift - 1);
  140|      4|    const bool lowerBits = unscaled.any_low_bits(shift - 1);
  141|      4|    const bool odd = quotient.test_bit(0);
  142|       |
  143|      4|    if (halfBit && (lowerBits || odd))
  ------------------
  |  Branch (143:9): [True: 3, False: 1]
  |  Branch (143:21): [True: 3, False: 0]
  |  Branch (143:34): [True: 0, False: 0]
  ------------------
  144|      3|        quotient += basic_bigint<Allocator>(1);
  145|       |
  146|      4|    if (negative && !quotient.is_zero())
  ------------------
  |  Branch (146:9): [True: 4, False: 0]
  |  Branch (146:21): [True: 4, False: 0]
  ------------------
  147|      4|        quotient = -quotient;
  148|       |
  149|      4|    value = basic_bigdec<Allocator> {
  150|      4|        std::move(quotient),
  151|      4|        static_cast<int64_t>(scale)
  152|      4|    };
  153|      4|    return cbor_errc{};
  154|      6|}
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE19read_mdarray_headerERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 2896|     35|    {
 2897|     35|        uint8_t b;
 2898|     35|        if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (2898:13): [True: 0, False: 35]
  ------------------
 2899|      0|        {
 2900|      0|            ec = cbor_errc::unexpected_eof;
 2901|      0|            more_ = false;
 2902|      0|            return;
 2903|      0|        }
 2904|     35|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(b);
 2905|     35|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::array);
  ------------------
  |  |   54|     35|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 35]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 2906|     35|        uint8_t info = get_additional_information(b);
 2907|     35|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|     37|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 35]
  |  |  |  Branch (79:50): [True: 2, False: 33]
  |  |  |  Branch (79:50): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 2908|      0|        {
 2909|      0|            ec = cbor_errc::reserved_additional_info;
 2910|      0|            more_ = false;
 2911|      0|            return;
 2912|      0|        }
 2913|       |       
 2914|     35|        read_extents(ec);   
 2915|     35|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     35|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 34, False: 1]
  |  |  ------------------
  ------------------
 2916|     34|        {
 2917|     34|            return;
 2918|     34|        }
 2919|       |
 2920|      1|        read_tags(ec);
 2921|      1|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2922|      0|        {
 2923|      0|            return;
 2924|      0|        }
 2925|      1|        auto c = source_.peek();
 2926|      1|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2927|      0|        {
 2928|      0|            ec = cbor_errc::unexpected_eof;
 2929|      0|            more_ = false;
 2930|      0|            return;
 2931|      0|        }
 2932|      1|        major_type = get_major_type(c.value);
 2933|      1|        info = get_additional_information(c.value);
 2934|      1|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  |  Branch (79:50): [True: 0, False: 1]
  |  |  |  Branch (79:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2935|      0|        {
 2936|      0|            ec = cbor_errc::reserved_additional_info;
 2937|      0|            more_ = false;
 2938|      0|            return;
 2939|      0|        }
 2940|      1|        state_stack_.emplace_back(parse_mode::multi_dim, 0);
 2941|      1|        ++state_stack_.back().index;
 2942|       |
 2943|      1|        if (major_type == jsoncons::cbor::detail::cbor_major_type::array && order_ == mdarray_order::row_major) 
  ------------------
  |  Branch (2943:13): [True: 1, False: 0]
  |  Branch (2943:77): [True: 0, False: 1]
  ------------------
 2944|      0|        {
 2945|      0|            source_.ignore(1);
 2946|      0|            begin_classical_array_storage(info, ec);
 2947|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2948|      0|            {
 2949|      0|                return;
 2950|      0|            }
 2951|      0|            auto iter = std::make_shared<cbor_mdarray_row_major_iterator<Source,Allocator>>(extents_, this, cursor_mode_, alloc_);
 2952|      0|            typed_array_stack_.push_back(iter);
 2953|      0|            if (!iter->done())
  ------------------
  |  Branch (2953:17): [True: 0, False: 0]
  ------------------
 2954|      0|            {
 2955|      0|                iter->next(visitor, *this, ec);
 2956|      0|            }
 2957|      0|        }
 2958|      1|        else if (major_type == jsoncons::cbor::detail::cbor_major_type::array && order_ == mdarray_order::column_major) 
  ------------------
  |  Branch (2958:18): [True: 1, False: 0]
  |  Branch (2958:82): [True: 1, False: 0]
  ------------------
 2959|      1|        {
 2960|      1|            source_.ignore(1);
 2961|      1|            begin_classical_array_storage(info, ec);
 2962|      1|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2963|      0|            {
 2964|      0|                return;
 2965|      0|            }
 2966|      1|            auto iter = std::make_shared<cbor_mdarray_column_major_iterator<Source,Allocator>>(extents_, this, cursor_mode_, alloc_);
 2967|      1|            typed_array_stack_.push_back(iter);
 2968|      1|            if (!iter->done())
  ------------------
  |  Branch (2968:17): [True: 1, False: 0]
  ------------------
 2969|      1|            {
 2970|      1|                iter->next(visitor, *this, ec);
 2971|      1|            }
 2972|      1|        }
 2973|      0|        else if (major_type == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (2973:18): [True: 0, False: 0]
  ------------------
 2974|      0|        {
 2975|      0|            std::size_t typed_array_count = typed_array_stack_.size();
 2976|      0|            read_byte_string_from_source read(this);
 2977|      0|            read_byte_string(read, visitor, ec);
 2978|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2979|      0|            {
 2980|      0|                return;
 2981|      0|            }
 2982|      0|            if (typed_array_stack_.size() == typed_array_count)
  ------------------
  |  Branch (2982:17): [True: 0, False: 0]
  ------------------
 2983|      0|            {
 2984|       |                // Byte string storage must be a typed array
 2985|      0|                ec = cbor_errc::bad_mdarray;
 2986|      0|                return;
 2987|      0|            }
 2988|      0|        }
 2989|      0|        else
 2990|      0|        {
 2991|      0|            ec = cbor_errc::bad_mdarray;
 2992|      0|            return;
 2993|      0|        }
 2994|       |        // cursor case
 2995|      1|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12read_extentsERNS3_10error_codeE:
 2998|     35|    {
 2999|     35|        extents_.clear();
 3000|       |
 3001|     35|        auto b = source_.peek();
 3002|     35|        if (JSONCONS_UNLIKELY(b.eof))
  ------------------
  |  |   79|     35|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 35]
  |  |  ------------------
  ------------------
 3003|      0|        {
 3004|      0|            ec = cbor_errc::unexpected_eof;
 3005|      0|            more_ = false;
 3006|      0|            return;
 3007|      0|        }
 3008|     35|        if (get_major_type(b.value) != jsoncons::cbor::detail::cbor_major_type::array)
  ------------------
  |  Branch (3008:13): [True: 0, False: 35]
  ------------------
 3009|      0|        {
 3010|      0|            ec = cbor_errc::bad_extents;
 3011|      0|            more_ = false;
 3012|      0|            return;
 3013|      0|        }
 3014|     35|        uint8_t info = get_additional_information(b.value);
 3015|     35|        if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|     60|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 35]
  |  |  |  Branch (79:50): [True: 25, False: 10]
  |  |  |  Branch (79:50): [True: 0, False: 25]
  |  |  ------------------
  ------------------
 3016|      0|        {
 3017|      0|            ec = cbor_errc::reserved_additional_info;
 3018|      0|            more_ = false;
 3019|      0|            return;
 3020|      0|        }
 3021|       |
 3022|     35|        source_.ignore(1);
 3023|     35|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (3023:13): [True: 25, False: 10]
  ------------------
 3024|     25|        {
 3025|     25|             bool done = false;
 3026|  3.20M|             while (!done)
  ------------------
  |  Branch (3026:21): [True: 3.20M, False: 8]
  ------------------
 3027|  3.20M|             {
 3028|  3.20M|                 auto c = source_.peek();
 3029|  3.20M|                 if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   79|  3.20M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 11, False: 3.20M]
  |  |  ------------------
  ------------------
 3030|     11|                 {
 3031|     11|                     ec = cbor_errc::unexpected_eof;
 3032|     11|                     more_ = false;
 3033|     11|                     return;
 3034|     11|                 }
 3035|  3.20M|                 if (c.value == 0xff)
  ------------------
  |  Branch (3035:22): [True: 8, False: 3.20M]
  ------------------
 3036|      8|                 {
 3037|      8|                     source_.ignore(1);
 3038|      8|                     done = true;
 3039|      8|                 }
 3040|  3.20M|                 else
 3041|  3.20M|                 {
 3042|  3.20M|                     source_.ignore(1);
 3043|  3.20M|                     std::size_t extent = read_size(get_additional_information(c.value), ec);
 3044|  3.20M|                     if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  3.20M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 6, False: 3.20M]
  |  |  ------------------
  ------------------
 3045|      6|                     {
 3046|      6|                         more_ = false;
 3047|      6|                         return;
 3048|      6|                     }
 3049|  3.20M|                     extents_.push_back(extent);
 3050|  3.20M|                 }
 3051|  3.20M|             }
 3052|     25|        }
 3053|     10|        else 
 3054|     10|        {
 3055|     10|            std::size_t size = read_size(info, ec);
 3056|     10|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     10|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 10]
  |  |  ------------------
  ------------------
 3057|      0|            {
 3058|      0|                more_ = false;
 3059|      0|                return;
 3060|      0|            }
 3061|  3.05M|            for (std::size_t i = 0; more_ && i < size; ++i)
  ------------------
  |  Branch (3061:37): [True: 3.05M, False: 0]
  |  Branch (3061:46): [True: 3.05M, False: 0]
  ------------------
 3062|  3.05M|            {
 3063|  3.05M|                uint8_t initial_byte;
 3064|  3.05M|                if (source_.read(&initial_byte, 1) == 0)
  ------------------
  |  Branch (3064:21): [True: 7, False: 3.05M]
  ------------------
 3065|      7|                {
 3066|      7|                    ec = cbor_errc::unexpected_eof;
 3067|      7|                    more_ = false;
 3068|      7|                    return;
 3069|      7|                }
 3070|  3.05M|                if (JSONCONS_UNLIKELY(get_major_type(initial_byte) != jsoncons::cbor::detail::cbor_major_type::unsigned_integer))
  ------------------
  |  |   79|  3.05M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 3.05M]
  |  |  ------------------
  ------------------
 3071|      2|                {
 3072|      2|                    ec = cbor_errc::unknown_type;
 3073|      2|                    more_ = false;
 3074|      2|                    return;
 3075|      2|                }
 3076|  3.05M|                info = get_additional_information(initial_byte);
 3077|  3.05M|                if (JSONCONS_UNLIKELY(info >= 0x1C && info <= 0x1E))
  ------------------
  |  |   79|  3.05M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 3.05M]
  |  |  |  Branch (79:50): [True: 1, False: 3.05M]
  |  |  |  Branch (79:50): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 3078|      1|                {
 3079|      1|                    ec = cbor_errc::reserved_additional_info;
 3080|      1|                    more_ = false;
 3081|      1|                    return;
 3082|      1|                }
 3083|  3.05M|                std::size_t extent = read_size(info, ec);
 3084|  3.05M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  3.05M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 3.05M]
  |  |  ------------------
  ------------------
 3085|      0|                {
 3086|      0|                    more_ = false;
 3087|      0|                    return;
 3088|      0|                }
 3089|  3.05M|                extents_.push_back(extent);
 3090|  3.05M|            }
 3091|     10|        }
 3092|      8|        auto r = calculate_mdarray_size(extents_);
 3093|      8|        if (!r || *r == 0)
  ------------------
  |  Branch (3093:13): [True: 7, False: 1]
  |  Branch (3093:19): [True: 0, False: 1]
  ------------------
 3094|      7|        {
 3095|      7|            ec = cbor_errc::bad_extents;
 3096|      7|            more_ = false;
 3097|      7|            return;
 3098|      7|        }
 3099|      1|        mdarray_size_ = *r;
 3100|      1|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE29begin_classical_array_storageEhRNS3_10error_codeE:
 1118|      1|    {
 1119|      1|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1120|      0|        {
 1121|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
 1122|      0|            more_ = false;
 1123|      0|            return;
 1124|      0|        }
 1125|      1|        bool pop_stringref_map_stack = false;
 1126|      1|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (1126:13): [True: 1, False: 0]
  ------------------
 1127|      1|        {
 1128|      1|            stringref_map_stack_.emplace_back();
 1129|      1|            other_tags_[stringref_namespace_tag] = false;
 1130|      1|            pop_stringref_map_stack = true;
 1131|      1|        }
 1132|      1|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1132:13): [True: 0, False: 1]
  ------------------
 1133|      0|        {
 1134|      0|            state_stack_.emplace_back(parse_mode::indefinite_array, 0, pop_stringref_map_stack);
 1135|      0|        }
 1136|      1|        else // definite length
 1137|      1|        {
 1138|      1|            std::size_t len = read_size(info, ec);
 1139|      1|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1140|      0|            {
 1141|      0|                return;
 1142|      0|            }
 1143|      1|            state_stack_.emplace_back(parse_mode::array, len, pop_stringref_map_stack);
 1144|      1|        }
 1145|      1|        more_ = !cursor_mode_;
 1146|      1|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayEhRNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 1055|      1|    {
 1056|      1|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1057|      0|        {
 1058|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
 1059|      0|            more_ = false;
 1060|      0|            return;
 1061|      0|        } 
 1062|      1|        semantic_tag tag = semantic_tag::none;
 1063|      1|        bool pop_stringref_map_stack = false;
 1064|      1|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (1064:13): [True: 0, False: 1]
  ------------------
 1065|      0|        {
 1066|      0|            stringref_map_stack_.emplace_back();
 1067|      0|            other_tags_[stringref_namespace_tag] = false;
 1068|      0|            pop_stringref_map_stack = true;
 1069|      0|        }
 1070|      1|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1070:13): [True: 0, False: 1]
  ------------------
 1071|      0|        {
 1072|      0|            state_stack_.emplace_back(parse_mode::indefinite_array,0,pop_stringref_map_stack);
 1073|      0|            visitor.begin_array(tag, *this, ec);
 1074|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1075|      0|            {
 1076|      0|                return;
 1077|      0|            }
 1078|      0|        }
 1079|      1|        else // definite length
 1080|      1|        {
 1081|      1|            std::size_t len = read_size(info, ec);
 1082|      1|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1083|      0|            {
 1084|      0|                return;
 1085|      0|            }
 1086|      1|            state_stack_.emplace_back(parse_mode::array,len,pop_stringref_map_stack);
 1087|      1|            visitor.begin_array(len, tag, *this, ec);
 1088|      1|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1089|      0|            {
 1090|      0|                return;
 1091|      0|            }
 1092|      1|        }
 1093|      1|        more_ = !cursor_mode_;
 1094|      1|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12begin_objectEhRNS_21basic_generic_visitorIcEERNS3_10error_codeE:
 1165|      1|    {
 1166|      1|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1167|      0|        {
 1168|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
 1169|      0|            more_ = false;
 1170|      0|            return;
 1171|      0|        } 
 1172|      1|        bool pop_stringref_map_stack = false;
 1173|      1|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (1173:13): [True: 0, False: 1]
  ------------------
 1174|      0|        {
 1175|      0|            stringref_map_stack_.emplace_back();
 1176|      0|            other_tags_[stringref_namespace_tag] = false;
 1177|      0|            pop_stringref_map_stack = true;
 1178|      0|        }
 1179|      1|        if (info == jsoncons::cbor::detail::additional_info::indefinite_length)
  ------------------
  |  Branch (1179:13): [True: 0, False: 1]
  ------------------
 1180|      0|        {
 1181|      0|            state_stack_.emplace_back(parse_mode::indefinite_map_key,0,pop_stringref_map_stack);
 1182|      0|            visitor.begin_object(semantic_tag::none, *this, ec);
 1183|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1184|      0|            {
 1185|      0|                return;
 1186|      0|            }
 1187|      0|        }
 1188|      1|        else // definite_length
 1189|      1|        {
 1190|      1|            std::size_t len = read_size(info, ec);
 1191|      1|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1192|      0|            {
 1193|      0|                return;
 1194|      0|            }
 1195|      1|            state_stack_.emplace_back(parse_mode::map_key,len,pop_stringref_map_stack);
 1196|      1|            visitor.begin_object(len, semantic_tag::none, *this, ec);
 1197|      1|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1198|      0|            {
 1199|      0|                return;
 1200|      0|            }
 1201|      1|        }
 1202|      1|        more_ = !cursor_mode_;
 1203|      1|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RKNS0_19cbor_decode_optionsERKS7_:
  336|    348|       : alloc_(alloc),
  337|    348|         source_(std::forward<Sourceable>(source)),
  338|    348|         max_nesting_depth_(options.max_nesting_depth()),
  339|    348|         bigfloat_precision_(options.bigfloat_precision()),
  340|    348|         text_buffer_(alloc),
  341|    348|         bytes_buffer_(alloc),
  342|    348|         state_stack_(alloc),
  343|    348|         stringref_map_stack_(alloc),
  344|    348|         extents_(alloc)
  345|    348|    {
  346|    348|        state_stack_.emplace_back(parse_mode::root,0);
  347|    348|    }
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4doneEv:
  435|    785|    {
  436|    785|        return done_;
  437|    785|    }

_ZN8jsoncons4cbor20typed_array_iteratorD2Ev:
   43|     20|    virtual ~typed_array_iterator() = default;
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_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_iteratorItNS_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_iteratorIjNS_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_iteratorIjNS_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_iteratorImNS_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_iteratorImNS_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_iteratorIsNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|      4|        : data_(std::move(data), alloc), 
  107|      4|          span_(typed_array_cast<ValueType>(data_)), 
  108|      4|          array_tag_(array_tag), 
  109|      4|          extent_(span_.size()), 
  110|      4|          tag_(tag), 
  111|      4|          func_(Func{})
  112|      4|    {
  113|      4|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIsNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|      4|    {
  148|      4|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  149|      4|        {
  150|      4|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|      4|            first_ = false;
  152|      4|        }
  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|      4|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIiNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|      7|        : data_(std::move(data), alloc), 
  107|      7|          span_(typed_array_cast<ValueType>(data_)), 
  108|      7|          array_tag_(array_tag), 
  109|      7|          extent_(span_.size()), 
  110|      7|          tag_(tag), 
  111|      7|          func_(Func{})
  112|      7|    {
  113|      7|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIiNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|      7|    {
  148|      7|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|      7|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 7, False: 0]
  |  |  ------------------
  ------------------
  149|      7|        {
  150|      7|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|      7|            first_ = false;
  152|      7|        }
  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|      7|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_11decode_halfENSt3__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_iteratorItNS_11decode_halfENSt3__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_iteratorIfNS_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_iteratorIfNS_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_iteratorIdNS_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_iteratorIdNS_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|    }
_ZN8jsoncons4cbor34cbor_mdarray_column_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2ERKNS3_6vectorImNS4_ImEEEEPNS0_17basic_cbor_parserIS6_S7_EEbRKS7_:
  478|      1|        : extents_(extents,alloc), dimensions_(extents.size(), mdarray_dimension{},alloc),
  479|      1|          parser_(parser), cursor_mode_(cursor_mode)
  480|      1|    {
  481|      1|        std::vector<std::size_t> strides(extents.size(), 0);
  482|      1|        std::size_t stride = 1;
  483|      1|        const size_t num_extents = extents.size();
  484|  27.6k|        for (size_t i = 0; i < num_extents; ++i)
  ------------------
  |  Branch (484:28): [True: 27.6k, False: 1]
  ------------------
  485|  27.6k|        {
  486|  27.6k|            strides[num_extents - i - 1] = stride;
  487|  27.6k|            stride *= extents[num_extents - i - 1];
  488|  27.6k|        }
  489|  27.6k|        for (std::size_t i = 0; i < strides.size(); ++i)
  ------------------
  |  Branch (489:33): [True: 27.6k, False: 1]
  ------------------
  490|  27.6k|        {
  491|  27.6k|            dimensions_[i].extent = extents[i];
  492|  27.6k|            dimensions_[i].stride = strides[i];
  493|  27.6k|            dimensions_[i].index = 0;
  494|  27.6k|            dimensions_[i].end = strides[i] * extents[i];
  495|  27.6k|        }
  496|      1|    }
_ZNK8jsoncons4cbor34cbor_mdarray_column_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4doneEv:
  519|      1|    {
  520|      1|        return done_;
  521|      1|    }
_ZN8jsoncons4cbor34cbor_mdarray_column_major_iteratorINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  530|      1|    {
  531|      1|        JSONCONS_ASSERT(!dimensions_.empty());
  ------------------
  |  |   54|      1|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 1]
  |  |  ------------------
  |  |   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|      1|        if (dim_ == 0)
  ------------------
  |  Branch (533:13): [True: 1, False: 0]
  ------------------
  534|      1|        {
  535|      1|            if (first_)
  ------------------
  |  Branch (535:17): [True: 1, False: 0]
  ------------------
  536|      1|            {
  537|      1|                if (!cursor_mode_)
  ------------------
  |  Branch (537:21): [True: 0, False: 1]
  ------------------
  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|      1|                visitor.begin_array(dimensions_[dim_].extent, tag_, context, ec);
  548|      1|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  549|      0|                {
  550|      0|                    return;
  551|      0|                }
  552|      1|                first_ = false;
  553|      1|                return;
  554|      1|            }
  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|    }