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

_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4sizeEv:
  116|  1.36M|        {
  117|  1.36M|            return size_;
  118|  1.36M|        }
_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2Ev:
   58|   390k|        {
   59|   390k|        }
_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2EPS2_m:
   61|  63.9k|            : data_(data), size_(size)
   62|  63.9k|        {
   63|  63.9k|        }
_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4dataEv:
  111|   909k|        {
  112|   909k|            return data_;
  113|   909k|        }

_ZN8jsoncons26basic_default_json_visitorIcEC2Ev:
  811|     33|        basic_default_json_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|     33|        basic_json_visitor() = default;
_ZN8jsoncons19typed_array_visitorD2Ev:
   33|     33|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  560|  3.01k|        {
  561|  3.01k|            visit_begin_array(tag, context, ec);
  562|  3.01k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.01k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  563|  3.01k|        }
_ZN8jsoncons26basic_default_json_visitorIcE15visit_end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  833|   469k|        {
  834|   469k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   469k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  835|   469k|        }
_ZN8jsoncons26basic_default_json_visitorIcE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  858|    182|        {
  859|    182|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    182|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  860|    182|        }
_ZN8jsoncons26basic_default_json_visitorIcE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  863|  74.0k|        {
  864|  74.0k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  74.0k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  865|  74.0k|        }
_ZN8jsoncons26basic_default_json_visitorIcE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  873|     25|        {
  874|     25|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     25|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  875|     25|        }
_ZN8jsoncons26basic_default_json_visitorIcE11visit_flushEv:
  814|      2|        {
  815|      2|        }
_ZN8jsoncons26basic_default_json_visitorIcE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  818|  1.55M|        {
  819|  1.55M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.55M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  820|  1.55M|        }
_ZN8jsoncons18basic_json_visitorIcE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  544|  3.10k|        {
  545|  3.10k|            visit_begin_object(tag, context, ec);
  546|  3.10k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.10k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  547|  3.10k|        }
_ZN8jsoncons26basic_default_json_visitorIcE16visit_end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  823|  1.55M|        {
  824|  1.55M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.55M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  825|  1.55M|        }
_ZN8jsoncons26basic_default_json_visitorIcE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  828|   471k|        {
  829|   471k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   471k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  830|   471k|        }
_ZN8jsoncons26basic_default_json_visitorIcE9visit_keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  838|   454k|        {
  839|   454k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   454k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  840|   454k|        }
_ZN8jsoncons26basic_default_json_visitorIcE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  843|  3.72M|        {
  844|  3.72M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.72M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  845|  3.72M|        }
_ZN8jsoncons26basic_default_json_visitorIcE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  878|   436k|        {
  879|   436k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   436k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  880|   436k|        }
_ZN8jsoncons26basic_default_json_visitorIcE12visit_stringERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  848|    154|        {
  849|    154|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    154|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  850|    154|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  345|  3.01k|        {
  346|  3.01k|            visit_begin_array(length, tag, context, ec);
  347|  3.01k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.01k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  348|  3.01k|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|    182|        {
  415|    182|            visit_uint64(value, tag, context, ec);
  416|    182|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    182|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  417|    182|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  351|   469k|        {
  352|   469k|            visit_end_array(context, ec);
  353|   469k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   469k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  354|   469k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|  74.0k|        {
  424|  74.0k|            visit_int64(value, tag, context, ec);
  425|  74.0k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  74.0k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  426|  74.0k|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|     25|        {
  442|     25|            visit_double(value, tag, context, ec);
  443|     25|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|     25|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  444|     25|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  365|  3.72M|        {
  366|  3.72M|            visit_null(tag, context, ec);
  367|  3.72M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.72M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  368|  3.72M|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  374|   436k|        {
  375|   436k|            visit_bool(value, tag, context, ec);
  376|   436k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   436k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  377|   436k|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  383|    154|        {
  384|    154|            visit_string(value, tag, context, ec);
  385|    154|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|    154|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  386|    154|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  339|   468k|        {
  340|   468k|            visit_begin_array(tag, context, ec);
  341|   468k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   468k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  342|   468k|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  327|  3.10k|        {
  328|  3.10k|            visit_begin_object(length, tag, context, ec);
  329|  3.10k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.10k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  330|  3.10k|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  318|  1.55M|        {
  319|  1.55M|            visit_begin_object(tag, context, ec);
  320|  1.55M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.55M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  321|  1.55M|        }
_ZN8jsoncons18basic_json_visitorIcE3keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  357|   454k|        {
  358|   454k|            visit_key(name, context, ec);
  359|   454k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   454k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  360|   454k|        }
_ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  333|  1.55M|        {
  334|  1.55M|            visit_end_object(context, ec);
  335|  1.55M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  1.55M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  336|  1.55M|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|      2|        {
  109|      2|            visit_flush();
  110|      2|        }

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

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

_ZN8jsoncons6binary13big_to_nativeIaNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|   533k|    {
  183|   533k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 533k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|   533k|        T val;
  188|   533k|        std::memcpy(&val,first,sizeof(T));
  189|   533k|        return byte_swap(val);
  190|   533k|    }
_ZN8jsoncons6binary9byte_swapIaEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_:
   21|   533k|    {
   22|   533k|        return val;
   23|   533k|    }
_ZN8jsoncons6binary13big_to_nativeIsNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  1.17k|    {
  183|  1.17k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 1.17k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  1.17k|        T val;
  188|  1.17k|        std::memcpy(&val,first,sizeof(T));
  189|  1.17k|        return byte_swap(val);
  190|  1.17k|    }
_ZN8jsoncons6binary9byte_swapIsEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|  1.17k|    {
   29|  1.17k|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|  1.17k|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  466|  1.17k|#      define JSONCONS_BYTE_SWAP_16    __builtin_bswap16
  ------------------
   31|       |    #else
   32|       |        return (static_cast<uint16_t>(val) >> 8) | (static_cast<uint16_t>(val) << 8);
   33|       |    #endif
   34|  1.17k|    }
_ZN8jsoncons6binary13big_to_nativeIiNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|     17|    {
  183|     17|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 17]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     17|        T val;
  188|     17|        std::memcpy(&val,first,sizeof(T));
  189|     17|        return byte_swap(val);
  190|     17|    }
_ZN8jsoncons6binary9byte_swapIiEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|     17|    {
   40|     17|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|     17|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  462|     17|#  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|     17|    }
_ZN8jsoncons6binary13big_to_nativeIlNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|     79|    {
  183|     79|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 79]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     79|        T val;
  188|     79|        std::memcpy(&val,first,sizeof(T));
  189|     79|        return byte_swap(val);
  190|     79|    }
_ZN8jsoncons6binary9byte_swapIlEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|     79|    {
   52|     79|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|     79|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|     79|#  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|     79|    }
_ZN8jsoncons6binary13big_to_nativeIdNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|     25|    {
  183|     25|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 25]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     25|        T val;
  188|     25|        std::memcpy(&val,first,sizeof(T));
  189|     25|        return byte_swap(val);
  190|     25|    }
_ZN8jsoncons6binary9byte_swapIdEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   76|     25|    {
   77|     25|        uint64_t x;
   78|     25|        std::memcpy(&x,&val,sizeof(uint64_t));
   79|     25|        uint64_t y = byte_swap(x);
   80|     25|        T val2;
   81|     25|        std::memcpy(&val2,&y,sizeof(uint64_t));
   82|     25|        return val2;
   83|     25|    }
_ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|     25|    {
   52|     25|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|     25|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|     25|#  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|    }

_ZN8jsoncons9is_base10IhEEbPKT_m:
  164|     38|{
  165|     38|    integer_chars_state state = integer_chars_state::initial;
  166|       |
  167|     38|    const CharT* end = s + length; 
  168|    100|    for (;s < end; ++s)
  ------------------
  |  Branch (168:11): [True: 97, False: 3]
  ------------------
  169|     97|    {
  170|     97|        switch(state)
  171|     97|        {
  172|     38|            case integer_chars_state::initial:
  ------------------
  |  Branch (172:13): [True: 38, False: 59]
  ------------------
  173|     38|            {
  174|     38|                switch(*s)
  175|     38|                {
  176|      3|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (176:21): [True: 1, False: 37]
  |  Branch (176:30): [True: 1, False: 37]
  |  Branch (176:39): [True: 0, False: 38]
  |  Branch (176:48): [True: 0, False: 38]
  |  Branch (176:57): [True: 0, False: 38]
  |  Branch (176:66): [True: 0, False: 38]
  |  Branch (176:75): [True: 1, False: 37]
  |  Branch (176:84): [True: 0, False: 38]
  |  Branch (176:93): [True: 0, False: 38]
  |  Branch (176:103): [True: 0, False: 38]
  ------------------
  177|      3|                        state = integer_chars_state::decimal;
  178|      3|                        break;
  179|     12|                    case '-':
  ------------------
  |  Branch (179:21): [True: 12, False: 26]
  ------------------
  180|     12|                        state = integer_chars_state::minus;
  181|     12|                        break;
  182|     23|                    default:
  ------------------
  |  Branch (182:21): [True: 23, False: 15]
  ------------------
  183|     23|                        return false;
  184|     38|                }
  185|     15|                break;
  186|     38|            }
  187|     15|            case integer_chars_state::minus:
  ------------------
  |  Branch (187:13): [True: 12, False: 85]
  ------------------
  188|     12|            {
  189|     12|                switch(*s)
  190|     12|                {
  191|     12|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (191:21): [True: 12, False: 0]
  |  Branch (191:30): [True: 0, False: 12]
  |  Branch (191:39): [True: 0, False: 12]
  |  Branch (191:48): [True: 0, False: 12]
  |  Branch (191:57): [True: 0, False: 12]
  |  Branch (191:66): [True: 0, False: 12]
  |  Branch (191:75): [True: 0, False: 12]
  |  Branch (191:84): [True: 0, False: 12]
  |  Branch (191:93): [True: 0, False: 12]
  |  Branch (191:103): [True: 0, False: 12]
  ------------------
  192|     12|                        state = integer_chars_state::decimal;
  193|     12|                        break;
  194|      0|                    default:
  ------------------
  |  Branch (194:21): [True: 0, False: 12]
  ------------------
  195|      0|                        return false;
  196|     12|                }
  197|     12|                break;
  198|     12|            }
  199|     47|            case integer_chars_state::decimal:
  ------------------
  |  Branch (199:13): [True: 47, False: 50]
  ------------------
  200|     47|            {
  201|     47|                switch(*s)
  202|     47|                {
  203|     35|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (203:21): [True: 1, False: 46]
  |  Branch (203:30): [True: 3, False: 44]
  |  Branch (203:39): [True: 8, False: 39]
  |  Branch (203:48): [True: 0, False: 47]
  |  Branch (203:57): [True: 12, False: 35]
  |  Branch (203:66): [True: 0, False: 47]
  |  Branch (203:75): [True: 0, False: 47]
  |  Branch (203:84): [True: 11, False: 36]
  |  Branch (203:93): [True: 0, False: 47]
  |  Branch (203:103): [True: 0, False: 47]
  ------------------
  204|     35|                        break;
  205|     12|                    default:
  ------------------
  |  Branch (205:21): [True: 12, False: 35]
  ------------------
  206|     12|                        return false;
  207|     47|                }
  208|     35|                break;
  209|     47|            }
  210|     35|            default:
  ------------------
  |  Branch (210:13): [True: 0, False: 97]
  ------------------
  211|      0|                break;
  212|     97|        }
  213|     97|    }
  214|      3|    return state == integer_chars_state::decimal ? true : false;
  ------------------
  |  Branch (214:12): [True: 3, False: 0]
  ------------------
  215|     38|}

_ZN8jsoncons14unicode_traits8validateIhEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_14unicode_resultIS4_EEE4typeEPKS4_m:
 1147|   454k|    {
 1148|   454k|        const uint8_t* it = reinterpret_cast<const uint8_t*>(data);
 1149|   454k|        const uint8_t* end = it + length;
 1150|       |
 1151|   454k|        unicode_errc  result{};
 1152|   590k|        while (it != end) 
  ------------------
  |  Branch (1152:16): [True: 136k, False: 454k]
  ------------------
 1153|   136k|        {
 1154|   136k|            if ((end - it) >= 8)
  ------------------
  |  Branch (1154:17): [True: 71.8k, False: 64.3k]
  ------------------
 1155|  71.8k|            {
 1156|   500k|                JSONCONS_REPEAT8({if (JSONCONS_LIKELY((*it & 0x80) == 0)) ++it; else goto non_ascii;})
  ------------------
  |  |  281|   143k|#define JSONCONS_REPEAT8(x)  { x x x x x x x x }
  |  |  ------------------
  |  |  |  Branch (281:32): [True: 71.8k, False: 8]
  |  |  |  Branch (281:34): [True: 71.7k, False: 22]
  |  |  |  Branch (281:36): [True: 71.7k, False: 44]
  |  |  |  Branch (281:38): [True: 71.3k, False: 415]
  |  |  |  Branch (281:40): [True: 71.3k, False: 30]
  |  |  |  Branch (281:42): [True: 71.2k, False: 31]
  |  |  |  Branch (281:44): [True: 71.2k, False: 21]
  |  |  |  Branch (281:46): [True: 71.2k, False: 7]
  |  |  ------------------
  ------------------
 1157|  71.2k|                continue;
 1158|   500k|            }
 1159|  64.9k|    non_ascii:
 1160|  64.9k|            const std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[*it]) + 1;
 1161|  64.9k|            if (len > (std::size_t)(end - it))
  ------------------
  |  Branch (1161:17): [True: 0, False: 64.9k]
  ------------------
 1162|      0|            {
 1163|      0|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), unicode_errc::source_exhausted};
 1164|      0|            }
 1165|  64.9k|            if ((result=is_legal_utf8(it, len)) != unicode_errc())
  ------------------
  |  Branch (1165:17): [True: 4, False: 64.9k]
  ------------------
 1166|      4|            {
 1167|      4|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1168|      4|            }
 1169|  64.9k|            it += len;
 1170|  64.9k|        }
 1171|   454k|        return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1172|   454k|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8EPKhm:
  305|  64.9k|    {
  306|  64.9k|        const uint8_t* it = reinterpret_cast<const uint8_t*>(bytes);
  307|  64.9k|        const uint8_t* end = it+length;
  308|       |
  309|  64.9k|        uint8_t byte;
  310|  64.9k|        switch (length) {
  311|      4|        default:
  ------------------
  |  Branch (311:9): [True: 4, False: 64.9k]
  ------------------
  312|      4|            return unicode_errc::over_long_utf8_sequence;
  313|    568|        case 4:
  ------------------
  |  Branch (313:9): [True: 568, False: 64.3k]
  ------------------
  314|    568|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 0, False: 568]
  ------------------
  315|      0|                return unicode_errc::bad_continuation_byte;
  316|    568|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|    568|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  317|    573|        case 3:
  ------------------
  |  Branch (317:9): [True: 5, False: 64.9k]
  ------------------
  318|    573|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (318:17): [True: 0, False: 573]
  ------------------
  319|      0|                return unicode_errc::bad_continuation_byte;
  320|    573|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|    573|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  321|    574|        case 2:
  ------------------
  |  Branch (321:9): [True: 1, False: 64.9k]
  ------------------
  322|    574|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (322:17): [True: 0, False: 574]
  ------------------
  323|      0|                return unicode_errc::bad_continuation_byte;
  324|       |
  325|    574|            switch (*it) 
  326|    574|            {
  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: 574]
  |  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: 574]
  |  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: 574]
  |  Branch (330:32): [True: 0, False: 0]
  ------------------
  331|    560|                case 0xF4: if (byte > 0x8F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (331:17): [True: 560, False: 14]
  |  Branch (331:32): [True: 0, False: 560]
  ------------------
  332|    560|                default:   if (byte < 0x80) return unicode_errc::source_illegal;
  ------------------
  |  Branch (332:17): [True: 14, False: 560]
  |  Branch (332:32): [True: 0, False: 14]
  ------------------
  333|    574|            }
  334|       |
  335|    574|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|    574|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  336|  64.9k|        case 1:
  ------------------
  |  Branch (336:9): [True: 64.3k, False: 578]
  ------------------
  337|  64.9k|            if (*it >= 0x80 && *it < 0xC2)
  ------------------
  |  Branch (337:17): [True: 574, False: 64.3k]
  |  Branch (337:32): [True: 0, False: 574]
  ------------------
  338|      0|                return unicode_errc::source_illegal;
  339|  64.9k|            break;
  340|  64.9k|        }
  341|  64.9k|        if (*it > 0xF4) 
  ------------------
  |  Branch (341:13): [True: 0, False: 64.9k]
  ------------------
  342|      0|            return unicode_errc::source_illegal;
  343|       |
  344|  64.9k|        return unicode_errc();
  345|  64.9k|    }

_ZN8jsoncons6ubjson15make_error_codeENS0_11ubjson_errcE:
   90|     32|{
   91|     32|    return std::error_code(static_cast<int>(e),ubjson_error_category());
   92|     32|}
_ZN8jsoncons6ubjson21ubjson_error_categoryEv:
   83|     32|{
   84|     32|  static ubjson_error_category_impl instance;
   85|     32|  return instance;
   86|     32|}

_ZN8jsoncons6ubjson21ubjson_decode_optionsC1Ev:
   38|     33|    ubjson_decode_options() = default;
_ZN8jsoncons6ubjson21ubjson_options_commonC2Ev:
   23|     33|    ubjson_options_common() = default;
_ZN8jsoncons6ubjson21ubjson_options_commonD2Ev:
   25|     33|    virtual ~ubjson_options_common() = default;
_ZNK8jsoncons6ubjson21ubjson_options_common17max_nesting_depthEv:
   28|     33|    {
   29|     33|        return max_nesting_depth_;
   30|     33|    }
_ZNK8jsoncons6ubjson21ubjson_decode_options9max_itemsEv:
   44|     33|    {
   45|     33|        return max_items_;
   46|     33|    }

_ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RKNS0_21ubjson_decode_optionsERKS7_:
   79|     33|       : source_(std::forward<Sourceable>(source)), 
   80|     33|         max_nesting_depth_(options.max_nesting_depth()),
   81|     33|         max_items_(options.max_items()),
   82|     33|         text_buffer_(alloc),
   83|     33|         state_stack_(alloc)
   84|     33|    {
   85|     33|        state_stack_.emplace_back(parse_mode::root,0);
   86|     33|    }
_ZN8jsoncons6ubjson11parse_stateC2ENS0_10parse_modeEmh:
   45|  2.03M|        : mode(mode), length(length), type(type)
   46|  2.03M|    {
   47|  2.03M|    }
_ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5resetEv:
   94|     33|    {
   95|     33|        more_ = true;
   96|     33|        done_ = false;
   97|     33|        text_buffer_.clear();
   98|     33|        state_stack_.clear();
   99|     33|        state_stack_.emplace_back(parse_mode::root,0,uint8_t(0));
  100|     33|        nesting_depth_ = 0;
  101|     33|    }
_ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_18basic_json_visitorIcEERNS3_10error_codeE:
  151|     33|    {
  152|  9.17M|        while (!done_ && more_)
  ------------------
  |  Branch (152:16): [True: 9.17M, False: 2]
  |  Branch (152:26): [True: 9.17M, False: 0]
  ------------------
  153|  9.17M|        {
  154|  9.17M|            switch (state_stack_.back().mode)
  ------------------
  |  Branch (154:21): [True: 9.17M, False: 0]
  ------------------
  155|  9.17M|            {
  156|  2.72k|                case parse_mode::array:
  ------------------
  |  Branch (156:17): [True: 2.72k, False: 9.16M]
  ------------------
  157|  2.72k|                {
  158|  2.72k|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (158:25): [True: 1.15k, False: 1.56k]
  ------------------
  159|  1.15k|                    {
  160|  1.15k|                        ++state_stack_.back().index;
  161|  1.15k|                        read_type_and_value(visitor, ec);
  162|  1.15k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.15k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.15k]
  |  |  ------------------
  ------------------
  163|      0|                        {
  164|      0|                            return;
  165|      0|                        }
  166|  1.15k|                    }
  167|  1.56k|                    else
  168|  1.56k|                    {
  169|  1.56k|                        end_array(visitor, ec);
  170|  1.56k|                    }
  171|  2.72k|                    break;
  172|  2.72k|                }
  173|  2.03M|                case parse_mode::strongly_typed_array:
  ------------------
  |  Branch (173:17): [True: 2.03M, False: 7.13M]
  ------------------
  174|  2.03M|                {
  175|  2.03M|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (175:25): [True: 2.03M, False: 708]
  ------------------
  176|  2.03M|                    {
  177|  2.03M|                        ++state_stack_.back().index;
  178|  2.03M|                        read_value(visitor, state_stack_.back().type, ec);
  179|  2.03M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.03M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 2.03M]
  |  |  ------------------
  ------------------
  180|      3|                        {
  181|      3|                            return;
  182|      3|                        }
  183|  2.03M|                    }
  184|    708|                    else
  185|    708|                    {
  186|    708|                        end_array(visitor, ec);
  187|    708|                    }
  188|  2.03M|                    break;
  189|  2.03M|                }
  190|  4.66M|                case parse_mode::indefinite_array:
  ------------------
  |  Branch (190:17): [True: 4.66M, False: 4.50M]
  ------------------
  191|  4.66M|                {
  192|  4.66M|                    auto c = source_.peek();
  193|  4.66M|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  4.66M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 6, False: 4.66M]
  |  |  ------------------
  ------------------
  194|      6|                    {
  195|      6|                        ec = ubjson_errc::unexpected_eof;
  196|      6|                        more_ = false;
  197|      6|                        return;
  198|      6|                    }
  199|  4.66M|                    if (c.value == jsoncons::ubjson::ubjson_type::end_array_marker)
  ------------------
  |  Branch (199:25): [True: 467k, False: 4.19M]
  ------------------
  200|   467k|                    {
  201|   467k|                        source_.ignore(1);
  202|   467k|                        end_array(visitor, ec);
  203|   467k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   467k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 467k]
  |  |  ------------------
  ------------------
  204|      0|                        {
  205|      0|                            return;
  206|      0|                        }
  207|   467k|                    }
  208|  4.19M|                    else
  209|  4.19M|                    {
  210|  4.19M|                        if (++state_stack_.back().index > max_items_)
  ------------------
  |  Branch (210:29): [True: 0, False: 4.19M]
  ------------------
  211|      0|                        {
  212|      0|                            ec = ubjson_errc::max_items_exceeded;
  213|      0|                            more_ = false;
  214|      0|                            return;
  215|      0|                        }
  216|  4.19M|                        read_type_and_value(visitor, ec);
  217|  4.19M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.19M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 4.19M]
  |  |  ------------------
  ------------------
  218|      3|                        {
  219|      3|                            return;
  220|      3|                        }
  221|  4.19M|                    }
  222|  4.66M|                    break;
  223|  4.66M|                }
  224|  4.66M|                case parse_mode::map_key:
  ------------------
  |  Branch (224:17): [True: 9, False: 9.17M]
  ------------------
  225|      9|                {
  226|      9|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (226:25): [True: 3, False: 6]
  ------------------
  227|      3|                    {
  228|      3|                        ++state_stack_.back().index;
  229|      3|                        read_key(visitor, ec);
  230|      3|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
  231|      0|                        {
  232|      0|                            return;
  233|      0|                        }
  234|      3|                        state_stack_.back().mode = parse_mode::map_value;
  235|      3|                    }
  236|      6|                    else
  237|      6|                    {
  238|      6|                        end_object(visitor, ec);
  239|      6|                    }
  240|      9|                    break;
  241|      9|                }
  242|      9|                case parse_mode::map_value:
  ------------------
  |  Branch (242:17): [True: 3, False: 9.17M]
  ------------------
  243|      3|                {
  244|      3|                    state_stack_.back().mode = parse_mode::map_key;
  245|      3|                    read_type_and_value(visitor, ec);
  246|      3|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
  247|      0|                    {
  248|      0|                        return;
  249|      0|                    }
  250|      3|                    break;
  251|      3|                }
  252|  3.09k|                case parse_mode::strongly_typed_map_key:
  ------------------
  |  Branch (252:17): [True: 3.09k, False: 9.16M]
  ------------------
  253|  3.09k|                {
  254|  3.09k|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (254:25): [True: 0, False: 3.09k]
  ------------------
  255|      0|                    {
  256|      0|                        ++state_stack_.back().index;
  257|      0|                        read_key(visitor, ec);
  258|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  259|      0|                        {
  260|      0|                            return;
  261|      0|                        }
  262|      0|                        state_stack_.back().mode = parse_mode::strongly_typed_map_value;
  263|      0|                    }
  264|  3.09k|                    else
  265|  3.09k|                    {
  266|  3.09k|                        end_object(visitor, ec);
  267|  3.09k|                    }
  268|  3.09k|                    break;
  269|  3.09k|                }
  270|  3.09k|                case parse_mode::strongly_typed_map_value:
  ------------------
  |  Branch (270:17): [True: 0, False: 9.17M]
  ------------------
  271|      0|                {
  272|      0|                    state_stack_.back().mode = parse_mode::strongly_typed_map_key;
  273|      0|                    read_value(visitor, state_stack_.back().type, ec);
  274|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  275|      0|                    {
  276|      0|                        return;
  277|      0|                    }
  278|      0|                    break;
  279|      0|                }
  280|  2.01M|                case parse_mode::indefinite_map_key:
  ------------------
  |  Branch (280:17): [True: 2.01M, False: 7.15M]
  ------------------
  281|  2.01M|                {
  282|  2.01M|                    auto c = source_.peek();
  283|  2.01M|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  2.01M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 2.01M]
  |  |  ------------------
  ------------------
  284|      1|                    {
  285|      1|                        ec = ubjson_errc::unexpected_eof;
  286|      1|                        more_ = false;
  287|      1|                        return;
  288|      1|                    }
  289|  2.01M|                    if (c.value == jsoncons::ubjson::ubjson_type::end_object_marker)
  ------------------
  |  Branch (289:25): [True: 1.55M, False: 454k]
  ------------------
  290|  1.55M|                    {
  291|  1.55M|                        source_.ignore(1);
  292|  1.55M|                        end_object(visitor, ec);
  293|  1.55M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.55M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.55M]
  |  |  ------------------
  ------------------
  294|      0|                        {
  295|      0|                            return;
  296|      0|                        }
  297|  1.55M|                    }
  298|   454k|                    else
  299|   454k|                    {
  300|   454k|                        if (++state_stack_.back().index > max_items_)
  ------------------
  |  Branch (300:29): [True: 0, False: 454k]
  ------------------
  301|      0|                        {
  302|      0|                            ec = ubjson_errc::max_items_exceeded;
  303|      0|                            more_ = false;
  304|      0|                            return;
  305|      0|                        }
  306|   454k|                        read_key(visitor, ec);
  307|   454k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   454k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 5, False: 454k]
  |  |  ------------------
  ------------------
  308|      5|                        {
  309|      5|                            return;
  310|      5|                        }
  311|   454k|                        state_stack_.back().mode = parse_mode::indefinite_map_value;
  312|   454k|                    }
  313|  2.01M|                    break;
  314|  2.01M|                }
  315|  2.01M|                case parse_mode::indefinite_map_value:
  ------------------
  |  Branch (315:17): [True: 454k, False: 8.71M]
  ------------------
  316|   454k|                {
  317|   454k|                    state_stack_.back().mode = parse_mode::indefinite_map_key;
  318|   454k|                    read_type_and_value(visitor, ec);
  319|   454k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   454k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 454k]
  |  |  ------------------
  ------------------
  320|      2|                    {
  321|      2|                        return;
  322|      2|                    }
  323|   454k|                    break;
  324|   454k|                }
  325|   454k|                case parse_mode::root:
  ------------------
  |  Branch (325:17): [True: 33, False: 9.17M]
  ------------------
  326|     33|                {
  327|     33|                    state_stack_.back().mode = parse_mode::accept;
  328|     33|                    read_type_and_value(visitor, ec);
  329|     33|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     33|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 11, False: 22]
  |  |  ------------------
  ------------------
  330|     11|                    {
  331|     11|                        return;
  332|     11|                    }
  333|     22|                    break;
  334|     33|                }
  335|     22|                case parse_mode::accept:
  ------------------
  |  Branch (335:17): [True: 2, False: 9.17M]
  ------------------
  336|      2|                {
  337|      2|                    JSONCONS_ASSERT(state_stack_.size() == 1);
  ------------------
  |  |   49|      2|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 2]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  338|      2|                    state_stack_.clear();
  339|      2|                    more_ = false;
  340|      2|                    done_ = true;
  341|      2|                    visitor.flush();
  342|      2|                    break;
  343|      2|                }
  344|  9.17M|            }
  345|  9.17M|        }
  346|     33|    }
_ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE19read_type_and_valueERNS_18basic_json_visitorIcEERNS3_10error_codeE:
  349|  4.65M|    {
  350|  4.65M|        if (source_.is_error())
  ------------------
  |  Branch (350:13): [True: 0, False: 4.65M]
  ------------------
  351|      0|        {
  352|      0|            ec = ubjson_errc::source_error;
  353|      0|            more_ = false;
  354|      0|            return;
  355|      0|        }   
  356|       |
  357|  4.65M|        uint8_t b;
  358|  4.65M|        if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (358:13): [True: 1, False: 4.65M]
  ------------------
  359|      1|        {
  360|      1|            ec = ubjson_errc::unexpected_eof;
  361|      1|            more_ = false;
  362|      1|            return;
  363|      1|        }
  364|  4.65M|        read_value(visitor, b, ec);
  365|  4.65M|    }
_ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9end_arrayERNS_18basic_json_visitorIcEERNS3_10error_codeE:
  671|   469k|    {
  672|   469k|        --nesting_depth_;
  673|       |
  674|   469k|        visitor.end_array(*this, ec);
  675|   469k|        more_ = !cursor_mode_;
  676|   469k|        if (level() == mark_level_)
  ------------------
  |  Branch (676:13): [True: 0, False: 469k]
  ------------------
  677|      0|        {
  678|      0|            more_ = false;
  679|      0|        }
  680|   469k|        state_stack_.pop_back();
  681|   469k|    }
_ZNK8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5levelEv:
  116|  2.02M|    {
  117|  2.02M|        return static_cast<int>(state_stack_.size());
  118|  2.02M|    }
_ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10read_valueERNS_18basic_json_visitorIcEEhRNS3_10error_codeE:
  368|  6.68M|    {
  369|  6.68M|        switch (type)
  370|  6.68M|        {
  371|  3.72M|            case jsoncons::ubjson::ubjson_type::null_type: 
  ------------------
  |  Branch (371:13): [True: 3.72M, False: 2.96M]
  ------------------
  372|  3.72M|            {
  373|  3.72M|                visitor.null_value(semantic_tag::none, *this, ec);
  374|  3.72M|                more_ = !cursor_mode_;
  375|  3.72M|                break;
  376|      0|            }
  377|   424k|            case jsoncons::ubjson::ubjson_type::no_op_type: 
  ------------------
  |  Branch (377:13): [True: 424k, False: 6.26M]
  ------------------
  378|   424k|            {
  379|   424k|                break;
  380|      0|            }
  381|   436k|            case jsoncons::ubjson::ubjson_type::true_type:
  ------------------
  |  Branch (381:13): [True: 436k, False: 6.25M]
  ------------------
  382|   436k|            {
  383|   436k|                visitor.bool_value(true, semantic_tag::none, *this, ec);
  384|   436k|                more_ = !cursor_mode_;
  385|   436k|                break;
  386|      0|            }
  387|     48|            case jsoncons::ubjson::ubjson_type::false_type:
  ------------------
  |  Branch (387:13): [True: 48, False: 6.68M]
  ------------------
  388|     48|            {
  389|     48|                visitor.bool_value(false, semantic_tag::none, *this, ec);
  390|     48|                more_ = !cursor_mode_;
  391|     48|                break;
  392|      0|            }
  393|  73.5k|            case jsoncons::ubjson::ubjson_type::int8_type: 
  ------------------
  |  Branch (393:13): [True: 73.5k, False: 6.61M]
  ------------------
  394|  73.5k|            {
  395|  73.5k|                uint8_t buf[sizeof(int8_t)];
  396|  73.5k|                if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (396:21): [True: 0, False: 73.5k]
  ------------------
  397|      0|                {
  398|      0|                    ec = ubjson_errc::unexpected_eof;
  399|      0|                    more_ = false;
  400|      0|                    return;
  401|      0|                }
  402|  73.5k|                int8_t val = binary::big_to_native<int8_t>(buf, sizeof(buf));
  403|  73.5k|                visitor.int64_value(val, semantic_tag::none, *this, ec);
  404|  73.5k|                more_ = !cursor_mode_;
  405|  73.5k|                break;
  406|  73.5k|            }
  407|    182|            case jsoncons::ubjson::ubjson_type::uint8_type: 
  ------------------
  |  Branch (407:13): [True: 182, False: 6.68M]
  ------------------
  408|    182|            {
  409|    182|                uint8_t b;
  410|    182|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (410:21): [True: 0, False: 182]
  ------------------
  411|      0|                {
  412|      0|                    ec = ubjson_errc::unexpected_eof;
  413|      0|                    more_ = false;
  414|      0|                    return;
  415|      0|                }
  416|    182|                visitor.uint64_value(b, semantic_tag::none, *this, ec);
  417|    182|                more_ = !cursor_mode_;
  418|    182|                break;
  419|    182|            }
  420|    467|            case jsoncons::ubjson::ubjson_type::int16_type: 
  ------------------
  |  Branch (420:13): [True: 467, False: 6.68M]
  ------------------
  421|    467|            {
  422|    467|                uint8_t buf[sizeof(int16_t)];
  423|    467|                if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t))
  ------------------
  |  Branch (423:21): [True: 0, False: 467]
  ------------------
  424|      0|                {
  425|      0|                    ec = ubjson_errc::unexpected_eof;
  426|      0|                    more_ = false;
  427|      0|                    return;
  428|      0|                }
  429|    467|                int16_t val = binary::big_to_native<int16_t>(buf, sizeof(buf));
  430|    467|                visitor.int64_value(val, semantic_tag::none, *this, ec);
  431|    467|                more_ = !cursor_mode_;
  432|    467|                break;
  433|    467|            }
  434|      4|            case jsoncons::ubjson::ubjson_type::int32_type: 
  ------------------
  |  Branch (434:13): [True: 4, False: 6.68M]
  ------------------
  435|      4|            {
  436|      4|                uint8_t buf[sizeof(int32_t)];
  437|      4|                if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t))
  ------------------
  |  Branch (437:21): [True: 0, False: 4]
  ------------------
  438|      0|                {
  439|      0|                    ec = ubjson_errc::unexpected_eof;
  440|      0|                    more_ = false;
  441|      0|                    return;
  442|      0|                }
  443|      4|                int32_t val = binary::big_to_native<int32_t>(buf, sizeof(buf));
  444|      4|                visitor.int64_value(val, semantic_tag::none, *this, ec);
  445|      4|                more_ = !cursor_mode_;
  446|      4|                break;
  447|      4|            }
  448|     74|            case jsoncons::ubjson::ubjson_type::int64_type: 
  ------------------
  |  Branch (448:13): [True: 74, False: 6.68M]
  ------------------
  449|     74|            {
  450|     74|                uint8_t buf[sizeof(int64_t)];
  451|     74|                if (source_.read(buf, sizeof(int64_t)) != sizeof(int64_t))
  ------------------
  |  Branch (451:21): [True: 0, False: 74]
  ------------------
  452|      0|                {
  453|      0|                    ec = ubjson_errc::unexpected_eof;
  454|      0|                    more_ = false;
  455|      0|                    return;
  456|      0|                }
  457|     74|                int64_t val = binary::big_to_native<int64_t>(buf, sizeof(buf));
  458|     74|                visitor.int64_value(val, semantic_tag::none, *this, ec);
  459|     74|                more_ = !cursor_mode_;
  460|     74|                break;
  461|     74|            }
  462|      0|            case jsoncons::ubjson::ubjson_type::float32_type: 
  ------------------
  |  Branch (462:13): [True: 0, False: 6.68M]
  ------------------
  463|      0|            {
  464|      0|                uint8_t buf[sizeof(float)];
  465|      0|                if (source_.read(buf, sizeof(float)) != sizeof(float))
  ------------------
  |  Branch (465:21): [True: 0, False: 0]
  ------------------
  466|      0|                {
  467|      0|                    ec = ubjson_errc::unexpected_eof;
  468|      0|                    more_ = false;
  469|      0|                    return;
  470|      0|                }
  471|      0|                float val = binary::big_to_native<float>(buf, sizeof(buf));
  472|      0|                visitor.double_value(val, semantic_tag::none, *this, ec);
  473|      0|                more_ = !cursor_mode_;
  474|      0|                break;
  475|      0|            }
  476|     25|            case jsoncons::ubjson::ubjson_type::float64_type: 
  ------------------
  |  Branch (476:13): [True: 25, False: 6.68M]
  ------------------
  477|     25|            {
  478|     25|                uint8_t buf[sizeof(double)];
  479|     25|                if (source_.read(buf, sizeof(double)) != sizeof(double))
  ------------------
  |  Branch (479:21): [True: 0, False: 25]
  ------------------
  480|      0|                {
  481|      0|                    ec = ubjson_errc::unexpected_eof;
  482|      0|                    more_ = false;
  483|      0|                    return;
  484|      0|                }
  485|     25|                double val = binary::big_to_native<double>(buf, sizeof(buf));
  486|     25|                visitor.double_value(val, semantic_tag::none, *this, ec);
  487|     25|                more_ = !cursor_mode_;
  488|     25|                break;
  489|     25|            }
  490|     84|            case jsoncons::ubjson::ubjson_type::char_type: 
  ------------------
  |  Branch (490:13): [True: 84, False: 6.68M]
  ------------------
  491|     84|            {
  492|     84|                uint8_t ch{};
  493|     84|                if (source_.read(&ch, 1) != 1)
  ------------------
  |  Branch (493:21): [True: 0, False: 84]
  ------------------
  494|      0|                {
  495|      0|                    ec = ubjson_errc::unexpected_eof;
  496|      0|                    more_ = false;
  497|      0|                    return;
  498|      0|                }
  499|     84|                auto result = unicode_traits::validate(&ch, 1);
  500|     84|                if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (500:21): [True: 0, False: 84]
  ------------------
  501|      0|                {
  502|      0|                    ec = ubjson_errc::invalid_utf8_text_string;
  503|      0|                    more_ = false;
  504|      0|                    return;
  505|      0|                }
  506|     84|                visitor.string_value(string_view(reinterpret_cast<const char*>(&ch), 1), semantic_tag::none, *this, ec);
  507|     84|                more_ = !cursor_mode_;
  508|     84|                break;
  509|     84|            }
  510|     34|            case jsoncons::ubjson::ubjson_type::string_type: 
  ------------------
  |  Branch (510:13): [True: 34, False: 6.68M]
  ------------------
  511|     34|            {
  512|     34|                std::size_t length = get_length(ec);
  513|     34|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     34|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 34]
  |  |  ------------------
  ------------------
  514|      0|                {
  515|      0|                    return;
  516|      0|                }
  517|     34|                auto data = source_.read_span(length, text_buffer_);
  518|     34|                if (data.size() != length)
  ------------------
  |  Branch (518:21): [True: 0, False: 34]
  ------------------
  519|      0|                {
  520|      0|                    ec = ubjson_errc::unexpected_eof;
  521|      0|                    more_ = false;
  522|      0|                    return;
  523|      0|                }
  524|     34|                auto result = unicode_traits::validate(data.data(), data.size());
  525|     34|                if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (525:21): [True: 2, False: 32]
  ------------------
  526|      2|                {
  527|      2|                    ec = ubjson_errc::invalid_utf8_text_string;
  528|      2|                    more_ = false;
  529|      2|                    return;
  530|      2|                }
  531|     32|                visitor.string_value(jsoncons::string_view(reinterpret_cast<const char*>(data.data()),data.size()), 
  532|     32|                    semantic_tag::none, *this, ec);
  533|     32|                more_ = !cursor_mode_;
  534|     32|                break;
  535|     34|            }
  536|     44|            case jsoncons::ubjson::ubjson_type::high_precision_number_type: 
  ------------------
  |  Branch (536:13): [True: 44, False: 6.68M]
  ------------------
  537|     44|            {
  538|     44|                std::size_t length = get_length(ec);
  539|     44|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     44|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 44]
  |  |  ------------------
  ------------------
  540|      0|                {
  541|      0|                    return;
  542|      0|                }
  543|     44|                auto data = source_.read_span(length, text_buffer_);
  544|     44|                if (data.size() != length)
  ------------------
  |  Branch (544:21): [True: 6, False: 38]
  ------------------
  545|      6|                {
  546|      6|                    ec = ubjson_errc::unexpected_eof;
  547|      6|                    more_ = false;
  548|      6|                    return;
  549|      6|                }
  550|     38|                if (jsoncons::is_base10(data.data(), data.size()))
  ------------------
  |  Branch (550:21): [True: 3, False: 35]
  ------------------
  551|      3|                {
  552|      3|                    visitor.string_value(jsoncons::string_view(reinterpret_cast<const char*>(data.data()), data.size()), 
  553|      3|                        semantic_tag::bigint, *this, ec);
  554|      3|                    more_ = !cursor_mode_;
  555|      3|                }
  556|     35|                else
  557|     35|                {
  558|     35|                    visitor.string_value(jsoncons::string_view(reinterpret_cast<const char*>(data.data()), data.size()), 
  559|     35|                        semantic_tag::bigdec, *this, ec);
  560|     35|                    more_ = !cursor_mode_;
  561|     35|                }
  562|     38|                break;
  563|     44|            }
  564|   471k|            case jsoncons::ubjson::ubjson_type::start_array_marker: 
  ------------------
  |  Branch (564:13): [True: 471k, False: 6.21M]
  ------------------
  565|   471k|            {
  566|   471k|                begin_array(visitor,ec);
  567|   471k|                break;
  568|     44|            }
  569|  1.55M|            case jsoncons::ubjson::ubjson_type::start_object_marker: 
  ------------------
  |  Branch (569:13): [True: 1.55M, False: 5.12M]
  ------------------
  570|  1.55M|            {
  571|  1.55M|                begin_object(visitor, ec);
  572|  1.55M|                break;
  573|     44|            }
  574|      6|            default:
  ------------------
  |  Branch (574:13): [True: 6, False: 6.68M]
  ------------------
  575|      6|            {
  576|      6|                ec = ubjson_errc::unknown_type;
  577|      6|                break;
  578|     44|            }
  579|  6.68M|        }
  580|  6.68M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  6.68M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 10, False: 6.68M]
  |  |  ------------------
  ------------------
  581|     10|        {
  582|     10|            more_ = false;
  583|     10|        }
  584|  6.68M|    }
_ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10get_lengthERNS3_10error_codeE:
  790|   460k|    {
  791|   460k|        std::size_t length = 0;
  792|   460k|        uint8_t type;
  793|   460k|        if (source_.read(&type, 1) == 0)
  ------------------
  |  Branch (793:13): [True: 0, False: 460k]
  ------------------
  794|      0|        {
  795|      0|            ec = ubjson_errc::unexpected_eof;
  796|      0|            more_ = false;
  797|      0|            return length;
  798|      0|        }
  799|   460k|        switch (type)
  800|   460k|        {
  801|   460k|            case jsoncons::ubjson::ubjson_type::int8_type: 
  ------------------
  |  Branch (801:13): [True: 460k, False: 741]
  ------------------
  802|   460k|            {
  803|   460k|                uint8_t buf[sizeof(int8_t)];
  804|   460k|                if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (804:21): [True: 0, False: 460k]
  ------------------
  805|      0|                {
  806|      0|                    ec = ubjson_errc::unexpected_eof;
  807|      0|                    more_ = false;
  808|      0|                    return length;
  809|      0|                }
  810|   460k|                int8_t val = binary::big_to_native<int8_t>(buf, sizeof(buf));
  811|   460k|                if (val >= 0)
  ------------------
  |  Branch (811:21): [True: 460k, False: 0]
  ------------------
  812|   460k|                {
  813|   460k|                    length = val;
  814|   460k|                }
  815|      0|                else
  816|      0|                {
  817|      0|                    ec = ubjson_errc::length_is_negative;
  818|      0|                    more_ = false;
  819|      0|                    return length;
  820|      0|                }
  821|   460k|                break;
  822|   460k|            }
  823|   460k|            case jsoncons::ubjson::ubjson_type::uint8_type: 
  ------------------
  |  Branch (823:13): [True: 11, False: 460k]
  ------------------
  824|     11|            {
  825|     11|                uint8_t b;
  826|     11|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (826:21): [True: 0, False: 11]
  ------------------
  827|      0|                {
  828|      0|                    ec = ubjson_errc::unexpected_eof;
  829|      0|                    more_ = false;
  830|      0|                    return length;
  831|      0|                }
  832|     11|                length = b;
  833|     11|                break;
  834|     11|            }
  835|    711|            case jsoncons::ubjson::ubjson_type::int16_type: 
  ------------------
  |  Branch (835:13): [True: 711, False: 460k]
  ------------------
  836|    711|            {
  837|    711|                uint8_t buf[sizeof(int16_t)];
  838|    711|                if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t))
  ------------------
  |  Branch (838:21): [True: 0, False: 711]
  ------------------
  839|      0|                {
  840|      0|                    ec = ubjson_errc::unexpected_eof;
  841|      0|                    more_ = false;
  842|      0|                    return length;
  843|      0|                }
  844|    711|                int16_t val = binary::big_to_native<int16_t>(buf, sizeof(buf));
  845|    711|                if (val >= 0)
  ------------------
  |  Branch (845:21): [True: 711, False: 0]
  ------------------
  846|    711|                {
  847|    711|                    length = val;
  848|    711|                }
  849|      0|                else
  850|      0|                {
  851|      0|                    ec = ubjson_errc::length_is_negative;
  852|      0|                    more_ = false;
  853|      0|                    return length;
  854|      0|                }
  855|    711|                break;
  856|    711|            }
  857|    711|            case jsoncons::ubjson::ubjson_type::int32_type: 
  ------------------
  |  Branch (857:13): [True: 13, False: 460k]
  ------------------
  858|     13|            {
  859|     13|                uint8_t buf[sizeof(int32_t)];
  860|     13|                if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t))
  ------------------
  |  Branch (860:21): [True: 0, False: 13]
  ------------------
  861|      0|                {
  862|      0|                    ec = ubjson_errc::unexpected_eof;
  863|      0|                    more_ = false;
  864|      0|                    return length;
  865|      0|                }
  866|     13|                int32_t val = binary::big_to_native<int32_t>(buf, sizeof(buf));
  867|     13|                if (val >= 0)
  ------------------
  |  Branch (867:21): [True: 13, False: 0]
  ------------------
  868|     13|                {
  869|     13|                    length = static_cast<std::size_t>(val);
  870|     13|                }
  871|      0|                else
  872|      0|                {
  873|      0|                    ec = ubjson_errc::length_is_negative;
  874|      0|                    more_ = false;
  875|      0|                    return length;
  876|      0|                }
  877|     13|                break;
  878|     13|            }
  879|     13|            case jsoncons::ubjson::ubjson_type::int64_type: 
  ------------------
  |  Branch (879:13): [True: 5, False: 460k]
  ------------------
  880|      5|            {
  881|      5|                uint8_t buf[sizeof(int64_t)];
  882|      5|                if (source_.read(buf, sizeof(int64_t)) != sizeof(int64_t))
  ------------------
  |  Branch (882:21): [True: 0, False: 5]
  ------------------
  883|      0|                {
  884|      0|                    ec = ubjson_errc::unexpected_eof;
  885|      0|                    more_ = false;
  886|      0|                    return length;
  887|      0|                }
  888|      5|                int64_t val = binary::big_to_native<int64_t>(buf, sizeof(buf));
  889|      5|                if (val >= 0)
  ------------------
  |  Branch (889:21): [True: 5, False: 0]
  ------------------
  890|      5|                {
  891|      5|                    length = (std::size_t)val;
  892|      5|                    if (length != (uint64_t)val)
  ------------------
  |  Branch (892:25): [True: 0, False: 5]
  ------------------
  893|      0|                    {
  894|      0|                        ec = ubjson_errc::number_too_large;
  895|      0|                        more_ = false;
  896|      0|                        return length;
  897|      0|                    }
  898|      5|                }
  899|      0|                else
  900|      0|                {
  901|      0|                    ec = ubjson_errc::length_is_negative;
  902|      0|                    more_ = false;
  903|      0|                    return length;
  904|      0|                }
  905|      5|                break;
  906|      5|            }
  907|      5|            default:
  ------------------
  |  Branch (907:13): [True: 1, False: 460k]
  ------------------
  908|      1|            {
  909|      1|                ec = ubjson_errc::length_must_be_integer;
  910|      1|                more_ = false;
  911|      1|                return length;
  912|      5|            }
  913|   460k|        }
  914|   460k|        return length;
  915|   460k|    }
_ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayERNS_18basic_json_visitorIcEERNS3_10error_codeE:
  587|   471k|    {
  588|   471k|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|   471k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 471k]
  |  |  ------------------
  ------------------
  589|      0|        {
  590|      0|            ec = ubjson_errc::max_nesting_depth_exceeded;
  591|      0|            more_ = false;
  592|      0|            return;
  593|      0|        } 
  594|       |
  595|   471k|        auto c = source_.peek();
  596|   471k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   471k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 471k]
  |  |  ------------------
  ------------------
  597|      1|        {
  598|      1|            ec = ubjson_errc::unexpected_eof;
  599|      1|            more_ = false;
  600|      1|            return;
  601|      1|        }
  602|   471k|        if (c.value == jsoncons::ubjson::ubjson_type::type_marker)
  ------------------
  |  Branch (602:13): [True: 1.38k, False: 470k]
  ------------------
  603|  1.38k|        {
  604|  1.38k|            source_.ignore(1);
  605|  1.38k|            uint8_t b;
  606|  1.38k|            if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (606:17): [True: 0, False: 1.38k]
  ------------------
  607|      0|            {
  608|      0|                ec = ubjson_errc::unexpected_eof;
  609|      0|                more_ = false;
  610|      0|                return;
  611|      0|            }
  612|  1.38k|            c = source_.peek();
  613|  1.38k|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.38k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.38k]
  |  |  ------------------
  ------------------
  614|      0|            {
  615|      0|                ec = ubjson_errc::unexpected_eof;
  616|      0|                more_ = false;
  617|      0|                return;
  618|      0|            }
  619|  1.38k|            if (c.value == jsoncons::ubjson::ubjson_type::count_marker)
  ------------------
  |  Branch (619:17): [True: 1.38k, False: 1]
  ------------------
  620|  1.38k|            {
  621|  1.38k|                source_.ignore(1);
  622|  1.38k|                std::size_t length = get_length(ec);
  623|  1.38k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.38k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.38k]
  |  |  ------------------
  ------------------
  624|      0|                {
  625|      0|                    return;
  626|      0|                }
  627|  1.38k|                if (length > max_items_)
  ------------------
  |  Branch (627:21): [True: 0, False: 1.38k]
  ------------------
  628|      0|                {
  629|      0|                    ec = ubjson_errc::max_items_exceeded;
  630|      0|                    more_ = false;
  631|      0|                    return;
  632|      0|                }
  633|  1.38k|                state_stack_.emplace_back(parse_mode::strongly_typed_array,length,b);
  634|  1.38k|                visitor.begin_array(length, semantic_tag::none, *this, ec);
  635|  1.38k|                more_ = !cursor_mode_;
  636|  1.38k|            }
  637|      1|            else
  638|      1|            {
  639|      1|                ec = ubjson_errc::count_required_after_type;
  640|      1|                more_ = false;
  641|      1|                return;
  642|      1|            }
  643|  1.38k|        }
  644|   470k|        else if (c.value == jsoncons::ubjson::ubjson_type::count_marker)
  ------------------
  |  Branch (644:18): [True: 1.62k, False: 468k]
  ------------------
  645|  1.62k|        {
  646|  1.62k|            source_.ignore(1);
  647|  1.62k|            std::size_t length = get_length(ec);
  648|  1.62k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.62k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.62k]
  |  |  ------------------
  ------------------
  649|      0|            {
  650|      0|                return;
  651|      0|            }
  652|  1.62k|            if (length > max_items_)
  ------------------
  |  Branch (652:17): [True: 0, False: 1.62k]
  ------------------
  653|      0|            {
  654|      0|                ec = ubjson_errc::max_items_exceeded;
  655|      0|                more_ = false;
  656|      0|                return;
  657|      0|            }
  658|  1.62k|            state_stack_.emplace_back(parse_mode::array,length);
  659|  1.62k|            visitor.begin_array(length, semantic_tag::none, *this, ec);
  660|  1.62k|            more_ = !cursor_mode_;
  661|  1.62k|        }
  662|   468k|        else
  663|   468k|        {
  664|   468k|            state_stack_.emplace_back(parse_mode::indefinite_array,0);
  665|   468k|            visitor.begin_array(semantic_tag::none, *this, ec);
  666|   468k|            more_ = !cursor_mode_;
  667|   468k|        }
  668|   471k|    }
_ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12begin_objectERNS_18basic_json_visitorIcEERNS3_10error_codeE:
  684|  1.55M|    {
  685|  1.55M|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|  1.55M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.55M]
  |  |  ------------------
  ------------------
  686|      0|        {
  687|      0|            ec = ubjson_errc::max_nesting_depth_exceeded;
  688|      0|            more_ = false;
  689|      0|            return;
  690|      0|        } 
  691|       |
  692|  1.55M|        auto c = source_.peek();
  693|  1.55M|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.55M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 1.55M]
  |  |  ------------------
  ------------------
  694|      2|        {
  695|      2|            ec = ubjson_errc::unexpected_eof;
  696|      2|            more_ = false;
  697|      2|            return;
  698|      2|        }
  699|  1.55M|        if (c.value == jsoncons::ubjson::ubjson_type::type_marker)
  ------------------
  |  Branch (699:13): [True: 3.09k, False: 1.55M]
  ------------------
  700|  3.09k|        {
  701|  3.09k|            source_.ignore(1);
  702|  3.09k|            uint8_t b;
  703|  3.09k|            if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (703:17): [True: 0, False: 3.09k]
  ------------------
  704|      0|            {
  705|      0|                ec = ubjson_errc::unexpected_eof;
  706|      0|                more_ = false;
  707|      0|                return;
  708|      0|            }
  709|  3.09k|            c = source_.peek();
  710|  3.09k|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  3.09k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.09k]
  |  |  ------------------
  ------------------
  711|      0|            {
  712|      0|                ec = ubjson_errc::unexpected_eof;
  713|      0|                more_ = false;
  714|      0|                return;
  715|      0|            }
  716|  3.09k|            if (c.value == jsoncons::ubjson::ubjson_type::count_marker)
  ------------------
  |  Branch (716:17): [True: 3.09k, False: 0]
  ------------------
  717|  3.09k|            {
  718|  3.09k|                source_.ignore(1);
  719|  3.09k|                std::size_t length = get_length(ec);
  720|  3.09k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.09k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.09k]
  |  |  ------------------
  ------------------
  721|      0|                {
  722|      0|                    return;
  723|      0|                }
  724|  3.09k|                if (length > max_items_)
  ------------------
  |  Branch (724:21): [True: 0, False: 3.09k]
  ------------------
  725|      0|                {
  726|      0|                    ec = ubjson_errc::max_items_exceeded;
  727|      0|                    more_ = false;
  728|      0|                    return;
  729|      0|                }
  730|  3.09k|                state_stack_.emplace_back(parse_mode::strongly_typed_map_key,length,b);
  731|  3.09k|                visitor.begin_object(length, semantic_tag::none, *this, ec);
  732|  3.09k|                more_ = !cursor_mode_;
  733|  3.09k|            }
  734|      0|            else
  735|      0|            {
  736|      0|                ec = ubjson_errc::count_required_after_type;
  737|      0|                more_ = false;
  738|      0|                return;
  739|      0|            }
  740|  3.09k|        }
  741|  1.55M|        else
  742|  1.55M|        {
  743|  1.55M|            c = source_.peek();
  744|  1.55M|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.55M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.55M]
  |  |  ------------------
  ------------------
  745|      0|            {
  746|      0|                ec = ubjson_errc::unexpected_eof;
  747|      0|                more_ = false;
  748|      0|                return;
  749|      0|            }
  750|  1.55M|            if (c.value == jsoncons::ubjson::ubjson_type::count_marker)
  ------------------
  |  Branch (750:17): [True: 9, False: 1.55M]
  ------------------
  751|      9|            {
  752|      9|                source_.ignore(1);
  753|      9|                std::size_t length = get_length(ec);
  754|      9|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      9|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 9]
  |  |  ------------------
  ------------------
  755|      0|                {
  756|      0|                    return;
  757|      0|                }
  758|      9|                if (length > max_items_)
  ------------------
  |  Branch (758:21): [True: 0, False: 9]
  ------------------
  759|      0|                {
  760|      0|                    ec = ubjson_errc::max_items_exceeded;
  761|      0|                    more_ = false;
  762|      0|                    return;
  763|      0|                }
  764|      9|                state_stack_.emplace_back(parse_mode::map_key,length);
  765|      9|                visitor.begin_object(length, semantic_tag::none, *this, ec);
  766|      9|                more_ = !cursor_mode_;
  767|      9|            }
  768|  1.55M|            else
  769|  1.55M|            {
  770|  1.55M|                state_stack_.emplace_back(parse_mode::indefinite_map_key,0);
  771|  1.55M|                visitor.begin_object(semantic_tag::none, *this, ec);
  772|  1.55M|                more_ = !cursor_mode_;
  773|  1.55M|            }
  774|  1.55M|        }
  775|  1.55M|    }
_ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE8read_keyERNS_18basic_json_visitorIcEERNS3_10error_codeE:
  918|   454k|    {
  919|   454k|        std::size_t length = get_length(ec);
  920|   454k|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   454k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 454k]
  |  |  ------------------
  ------------------
  921|      1|        {
  922|      1|            ec = ubjson_errc::key_expected;
  923|      1|            more_ = false;
  924|      1|            return;
  925|      1|        }
  926|   454k|        auto data = source_.read_span(length, text_buffer_);
  927|   454k|        if (data.size() != length)
  ------------------
  |  Branch (927:13): [True: 2, False: 454k]
  ------------------
  928|      2|        {
  929|      2|            ec = ubjson_errc::unexpected_eof;
  930|      2|            more_ = false;
  931|      2|            return;
  932|      2|        }
  933|       |
  934|   454k|        auto result = unicode_traits::validate(data.data(), data.size());
  935|   454k|        if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (935:13): [True: 2, False: 454k]
  ------------------
  936|      2|        {
  937|      2|            ec = ubjson_errc::invalid_utf8_text_string;
  938|      2|            more_ = false;
  939|      2|            return;
  940|      2|        }
  941|   454k|        visitor.key(jsoncons::string_view(reinterpret_cast<const char*>(data.data()),data.size()), 
  942|   454k|            *this, ec);
  943|   454k|        more_ = !cursor_mode_;
  944|   454k|    }
_ZN8jsoncons6ubjson19basic_ubjson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10end_objectERNS_18basic_json_visitorIcEERNS3_10error_codeE:
  778|  1.55M|    {
  779|  1.55M|        --nesting_depth_;
  780|  1.55M|        visitor.end_object(*this, ec);
  781|  1.55M|        more_ = !cursor_mode_;
  782|  1.55M|        if (level() == mark_level_)
  ------------------
  |  Branch (782:13): [True: 0, False: 1.55M]
  ------------------
  783|      0|        {
  784|      0|            more_ = false;
  785|      0|        }
  786|  1.55M|        state_stack_.pop_back();
  787|  1.55M|    }

_ZN8jsoncons6ubjson19basic_ubjson_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RNS_18basic_json_visitorIcEERKNS0_21ubjson_decode_optionsERKS7_:
   48|     33|       : parser_(std::forward<Sourceable>(source), options, alloc),
   49|     33|         visitor_(visitor)
   50|     33|    {
   51|     33|    }
_ZN8jsoncons6ubjson19basic_ubjson_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4readERNS3_10error_codeE:
   64|     33|    {
   65|     33|        parser_.reset();
   66|     33|        parser_.parse(visitor_, ec);
   67|     33|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     33|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 31, False: 2]
  |  |  ------------------
  ------------------
   68|     31|        {
   69|     31|            return;
   70|     31|        }
   71|     33|    }