LLVMFuzzerTestOneInput:
   11|  4.49k|{
   12|  4.49k|	std::string s(reinterpret_cast<const char*>(data), size);
   13|  4.49k|	std::istringstream is(s);
   14|       |
   15|  4.49k|    default_json_visitor visitor;
   16|  4.49k|	msgpack_options options;
   17|  4.49k|	options.max_nesting_depth(std::numeric_limits<int>::max());
   18|       |
   19|  4.49k|	msgpack_stream_reader reader(is, visitor, options);
   20|  4.49k|	std::error_code ec;
   21|  4.49k|	reader.read(ec);
   22|       |
   23|  4.49k|	return 0;
   24|  4.49k|}

_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEEC2ImEET_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  328|  60.4k|    {
  329|  60.4k|        ::new (&short_stor_) short_storage(n);
  330|  60.4k|    }
_ZN8jsoncons6detail17basic_bigint_baseINSt3__19allocatorIhEEEC2Ev:
   56|   137k|        {
   57|   137k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE13short_storageC2ImEET_PNS1_9enable_ifIXaaaasr3std11is_integralIS7_EE5valuelestS7_Lm8Entsr3std9is_signedIS7_EE5valueEvE4typeE:
  137|  60.4k|        {
  138|  60.4k|            values_[0] = n;
  139|  60.4k|            values_[1] = 0;
  140|  60.4k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEEmLEm:
  634|  23.9k|    {
  635|  23.9k|        size_type len0 = length();
  636|  23.9k|        uint64_t hi;
  637|  23.9k|        uint64_t lo;
  638|  23.9k|        uint64_t dig = data()[0];
  639|  23.9k|        uint64_t carry = 0;
  640|       |
  641|  23.9k|        resize( length() + 1 );
  642|       |
  643|  23.9k|        size_type i = 0;
  644|  45.4k|        for (i = 0; i < len0; i++ )
  ------------------
  |  Branch (644:21): [True: 21.5k, False: 23.9k]
  ------------------
  645|  21.5k|        {
  646|  21.5k|            DDproduct( dig, y, hi, lo );
  647|  21.5k|            data()[i] = lo + carry;
  648|  21.5k|            dig = data()[i+1];
  649|  21.5k|            carry = hi + (data()[i] < lo);
  650|  21.5k|        }
  651|  23.9k|        data()[i] = carry;
  652|  23.9k|        reduce();
  653|  23.9k|        return *this;
  654|  23.9k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE6lengthEv:
  343|  1.69M|    {
  344|  1.69M|        return common_stor_.length_;
  345|  1.69M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE4dataEv:
  368|   500k|    {
  369|   500k|        return is_dynamic() ? dynamic_stor_.data_ : short_stor_.values_;
  ------------------
  |  Branch (369:16): [True: 81.8k, False: 418k]
  ------------------
  370|   500k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE10is_dynamicEv:
  338|  1.45M|    {
  339|  1.45M|        return common_stor_.is_dynamic_;
  340|  1.45M|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE6resizeEm:
  508|   129k|    {
  509|   129k|        size_type len_old = common_stor_.length_;
  510|   129k|        reserve(n);
  511|   129k|        common_stor_.length_ = n;
  512|   129k|        if ( common_stor_.length_ > len_old )
  ------------------
  |  Branch (512:14): [True: 73.4k, False: 56.3k]
  ------------------
  513|  73.4k|        {
  514|  73.4k|            memset( data()+len_old, 0, (common_stor_.length_ - len_old)*sizeof(uint64_t) );
  515|  73.4k|        }
  516|   129k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE7reserveEm:
  519|   129k|    {
  520|   129k|       if (capacity() < n)
  ------------------
  |  Branch (520:12): [True: 15.8k, False: 113k]
  ------------------
  521|  15.8k|       {
  522|  15.8k|           if (!is_dynamic())
  ------------------
  |  Branch (522:16): [True: 15.8k, False: 0]
  ------------------
  523|  15.8k|           {
  524|  15.8k|               size_type size = short_stor_.length_;
  525|  15.8k|               size_type is_neg = short_stor_.is_negative_;
  526|  15.8k|               uint64_t values[2] = {short_stor_.values_[0], short_stor_.values_[1]};
  527|       |
  528|  15.8k|               ::new (&dynamic_stor_) dynamic_storage();
  529|  15.8k|               dynamic_stor_.reserve(n, get_allocator());
  530|  15.8k|               dynamic_stor_.length_ = size;
  531|  15.8k|               dynamic_stor_.is_negative_ = is_neg;
  532|  15.8k|               dynamic_stor_.data_[0] = values[0];
  533|  15.8k|               dynamic_stor_.data_[1] = values[1];
  534|  15.8k|           }
  535|      0|           else
  536|      0|           {
  537|      0|               dynamic_stor_.reserve(n, get_allocator());
  538|      0|           }
  539|  15.8k|       }
  540|   129k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE8capacityEv:
  348|   129k|    {
  349|   129k|        return is_dynamic() ? dynamic_stor_.capacity_ : 2;
  ------------------
  |  Branch (349:16): [True: 31.7k, False: 98.0k]
  ------------------
  350|   129k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE15dynamic_storageC2Ev:
  202|  15.8k|        {
  203|  15.8k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE15dynamic_storage7reserveEmRKNS2_ImEE:
  255|  15.8k|        {
  256|  15.8k|            real_allocator_type alloc(a);
  257|       |
  258|  15.8k|            size_type capacity_new = round_up(n);
  259|  15.8k|            uint64_t* data_old = data_;
  260|  15.8k|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_new);
  261|  15.8k|            if (length_ > 0)
  ------------------
  |  Branch (261:17): [True: 0, False: 15.8k]
  ------------------
  262|      0|            {
  263|      0|                std::memcpy( data_, data_old, length_*sizeof(uint64_t));
  264|      0|            }
  265|  15.8k|            if (capacity_ > 0 && data_ != nullptr)
  ------------------
  |  Branch (265:17): [True: 0, False: 15.8k]
  |  Branch (265:34): [True: 0, False: 0]
  ------------------
  266|      0|            {
  267|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_old, capacity_);
  268|      0|            }
  269|  15.8k|            capacity_ = capacity_new;
  270|  15.8k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE15dynamic_storage8round_upEm:
  274|  79.3k|        {
  275|  79.3k|            return (i/word_length + 1) * word_length;
  276|  79.3k|        }
_ZNK8jsoncons6detail17basic_bigint_baseINSt3__19allocatorIhEEE13get_allocatorEv:
   64|   305k|        {
   65|   305k|            return alloc_;
   66|   305k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE9DDproductEmmRmS5_:
 1438|  37.7k|    {
 1439|  37.7k|        uint64_t hiA = A >> basic_type_halfBits, loA = A & r_mask,
 1440|  37.7k|                   hiB = B >> basic_type_halfBits, loB = B & r_mask,
 1441|  37.7k|                   mid1, mid2, old;
 1442|       |
 1443|  37.7k|        lo = loA * loB;
 1444|  37.7k|        hi = hiA * hiB;
 1445|  37.7k|        mid1 = loA * hiB;
 1446|  37.7k|        mid2 = hiA * loB;
 1447|  37.7k|        old = lo;
 1448|  37.7k|        lo += mid1 << basic_type_halfBits;
 1449|  37.7k|            hi += (lo < old) + (mid1 >> basic_type_halfBits);
 1450|  37.7k|        old = lo;
 1451|  37.7k|        lo += mid2 << basic_type_halfBits;
 1452|  37.7k|            hi += (lo < old) + (mid2 >> basic_type_halfBits);
 1453|  37.7k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE6reduceEv:
 1573|   112k|    {
 1574|   112k|        uint64_t* p = end() - 1;
 1575|   112k|        uint64_t* pBegin = begin();
 1576|   164k|        while ( p >= pBegin )
  ------------------
  |  Branch (1576:17): [True: 156k, False: 7.89k]
  ------------------
 1577|   156k|        {
 1578|   156k|            if ( *p )
  ------------------
  |  Branch (1578:18): [True: 104k, False: 51.4k]
  ------------------
 1579|   104k|            {
 1580|   104k|                break;
 1581|   104k|            }
 1582|  51.4k|            --common_stor_.length_;
 1583|  51.4k|            --p;
 1584|  51.4k|        }
 1585|   112k|        if ( length() == 0 )
  ------------------
  |  Branch (1585:14): [True: 7.89k, False: 104k]
  ------------------
 1586|  7.89k|        {
 1587|  7.89k|            common_stor_.is_negative_ = false;
 1588|  7.89k|        }
 1589|   112k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE3endEv:
  504|   112k|    uint64_t* end() { return begin() + length(); }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE5beginEv:
  502|   225k|    uint64_t* begin() { return is_dynamic() ? dynamic_stor_.data_ : short_stor_.values_; }
  ------------------
  |  Branch (502:32): [True: 95.1k, False: 130k]
  ------------------
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEEpLERKS4_:
  571|  23.9k|    {
  572|  23.9k|        if ( is_negative() != y.is_negative() )
  ------------------
  |  Branch (572:14): [True: 0, False: 23.9k]
  ------------------
  573|      0|            return *this -= -y;
  574|  23.9k|        uint64_t d;
  575|  23.9k|        uint64_t carry = 0;
  576|       |
  577|  23.9k|        resize( (std::max)(y.length(), length()) + 1 );
  578|       |
  579|  39.2k|        for (size_type i = 0; i < length(); i++ )
  ------------------
  |  Branch (579:31): [True: 38.8k, False: 325]
  ------------------
  580|  38.8k|        {
  581|  38.8k|            if ( i >= y.length() && carry == 0 )
  ------------------
  |  Branch (581:18): [True: 24.4k, False: 14.4k]
  |  Branch (581:37): [True: 23.6k, False: 861]
  ------------------
  582|  23.6k|                break;
  583|  15.2k|            d = data()[i] + carry;
  584|  15.2k|            carry = d < carry;
  585|  15.2k|            if ( i < y.length() )
  ------------------
  |  Branch (585:18): [True: 14.4k, False: 861]
  ------------------
  586|  14.4k|            {
  587|  14.4k|                data()[i] = d + y.data()[i];
  588|  14.4k|                if ( data()[i] < d )
  ------------------
  |  Branch (588:22): [True: 861, False: 13.5k]
  ------------------
  589|    861|                    carry = 1;
  590|  14.4k|            }
  591|    861|            else
  592|    861|                data()[i] = d;
  593|  15.2k|        }
  594|  23.9k|        reduce();
  595|  23.9k|        return *this;
  596|  23.9k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE11is_negativeEv:
  353|   469k|    {
  354|   469k|        return common_stor_.is_negative_;
  355|   469k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEEngEv:
  550|  8.18k|    {
  551|  8.18k|        basic_bigint<Allocator> v(*this);
  552|  8.18k|        v.common_stor_.is_negative_ = !v.is_negative();
  553|  8.18k|        return v;
  554|  8.18k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEEC2ERKS4_:
  301|   146k|    {
  302|   146k|        if (!n.is_dynamic())
  ------------------
  |  Branch (302:13): [True: 82.9k, False: 63.4k]
  ------------------
  303|  82.9k|        {
  304|  82.9k|            ::new (&short_stor_) short_storage(n.short_stor_);
  305|  82.9k|        }
  306|  63.4k|        else
  307|  63.4k|        {
  308|  63.4k|            ::new (&dynamic_stor_) dynamic_storage(n.dynamic_stor_, get_allocator());
  309|  63.4k|        }
  310|   146k|    }
_ZN8jsoncons6detail17basic_bigint_baseINSt3__19allocatorIhEEEC2ERKS4_:
   60|   146k|        {
   61|   146k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE13short_storageC2ERKS5_:
  177|  82.9k|        {
  178|  82.9k|            values_[0] = stor.values_[0];
  179|  82.9k|            values_[1] = stor.values_[1];
  180|  82.9k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE15dynamic_storageC2ERKS5_RKNS2_ImEE:
  211|  63.4k|        {
  212|  63.4k|            create(stor.length_, alloc);
  213|  63.4k|            std::memcpy(data_, stor.data_, stor.length_*sizeof(uint64_t));
  214|  63.4k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE15dynamic_storage6createEmNS2_ImEE:
  229|  63.4k|        {
  230|  63.4k|            capacity_ = round_up(length);
  231|  63.4k|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_);
  232|  63.4k|            JSONCONS_TRY
  ------------------
  |  |  239|  63.4k|    #define JSONCONS_TRY try
  ------------------
  233|  63.4k|            {
  234|  63.4k|                std::allocator_traits<real_allocator_type>::construct(alloc, extension_traits::to_plain_pointer(data_));
  235|  63.4k|            }
  236|  63.4k|            JSONCONS_CATCH(...)
  237|  63.4k|            {
  238|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  239|      0|                JSONCONS_RETHROW;
  ------------------
  |  |  238|      0|    #define JSONCONS_RETHROW throw
  ------------------
  240|      0|            }
  241|  63.4k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE4dataEv:
  363|   152k|    {
  364|   152k|        return is_dynamic() ? dynamic_stor_.data_ : short_stor_.values_;
  ------------------
  |  Branch (364:16): [True: 63.4k, False: 88.7k]
  ------------------
  365|   152k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEED2Ev:
  333|   284k|    {
  334|   284k|        destroy();
  335|   284k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE7destroyEv:
 1429|   284k|    {
 1430|   284k|        if (is_dynamic())
  ------------------
  |  Branch (1430:13): [True: 79.3k, False: 205k]
  ------------------
 1431|  79.3k|        {
 1432|  79.3k|            dynamic_stor_.destroy(get_allocator());
 1433|  79.3k|        }
 1434|   284k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE15dynamic_storage7destroyERKNS2_ImEE:
  244|  79.3k|        {
  245|  79.3k|            if (data_ != nullptr)
  ------------------
  |  Branch (245:17): [True: 79.3k, False: 0]
  ------------------
  246|  79.3k|            {
  247|  79.3k|                real_allocator_type alloc(a);
  248|       |
  249|  79.3k|                std::allocator_traits<real_allocator_type>::destroy(alloc, extension_traits::to_plain_pointer(data_));
  250|  79.3k|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_,capacity_);
  251|  79.3k|            }
  252|  79.3k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE12write_stringIcNS1_11char_traitsIcEENS2_IcEEEEvRNS1_12basic_stringIT_T0_T1_EE:
  981|  23.9k|    {
  982|  23.9k|        basic_bigint<Allocator> v(*this);
  983|       |
  984|  23.9k|        size_t len = (v.length() * basic_type_bits / 3) + 2;
  985|  23.9k|        data.reserve(len);
  986|       |
  987|  23.9k|        static uint64_t p10 = 1;
  988|  23.9k|        static uint64_t ip10 = 0;
  989|       |
  990|  23.9k|        if ( v.length() == 0 )
  ------------------
  |  Branch (990:14): [True: 1.91k, False: 22.0k]
  ------------------
  991|  1.91k|        {
  992|  1.91k|            data.push_back('0');
  993|  1.91k|        }
  994|  22.0k|        else
  995|  22.0k|        {
  996|  22.0k|            uint64_t r;
  997|  22.0k|            if ( p10 == 1 )
  ------------------
  |  Branch (997:18): [True: 1, False: 22.0k]
  ------------------
  998|      1|            {
  999|     20|                while ( p10 <= (std::numeric_limits<uint64_t>::max)()/10 )
  ------------------
  |  Branch (999:25): [True: 19, False: 1]
  ------------------
 1000|     19|                {
 1001|     19|                    p10 *= 10;
 1002|     19|                    ip10++;
 1003|     19|                }
 1004|      1|            }                     
 1005|       |            // p10 is max unsigned power of 10
 1006|  22.0k|            basic_bigint<Allocator> R;
 1007|  22.0k|            basic_bigint<Allocator> LP10 = p10; // LP10 = p10 = ::pow(10, ip10)
 1008|       |
 1009|  22.0k|            do
 1010|  40.9k|            {
 1011|  40.9k|                v.divide( LP10, v, R, true );
 1012|  40.9k|                r = (R.length() ? R.data()[0] : 0);
  ------------------
  |  Branch (1012:22): [True: 36.9k, False: 4.03k]
  ------------------
 1013|   556k|                for ( size_type j=0; j < ip10; j++ )
  ------------------
  |  Branch (1013:38): [True: 537k, False: 18.9k]
  ------------------
 1014|   537k|                {
 1015|   537k|                    data.push_back(char(r % 10 + '0'));
 1016|   537k|                    r /= 10;
 1017|   537k|                    if ( r + v.length() == 0 )
  ------------------
  |  Branch (1017:26): [True: 22.0k, False: 515k]
  ------------------
 1018|  22.0k|                        break;
 1019|   537k|                }
 1020|  40.9k|            } 
 1021|  40.9k|            while ( v.length() );
  ------------------
  |  Branch (1021:21): [True: 18.9k, False: 22.0k]
  ------------------
 1022|  22.0k|            if (is_negative())
  ------------------
  |  Branch (1022:17): [True: 8.18k, False: 13.8k]
  ------------------
 1023|  8.18k|            {
 1024|  8.18k|                data.push_back('-');
 1025|  8.18k|            }
 1026|  22.0k|            std::reverse(data.begin(),data.end());
 1027|  22.0k|        }
 1028|  23.9k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEEC2Ev:
  288|  22.0k|    {
  289|  22.0k|        ::new (&short_stor_) short_storage();
  290|  22.0k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE13short_storageC2Ev:
  113|  22.0k|        {
  114|  22.0k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE6divideES4_RS4_S5_b:
 1351|  40.9k|    {
 1352|  40.9k|        if ( denom.length() == 0 )
  ------------------
  |  Branch (1352:14): [True: 0, False: 40.9k]
  ------------------
 1353|      0|        {
 1354|      0|            JSONCONS_THROW(std::runtime_error( "Zero divide." ));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1355|      0|        }
 1356|  40.9k|        bool quot_neg = is_negative() ^ denom.is_negative();
 1357|  40.9k|        bool rem_neg = is_negative();
 1358|  40.9k|        int x = 0;
 1359|  40.9k|        basic_bigint<Allocator> num = *this;
 1360|  40.9k|        num.common_stor_.is_negative_ = denom.common_stor_.is_negative_ = false;
 1361|  40.9k|        if ( num < denom )
  ------------------
  |  Branch (1361:14): [True: 22.0k, False: 18.9k]
  ------------------
 1362|  22.0k|        {
 1363|  22.0k|            quot = uint64_t(0);
 1364|  22.0k|            rem = num;
 1365|  22.0k|            rem.common_stor_.is_negative_ = rem_neg;
 1366|  22.0k|            return;
 1367|  22.0k|        }
 1368|  18.9k|        if ( denom.length() == 1 && num.length() == 1 )
  ------------------
  |  Branch (1368:14): [True: 18.9k, False: 0]
  |  Branch (1368:37): [True: 2.75k, False: 16.1k]
  ------------------
 1369|  2.75k|        {
 1370|  2.75k|            quot = uint64_t( num.data()[0]/denom.data()[0] );
 1371|  2.75k|            rem = uint64_t( num.data()[0]%denom.data()[0] );
 1372|  2.75k|            quot.common_stor_.is_negative_ = quot_neg;
 1373|  2.75k|            rem.common_stor_.is_negative_ = rem_neg;
 1374|  2.75k|            return;
 1375|  2.75k|        }
 1376|  16.1k|        else if (denom.length() == 1 && (denom.data()[0] & l_mask) == 0 )
  ------------------
  |  Branch (1376:18): [True: 16.1k, False: 0]
  |  Branch (1376:41): [True: 0, False: 16.1k]
  ------------------
 1377|      0|        {
 1378|       |            // Denominator fits into a half word
 1379|      0|            uint64_t divisor = denom.data()[0], dHi = 0,
 1380|      0|                     q1, r, q2, dividend;
 1381|      0|            quot.resize(length());
 1382|      0|            for (size_type i=length(); i-- > 0; )
  ------------------
  |  Branch (1382:40): [True: 0, False: 0]
  ------------------
 1383|      0|            {
 1384|      0|                dividend = (dHi << basic_type_halfBits) | (data()[i] >> basic_type_halfBits);
 1385|      0|                q1 = dividend/divisor;
 1386|      0|                r = dividend % divisor;
 1387|      0|                dividend = (r << basic_type_halfBits) | (data()[i] & r_mask);
 1388|      0|                q2 = dividend/divisor;
 1389|      0|                dHi = dividend % divisor;
 1390|      0|                quot.data()[i] = (q1 << basic_type_halfBits) | q2;
 1391|      0|            }
 1392|      0|            quot.reduce();
 1393|      0|            rem = dHi;
 1394|      0|            quot.common_stor_.is_negative_ = quot_neg;
 1395|      0|            rem.common_stor_.is_negative_ = rem_neg;
 1396|      0|            return;
 1397|      0|        }
 1398|  16.1k|        basic_bigint<Allocator> num0 = num, denom0 = denom;
 1399|  16.1k|        int second_done = normalize(denom, num, x);
 1400|  16.1k|        size_type l = denom.length() - 1;
 1401|  16.1k|        size_type n = num.length() - 1;
 1402|  16.1k|        quot.resize(n - l);
 1403|  32.3k|        for (size_type i=quot.length(); i-- > 0; )
  ------------------
  |  Branch (1403:41): [True: 16.1k, False: 16.1k]
  ------------------
 1404|  16.1k|            quot.data()[i] = 0;
 1405|  16.1k|        rem = num;
 1406|  16.1k|        if ( rem.data()[n] >= denom.data()[l] )
  ------------------
  |  Branch (1406:14): [True: 0, False: 16.1k]
  ------------------
 1407|      0|        {
 1408|      0|            rem.resize(rem.length() + 1);
 1409|      0|            n++;
 1410|      0|            quot.resize(quot.length() + 1);
 1411|      0|        }
 1412|  16.1k|        uint64_t d = denom.data()[l];
 1413|  32.3k|        for ( size_type k = n; k > l; k-- )
  ------------------
  |  Branch (1413:32): [True: 16.1k, False: 16.1k]
  ------------------
 1414|  16.1k|        {
 1415|  16.1k|            uint64_t q = DDquotient(rem.data()[k], rem.data()[k-1], d);
 1416|  16.1k|            subtractmul( rem.data() + k - l - 1, denom.data(), l + 1, q );
 1417|  16.1k|            quot.data()[k - l - 1] = q;
 1418|  16.1k|        }
 1419|  16.1k|        quot.reduce();
 1420|  16.1k|        quot.common_stor_.is_negative_ = quot_neg;
 1421|  16.1k|        if ( remDesired )
  ------------------
  |  Branch (1421:14): [True: 16.1k, False: 0]
  ------------------
 1422|  16.1k|        {
 1423|  16.1k|            unnormalize(rem, x, second_done);
 1424|  16.1k|            rem.common_stor_.is_negative_ = rem_neg;
 1425|  16.1k|        }
 1426|  16.1k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorIhEEEES6_:
 1111|  40.9k|    {
 1112|  40.9k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1112:15): [True: 22.0k, False: 18.9k]
  ------------------
 1113|  40.9k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE7compareERKS4_:
 1321|  59.4k|    {
 1322|  59.4k|        if ( is_negative() != y.is_negative() )
  ------------------
  |  Branch (1322:14): [True: 8.18k, False: 51.2k]
  ------------------
 1323|  8.18k|            return y.is_negative() - is_negative();
 1324|  51.2k|        int code = 0;
 1325|  51.2k|        if ( length() == 0 && y.length() == 0 )
  ------------------
  |  Branch (1325:14): [True: 1.22k, False: 50.0k]
  |  Branch (1325:31): [True: 1.22k, False: 0]
  ------------------
 1326|  1.22k|            code = 0;
 1327|  50.0k|        else if ( length() < y.length() )
  ------------------
  |  Branch (1327:19): [True: 0, False: 50.0k]
  ------------------
 1328|      0|            code = -1;
 1329|  50.0k|        else if ( length() > y.length() )
  ------------------
  |  Branch (1329:19): [True: 25.2k, False: 24.7k]
  ------------------
 1330|  25.2k|            code = +1;
 1331|  24.7k|        else
 1332|  24.7k|        {
 1333|  25.2k|            for (size_type i = length(); i-- > 0; )
  ------------------
  |  Branch (1333:42): [True: 24.7k, False: 433]
  ------------------
 1334|  24.7k|            {
 1335|  24.7k|                if (data()[i] > y.data()[i])
  ------------------
  |  Branch (1335:21): [True: 2.32k, False: 22.4k]
  ------------------
 1336|  2.32k|                {
 1337|  2.32k|                    code = 1;
 1338|  2.32k|                    break;
 1339|  2.32k|                }
 1340|  22.4k|                else if (data()[i] < y.data()[i])
  ------------------
  |  Branch (1340:26): [True: 22.0k, False: 433]
  ------------------
 1341|  22.0k|                {
 1342|  22.0k|                    code = -1;
 1343|  22.0k|                    break;
 1344|  22.0k|                }
 1345|  24.7k|            }
 1346|  24.7k|        }
 1347|  51.2k|        return is_negative() ? -code : code;
  ------------------
  |  Branch (1347:16): [True: 0, False: 51.2k]
  ------------------
 1348|  59.4k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEEaSERKS4_:
  557|  65.7k|    {
  558|  65.7k|        if ( this != &y )
  ------------------
  |  Branch (558:14): [True: 65.7k, False: 0]
  ------------------
  559|  65.7k|        {
  560|  65.7k|            resize( y.length() );
  561|  65.7k|            common_stor_.is_negative_ = y.is_negative();
  562|  65.7k|            if ( y.length() > 0 )
  ------------------
  |  Branch (562:18): [True: 43.2k, False: 22.4k]
  ------------------
  563|  43.2k|            {
  564|  43.2k|                std::memcpy( data(), y.data(), y.length()*sizeof(uint64_t) );
  565|  43.2k|            }
  566|  65.7k|        }
  567|  65.7k|        return *this;
  568|  65.7k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE9normalizeERS4_S5_Ri:
 1530|  16.1k|    {
 1531|  16.1k|        size_type r = denom.length() - 1;
 1532|  16.1k|        uint64_t y = denom.data()[r];
 1533|       |
 1534|  16.1k|        x = 0;
 1535|  16.1k|        while ( (y & l_bit) == 0 )
  ------------------
  |  Branch (1535:17): [True: 0, False: 16.1k]
  ------------------
 1536|      0|        {
 1537|      0|            y <<= 1;
 1538|      0|            x++;
 1539|      0|        }
 1540|  16.1k|        denom <<= x;
 1541|  16.1k|        num <<= x;
 1542|  16.1k|        if ( r > 0 && denom.data()[r] < denom.data()[r-1] )
  ------------------
  |  Branch (1542:14): [True: 0, False: 16.1k]
  |  Branch (1542:23): [True: 0, False: 0]
  ------------------
 1543|      0|        {
 1544|      0|            denom *= max_basic_type;
 1545|      0|                    num *= max_basic_type;
 1546|      0|            return 1;
 1547|      0|        }
 1548|  16.1k|        return 0;
 1549|  16.1k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEElSEm:
  735|  32.3k|    {
  736|  32.3k|        size_type q = (size_type)(k / basic_type_bits);
  737|  32.3k|        if ( q ) // Increase common_stor_.length_ by q:
  ------------------
  |  Branch (737:14): [True: 0, False: 32.3k]
  ------------------
  738|      0|        {
  739|      0|            resize(length() + q);
  740|      0|            for (size_type i = length(); i-- > 0; )
  ------------------
  |  Branch (740:42): [True: 0, False: 0]
  ------------------
  741|      0|                data()[i] = ( i < q ? 0 : data()[i - q]);
  ------------------
  |  Branch (741:31): [True: 0, False: 0]
  ------------------
  742|      0|            k %= basic_type_bits;
  743|      0|        }
  744|  32.3k|        if ( k )  // 0 < k < basic_type_bits:
  ------------------
  |  Branch (744:14): [True: 0, False: 32.3k]
  ------------------
  745|      0|        {
  746|      0|            uint64_t k1 = basic_type_bits - k;
  747|      0|            uint64_t mask = (uint64_t(1) << k) - uint64_t(1);
  748|      0|            resize( length() + 1 );
  749|      0|            for (size_type i = length(); i-- > 0; )
  ------------------
  |  Branch (749:42): [True: 0, False: 0]
  ------------------
  750|      0|            {
  751|      0|                data()[i] <<= k;
  752|      0|                if ( i > 0 )
  ------------------
  |  Branch (752:22): [True: 0, False: 0]
  ------------------
  753|      0|                    data()[i] |= (data()[i-1] >> k1) & mask;
  754|      0|            }
  755|      0|        }
  756|  32.3k|        reduce();
  757|  32.3k|        return *this;
  758|  32.3k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE10DDquotientEmmm:
 1457|  16.1k|    {
 1458|  16.1k|        uint64_t left, middle, right, qHi, qLo, x, dLo1,
 1459|  16.1k|                   dHi = d >> basic_type_halfBits, dLo = d & r_mask;
 1460|  16.1k|        qHi = A/(dHi + 1);
 1461|       |        // This initial guess of qHi may be too small.
 1462|  16.1k|        middle = qHi * dLo;
 1463|  16.1k|        left = qHi * dHi;
 1464|  16.1k|        x = B - (middle << basic_type_halfBits);
 1465|  16.1k|        A -= (middle >> basic_type_halfBits) + left + (x > B);
 1466|  16.1k|        B = x;
 1467|  16.1k|        dLo1 = dLo << basic_type_halfBits;
 1468|       |        // Increase qHi if necessary:
 1469|  16.1k|        while ( A > dHi || (A == dHi && B >= dLo1) )
  ------------------
  |  Branch (1469:17): [True: 0, False: 16.1k]
  |  Branch (1469:29): [True: 0, False: 16.1k]
  |  Branch (1469:41): [True: 0, False: 0]
  ------------------
 1470|      0|        {
 1471|      0|            x = B - dLo1;
 1472|      0|            A -= dHi + (x > B);
 1473|      0|            B = x;
 1474|      0|            qHi++;
 1475|      0|        }
 1476|  16.1k|        qLo = ((A << basic_type_halfBits) | (B >> basic_type_halfBits))/(dHi + 1);
 1477|       |        // This initial guess of qLo may be too small.
 1478|  16.1k|        right = qLo * dLo;
 1479|  16.1k|        middle = qLo * dHi;
 1480|  16.1k|        x = B - right;
 1481|  16.1k|        A -= (x > B);
 1482|  16.1k|        B = x;
 1483|  16.1k|        x = B - (middle << basic_type_halfBits);
 1484|  16.1k|            A -= (middle >> basic_type_halfBits) + (x > B);
 1485|  16.1k|        B = x;
 1486|       |        // Increase qLo if necessary:
 1487|  25.7k|        while ( A || B >= d )
  ------------------
  |  Branch (1487:17): [True: 0, False: 25.7k]
  |  Branch (1487:22): [True: 9.51k, False: 16.1k]
  ------------------
 1488|  9.51k|        {
 1489|  9.51k|            x = B - d;
 1490|  9.51k|            A -= (x > B);
 1491|  9.51k|            B = x;
 1492|  9.51k|            qLo++;
 1493|  9.51k|        }
 1494|  16.1k|        return (qHi << basic_type_halfBits) + qLo;
 1495|  16.1k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE11subtractmulEPmS5_mRm:
 1499|  16.1k|    {
 1500|  16.1k|        uint64_t hi, lo, d, carry = 0;
 1501|  16.1k|        size_type i;
 1502|  32.3k|        for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1502:22): [True: 16.1k, False: 16.1k]
  ------------------
 1503|  16.1k|        {
 1504|  16.1k|            DDproduct( b[i], q, hi, lo );
 1505|  16.1k|            d = a[i];
 1506|  16.1k|            a[i] -= lo;
 1507|  16.1k|            if ( a[i] > d )
  ------------------
  |  Branch (1507:18): [True: 2.74k, False: 13.4k]
  ------------------
 1508|  2.74k|                carry++;
 1509|  16.1k|            d = a[i + 1];
 1510|  16.1k|            a[i + 1] -= hi + carry;
 1511|  16.1k|            carry = a[i + 1] > d;
 1512|  16.1k|        }
 1513|  16.1k|        if ( carry ) // q was too large
  ------------------
  |  Branch (1513:14): [True: 0, False: 16.1k]
  ------------------
 1514|      0|        {
 1515|      0|            q--;
 1516|      0|            carry = 0;
 1517|      0|            for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1517:26): [True: 0, False: 0]
  ------------------
 1518|      0|            {
 1519|      0|                d = a[i] + carry;
 1520|      0|                carry = d < carry;
 1521|      0|                a[i] = d + b[i];
 1522|      0|                if ( a[i] < d )
  ------------------
  |  Branch (1522:22): [True: 0, False: 0]
  ------------------
 1523|      0|                    carry = 1;
 1524|      0|            }
 1525|      0|            a[n] = 0;
 1526|      0|        }
 1527|  16.1k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorIhEEE11unnormalizeERS4_ii:
 1552|  16.1k|    {
 1553|  16.1k|        if ( secondDone )
  ------------------
  |  Branch (1553:14): [True: 0, False: 16.1k]
  ------------------
 1554|      0|        {
 1555|      0|            rem /= max_basic_type;
 1556|      0|        }
 1557|  16.1k|        if ( x > 0 )
  ------------------
  |  Branch (1557:14): [True: 0, False: 16.1k]
  ------------------
 1558|      0|        {
 1559|      0|            rem >>= x;
 1560|      0|        }
 1561|  16.1k|        else
 1562|  16.1k|        {
 1563|  16.1k|            rem.reduce();
 1564|  16.1k|        }
 1565|  16.1k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEEC2IlEET_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  328|  36.9k|    {
  329|  36.9k|        ::new (&short_stor_) short_storage(n);
  330|  36.9k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE13short_storageC2IlEET_PNS1_9enable_ifIXaaaasr3std11is_integralIS7_EE5valuelestS7_Lm8Esr3std9is_signedIS7_EE5valueEvE4typeE:
  124|  36.9k|        {
  125|  36.9k|            values_[0] = n < 0 ? (uint64_t(0)-static_cast<uint64_t>(n)) : static_cast<uint64_t>(n);
  ------------------
  |  Branch (125:26): [True: 8.18k, False: 28.7k]
  ------------------
  126|  36.9k|            values_[1] = 0;
  127|  36.9k|        }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorIhEEEEl:
 1116|  18.4k|    {
 1117|  18.4k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1117:15): [True: 8.18k, False: 10.2k]
  ------------------
 1118|  18.4k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEEC2IjEET_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  328|  18.4k|    {
  329|  18.4k|        ::new (&short_stor_) short_storage(n);
  330|  18.4k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEE13short_storageC2IjEET_PNS1_9enable_ifIXaaaasr3std11is_integralIS7_EE5valuelestS7_Lm8Entsr3std9is_signedIS7_EE5valueEvE4typeE:
  137|  18.4k|        {
  138|  18.4k|            values_[0] = n;
  139|  18.4k|            values_[1] = 0;
  140|  18.4k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorIhEEEmIERKS4_:
  599|  8.18k|    {
  600|  8.18k|        if ( is_negative() != y.is_negative() )
  ------------------
  |  Branch (600:14): [True: 8.18k, False: 0]
  ------------------
  601|  8.18k|            return *this += -y;
  602|      0|        if ( (!is_negative() && y > *this) || (is_negative() && y < *this) )
  ------------------
  |  Branch (602:15): [True: 0, False: 0]
  |  Branch (602:33): [True: 0, False: 0]
  |  Branch (602:48): [True: 0, False: 0]
  |  Branch (602:65): [True: 0, False: 0]
  ------------------
  603|      0|            return *this = -(y - *this);
  604|      0|        uint64_t borrow = 0;
  605|      0|        uint64_t d;
  606|      0|        for (size_type i = 0; i < length(); i++ )
  ------------------
  |  Branch (606:31): [True: 0, False: 0]
  ------------------
  607|      0|        {
  608|      0|            if ( i >= y.length() && borrow == 0 )
  ------------------
  |  Branch (608:18): [True: 0, False: 0]
  |  Branch (608:37): [True: 0, False: 0]
  ------------------
  609|      0|                break;
  610|      0|            d = data()[i] - borrow;
  611|      0|            borrow = d > data()[i];
  612|      0|            if ( i < y.length())
  ------------------
  |  Branch (612:18): [True: 0, False: 0]
  ------------------
  613|      0|            {
  614|      0|                data()[i] = d - y.data()[i];
  615|      0|                if ( data()[i] > d )
  ------------------
  |  Branch (615:22): [True: 0, False: 0]
  ------------------
  616|      0|                    borrow = 1;
  617|      0|            }
  618|      0|            else 
  619|      0|                data()[i] = d;
  620|      0|        }
  621|      0|        reduce();
  622|      0|        return *this;
  623|      0|    }

_ZN8jsoncons6detail21encode_base64_genericIPKhNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS4_9enable_ifIXsr3std7is_sameINS4_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESD_SD_PKcRT0_:
   35|  13.0k|    {
   36|  13.0k|        std::size_t count = 0;
   37|  13.0k|        unsigned char a3[3];
   38|  13.0k|        unsigned char a4[4];
   39|  13.0k|        unsigned char fill = alphabet[64];
   40|  13.0k|        int i = 0;
   41|  13.0k|        int j = 0;
   42|       |
   43|  4.68M|        while (first != last)
  ------------------
  |  Branch (43:16): [True: 4.67M, False: 13.0k]
  ------------------
   44|  4.67M|        {
   45|  4.67M|            a3[i++] = *first++;
   46|  4.67M|            if (i == 3)
  ------------------
  |  Branch (46:17): [True: 1.55M, False: 3.11M]
  ------------------
   47|  1.55M|            {
   48|  1.55M|                a4[0] = (a3[0] & 0xfc) >> 2;
   49|  1.55M|                a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   50|  1.55M|                a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   51|  1.55M|                a4[3] = a3[2] & 0x3f;
   52|       |
   53|  7.77M|                for (i = 0; i < 4; i++) 
  ------------------
  |  Branch (53:29): [True: 6.22M, False: 1.55M]
  ------------------
   54|  6.22M|                {
   55|  6.22M|                    result.push_back(alphabet[a4[i]]);
   56|  6.22M|                    ++count;
   57|  6.22M|                }
   58|  1.55M|                i = 0;
   59|  1.55M|            }
   60|  4.67M|        }
   61|       |
   62|  13.0k|        if (i > 0)
  ------------------
  |  Branch (62:13): [True: 6.83k, False: 6.18k]
  ------------------
   63|  6.83k|        {
   64|  19.2k|            for (j = i; j < 3; ++j) 
  ------------------
  |  Branch (64:25): [True: 12.4k, False: 6.83k]
  ------------------
   65|  12.4k|            {
   66|  12.4k|                a3[j] = 0;
   67|  12.4k|            }
   68|       |
   69|  6.83k|            a4[0] = (a3[0] & 0xfc) >> 2;
   70|  6.83k|            a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   71|  6.83k|            a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   72|       |
   73|  21.7k|            for (j = 0; j < i + 1; ++j) 
  ------------------
  |  Branch (73:25): [True: 14.8k, False: 6.83k]
  ------------------
   74|  14.8k|            {
   75|  14.8k|                result.push_back(alphabet[a4[j]]);
   76|  14.8k|                ++count;
   77|  14.8k|            }
   78|       |
   79|  6.83k|            if (fill != 0)
  ------------------
  |  Branch (79:17): [True: 0, False: 6.83k]
  ------------------
   80|      0|            {
   81|      0|                while (i++ < 3) 
  ------------------
  |  Branch (81:24): [True: 0, False: 0]
  ------------------
   82|      0|                {
   83|      0|                    result.push_back(fill);
   84|      0|                    ++count;
   85|      0|                }
   86|      0|            }
   87|  6.83k|        }
   88|       |
   89|  13.0k|        return count;
   90|  13.0k|    }
_ZNK8jsoncons16byte_string_view5beginEv:
  409|  13.0k|        {
  410|  13.0k|            return data_;
  411|  13.0k|        }
_ZNK8jsoncons16byte_string_view3endEv:
  413|  13.0k|        {
  414|  13.0k|            return data_ + size_;
  415|  13.0k|        }
_ZN8jsoncons16encode_base64urlIPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  168|  13.0k|    {
  169|  13.0k|        static constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  170|  13.0k|                                                      "abcdefghijklmnopqrstuvwxyz"
  171|  13.0k|                                                      "0123456789-_"
  172|  13.0k|                                                      "\0";
  173|  13.0k|        return detail::encode_base64_generic(first, last, alphabet, result);
  174|  13.0k|    }
_ZNK8jsoncons16byte_string_view4dataEv:
  392|  17.6k|        {
  393|  17.6k|            return data_;
  394|  17.6k|        }
_ZNK8jsoncons16byte_string_view4sizeEv:
  403|  17.6k|        {
  404|  17.6k|            return size_;
  405|  17.6k|        }
_ZN8jsoncons16byte_string_viewC2EPKhm:
  355|  32.9k|        {
  356|  32.9k|        }

_ZN8jsoncons6binary9byte_swapIfEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
  182|  18.6k|    {
  183|  18.6k|        uint32_t x;
  184|  18.6k|        std::memcpy(&x,&val,sizeof(uint32_t));
  185|  18.6k|        uint32_t y = byte_swap(x);
  186|  18.6k|        T val2;
  187|  18.6k|        std::memcpy(&val2,&y,sizeof(uint32_t));
  188|  18.6k|        return val2;
  189|  18.6k|    }
_ZN8jsoncons6binary9byte_swapIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
  157|  40.0k|    {
  158|  40.0k|    #if defined(JSONCONS_BYTE_SWAP_32)
  159|  40.0k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |   31|  40.0k|#  define JSONCONS_BYTE_SWAP_32 __builtin_bswap32
  ------------------
  160|       |    #else
  161|       |        uint32_t tmp = ((static_cast<uint32_t>(val) << 8) & 0xff00ff00) | ((static_cast<uint32_t>(val) >> 8) & 0xff00ff);
  162|       |        return (tmp << 16) | (tmp >> 16);
  163|       |    #endif
  164|  40.0k|    }
_ZN8jsoncons6binary9byte_swapIdEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
  194|  7.20k|    {
  195|  7.20k|        uint64_t x;
  196|  7.20k|        std::memcpy(&x,&val,sizeof(uint64_t));
  197|  7.20k|        uint64_t y = byte_swap(x);
  198|  7.20k|        T val2;
  199|  7.20k|        std::memcpy(&val2,&y,sizeof(uint64_t));
  200|  7.20k|        return val2;
  201|  7.20k|    }
_ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
  169|  13.4k|    {
  170|  13.4k|    #if defined(JSONCONS_BYTE_SWAP_64)
  171|  13.4k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |   30|  13.4k|#  define JSONCONS_BYTE_SWAP_64 __builtin_bswap64
  ------------------
  172|       |    #else
  173|       |        uint64_t tmp = ((static_cast<uint64_t>(val) & 0x00000000ffffffffull) << 32) | ((static_cast<uint64_t>(val) & 0xffffffff00000000ull) >> 32);
  174|       |        tmp = ((tmp & 0x0000ffff0000ffffull) << 16) | ((tmp & 0xffff0000ffff0000ull) >> 16);
  175|       |        return ((tmp & 0x00ff00ff00ff00ffull) << 8)  | ((tmp & 0xff00ff00ff00ff00ull) >> 8);
  176|       |    #endif
  177|  13.4k|    }
_ZN8jsoncons6binary9byte_swapItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
  146|  4.43k|    {
  147|  4.43k|    #if defined(JSONCONS_BYTE_SWAP_16)
  148|  4.43k|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |   35|  4.43k|#      define JSONCONS_BYTE_SWAP_16    __builtin_bswap16
  ------------------
  149|       |    #else
  150|       |        return (static_cast<uint16_t>(val) >> 8) | (static_cast<uint16_t>(val) << 8);
  151|       |    #endif
  152|  4.43k|    }
_ZN8jsoncons6binary9byte_swapIaEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_:
  139|  35.9k|    {
  140|  35.9k|        return val;
  141|  35.9k|    }
_ZN8jsoncons6binary9byte_swapIsEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
  146|    916|    {
  147|    916|    #if defined(JSONCONS_BYTE_SWAP_16)
  148|    916|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |   35|    916|#      define JSONCONS_BYTE_SWAP_16    __builtin_bswap16
  ------------------
  149|       |    #else
  150|       |        return (static_cast<uint16_t>(val) >> 8) | (static_cast<uint16_t>(val) << 8);
  151|       |    #endif
  152|    916|    }
_ZN8jsoncons6binary9byte_swapIiEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
  157|  2.90k|    {
  158|  2.90k|    #if defined(JSONCONS_BYTE_SWAP_32)
  159|  2.90k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |   31|  2.90k|#  define JSONCONS_BYTE_SWAP_32 __builtin_bswap32
  ------------------
  160|       |    #else
  161|       |        uint32_t tmp = ((static_cast<uint32_t>(val) << 8) & 0xff00ff00) | ((static_cast<uint32_t>(val) >> 8) & 0xff00ff);
  162|       |        return (tmp << 16) | (tmp >> 16);
  163|       |    #endif
  164|  2.90k|    }
_ZN8jsoncons6binary9byte_swapIlEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
  169|  19.2k|    {
  170|  19.2k|    #if defined(JSONCONS_BYTE_SWAP_64)
  171|  19.2k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |   30|  19.2k|#  define JSONCONS_BYTE_SWAP_64 __builtin_bswap64
  ------------------
  172|       |    #else
  173|       |        uint64_t tmp = ((static_cast<uint64_t>(val) & 0x00000000ffffffffull) << 32) | ((static_cast<uint64_t>(val) & 0xffffffff00000000ull) >> 32);
  174|       |        tmp = ((tmp & 0x0000ffff0000ffffull) << 16) | ((tmp & 0xffff0000ffff0000ull) >> 16);
  175|       |        return ((tmp & 0x00ff00ff00ff00ffull) << 8)  | ((tmp & 0xff00ff00ff00ff00ull) >> 8);
  176|       |    #endif
  177|  19.2k|    }
_ZN8jsoncons6binary9byte_swapIhEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_:
  139|  25.8k|    {
  140|  25.8k|        return val;
  141|  25.8k|    }

_ZN8jsoncons6binary13big_to_nativeIfNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  204|  18.6k|    {
  205|  18.6k|        if (sizeof(T) > count)
  ------------------
  |  Branch (205:13): [True: 0, False: 18.6k]
  ------------------
  206|      0|        {
  207|      0|            return T{};
  208|      0|        }
  209|  18.6k|        T val;
  210|  18.6k|        std::memcpy(&val,first,sizeof(T));
  211|  18.6k|        return byte_swap(val);
  212|  18.6k|    }
_ZN8jsoncons6binary13big_to_nativeIdNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  204|  7.20k|    {
  205|  7.20k|        if (sizeof(T) > count)
  ------------------
  |  Branch (205:13): [True: 0, False: 7.20k]
  ------------------
  206|      0|        {
  207|      0|            return T{};
  208|      0|        }
  209|  7.20k|        T val;
  210|  7.20k|        std::memcpy(&val,first,sizeof(T));
  211|  7.20k|        return byte_swap(val);
  212|  7.20k|    }
_ZN8jsoncons6binary13big_to_nativeItNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  204|  4.43k|    {
  205|  4.43k|        if (sizeof(T) > count)
  ------------------
  |  Branch (205:13): [True: 0, False: 4.43k]
  ------------------
  206|      0|        {
  207|      0|            return T{};
  208|      0|        }
  209|  4.43k|        T val;
  210|  4.43k|        std::memcpy(&val,first,sizeof(T));
  211|  4.43k|        return byte_swap(val);
  212|  4.43k|    }
_ZN8jsoncons6binary13big_to_nativeIjNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  204|  21.4k|    {
  205|  21.4k|        if (sizeof(T) > count)
  ------------------
  |  Branch (205:13): [True: 0, False: 21.4k]
  ------------------
  206|      0|        {
  207|      0|            return T{};
  208|      0|        }
  209|  21.4k|        T val;
  210|  21.4k|        std::memcpy(&val,first,sizeof(T));
  211|  21.4k|        return byte_swap(val);
  212|  21.4k|    }
_ZN8jsoncons6binary13big_to_nativeImNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  204|  6.24k|    {
  205|  6.24k|        if (sizeof(T) > count)
  ------------------
  |  Branch (205:13): [True: 0, False: 6.24k]
  ------------------
  206|      0|        {
  207|      0|            return T{};
  208|      0|        }
  209|  6.24k|        T val;
  210|  6.24k|        std::memcpy(&val,first,sizeof(T));
  211|  6.24k|        return byte_swap(val);
  212|  6.24k|    }
_ZN8jsoncons6binary13big_to_nativeIaNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  204|  35.9k|    {
  205|  35.9k|        if (sizeof(T) > count)
  ------------------
  |  Branch (205:13): [True: 0, False: 35.9k]
  ------------------
  206|      0|        {
  207|      0|            return T{};
  208|      0|        }
  209|  35.9k|        T val;
  210|  35.9k|        std::memcpy(&val,first,sizeof(T));
  211|  35.9k|        return byte_swap(val);
  212|  35.9k|    }
_ZN8jsoncons6binary13big_to_nativeIsNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  204|    916|    {
  205|    916|        if (sizeof(T) > count)
  ------------------
  |  Branch (205:13): [True: 0, False: 916]
  ------------------
  206|      0|        {
  207|      0|            return T{};
  208|      0|        }
  209|    916|        T val;
  210|    916|        std::memcpy(&val,first,sizeof(T));
  211|    916|        return byte_swap(val);
  212|    916|    }
_ZN8jsoncons6binary13big_to_nativeIiNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  204|  2.90k|    {
  205|  2.90k|        if (sizeof(T) > count)
  ------------------
  |  Branch (205:13): [True: 0, False: 2.90k]
  ------------------
  206|      0|        {
  207|      0|            return T{};
  208|      0|        }
  209|  2.90k|        T val;
  210|  2.90k|        std::memcpy(&val,first,sizeof(T));
  211|  2.90k|        return byte_swap(val);
  212|  2.90k|    }
_ZN8jsoncons6binary13big_to_nativeIlNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  204|  19.2k|    {
  205|  19.2k|        if (sizeof(T) > count)
  ------------------
  |  Branch (205:13): [True: 0, False: 19.2k]
  ------------------
  206|      0|        {
  207|      0|            return T{};
  208|      0|        }
  209|  19.2k|        T val;
  210|  19.2k|        std::memcpy(&val,first,sizeof(T));
  211|  19.2k|        return byte_swap(val);
  212|  19.2k|    }
_ZN8jsoncons6binary13big_to_nativeIhNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  204|  25.8k|    {
  205|  25.8k|        if (sizeof(T) > count)
  ------------------
  |  Branch (205:13): [True: 0, False: 25.8k]
  ------------------
  206|      0|        {
  207|      0|            return T{};
  208|      0|        }
  209|  25.8k|        T val;
  210|  25.8k|        std::memcpy(&val,first,sizeof(T));
  211|  25.8k|        return byte_swap(val);
  212|  25.8k|    }

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

_ZN8jsoncons6detail8chars_toC2Ev:
 1082|  29.2k|    {
 1083|  29.2k|        struct lconv * lc = localeconv();
 1084|  29.2k|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (1084:13): [True: 29.2k, False: 0]
  |  Branch (1084:30): [True: 29.2k, False: 0]
  ------------------
 1085|  29.2k|        {
 1086|  29.2k|            decimal_point_ = lc->decimal_point[0];    
 1087|  29.2k|        }
 1088|      0|        else
 1089|      0|        {
 1090|      0|            decimal_point_ = '.'; 
 1091|      0|        }
 1092|  29.2k|        buffer_.reserve(100);
 1093|  29.2k|    }
_ZNK8jsoncons6detail8chars_toclIcEENSt3__19enable_ifIXsr3std7is_sameIT_cEE5valueEdE4typeEPKS5_m:
 1106|  4.04k|    {
 1107|  4.04k|        CharT *end = nullptr;
 1108|  4.04k|        double val = strtod(s, &end);
 1109|  4.04k|        if (s == end)
  ------------------
  |  Branch (1109:13): [True: 0, False: 4.04k]
  ------------------
 1110|      0|        {
 1111|      0|            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("Convert string to double failed"));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1112|      0|        }
 1113|  4.04k|        return val;
 1114|  4.04k|    }

_ZN8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEEC2IS4_NS2_9allocatorIcEEEERKNS2_12basic_stringIcT_T0_EE:
   60|  47.3k|        {
   61|  47.3k|        }
_ZNK8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEE5beginEv:
   79|  6.02M|        {
   80|  6.02M|            return data_;
   81|  6.02M|        }
_ZNK8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEE3endEv:
   83|  6.02M|        {
   84|  6.02M|            return data_ + length_;
   85|  6.02M|        }
_ZN8jsoncons6detail17basic_string_viewIcNSt3__111char_traitsIcEEEC2EPKcm:
   48|  6.01M|        {
   49|  6.01M|        }

_ZN8jsoncons6detail12from_integerImNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_9enable_ifIXsr16extension_traits10is_integerIT_EE5valueEmE4typeESA_RT0_:
   37|  4.19M|    {
   38|  4.19M|        using char_type = typename Result::value_type;
   39|       |
   40|  4.19M|        char_type buf[255];
   41|  4.19M|        char_type *p = buf;
   42|  4.19M|        const char_type* last = buf+255;
   43|       |
   44|  4.19M|        bool is_negative = value < 0;
   45|       |
   46|  4.19M|        if (value < 0)
  ------------------
  |  Branch (46:13): [True: 0, False: 4.19M]
  ------------------
   47|      0|        {
   48|      0|            do
   49|      0|            {
   50|      0|                *p++ = static_cast<char_type>(48 - (value % 10));
   51|      0|            }
   52|      0|            while ((value /= 10) && (p < last));
  ------------------
  |  Branch (52:20): [True: 0, False: 0]
  |  Branch (52:37): [True: 0, False: 0]
  ------------------
   53|      0|        }
   54|  4.19M|        else
   55|  4.19M|        {
   56|       |
   57|  4.19M|            do
   58|  8.30M|            {
   59|  8.30M|                *p++ = static_cast<char_type>(48 + value % 10);
   60|  8.30M|            }
   61|  8.30M|            while ((value /= 10) && (p < last));
  ------------------
  |  Branch (61:20): [True: 4.11M, False: 4.19M]
  |  Branch (61:37): [True: 4.11M, False: 0]
  ------------------
   62|  4.19M|        }
   63|  4.19M|        JSONCONS_ASSERT(p != last);
  ------------------
  |  |  378|  4.19M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 4.19M]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   64|       |
   65|  4.19M|        std::size_t count = (p - buf);
   66|  4.19M|        if (is_negative)
  ------------------
  |  Branch (66:13): [True: 0, False: 4.19M]
  ------------------
   67|      0|        {
   68|      0|            result.push_back('-');
   69|      0|            ++count;
   70|      0|        }
   71|  12.4M|        while (--p >= buf)
  ------------------
  |  Branch (71:16): [True: 8.30M, False: 4.19M]
  ------------------
   72|  8.30M|        {
   73|  8.30M|            result.push_back(*p);
   74|  8.30M|        }
   75|       |
   76|  4.19M|        return count;
   77|  4.19M|    }
_ZN8jsoncons6detail12from_integerIlNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_9enable_ifIXsr16extension_traits10is_integerIT_EE5valueEmE4typeESA_RT0_:
   37|  3.48M|    {
   38|  3.48M|        using char_type = typename Result::value_type;
   39|       |
   40|  3.48M|        char_type buf[255];
   41|  3.48M|        char_type *p = buf;
   42|  3.48M|        const char_type* last = buf+255;
   43|       |
   44|  3.48M|        bool is_negative = value < 0;
   45|       |
   46|  3.48M|        if (value < 0)
  ------------------
  |  Branch (46:13): [True: 3.48M, False: 786]
  ------------------
   47|  3.48M|        {
   48|  3.48M|            do
   49|  3.56M|            {
   50|  3.56M|                *p++ = static_cast<char_type>(48 - (value % 10));
   51|  3.56M|            }
   52|  3.56M|            while ((value /= 10) && (p < last));
  ------------------
  |  Branch (52:20): [True: 89.3k, False: 3.48M]
  |  Branch (52:37): [True: 89.3k, False: 0]
  ------------------
   53|  3.48M|        }
   54|    786|        else
   55|    786|        {
   56|       |
   57|    786|            do
   58|  3.88k|            {
   59|  3.88k|                *p++ = static_cast<char_type>(48 + value % 10);
   60|  3.88k|            }
   61|  3.88k|            while ((value /= 10) && (p < last));
  ------------------
  |  Branch (61:20): [True: 3.10k, False: 786]
  |  Branch (61:37): [True: 3.10k, False: 0]
  ------------------
   62|    786|        }
   63|  3.48M|        JSONCONS_ASSERT(p != last);
  ------------------
  |  |  378|  3.48M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 3.48M]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   64|       |
   65|  3.48M|        std::size_t count = (p - buf);
   66|  3.48M|        if (is_negative)
  ------------------
  |  Branch (66:13): [True: 3.48M, False: 786]
  ------------------
   67|  3.48M|        {
   68|  3.48M|            result.push_back('-');
   69|  3.48M|            ++count;
   70|  3.48M|        }
   71|  7.05M|        while (--p >= buf)
  ------------------
  |  Branch (71:16): [True: 3.57M, False: 3.48M]
  ------------------
   72|  3.57M|        {
   73|  3.57M|            result.push_back(*p);
   74|  3.57M|        }
   75|       |
   76|  3.48M|        return count;
   77|  3.48M|    }
_ZN8jsoncons6detail12write_doubleC2ENS_18float_chars_formatEi:
  472|  25.2k|        {
  473|  25.2k|    #if !defined(JSONCONS_NO_LOCALECONV)
  474|  25.2k|            struct lconv *lc = localeconv();
  475|  25.2k|            if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (475:17): [True: 25.2k, False: 0]
  |  Branch (475:34): [True: 25.2k, False: 0]
  ------------------
  476|  25.2k|            {
  477|  25.2k|                decimal_point_ = lc->decimal_point[0];
  478|  25.2k|            }
  479|  25.2k|    #endif
  480|  25.2k|        }
_ZN8jsoncons6detail12write_doubleclINS_11string_sinkINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEmdRT_:
  487|  25.2k|        {
  488|  25.2k|            std::size_t count = 0;
  489|       |
  490|  25.2k|            char number_buffer[200];
  491|  25.2k|            int length = 0;
  492|       |
  493|  25.2k|            switch (float_format_)
  494|  25.2k|            {
  495|      0|            case float_chars_format::fixed:
  ------------------
  |  Branch (495:13): [True: 0, False: 25.2k]
  ------------------
  496|      0|                {
  497|      0|                    if (precision_ > 0)
  ------------------
  |  Branch (497:25): [True: 0, False: 0]
  ------------------
  498|      0|                    {
  499|      0|                        length = snprintf(number_buffer, sizeof(number_buffer), "%1.*f", precision_, val);
  500|      0|                        if (length < 0)
  ------------------
  |  Branch (500:29): [True: 0, False: 0]
  ------------------
  501|      0|                        {
  502|      0|                            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  503|      0|                        }
  504|      0|                        dump_buffer(number_buffer, length, decimal_point_, result);
  505|      0|                    }
  506|      0|                    else
  507|      0|                    {
  508|      0|                        if (!dtoa_fixed(val, decimal_point_, result))
  ------------------
  |  Branch (508:29): [True: 0, False: 0]
  ------------------
  509|      0|                        {
  510|      0|                            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  511|      0|                        }
  512|      0|                    }
  513|      0|                }
  514|      0|                break;
  515|      0|            case float_chars_format::scientific:
  ------------------
  |  Branch (515:13): [True: 0, False: 25.2k]
  ------------------
  516|      0|                {
  517|      0|                    if (precision_ > 0)
  ------------------
  |  Branch (517:25): [True: 0, False: 0]
  ------------------
  518|      0|                    {
  519|      0|                        length = snprintf(number_buffer, sizeof(number_buffer), "%1.*e", precision_, val);
  520|      0|                        if (length < 0)
  ------------------
  |  Branch (520:29): [True: 0, False: 0]
  ------------------
  521|      0|                        {
  522|      0|                            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  523|      0|                        }
  524|      0|                        dump_buffer(number_buffer, length, decimal_point_, result);
  525|      0|                    }
  526|      0|                    else
  527|      0|                    {
  528|      0|                        if (!dtoa_scientific(val, decimal_point_, result))
  ------------------
  |  Branch (528:29): [True: 0, False: 0]
  ------------------
  529|      0|                        {
  530|      0|                            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  531|      0|                        }
  532|      0|                    }
  533|      0|                }
  534|      0|                break;
  535|  25.2k|            case float_chars_format::general:
  ------------------
  |  Branch (535:13): [True: 25.2k, False: 0]
  ------------------
  536|  25.2k|                {
  537|  25.2k|                    if (precision_ > 0)
  ------------------
  |  Branch (537:25): [True: 0, False: 25.2k]
  ------------------
  538|      0|                    {
  539|      0|                        length = snprintf(number_buffer, sizeof(number_buffer), "%1.*g", precision_, val);
  540|      0|                        if (length < 0)
  ------------------
  |  Branch (540:29): [True: 0, False: 0]
  ------------------
  541|      0|                        {
  542|      0|                            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  543|      0|                        }
  544|      0|                        dump_buffer(number_buffer, length, decimal_point_, result);
  545|      0|                    }
  546|  25.2k|                    else
  547|  25.2k|                    {
  548|  25.2k|                        if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (548:29): [True: 0, False: 25.2k]
  ------------------
  549|      0|                        {
  550|      0|                            JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  551|      0|                        }
  552|  25.2k|                    }             
  553|  25.2k|                    break;
  554|  25.2k|                }
  555|  25.2k|                default:
  ------------------
  |  Branch (555:17): [True: 0, False: 25.2k]
  ------------------
  556|      0|                    JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  557|      0|                    break;
  558|  25.2k|            }
  559|  25.2k|            return count;
  560|  25.2k|        }
_ZN8jsoncons6detail11dump_bufferINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEvPKcmcRT_:
  238|  4.04k|    {
  239|  4.04k|        const char *sbeg = buffer;
  240|  4.04k|        const char *send = sbeg + length;
  241|       |
  242|  4.04k|        if (sbeg != send)
  ------------------
  |  Branch (242:13): [True: 4.04k, False: 0]
  ------------------
  243|  4.04k|        {
  244|  4.04k|            bool needs_dot = true;
  245|  70.0k|            for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (245:40): [True: 65.9k, False: 4.04k]
  ------------------
  246|  65.9k|            {
  247|  65.9k|                switch (*q)
  248|  65.9k|                {
  249|  3.82k|                case '-':
  ------------------
  |  Branch (249:17): [True: 3.82k, False: 62.1k]
  ------------------
  250|  9.21k|                case '0':
  ------------------
  |  Branch (250:17): [True: 5.38k, False: 60.5k]
  ------------------
  251|  14.8k|                case '1':
  ------------------
  |  Branch (251:17): [True: 5.68k, False: 60.3k]
  ------------------
  252|  19.9k|                case '2':
  ------------------
  |  Branch (252:17): [True: 5.03k, False: 60.9k]
  ------------------
  253|  24.6k|                case '3':
  ------------------
  |  Branch (253:17): [True: 4.75k, False: 61.2k]
  ------------------
  254|  29.1k|                case '4':
  ------------------
  |  Branch (254:17): [True: 4.48k, False: 61.4k]
  ------------------
  255|  33.5k|                case '5':
  ------------------
  |  Branch (255:17): [True: 4.42k, False: 61.5k]
  ------------------
  256|  42.8k|                case '6':
  ------------------
  |  Branch (256:17): [True: 9.23k, False: 56.7k]
  ------------------
  257|  48.4k|                case '7':
  ------------------
  |  Branch (257:17): [True: 5.66k, False: 60.3k]
  ------------------
  258|  51.8k|                case '8':
  ------------------
  |  Branch (258:17): [True: 3.32k, False: 62.6k]
  ------------------
  259|  56.8k|                case '9':
  ------------------
  |  Branch (259:17): [True: 5.05k, False: 60.9k]
  ------------------
  260|  57.6k|                case '+':
  ------------------
  |  Branch (260:17): [True: 735, False: 65.2k]
  ------------------
  261|  57.6k|                    result.push_back(*q);
  262|  57.6k|                    break;
  263|  2.25k|                case 'e':
  ------------------
  |  Branch (263:17): [True: 2.25k, False: 63.7k]
  ------------------
  264|  2.25k|                case 'E':
  ------------------
  |  Branch (264:17): [True: 0, False: 65.9k]
  ------------------
  265|  2.25k|                    result.push_back('e');
  266|  2.25k|                    needs_dot = false;
  267|  2.25k|                    break;
  268|  6.12k|                default:
  ------------------
  |  Branch (268:17): [True: 6.12k, False: 59.8k]
  ------------------
  269|  6.12k|                    if (*q == decimal_point)
  ------------------
  |  Branch (269:25): [True: 2.76k, False: 3.35k]
  ------------------
  270|  2.76k|                    {
  271|  2.76k|                        needs_dot = false;
  272|  2.76k|                        result.push_back('.');
  273|  2.76k|                    }
  274|  6.12k|                    break;
  275|  65.9k|                }
  276|  65.9k|            }
  277|  4.04k|            if (needs_dot)
  ------------------
  |  Branch (277:17): [True: 1.28k, False: 2.76k]
  ------------------
  278|  1.28k|            {
  279|  1.28k|                result.push_back('.');
  280|  1.28k|                result.push_back('0');
  281|  1.28k|            }
  282|  4.04k|        }
  283|  4.04k|    }
_ZN8jsoncons6detail15prettify_stringINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEvPKcmiiiRT_:
  166|  20.3k|    {
  167|  20.3k|        int nb_digits = (int)length;
  168|  20.3k|        int offset;
  169|       |        /* v = buffer * 10^k
  170|       |           kk is such that 10^(kk-1) <= v < 10^kk
  171|       |           this way kk gives the position of the decimal point.
  172|       |        */
  173|  20.3k|        int kk = nb_digits + k;
  174|       |
  175|  20.3k|        if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (175:13): [True: 4.57k, False: 15.7k]
  |  Branch (175:32): [True: 2.82k, False: 1.75k]
  ------------------
  176|  2.82k|        {
  177|       |            /* the first digits are already in. Add some 0s and call it a day. */
  178|       |            /* the max_exp is a personal choice. Only 16 digits could possibly be relevant.
  179|       |             * Basically we want to print 12340000000 rather than 1234.0e7 or 1.234e10 */
  180|  19.2k|            for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (180:29): [True: 16.4k, False: 2.82k]
  ------------------
  181|  16.4k|            {
  182|  16.4k|                result.push_back(buffer[i]);
  183|  16.4k|            }
  184|  4.13k|            for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (184:37): [True: 1.31k, False: 2.82k]
  ------------------
  185|  1.31k|            {
  186|  1.31k|                result.push_back('0');
  187|  1.31k|            }
  188|  2.82k|            result.push_back('.');
  189|  2.82k|            result.push_back('0');
  190|  2.82k|        } 
  191|  17.4k|        else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (191:18): [True: 7.37k, False: 10.1k]
  |  Branch (191:28): [True: 5.62k, False: 1.75k]
  ------------------
  192|  5.62k|        {
  193|       |            /* comma number. Just insert a '.' at the correct location. */
  194|  23.1k|            for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (194:29): [True: 17.5k, False: 5.62k]
  ------------------
  195|  17.5k|            {
  196|  17.5k|                result.push_back(buffer[i]);
  197|  17.5k|            }
  198|  5.62k|            result.push_back('.');
  199|  75.9k|            for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (199:30): [True: 70.3k, False: 5.62k]
  ------------------
  200|  70.3k|            {
  201|  70.3k|                result.push_back(buffer[i]);
  202|  70.3k|            }
  203|  5.62k|        } 
  204|  11.8k|        else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (204:18): [True: 2.58k, False: 9.28k]
  |  Branch (204:34): [True: 830, False: 1.75k]
  ------------------
  205|    830|        {
  206|    830|            offset = 2 - kk;
  207|       |
  208|    830|            result.push_back('0');
  209|    830|            result.push_back('.');
  210|  2.26k|            for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (210:29): [True: 1.43k, False: 830]
  ------------------
  211|  1.43k|                result.push_back('0');
  212|  13.1k|            for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (212:29): [True: 12.3k, False: 830]
  ------------------
  213|  12.3k|            {
  214|  12.3k|                result.push_back(buffer[i]);
  215|  12.3k|            }
  216|    830|        } 
  217|  11.0k|        else if (nb_digits == 1)
  ------------------
  |  Branch (217:18): [True: 1.75k, False: 9.28k]
  ------------------
  218|  1.75k|        {
  219|  1.75k|            result.push_back(buffer[0]);
  220|  1.75k|            result.push_back('e');
  221|  1.75k|            fill_exponent(kk - 1, result);
  222|  1.75k|        } 
  223|  9.28k|        else
  224|  9.28k|        {
  225|  9.28k|            result.push_back(buffer[0]);
  226|  9.28k|            result.push_back('.');
  227|   120k|            for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (227:29): [True: 111k, False: 9.28k]
  ------------------
  228|   111k|            {
  229|   111k|                result.push_back(buffer[i]);
  230|   111k|            }
  231|  9.28k|            result.push_back('e');
  232|  9.28k|            fill_exponent(kk - 1, result);
  233|  9.28k|        }
  234|  20.3k|    }
_ZN8jsoncons6detail13fill_exponentINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEviRT_:
  131|  11.0k|    {
  132|  11.0k|        if (K < 0)
  ------------------
  |  Branch (132:13): [True: 9.28k, False: 1.75k]
  ------------------
  133|  9.28k|        {
  134|  9.28k|            result.push_back('-');
  135|  9.28k|            K = -K;
  136|  9.28k|        }
  137|  1.75k|        else
  138|  1.75k|        {
  139|  1.75k|            result.push_back('+'); // compatibility with sprintf
  140|  1.75k|        }
  141|       |
  142|  11.0k|        if (K < 10)
  ------------------
  |  Branch (142:13): [True: 376, False: 10.6k]
  ------------------
  143|    376|        {
  144|    376|            result.push_back('0'); // compatibility with sprintf
  145|    376|            result.push_back((char)('0' + K));
  146|    376|        }
  147|  10.6k|        else if (K < 100)
  ------------------
  |  Branch (147:18): [True: 4.04k, False: 6.61k]
  ------------------
  148|  4.04k|        {
  149|  4.04k|            result.push_back((char)('0' + K / 10)); K %= 10;
  150|  4.04k|            result.push_back((char)('0' + K));
  151|  4.04k|        }
  152|  6.61k|        else if (K < 1000)
  ------------------
  |  Branch (152:18): [True: 6.61k, False: 0]
  ------------------
  153|  6.61k|        {
  154|  6.61k|            result.push_back((char)('0' + K / 100)); K %= 100;
  155|  6.61k|            result.push_back((char)('0' + K / 10)); K %= 10;
  156|  6.61k|            result.push_back((char)('0' + K));
  157|  6.61k|        }
  158|      0|        else
  159|      0|        {
  160|      0|            jsoncons::detail::from_integer(K, result);
  161|      0|        }
  162|  11.0k|    }
_ZN8jsoncons6detail12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEbdcRT_:
  458|  25.2k|    {
  459|  25.2k|        return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  460|  25.2k|    }
_ZN8jsoncons6detail12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEbdcRT_NS3_17integral_constantIbLb1EEE:
  353|  25.2k|    {
  354|  25.2k|        if (v == 0)
  ------------------
  |  Branch (354:13): [True: 859, False: 24.3k]
  ------------------
  355|    859|        {
  356|    859|            result.push_back('0');
  357|    859|            result.push_back('.');
  358|    859|            result.push_back('0');
  359|    859|            return true;
  360|    859|        }
  361|       |
  362|  24.3k|        int length = 0;
  363|  24.3k|        int k;
  364|       |
  365|  24.3k|        char buffer[100];
  366|       |
  367|  24.3k|        double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (367:20): [True: 11.3k, False: 13.0k]
  ------------------
  368|  24.3k|        if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (368:13): [True: 20.3k, False: 4.04k]
  ------------------
  369|  20.3k|        {
  370|  20.3k|            if (std::signbit(v))
  ------------------
  |  Branch (370:17): [True: 9.01k, False: 11.3k]
  ------------------
  371|  9.01k|            {
  372|  9.01k|                result.push_back('-');
  373|  9.01k|            }
  374|       |            // min exp: -4 is consistent with sprintf
  375|       |            // max exp: std::numeric_limits<double>::max_digits10
  376|  20.3k|            jsoncons::detail::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  377|  20.3k|            return true;
  378|  20.3k|        }
  379|  4.04k|        else
  380|  4.04k|        {
  381|  4.04k|            return dtoa_general(v, decimal_point, result, std::false_type());
  382|  4.04k|        }
  383|  24.3k|    }
_ZN8jsoncons6detail12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEbdcRT_NS3_17integral_constantIbLb0EEE:
  320|  4.04k|    {
  321|  4.04k|        if (val == 0)
  ------------------
  |  Branch (321:13): [True: 0, False: 4.04k]
  ------------------
  322|      0|        {
  323|      0|            result.push_back('0');
  324|      0|            result.push_back('.');
  325|      0|            result.push_back('0');
  326|      0|            return true;
  327|      0|        }
  328|       |
  329|  4.04k|        jsoncons::detail::chars_to to_double_;
  330|       |
  331|  4.04k|        char buffer[100];
  332|  4.04k|        int precision = std::numeric_limits<double>::digits10;
  333|  4.04k|        int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  334|  4.04k|        if (length < 0)
  ------------------
  |  Branch (334:13): [True: 0, False: 4.04k]
  ------------------
  335|      0|        {
  336|      0|            return false;
  337|      0|        }
  338|  4.04k|        if (to_double_(buffer, sizeof(buffer)) != val)
  ------------------
  |  Branch (338:13): [True: 3.46k, False: 587]
  ------------------
  339|  3.46k|        {
  340|  3.46k|            const int precision2 = std::numeric_limits<double>::max_digits10;
  341|  3.46k|            length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  342|  3.46k|            if (length < 0)
  ------------------
  |  Branch (342:17): [True: 0, False: 3.46k]
  ------------------
  343|      0|            {
  344|      0|                return false;
  345|      0|            }
  346|  3.46k|        }
  347|  4.04k|        dump_buffer(buffer, length, decimal_point, result);
  348|  4.04k|        return true;
  349|  4.04k|    }

_ZN8jsoncons16extension_traits16to_plain_pointerImEEPT_S3_:
  238|   142k|    {       
  239|   142k|        return (ptr);
  240|   142k|    }  

_ZN8jsoncons24basic_item_event_visitorIcED2Ev:
   35|  4.49k|        virtual ~basic_item_event_visitor() noexcept = default;
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE11visit_flushEv:
  856|    851|        {
  857|    851|            destination_->flush();
  858|    851|        }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level6is_keyEv:
  786|  80.9M|            {
  787|  80.9M|                return even_odd_ == 0;
  788|  80.9M|            }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level6targetEv:
  796|  49.8M|            {
  797|  49.8M|                return state_;
  798|  49.8M|            }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level5countEv:
  801|  23.3M|            {
  802|  23.3M|                return count_;
  803|  23.3M|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5levelC2ENS4_8target_tENS4_11container_tE:
  770|  9.56M|            {
  771|  9.56M|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  888|  2.45M|        {
  889|  2.45M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (889:17): [True: 2.23M, False: 220k]
  ------------------
  890|  2.23M|            {
  891|  2.23M|                if (level_stack_.back().target() == target_t::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (891:21): [True: 2.22M, False: 2.77k]
  |  Branch (891:73): [True: 22.2k, False: 2.20M]
  ------------------
  892|  22.2k|                {
  893|  22.2k|                    key_buffer_.push_back(',');
  894|  22.2k|                }
  895|  2.23M|                level_stack_.emplace_back(target_t::buffer, container_t::object);
  896|  2.23M|                key_buffer_.push_back('{');
  897|  2.23M|                return true;
  898|  2.23M|            }
  899|   220k|            else
  900|   220k|            {
  901|   220k|                switch (level_stack_.back().target())
  902|   220k|                {
  903|   213k|                    case target_t::buffer:
  ------------------
  |  Branch (903:21): [True: 213k, False: 7.03k]
  ------------------
  904|   213k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (904:29): [True: 186k, False: 27.3k]
  |  Branch (904:65): [True: 87.1k, False: 99.4k]
  ------------------
  905|  87.1k|                        {
  906|  87.1k|                            key_buffer_.push_back(',');
  907|  87.1k|                        }
  908|   213k|                        level_stack_.emplace_back(target_t::buffer, container_t::object);
  909|   213k|                        key_buffer_.push_back('{');
  910|   213k|                        return true;
  911|  7.03k|                    default:
  ------------------
  |  Branch (911:21): [True: 7.03k, False: 213k]
  ------------------
  912|  7.03k|                        level_stack_.emplace_back(target_t::destination, container_t::object);
  913|  7.03k|                        return destination_->begin_object(length, tag, context, ec);
  914|   220k|                }
  915|   220k|            }
  916|  2.45M|        }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level9is_objectEv:
  791|  47.1M|            {
  792|  47.1M|                return type_ == container_t::object;
  793|  47.1M|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE16visit_end_objectERKNS_11ser_contextERNS1_10error_codeE:
  919|   141k|        {
  920|   141k|            bool retval = true;
  921|   141k|            switch (level_stack_.back().target())
  922|   141k|            {
  923|   140k|                case target_t::buffer:
  ------------------
  |  Branch (923:17): [True: 140k, False: 1.71k]
  ------------------
  924|   140k|                    key_buffer_.push_back('}');
  925|   140k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |  378|   140k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 140k]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  926|   140k|                    level_stack_.pop_back();
  927|       |                    
  928|   140k|                    if (level_stack_.back().target() == target_t::destination)
  ------------------
  |  Branch (928:25): [True: 1.84k, False: 138k]
  ------------------
  929|  1.84k|                    {
  930|  1.84k|                        retval = destination_->key(key_buffer_,context, ec);
  931|  1.84k|                        key_buffer_.clear();
  932|  1.84k|                    }
  933|   138k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (933:30): [True: 30.8k, False: 107k]
  ------------------
  934|  30.8k|                    {
  935|  30.8k|                        key_buffer_.push_back(':');
  936|  30.8k|                    }
  937|   140k|                    level_stack_.back().advance();
  938|   140k|                    break;
  939|  1.71k|                default:
  ------------------
  |  Branch (939:17): [True: 1.71k, False: 140k]
  ------------------
  940|  1.71k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |  378|  1.71k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 1.71k]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  941|  1.71k|                    level_stack_.pop_back();
  942|  1.71k|                    level_stack_.back().advance();
  943|  1.71k|                    retval = destination_->end_object(context, ec);
  944|  1.71k|                    break;
  945|   141k|            }
  946|   141k|            return retval;
  947|   141k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level7advanceEv:
  774|  26.0M|            {
  775|  26.0M|                if (!is_key())
  ------------------
  |  Branch (775:21): [True: 18.3M, False: 7.69M]
  ------------------
  776|  18.3M|                {
  777|  18.3M|                    ++count_;
  778|  18.3M|                }
  779|  26.0M|                if (is_object())
  ------------------
  |  Branch (779:21): [True: 15.3M, False: 10.6M]
  ------------------
  780|  15.3M|                {
  781|  15.3M|                    even_odd_ = !even_odd_;
  782|  15.3M|                }
  783|  26.0M|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  981|  7.11M|        {
  982|  7.11M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (982:17): [True: 114k, False: 6.99M]
  ------------------
  983|   114k|            {
  984|   114k|                if (level_stack_.back().target() == target_t::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (984:21): [True: 112k, False: 2.13k]
  |  Branch (984:73): [True: 11.6k, False: 100k]
  ------------------
  985|  11.6k|                {
  986|  11.6k|                    key_buffer_.push_back(',');
  987|  11.6k|                }
  988|   114k|                level_stack_.emplace_back(target_t::buffer, container_t::array);
  989|   114k|                key_buffer_.push_back('[');
  990|   114k|                return true;
  991|   114k|            }
  992|  6.99M|            else
  993|  6.99M|            {
  994|  6.99M|                switch (level_stack_.back().target())
  995|  6.99M|                {
  996|  3.17M|                    case target_t::buffer:
  ------------------
  |  Branch (996:21): [True: 3.17M, False: 3.82M]
  ------------------
  997|  3.17M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (997:29): [True: 3.15M, False: 12.3k]
  |  Branch (997:65): [True: 32.6k, False: 3.12M]
  ------------------
  998|  32.6k|                        {
  999|  32.6k|                            key_buffer_.push_back(',');
 1000|  32.6k|                        }
 1001|  3.17M|                        level_stack_.emplace_back(target_t::buffer, container_t::array);
 1002|  3.17M|                        key_buffer_.push_back('[');
 1003|  3.17M|                        return true;
 1004|  3.82M|                    default:
  ------------------
  |  Branch (1004:21): [True: 3.82M, False: 3.17M]
  ------------------
 1005|  3.82M|                        level_stack_.emplace_back(target_t::destination, container_t::array);
 1006|  3.82M|                        return destination_->begin_array(length, tag, context, ec);
 1007|  6.99M|                }
 1008|  6.99M|            }
 1009|  7.11M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE15visit_end_arrayERKNS_11ser_contextERNS1_10error_codeE:
 1012|   519k|        {
 1013|   519k|            bool retval = true;
 1014|   519k|            switch (level_stack_.back().target())
 1015|   519k|            {
 1016|   483k|                case target_t::buffer:
  ------------------
  |  Branch (1016:17): [True: 483k, False: 35.8k]
  ------------------
 1017|   483k|                    key_buffer_.push_back(']');
 1018|   483k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |  378|   483k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 483k]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1019|   483k|                    level_stack_.pop_back();
 1020|   483k|                    if (level_stack_.back().target() == target_t::destination)
  ------------------
  |  Branch (1020:25): [True: 1.56k, False: 482k]
  ------------------
 1021|  1.56k|                    {
 1022|  1.56k|                        retval = destination_->key(key_buffer_, context, ec);
 1023|  1.56k|                        key_buffer_.clear();
 1024|  1.56k|                    }
 1025|   482k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (1025:30): [True: 12.8k, False: 469k]
  ------------------
 1026|  12.8k|                    {
 1027|  12.8k|                        key_buffer_.push_back(':');
 1028|  12.8k|                    }
 1029|   483k|                    level_stack_.back().advance();
 1030|   483k|                    break;
 1031|  35.8k|                default:
  ------------------
  |  Branch (1031:17): [True: 35.8k, False: 483k]
  ------------------
 1032|  35.8k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |  378|  35.8k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 35.8k]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1033|  35.8k|                    level_stack_.pop_back();
 1034|  35.8k|                    level_stack_.back().advance();
 1035|  35.8k|                    retval = destination_->end_array(context, ec);
 1036|  35.8k|                    break;
 1037|   519k|            }
 1038|   519k|            return retval;
 1039|   519k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1473|  78.5k|        {
 1474|  78.5k|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1474:17): [True: 27.5k, False: 50.9k]
  |  Branch (1474:49): [True: 50.2k, False: 786]
  ------------------
 1475|  77.7k|            {
 1476|  77.7k|                key_.clear(); 
 1477|  77.7k|                key_.insert(key_.begin(), null_constant.begin(), null_constant.end());
 1478|  77.7k|            }
 1479|       |
 1480|  78.5k|            bool retval;
 1481|  78.5k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1481:17): [True: 27.5k, False: 50.9k]
  ------------------
 1482|  27.5k|            {
 1483|  27.5k|                switch (level_stack_.back().target())
 1484|  27.5k|                {
 1485|  26.7k|                    case target_t::buffer:
  ------------------
  |  Branch (1485:21): [True: 26.7k, False: 884]
  ------------------
 1486|  26.7k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1486:29): [True: 25.7k, False: 941]
  ------------------
 1487|  25.7k|                        {
 1488|  25.7k|                            key_buffer_.push_back(',');
 1489|  25.7k|                        }
 1490|  26.7k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1491|  26.7k|                        key_buffer_.push_back(':');
 1492|  26.7k|                        retval = true; 
 1493|  26.7k|                        break;
 1494|    884|                    default:
  ------------------
  |  Branch (1494:21): [True: 884, False: 26.7k]
  ------------------
 1495|    884|                        retval = destination_->key(key_, context, ec);
 1496|    884|                        break;
 1497|  27.5k|                }
 1498|  27.5k|            }
 1499|  50.9k|            else
 1500|  50.9k|            {
 1501|  50.9k|                switch (level_stack_.back().target())
 1502|  50.9k|                {
 1503|  50.2k|                    case target_t::buffer:
  ------------------
  |  Branch (1503:21): [True: 50.2k, False: 786]
  ------------------
 1504|  50.2k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1504:29): [True: 24.4k, False: 25.7k]
  |  Branch (1504:65): [True: 24.0k, False: 423]
  ------------------
 1505|  24.0k|                        {
 1506|  24.0k|                            key_buffer_.push_back(',');
 1507|  24.0k|                        }
 1508|  50.2k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1509|  50.2k|                        retval = true; 
 1510|  50.2k|                        break;
 1511|    786|                    default:
  ------------------
  |  Branch (1511:21): [True: 786, False: 50.2k]
  ------------------
 1512|    786|                        retval = destination_->null_value(tag, context, ec);
 1513|    786|                        break;
 1514|  50.9k|                }
 1515|  50.9k|            }
 1516|       |
 1517|  78.5k|            level_stack_.back().advance();
 1518|  78.5k|            return retval;
 1519|  78.5k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1417|  11.5M|        {
 1418|  11.5M|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1418:17): [True: 3.51M, False: 8.01M]
  |  Branch (1418:49): [True: 8.00M, False: 2.86k]
  ------------------
 1419|  11.5M|            {
 1420|  11.5M|                key_.clear(); 
 1421|  11.5M|                if (value)
  ------------------
  |  Branch (1421:21): [True: 7.56M, False: 3.96M]
  ------------------
 1422|  7.56M|                {
 1423|  7.56M|                    key_.insert(key_.begin(), true_constant.begin(), true_constant.end());
 1424|  7.56M|                }
 1425|  3.96M|                else
 1426|  3.96M|                {
 1427|  3.96M|                    key_.insert(key_.begin(), false_constant.begin(), false_constant.end());
 1428|  3.96M|                }
 1429|  11.5M|            }
 1430|       |
 1431|  11.5M|            bool retval;
 1432|  11.5M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1432:17): [True: 3.51M, False: 8.01M]
  ------------------
 1433|  3.51M|            {
 1434|  3.51M|                switch (level_stack_.back().target())
 1435|  3.51M|                {
 1436|  3.51M|                    case target_t::buffer:
  ------------------
  |  Branch (1436:21): [True: 3.51M, False: 2.78k]
  ------------------
 1437|  3.51M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1437:29): [True: 3.51M, False: 2.70k]
  ------------------
 1438|  3.51M|                        {
 1439|  3.51M|                            key_buffer_.push_back(',');
 1440|  3.51M|                        }
 1441|  3.51M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1442|  3.51M|                        key_buffer_.push_back(':');
 1443|  3.51M|                        retval = true; 
 1444|  3.51M|                        break;
 1445|  2.78k|                    default:
  ------------------
  |  Branch (1445:21): [True: 2.78k, False: 3.51M]
  ------------------
 1446|  2.78k|                        retval = destination_->key(key_, context, ec);
 1447|  2.78k|                        break;
 1448|  3.51M|                }
 1449|  3.51M|            }
 1450|  8.01M|            else
 1451|  8.01M|            {
 1452|  8.01M|                switch (level_stack_.back().target())
 1453|  8.01M|                {
 1454|  8.00M|                    case target_t::buffer:
  ------------------
  |  Branch (1454:21): [True: 8.00M, False: 2.86k]
  ------------------
 1455|  8.00M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1455:29): [True: 4.48M, False: 3.52M]
  |  Branch (1455:65): [True: 4.48M, False: 806]
  ------------------
 1456|  4.48M|                        {
 1457|  4.48M|                            key_buffer_.push_back(',');
 1458|  4.48M|                        }
 1459|  8.00M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1460|  8.00M|                        retval = true; 
 1461|  8.00M|                        break;
 1462|  2.86k|                    default:
  ------------------
  |  Branch (1462:21): [True: 2.86k, False: 8.00M]
  ------------------
 1463|  2.86k|                        retval = destination_->bool_value(value, tag, context, ec);
 1464|  2.86k|                        break;
 1465|  8.01M|                }
 1466|  8.01M|            }
 1467|       |
 1468|  11.5M|            level_stack_.back().advance();
 1469|  11.5M|            return retval;
 1470|  11.5M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE12visit_stringERKNS_6detail17basic_string_viewIcNS1_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1045|  6.04M|        {
 1046|  6.04M|            bool retval;
 1047|       |
 1048|  6.04M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1048:17): [True: 1.94M, False: 4.09M]
  ------------------
 1049|  1.94M|            {
 1050|  1.94M|                switch (level_stack_.back().target())
 1051|  1.94M|                {
 1052|  1.94M|                    case target_t::buffer:
  ------------------
  |  Branch (1052:21): [True: 1.94M, False: 6.69k]
  ------------------
 1053|  1.94M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1053:29): [True: 1.93M, False: 1.87k]
  ------------------
 1054|  1.93M|                        {
 1055|  1.93M|                            key_buffer_.push_back(',');
 1056|  1.93M|                        }
 1057|  1.94M|                        key_buffer_.push_back('\"');
 1058|  1.94M|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1059|  1.94M|                        key_buffer_.push_back('\"');
 1060|  1.94M|                        key_buffer_.push_back(':');
 1061|  1.94M|                        retval = true;
 1062|  1.94M|                        break;
 1063|  6.69k|                    default:
  ------------------
  |  Branch (1063:21): [True: 6.69k, False: 1.94M]
  ------------------
 1064|  6.69k|                        retval = destination_->key(value, context, ec);
 1065|  6.69k|                        break;
 1066|  1.94M|                }
 1067|  1.94M|            }
 1068|  4.09M|            else
 1069|  4.09M|            {
 1070|  4.09M|                switch (level_stack_.back().target())
 1071|  4.09M|                {
 1072|  4.08M|                    case target_t::buffer:
  ------------------
  |  Branch (1072:21): [True: 4.08M, False: 9.01k]
  ------------------
 1073|  4.08M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1073:29): [True: 2.14M, False: 1.93M]
  |  Branch (1073:65): [True: 2.14M, False: 416]
  ------------------
 1074|  2.14M|                        {
 1075|  2.14M|                            key_buffer_.push_back(',');
 1076|  2.14M|                        }
 1077|  4.08M|                        key_buffer_.push_back('\"');
 1078|  4.08M|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1079|  4.08M|                        key_buffer_.push_back('\"');
 1080|  4.08M|                        retval = true;
 1081|  4.08M|                        break;
 1082|  9.01k|                    default:
  ------------------
  |  Branch (1082:21): [True: 9.01k, False: 4.08M]
  ------------------
 1083|  9.01k|                        retval = destination_->string_value(value, tag, context, ec);
 1084|  9.01k|                        break;
 1085|  4.09M|                }
 1086|  4.09M|            }
 1087|       |
 1088|  6.04M|            level_stack_.back().advance();
 1089|  6.04M|            return retval;
 1090|  6.04M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1096|  5.12k|        {
 1097|  5.12k|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1097:17): [True: 2.33k, False: 2.78k]
  |  Branch (1097:49): [True: 2.02k, False: 766]
  ------------------
 1098|  4.35k|            {
 1099|  4.35k|                key_.clear();
 1100|  4.35k|                switch (tag)
 1101|  4.35k|                {
 1102|      0|                    case semantic_tag::base64:
  ------------------
  |  Branch (1102:21): [True: 0, False: 4.35k]
  ------------------
 1103|      0|                        encode_base64(value.begin(), value.end(), key_);
 1104|      0|                        break;
 1105|      0|                    case semantic_tag::base16:
  ------------------
  |  Branch (1105:21): [True: 0, False: 4.35k]
  ------------------
 1106|      0|                        encode_base16(value.begin(), value.end(),key_);
 1107|      0|                        break;
 1108|  4.35k|                    default:
  ------------------
  |  Branch (1108:21): [True: 4.35k, False: 0]
  ------------------
 1109|  4.35k|                        encode_base64url(value.begin(), value.end(),key_);
 1110|  4.35k|                        break;
 1111|  4.35k|                }
 1112|  4.35k|            }
 1113|       |
 1114|  5.12k|            bool retval;
 1115|  5.12k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1115:17): [True: 2.33k, False: 2.78k]
  ------------------
 1116|  2.33k|            {
 1117|  2.33k|                switch (level_stack_.back().target())
 1118|  2.33k|                {
 1119|  1.45k|                    case target_t::buffer:
  ------------------
  |  Branch (1119:21): [True: 1.45k, False: 877]
  ------------------
 1120|  1.45k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1120:29): [True: 756, False: 699]
  ------------------
 1121|    756|                        {
 1122|    756|                            key_buffer_.push_back(',');
 1123|    756|                        }
 1124|  1.45k|                        key_buffer_.push_back('\"');
 1125|  1.45k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1126|  1.45k|                        key_buffer_.push_back('\"');
 1127|  1.45k|                        key_buffer_.push_back(':');
 1128|  1.45k|                        retval = true; 
 1129|  1.45k|                        break;
 1130|    877|                    default:
  ------------------
  |  Branch (1130:21): [True: 877, False: 1.45k]
  ------------------
 1131|    877|                        retval = destination_->key(key_, context, ec);
 1132|    877|                        break;
 1133|  2.33k|                }
 1134|  2.33k|            }
 1135|  2.78k|            else
 1136|  2.78k|            {
 1137|  2.78k|                switch (level_stack_.back().target())
 1138|  2.78k|                {
 1139|  2.02k|                    case target_t::buffer:
  ------------------
  |  Branch (1139:21): [True: 2.02k, False: 766]
  ------------------
 1140|  2.02k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1140:29): [True: 1.41k, False: 606]
  |  Branch (1140:65): [True: 934, False: 483]
  ------------------
 1141|    934|                        {
 1142|    934|                            key_buffer_.push_back(',');
 1143|    934|                        }
 1144|  2.02k|                        key_buffer_.push_back('\"');
 1145|  2.02k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1146|  2.02k|                        key_buffer_.push_back('\"');
 1147|  2.02k|                        retval = true; 
 1148|  2.02k|                        break;
 1149|    766|                    default:
  ------------------
  |  Branch (1149:21): [True: 766, False: 2.02k]
  ------------------
 1150|    766|                        retval = destination_->byte_string_value(value, tag, context, ec);
 1151|    766|                        break;
 1152|  2.78k|                }
 1153|  2.78k|            }
 1154|       |
 1155|  5.12k|            level_stack_.back().advance();
 1156|  5.12k|            return retval;
 1157|  5.12k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS1_10error_codeE:
 1163|  10.1k|        {
 1164|  10.1k|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1164:17): [True: 4.92k, False: 5.27k]
  |  Branch (1164:49): [True: 3.74k, False: 1.53k]
  ------------------
 1165|  8.66k|            {
 1166|  8.66k|                key_.clear();
 1167|  8.66k|                encode_base64url(value.begin(), value.end(),key_);
 1168|  8.66k|            }
 1169|       |
 1170|  10.1k|            bool retval;
 1171|  10.1k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1171:17): [True: 4.92k, False: 5.27k]
  ------------------
 1172|  4.92k|            {
 1173|  4.92k|                switch (level_stack_.back().target())
 1174|  4.92k|                {
 1175|  3.92k|                    case target_t::buffer:
  ------------------
  |  Branch (1175:21): [True: 3.92k, False: 1.00k]
  ------------------
 1176|  3.92k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1176:29): [True: 1.89k, False: 2.02k]
  ------------------
 1177|  1.89k|                        {
 1178|  1.89k|                            key_buffer_.push_back(',');
 1179|  1.89k|                        }
 1180|  3.92k|                        key_buffer_.push_back('\"');
 1181|  3.92k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1182|  3.92k|                        key_buffer_.push_back('\"');
 1183|  3.92k|                        key_buffer_.push_back(':');
 1184|  3.92k|                        retval = true; 
 1185|  3.92k|                        break;
 1186|  1.00k|                    default:
  ------------------
  |  Branch (1186:21): [True: 1.00k, False: 3.92k]
  ------------------
 1187|  1.00k|                        retval = destination_->key(key_, context, ec);
 1188|  1.00k|                        break;
 1189|  4.92k|                }
 1190|  4.92k|            }
 1191|  5.27k|            else
 1192|  5.27k|            {
 1193|  5.27k|                switch (level_stack_.back().target())
 1194|  5.27k|                {
 1195|  3.74k|                    case target_t::buffer:
  ------------------
  |  Branch (1195:21): [True: 3.74k, False: 1.53k]
  ------------------
 1196|  3.74k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1196:29): [True: 1.92k, False: 1.81k]
  |  Branch (1196:65): [True: 1.57k, False: 350]
  ------------------
 1197|  1.57k|                        {
 1198|  1.57k|                            key_buffer_.push_back(',');
 1199|  1.57k|                        }
 1200|  3.74k|                        key_buffer_.push_back('\"');
 1201|  3.74k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1202|  3.74k|                        key_buffer_.push_back('\"');
 1203|  3.74k|                        retval = true; 
 1204|  3.74k|                        break;
 1205|  1.53k|                    default:
  ------------------
  |  Branch (1205:21): [True: 1.53k, False: 3.74k]
  ------------------
 1206|  1.53k|                        retval = destination_->byte_string_value(value, ext_tag, context, ec);
 1207|  1.53k|                        break;
 1208|  5.27k|                }
 1209|  5.27k|            }
 1210|       |
 1211|  10.1k|            level_stack_.back().advance();
 1212|  10.1k|            return retval;
 1213|  10.1k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1216|  4.20M|        {
 1217|  4.20M|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1217:17): [True: 1.24M, False: 2.95M]
  |  Branch (1217:49): [True: 2.94M, False: 11.4k]
  ------------------
 1218|  4.19M|            {
 1219|  4.19M|                key_.clear();
 1220|  4.19M|                jsoncons::detail::from_integer(value,key_);
 1221|  4.19M|            }
 1222|       |
 1223|  4.20M|            bool retval;
 1224|  4.20M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1224:17): [True: 1.24M, False: 2.95M]
  ------------------
 1225|  1.24M|            {
 1226|  1.24M|                switch (level_stack_.back().target())
 1227|  1.24M|                {
 1228|  1.23M|                    case target_t::buffer:
  ------------------
  |  Branch (1228:21): [True: 1.23M, False: 9.57k]
  ------------------
 1229|  1.23M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1229:29): [True: 1.23M, False: 8.90k]
  ------------------
 1230|  1.23M|                        {
 1231|  1.23M|                            key_buffer_.push_back(',');
 1232|  1.23M|                        }
 1233|  1.23M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1234|  1.23M|                        key_buffer_.push_back(':');
 1235|  1.23M|                        retval = true; 
 1236|  1.23M|                        break;
 1237|  9.57k|                    default:
  ------------------
  |  Branch (1237:21): [True: 9.57k, False: 1.23M]
  ------------------
 1238|  9.57k|                        retval = destination_->key(key_, context, ec);
 1239|  9.57k|                        break;
 1240|  1.24M|                }
 1241|  1.24M|            }
 1242|  2.95M|            else
 1243|  2.95M|            {
 1244|  2.95M|                switch (level_stack_.back().target())
 1245|  2.95M|                {
 1246|  2.94M|                    case target_t::buffer:
  ------------------
  |  Branch (1246:21): [True: 2.94M, False: 11.4k]
  ------------------
 1247|  2.94M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1247:29): [True: 1.70M, False: 1.24M]
  |  Branch (1247:65): [True: 1.69M, False: 2.94k]
  ------------------
 1248|  1.69M|                        {
 1249|  1.69M|                            key_buffer_.push_back(',');
 1250|  1.69M|                        }
 1251|  2.94M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1252|  2.94M|                        retval = true; 
 1253|  2.94M|                        break;
 1254|  11.4k|                    default:
  ------------------
  |  Branch (1254:21): [True: 11.4k, False: 2.94M]
  ------------------
 1255|  11.4k|                        retval = destination_->uint64_value(value, tag, context, ec);
 1256|  11.4k|                        break;
 1257|  2.95M|                }
 1258|  2.95M|            }
 1259|       |
 1260|  4.20M|            level_stack_.back().advance();
 1261|  4.20M|            return retval;
 1262|  4.20M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1265|  3.48M|        {
 1266|  3.48M|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1266:17): [True: 886k, False: 2.59M]
  |  Branch (1266:49): [True: 2.59M, False: 3.95k]
  ------------------
 1267|  3.48M|            {
 1268|  3.48M|                key_.clear();
 1269|  3.48M|                jsoncons::detail::from_integer(value,key_);
 1270|  3.48M|            }
 1271|       |
 1272|  3.48M|            bool retval;
 1273|  3.48M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1273:17): [True: 886k, False: 2.59M]
  ------------------
 1274|   886k|            {
 1275|   886k|                switch (level_stack_.back().target())
 1276|   886k|                {
 1277|   882k|                    case target_t::buffer:
  ------------------
  |  Branch (1277:21): [True: 882k, False: 3.43k]
  ------------------
 1278|   882k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1278:29): [True: 880k, False: 2.58k]
  ------------------
 1279|   880k|                        {
 1280|   880k|                            key_buffer_.push_back(',');
 1281|   880k|                        }
 1282|   882k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1283|   882k|                        key_buffer_.push_back(':');
 1284|   882k|                        retval = true; 
 1285|   882k|                        break;
 1286|  3.43k|                    default:
  ------------------
  |  Branch (1286:21): [True: 3.43k, False: 882k]
  ------------------
 1287|  3.43k|                        retval = destination_->key(key_, context, ec);
 1288|  3.43k|                        break;
 1289|   886k|                }
 1290|   886k|            }
 1291|  2.59M|            else
 1292|  2.59M|            {
 1293|  2.59M|                switch (level_stack_.back().target())
 1294|  2.59M|                {
 1295|  2.59M|                    case target_t::buffer:
  ------------------
  |  Branch (1295:21): [True: 2.59M, False: 3.95k]
  ------------------
 1296|  2.59M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1296:29): [True: 1.70M, False: 884k]
  |  Branch (1296:65): [True: 1.70M, False: 2.50k]
  ------------------
 1297|  1.70M|                        {
 1298|  1.70M|                            key_buffer_.push_back(',');
 1299|  1.70M|                        }
 1300|  2.59M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1301|  2.59M|                        retval = true; 
 1302|  2.59M|                        break;
 1303|  3.95k|                    default:
  ------------------
  |  Branch (1303:21): [True: 3.95k, False: 2.59M]
  ------------------
 1304|  3.95k|                        retval = destination_->int64_value(value, tag, context, ec);
 1305|  3.95k|                        break;
 1306|  2.59M|                }
 1307|  2.59M|            }
 1308|       |
 1309|  3.48M|            level_stack_.back().advance();
 1310|  3.48M|            return retval;
 1311|  3.48M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1366|  25.8k|        {
 1367|  25.8k|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1367:17): [True: 11.9k, False: 13.8k]
  |  Branch (1367:49): [True: 13.2k, False: 590]
  ------------------
 1368|  25.2k|            {
 1369|  25.2k|                key_.clear();
 1370|  25.2k|                string_sink<string_type> sink(key_);
 1371|  25.2k|                jsoncons::detail::write_double f{float_chars_format::general,0};
 1372|  25.2k|                f(value, sink);
 1373|  25.2k|            }
 1374|       |
 1375|  25.8k|            bool retval;
 1376|  25.8k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1376:17): [True: 11.9k, False: 13.8k]
  ------------------
 1377|  11.9k|            {
 1378|  11.9k|                switch (level_stack_.back().target())
 1379|  11.9k|                {
 1380|  10.4k|                    case target_t::buffer:
  ------------------
  |  Branch (1380:21): [True: 10.4k, False: 1.45k]
  ------------------
 1381|  10.4k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1381:29): [True: 6.65k, False: 3.82k]
  ------------------
 1382|  6.65k|                        {
 1383|  6.65k|                            key_buffer_.push_back(',');
 1384|  6.65k|                        }
 1385|  10.4k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1386|  10.4k|                        key_buffer_.push_back(':');
 1387|  10.4k|                        retval = true; 
 1388|  10.4k|                        break;
 1389|  1.45k|                    default:
  ------------------
  |  Branch (1389:21): [True: 1.45k, False: 10.4k]
  ------------------
 1390|  1.45k|                        retval = destination_->key(key_, context, ec);
 1391|  1.45k|                        break;
 1392|  11.9k|                }
 1393|  11.9k|            }
 1394|  13.8k|            else
 1395|  13.8k|            {
 1396|  13.8k|                switch (level_stack_.back().target())
 1397|  13.8k|                {
 1398|  13.2k|                    case target_t::buffer:
  ------------------
  |  Branch (1398:21): [True: 13.2k, False: 590]
  ------------------
 1399|  13.2k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1399:29): [True: 5.82k, False: 7.47k]
  |  Branch (1399:65): [True: 4.64k, False: 1.17k]
  ------------------
 1400|  4.64k|                        {
 1401|  4.64k|                            key_buffer_.push_back(',');
 1402|  4.64k|                        }
 1403|  13.2k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1404|  13.2k|                        retval = true; 
 1405|  13.2k|                        break;
 1406|    590|                    default:
  ------------------
  |  Branch (1406:21): [True: 590, False: 13.2k]
  ------------------
 1407|    590|                        retval = destination_->double_value(value, tag, context, ec);
 1408|    590|                        break;
 1409|  13.8k|                }
 1410|  13.8k|            }
 1411|       |
 1412|  25.8k|            level_stack_.back().advance();
 1413|  25.8k|            return retval;
 1414|  25.8k|        }
_ZN8jsoncons24basic_item_event_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  271|  7.11M|        {
  272|  7.11M|            return visit_begin_array(length, tag, context, ec);
  273|  7.11M|        }
_ZN8jsoncons24basic_item_event_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  332|  4.20M|        {
  333|  4.20M|            return visit_uint64(value, tag, context, ec);
  334|  4.20M|        }
_ZN8jsoncons24basic_item_event_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  276|   519k|        {
  277|   519k|            return visit_end_array(context, ec);
  278|   519k|        }
_ZN8jsoncons24basic_item_event_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  340|  3.48M|        {
  341|  3.48M|            return visit_int64(value, tag, context, ec);
  342|  3.48M|        }
_ZN8jsoncons24basic_item_event_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  356|  25.8k|        {
  357|  25.8k|            return visit_double(value, tag, context, ec);
  358|  25.8k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEEC2ERNS_18basic_json_visitorIcEERKS3_:
  832|  4.49k|        {
  833|  4.49k|            level_stack_.emplace_back(target_t::destination,container_t::root); // root
  834|  4.49k|        }
_ZN8jsoncons24basic_item_event_visitorIcEC2Ev:
   33|  4.49k|        basic_item_event_visitor() = default;
_ZN8jsoncons24basic_item_event_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  256|  2.45M|        {
  257|  2.45M|            return visit_begin_object(length, tag, context, ec);
  258|  2.45M|        }
_ZN8jsoncons24basic_item_event_visitorIcE12string_valueERKNS_6detail17basic_string_viewIcNSt3__111char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS4_10error_codeE:
  304|  6.04M|        {
  305|  6.04M|            return visit_string(value, tag, context, ec);
  306|  6.04M|        }
_ZN8jsoncons24basic_item_event_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  288|  78.5k|        {
  289|  78.5k|            return visit_null(tag, context, ec);
  290|  78.5k|        }
_ZN8jsoncons24basic_item_event_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  296|  11.5M|        {
  297|  11.5M|            return visit_bool(value, tag, context, ec);
  298|  11.5M|        }
_ZN8jsoncons24basic_item_event_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr16extension_traits16is_byte_sequenceIS4_EE5valueEiE4typeE:
  314|  5.12k|        {
  315|  5.12k|            return visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  316|  5.12k|        }
_ZN8jsoncons24basic_item_event_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr16extension_traits16is_byte_sequenceIS4_EE5valueEiE4typeE:
  324|  10.1k|        {
  325|  10.1k|            return visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), ext_tag, context, ec);
  326|  10.1k|        }
_ZN8jsoncons24basic_item_event_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  261|   141k|        {
  262|   141k|            return visit_end_object(context, ec);
  263|   141k|        }
_ZN8jsoncons24basic_item_event_visitorIcE5flushEv:
   38|    851|        {
   39|    851|            visit_flush();
   40|    851|        }

_ZN8jsoncons18basic_json_visitorIcE5flushEv:
   41|    851|        {
   42|    851|            visit_flush();
   43|    851|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  259|  7.03k|        {
  260|  7.03k|            return visit_begin_object(length, tag, context, ec);
  261|  7.03k|        }
_ZN8jsoncons18basic_json_visitorIcE3keyERKNS_6detail17basic_string_viewIcNSt3__111char_traitsIcEEEERKNS_11ser_contextERNS4_10error_codeE:
  284|  30.1k|        {
  285|  30.1k|            return visit_key(name, context, ec);
  286|  30.1k|        }
_ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  264|  1.71k|        {
  265|  1.71k|            return visit_end_object(context, ec);
  266|  1.71k|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  274|  3.82M|        {
  275|  3.82M|            return visit_begin_array(length, tag, context, ec);
  276|  3.82M|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  279|  35.8k|        {
  280|  35.8k|            return visit_end_array(context, ec);
  281|  35.8k|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  291|    786|        {
  292|    786|            return visit_null(tag, context, ec);
  293|    786|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  299|  2.86k|        {
  300|  2.86k|            return visit_bool(value, tag, context, ec);
  301|  2.86k|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNS_6detail17basic_string_viewIcNSt3__111char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS4_10error_codeE:
  307|  9.01k|        {
  308|  9.01k|            return visit_string(value, tag, context, ec);
  309|  9.01k|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr16extension_traits16is_byte_sequenceIS4_EE5valueEiE4typeE:
  317|    766|        {
  318|    766|            return visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  319|    766|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr16extension_traits16is_byte_sequenceIS4_EE5valueEiE4typeE:
  327|  1.53k|        {
  328|  1.53k|            return visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), ext_tag, context, ec);
  329|  1.53k|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  335|  11.4k|        {
  336|  11.4k|            return visit_uint64(value, tag, context, ec);
  337|  11.4k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  343|  3.95k|        {
  344|  3.95k|            return visit_int64(value, tag, context, ec);
  345|  3.95k|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  359|    590|        {
  360|    590|            return visit_double(value, tag, context, ec);
  361|    590|        }
_ZN8jsoncons18basic_json_visitorIcED2Ev:
   38|  8.99k|        virtual ~basic_json_visitor() noexcept = default;
_ZN8jsoncons26basic_default_json_visitorIcEC2EbNSt3__110error_codeE:
  931|  8.99k|        {
  932|  8.99k|        }
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
   36|  8.99k|        basic_json_visitor() = default;
_ZN8jsoncons26basic_default_json_visitorIcE11visit_flushEv:
  935|    851|        {
  936|    851|        }
_ZN8jsoncons26basic_default_json_visitorIcE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  939|  7.03k|        {
  940|  7.03k|            if (ec_)
  ------------------
  |  Branch (940:17): [True: 0, False: 7.03k]
  ------------------
  941|      0|            {
  942|      0|                ec = ec_;
  943|      0|            }
  944|  7.03k|            return parse_more_;
  945|  7.03k|        }
_ZN8jsoncons18basic_json_visitorIcE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  625|  7.03k|        {
  626|  7.03k|            return visit_begin_object(tag, context, ec);
  627|  7.03k|        }
_ZN8jsoncons26basic_default_json_visitorIcE16visit_end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  948|  1.71k|        {
  949|  1.71k|            if (ec_)
  ------------------
  |  Branch (949:17): [True: 0, False: 1.71k]
  ------------------
  950|      0|            {
  951|      0|                ec = ec_;
  952|      0|            }
  953|  1.71k|            return parse_more_;
  954|  1.71k|        }
_ZN8jsoncons26basic_default_json_visitorIcE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  957|  3.82M|        {
  958|  3.82M|            if (ec_)
  ------------------
  |  Branch (958:17): [True: 0, False: 3.82M]
  ------------------
  959|      0|            {
  960|      0|                ec = ec_;
  961|      0|            }
  962|  3.82M|            return parse_more_;
  963|  3.82M|        }
_ZN8jsoncons18basic_json_visitorIcE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  640|  3.82M|        {
  641|  3.82M|            return visit_begin_array(tag, context, ec);
  642|  3.82M|        }
_ZN8jsoncons26basic_default_json_visitorIcE15visit_end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  966|  35.8k|        {
  967|  35.8k|            if (ec_)
  ------------------
  |  Branch (967:17): [True: 0, False: 35.8k]
  ------------------
  968|      0|            {
  969|      0|                ec = ec_;
  970|      0|            }
  971|  35.8k|            return parse_more_;
  972|  35.8k|        }
_ZN8jsoncons26basic_default_json_visitorIcE9visit_keyERKNS_6detail17basic_string_viewIcNSt3__111char_traitsIcEEEERKNS_11ser_contextERNS4_10error_codeE:
  975|  30.1k|        {
  976|  30.1k|            if (ec_)
  ------------------
  |  Branch (976:17): [True: 0, False: 30.1k]
  ------------------
  977|      0|            {
  978|      0|                ec = ec_;
  979|      0|            }
  980|  30.1k|            return parse_more_;
  981|  30.1k|        }
_ZN8jsoncons26basic_default_json_visitorIcE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  984|    786|        {
  985|    786|            if (ec_)
  ------------------
  |  Branch (985:17): [True: 0, False: 786]
  ------------------
  986|      0|            {
  987|      0|                ec = ec_;
  988|      0|            }
  989|    786|            return parse_more_;
  990|    786|        }
_ZN8jsoncons26basic_default_json_visitorIcE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
 1047|  2.86k|        {
 1048|  2.86k|            if (ec_)
  ------------------
  |  Branch (1048:17): [True: 0, False: 2.86k]
  ------------------
 1049|      0|            {
 1050|      0|                ec = ec_;
 1051|      0|            }
 1052|  2.86k|            return parse_more_;
 1053|  2.86k|        }
_ZN8jsoncons26basic_default_json_visitorIcE12visit_stringERKNS_6detail17basic_string_viewIcNSt3__111char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS4_10error_codeE:
  993|  9.01k|        {
  994|  9.01k|            if (ec_)
  ------------------
  |  Branch (994:17): [True: 0, False: 9.01k]
  ------------------
  995|      0|            {
  996|      0|                ec = ec_;
  997|      0|            }
  998|  9.01k|            return parse_more_;
  999|  9.01k|        }
_ZN8jsoncons26basic_default_json_visitorIcE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
 1002|  2.30k|        {
 1003|  2.30k|            if (ec_)
  ------------------
  |  Branch (1003:17): [True: 0, False: 2.30k]
  ------------------
 1004|      0|            {
 1005|      0|                ec = ec_;
 1006|      0|            }
 1007|  2.30k|            return parse_more_;
 1008|  2.30k|        }
_ZN8jsoncons18basic_json_visitorIcE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNSt3__110error_codeE:
  674|  1.53k|        {
  675|  1.53k|            return visit_byte_string(value, semantic_tag::none, context, ec);
  676|  1.53k|        }
_ZN8jsoncons26basic_default_json_visitorIcE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
 1011|  11.4k|        {
 1012|  11.4k|            if (ec_)
  ------------------
  |  Branch (1012:17): [True: 0, False: 11.4k]
  ------------------
 1013|      0|            {
 1014|      0|                ec = ec_;
 1015|      0|            }
 1016|  11.4k|            return parse_more_;
 1017|  11.4k|        }
_ZN8jsoncons26basic_default_json_visitorIcE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
 1020|  3.95k|        {
 1021|  3.95k|            if (ec_)
  ------------------
  |  Branch (1021:17): [True: 0, False: 3.95k]
  ------------------
 1022|      0|            {
 1023|      0|                ec = ec_;
 1024|      0|            }
 1025|  3.95k|            return parse_more_;
 1026|  3.95k|        }
_ZN8jsoncons26basic_default_json_visitorIcE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
 1038|    590|        {
 1039|    590|            if (ec_)
  ------------------
  |  Branch (1039:17): [True: 0, False: 590]
  ------------------
 1040|      0|            {
 1041|      0|                ec = ec_;
 1042|      0|            }
 1043|    590|            return parse_more_;
 1044|    590|        }

_ZN8jsoncons11ser_contextD2Ev:
   15|  4.49k|    virtual ~ser_context() noexcept = default;

_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERS7_:
  222|  25.2k|        {
  223|  25.2k|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9push_backEc:
  243|   391k|        {
  244|   391k|            buf_ptr->push_back(ch);
  245|   391k|        }

_ZN8jsoncons13stream_sourceIhED2Ev:
  121|  4.49k|        {
  122|  4.49k|        }
_ZN8jsoncons13stream_sourceIhEC2ERNSt3__113basic_istreamIcNS2_11char_traitsIcEEEEm:
  101|  4.49k|        {
  102|  4.49k|        }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   48|  4.49k|        {
   49|  4.49k|        }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   36|  4.49k|            null_buffer() = default;
_ZNK8jsoncons13stream_sourceIhE8is_errorEv:
  153|  34.9M|        {
  154|  34.9M|            return stream_ptr_->bad();  
  155|  34.9M|        }
_ZN8jsoncons13stream_sourceIhE4readEPhm:
  220|  40.1M|        {
  221|  40.1M|            std::size_t len = 0;
  222|  40.1M|            if (buffer_length_ > 0)
  ------------------
  |  Branch (222:17): [True: 40.1M, False: 10.1k]
  ------------------
  223|  40.1M|            {
  224|  40.1M|                len = (std::min)(buffer_length_, length);
  225|  40.1M|                std::memcpy(p, buffer_data_, len*sizeof(value_type));
  226|  40.1M|                buffer_data_ += len;
  227|  40.1M|                buffer_length_ -= len;
  228|  40.1M|                position_ += len;
  229|  40.1M|            }
  230|  40.1M|            if (length - len == 0)
  ------------------
  |  Branch (230:17): [True: 40.1M, False: 11.1k]
  ------------------
  231|  40.1M|            {
  232|  40.1M|                return len;
  233|  40.1M|            }
  234|  11.1k|            else if (length - len < buffer_.size())
  ------------------
  |  Branch (234:22): [True: 11.0k, False: 128]
  ------------------
  235|  11.0k|            {
  236|  11.0k|                fill_buffer();
  237|  11.0k|                if (buffer_length_ > 0)
  ------------------
  |  Branch (237:21): [True: 7.66k, False: 3.36k]
  ------------------
  238|  7.66k|                {
  239|  7.66k|                    std::size_t len2 = (std::min)(buffer_length_, length-len);
  240|  7.66k|                    std::memcpy(p+len, buffer_data_, len2*sizeof(value_type));
  241|  7.66k|                    buffer_data_ += len2;
  242|  7.66k|                    buffer_length_ -= len2;
  243|  7.66k|                    position_ += len2;
  244|  7.66k|                    len += len2;
  245|  7.66k|                }
  246|  11.0k|                return len;
  247|  11.0k|            }
  248|    128|            else
  249|    128|            {
  250|    128|                if (stream_ptr_->eof())
  ------------------
  |  Branch (250:21): [True: 0, False: 128]
  ------------------
  251|      0|                {
  252|      0|                    buffer_length_ = 0;
  253|      0|                    return 0;
  254|      0|                }
  255|    128|                JSONCONS_TRY
  ------------------
  |  |  239|    128|    #define JSONCONS_TRY try
  ------------------
  256|    128|                {
  257|    128|                    std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(p+len), length-len);
  258|    128|                    std::size_t len2 = static_cast<std::size_t>(count);
  259|    128|                    if (len2 < length-len)
  ------------------
  |  Branch (259:25): [True: 12, False: 116]
  ------------------
  260|     12|                    {
  261|     12|                        stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  262|     12|                    }
  263|    128|                    len += len2;
  264|    128|                    position_ += len2;
  265|    128|                    return len;
  266|    128|                }
  267|    128|                JSONCONS_CATCH(const std::exception&)     
  268|    128|                {
  269|      0|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  270|      0|                    return 0;
  271|      0|                }
  272|    128|            }
  273|  40.1M|        }
_ZN8jsoncons13stream_sourceIhE11fill_bufferEv:
  276|  11.0k|        {
  277|  11.0k|            if (stream_ptr_->eof())
  ------------------
  |  Branch (277:17): [True: 3.34k, False: 7.69k]
  ------------------
  278|  3.34k|            {
  279|  3.34k|                buffer_length_ = 0;
  280|  3.34k|                return;
  281|  3.34k|            }
  282|       |
  283|  7.69k|            buffer_data_ = buffer_.data();
  284|  7.69k|            JSONCONS_TRY
  ------------------
  |  |  239|  7.69k|    #define JSONCONS_TRY try
  ------------------
  285|  7.69k|            {
  286|  7.69k|                std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(buffer_.data()), buffer_.size());
  287|  7.69k|                buffer_length_ = static_cast<std::size_t>(count);
  288|       |
  289|  7.69k|                if (buffer_length_ < buffer_.size())
  ------------------
  |  Branch (289:21): [True: 4.47k, False: 3.21k]
  ------------------
  290|  4.47k|                {
  291|  4.47k|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  292|  4.47k|                }
  293|  7.69k|            }
  294|  7.69k|            JSONCONS_CATCH(const std::exception&)     
  295|  7.69k|            {
  296|      0|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  297|      0|                buffer_length_ = 0;
  298|      0|            }
  299|  7.69k|        }
_ZN8jsoncons13source_readerINS_13stream_sourceIhEEE4readINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEENS5_9enable_ifIXaaaasr3std14is_convertibleIhNT_10value_typeEEE5valuesr16extension_traits11has_reserveISD_EE5valuentsr16extension_traits14has_data_exactIPhSD_EE5valueEmE4typeERS2_RSD_m:
  759|  6.02M|        {
  760|  6.02M|            std::size_t unread = length;
  761|       |
  762|  6.02M|            std::size_t n = (std::min)(max_buffer_length, unread);
  763|  6.02M|            while (n > 0 && !source.eof())
  ------------------
  |  Branch (763:20): [True: 2.48k, False: 6.01M]
  |  Branch (763:29): [True: 2.35k, False: 132]
  ------------------
  764|  2.35k|            {
  765|  2.35k|                v.reserve(v.size()+n);
  766|  2.35k|                std::size_t actual = 0;
  767|  5.08M|                while (actual < n)
  ------------------
  |  Branch (767:24): [True: 5.08M, False: 2.27k]
  ------------------
  768|  5.08M|                {
  769|  5.08M|                    typename Source::value_type c;
  770|  5.08M|                    if (source.read(&c,1) != 1)
  ------------------
  |  Branch (770:25): [True: 80, False: 5.08M]
  ------------------
  771|     80|                    {
  772|     80|                        break;
  773|     80|                    }
  774|  5.08M|                    v.push_back(c);
  775|  5.08M|                    ++actual;
  776|  5.08M|                }
  777|  2.35k|                unread -= actual;
  778|  2.35k|                n = (std::min)(max_buffer_length, unread);
  779|  2.35k|            }
  780|       |
  781|  6.02M|            return length - unread;
  782|  6.02M|        }
_ZNK8jsoncons13stream_sourceIhE3eofEv:
  148|  12.2k|        {
  149|  12.2k|            return buffer_length_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (149:20): [True: 619, False: 11.6k]
  |  Branch (149:43): [True: 391, False: 228]
  ------------------
  150|  12.2k|        }
_ZN8jsoncons13source_readerINS_13stream_sourceIhEEE4readINSt3__16vectorIhNS5_9allocatorIhEEEEEENS5_9enable_ifIXaaaasr3std14is_convertibleIhNT_10value_typeEEE5valuesr16extension_traits11has_reserveISB_EE5valuesr16extension_traits14has_data_exactIPhSB_EE5valueEmE4typeERS2_RSB_m:
  736|  15.5k|        {
  737|  15.5k|            std::size_t unread = length;
  738|       |
  739|  15.5k|            std::size_t n = (std::min)(max_buffer_length, unread);
  740|  25.0k|            while (n > 0 && !source.eof())
  ------------------
  |  Branch (740:20): [True: 9.77k, False: 15.3k]
  |  Branch (740:29): [True: 9.51k, False: 259]
  ------------------
  741|  9.51k|            {
  742|  9.51k|                std::size_t offset = v.size();
  743|  9.51k|                v.resize(v.size()+n);
  744|  9.51k|                std::size_t actual = source.read(v.data()+offset, n);
  745|  9.51k|                unread -= actual;
  746|  9.51k|                n = (std::min)(max_buffer_length, unread);
  747|  9.51k|            }
  748|       |
  749|  15.5k|            return length - unread;
  750|  15.5k|        }

_ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr16extension_traits8is_char8IT_EE5valueENS0_14convert_resultIS4_EEE4typeEPKS4_m:
 1130|  6.01M|    {
 1131|  6.01M|        conv_errc  result = conv_errc();
 1132|  6.01M|        const CharT* last = data + length;
 1133|  6.99M|        while (data != last) 
  ------------------
  |  Branch (1133:16): [True: 976k, False: 6.01M]
  ------------------
 1134|   976k|        {
 1135|   976k|            std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[static_cast<uint8_t>(*data)]) + 1;
 1136|   976k|            if (len > (std::size_t)(last - data))
  ------------------
  |  Branch (1136:17): [True: 5, False: 976k]
  ------------------
 1137|      5|            {
 1138|      5|                return convert_result<CharT>{data, conv_errc::source_exhausted};
 1139|      5|            }
 1140|   976k|            if ((result=is_legal_utf8(data, len)) != conv_errc())
  ------------------
  |  Branch (1140:17): [True: 86, False: 976k]
  ------------------
 1141|     86|            {
 1142|     86|                return convert_result<CharT>{data,result} ;
 1143|     86|            }
 1144|   976k|            data += len;
 1145|   976k|        }
 1146|  6.01M|        return convert_result<CharT>{data,result} ;
 1147|  6.01M|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8IcEENSt3__19enable_ifIXsr16extension_traits8is_char8IT_EE5valueENS0_9conv_errcEE4typeEPKS4_m:
  299|   976k|    {
  300|   976k|        uint8_t a;
  301|   976k|        const CharT* srcptr = first+length;
  302|   976k|        switch (length) {
  303|      9|        default:
  ------------------
  |  Branch (303:9): [True: 9, False: 976k]
  ------------------
  304|      9|            return conv_errc::over_long_utf8_sequence;
  305|    420|        case 4:
  ------------------
  |  Branch (305:9): [True: 420, False: 975k]
  ------------------
  306|    420|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (306:17): [True: 4, False: 416]
  ------------------
  307|      4|                return conv_errc::expected_continuation_byte;
  308|    420|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|    416|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  309|    842|        case 3:
  ------------------
  |  Branch (309:9): [True: 426, False: 975k]
  ------------------
  310|    842|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (310:17): [True: 4, False: 838]
  ------------------
  311|      4|                return conv_errc::expected_continuation_byte;
  312|    842|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|    838|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  313|  1.06k|        case 2:
  ------------------
  |  Branch (313:9): [True: 227, False: 976k]
  ------------------
  314|  1.06k|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 12, False: 1.05k]
  ------------------
  315|     12|                return conv_errc::expected_continuation_byte;
  316|       |
  317|  1.05k|            switch (static_cast<uint8_t>(*first)) 
  318|  1.05k|            {
  319|       |                // no fall-through in this inner switch
  320|    202|                case 0xE0: if (a < 0xA0) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (320:17): [True: 202, False: 851]
  |  Branch (320:32): [True: 6, False: 196]
  ------------------
  321|    201|                case 0xED: if (a > 0x9F) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (321:17): [True: 201, False: 852]
  |  Branch (321:32): [True: 2, False: 199]
  ------------------
  322|    201|                case 0xF0: if (a < 0x90) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (322:17): [True: 201, False: 852]
  |  Branch (322:32): [True: 6, False: 195]
  ------------------
  323|    198|                case 0xF4: if (a > 0x8F) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (323:17): [True: 198, False: 855]
  |  Branch (323:32): [True: 3, False: 195]
  ------------------
  324|    251|                default:   if (a < 0x80) return conv_errc::source_illegal;
  ------------------
  |  Branch (324:17): [True: 251, False: 802]
  |  Branch (324:32): [True: 0, False: 251]
  ------------------
  325|  1.05k|            }
  326|       |
  327|  1.05k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |   34|  1.03k|#  define JSONCONS_FALLTHROUGH [[clang::fallthrough]]
  ------------------
  328|   976k|        case 1:
  ------------------
  |  Branch (328:9): [True: 975k, False: 1.08k]
  ------------------
  329|   976k|            if (static_cast<uint8_t>(*first) >= 0x80 && static_cast<uint8_t>(*first) < 0xC2)
  ------------------
  |  Branch (329:17): [True: 1.07k, False: 975k]
  |  Branch (329:57): [True: 39, False: 1.03k]
  ------------------
  330|     39|                return conv_errc::source_illegal;
  331|   976k|            break;
  332|   976k|        }
  333|   976k|        if (static_cast<uint8_t>(*first) > 0xF4) 
  ------------------
  |  Branch (333:13): [True: 1, False: 976k]
  ------------------
  334|      1|            return conv_errc::source_illegal;
  335|       |
  336|   976k|        return conv_errc();
  337|   976k|    }

_ZN8jsoncons7msgpack15make_error_codeENS0_12msgpack_errcE:
   80|  3.64k|{
   81|  3.64k|    return std::error_code(static_cast<int>(e),msgpack_error_category());
   82|  3.64k|}
_ZN8jsoncons7msgpack22msgpack_error_categoryEv:
   73|  3.64k|{
   74|  3.64k|  static msgpack_error_category_impl instance;
   75|  3.64k|  return instance;
   76|  3.64k|}

_ZN8jsoncons7msgpack22msgpack_options_commonC2Ev:
   29|  4.49k|    {
   30|  4.49k|    }
_ZN8jsoncons7msgpack22msgpack_decode_optionsC2Ev:
   48|  4.49k|    {
   49|  4.49k|    }
_ZN8jsoncons7msgpack22msgpack_encode_optionsC2Ev:
   57|  4.49k|    {
   58|  4.49k|    }
_ZN8jsoncons7msgpack22msgpack_options_commonD2Ev:
   25|  8.99k|    virtual ~msgpack_options_common() = default;
_ZN8jsoncons7msgpack15msgpack_options17max_nesting_depthEi:
   67|  4.49k|    {
   68|  4.49k|        this->max_nesting_depth_ = value;
   69|  4.49k|        return *this;
   70|  4.49k|    }
_ZN8jsoncons7msgpack22msgpack_options_commonC2ERKS1_:
   32|  4.49k|    msgpack_options_common(const msgpack_options_common&) = default;
_ZNK8jsoncons7msgpack22msgpack_options_common17max_nesting_depthEv:
   38|  9.56M|    {
   39|  9.56M|        return max_nesting_depth_;
   40|  9.56M|    }

_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhEENSt3__19allocatorIcEEEC2IRNS4_19basic_istringstreamIcNS4_11char_traitsIcEES6_EEEEOT_RKNS0_22msgpack_decode_optionsERKS6_:
   78|  4.49k|    {
   79|  4.49k|        state_stack_.emplace_back(parse_mode::root,0);
   80|  4.49k|    }
_ZN8jsoncons7msgpack11parse_stateC2ENS0_10parse_modeEm:
   36|  9.57M|    {
   37|  9.57M|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhEENSt3__19allocatorIcEEE5resetEv:
   88|  4.49k|    {
   89|  4.49k|        more_ = true;
   90|  4.49k|        done_ = false;
   91|  4.49k|        text_buffer_.clear();
   92|  4.49k|        bytes_buffer_.clear();
   93|  4.49k|        state_stack_.clear();
   94|  4.49k|        state_stack_.emplace_back(parse_mode::root,0);
   95|  4.49k|        nesting_depth_ = 0;
   96|  4.49k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhEENSt3__19allocatorIcEEE5parseERNS_24basic_item_event_visitorIcEERNS4_10error_codeE:
  126|  4.49k|    {
  127|  35.6M|        while (!done_ && more_)
  ------------------
  |  Branch (127:16): [True: 35.6M, False: 851]
  |  Branch (127:26): [True: 35.6M, False: 0]
  ------------------
  128|  35.6M|        {
  129|  35.6M|            switch (state_stack_.back().mode)
  ------------------
  |  Branch (129:21): [True: 0, False: 35.6M]
  ------------------
  130|  35.6M|            {
  131|  17.7M|                case parse_mode::array:
  ------------------
  |  Branch (131:17): [True: 17.7M, False: 17.8M]
  ------------------
  132|  17.7M|                {
  133|  17.7M|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (133:25): [True: 17.2M, False: 519k]
  ------------------
  134|  17.2M|                    {
  135|  17.2M|                        ++state_stack_.back().index;
  136|  17.2M|                        read_item(visitor, ec);
  137|  17.2M|                        if (ec)
  ------------------
  |  Branch (137:29): [True: 786, False: 17.2M]
  ------------------
  138|    786|                        {
  139|    786|                            return;
  140|    786|                        }
  141|  17.2M|                    }
  142|   519k|                    else
  143|   519k|                    {
  144|   519k|                        end_array(visitor, ec);
  145|   519k|                    }
  146|  17.7M|                    break;
  147|  17.7M|                }
  148|  17.7M|                case parse_mode::map_key:
  ------------------
  |  Branch (148:17): [True: 10.1M, False: 25.4M]
  ------------------
  149|  10.1M|                {
  150|  10.1M|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (150:25): [True: 9.99M, False: 141k]
  ------------------
  151|  9.99M|                    {
  152|  9.99M|                        ++state_stack_.back().index;
  153|  9.99M|                        state_stack_.back().mode = parse_mode::map_value;
  154|  9.99M|                        read_item(visitor, ec);
  155|  9.99M|                        if (ec)
  ------------------
  |  Branch (155:29): [True: 633, False: 9.99M]
  ------------------
  156|    633|                        {
  157|    633|                            return;
  158|    633|                        }
  159|  9.99M|                    }
  160|   141k|                    else
  161|   141k|                    {
  162|   141k|                        end_object(visitor, ec);
  163|   141k|                    }
  164|  10.1M|                    break;
  165|  10.1M|                }
  166|  10.1M|                case parse_mode::map_value:
  ------------------
  |  Branch (166:17): [True: 7.69M, False: 27.9M]
  ------------------
  167|  7.69M|                {
  168|  7.69M|                    state_stack_.back().mode = parse_mode::map_key;
  169|  7.69M|                    read_item(visitor, ec);
  170|  7.69M|                    if (ec)
  ------------------
  |  Branch (170:25): [True: 1.85k, False: 7.69M]
  ------------------
  171|  1.85k|                    {
  172|  1.85k|                        return;
  173|  1.85k|                    }
  174|  7.69M|                    break;
  175|  7.69M|                }
  176|  7.69M|                case parse_mode::root:
  ------------------
  |  Branch (176:17): [True: 4.49k, False: 35.6M]
  ------------------
  177|  4.49k|                {
  178|  4.49k|                    state_stack_.back().mode = parse_mode::accept;
  179|  4.49k|                    read_item(visitor, ec);
  180|  4.49k|                    if (ec)
  ------------------
  |  Branch (180:25): [True: 369, False: 4.12k]
  ------------------
  181|    369|                    {
  182|    369|                        return;
  183|    369|                    }
  184|  4.12k|                    break;
  185|  4.49k|                }
  186|  4.12k|                case parse_mode::accept:
  ------------------
  |  Branch (186:17): [True: 851, False: 35.6M]
  ------------------
  187|    851|                {
  188|    851|                    JSONCONS_ASSERT(state_stack_.size() == 1);
  ------------------
  |  |  378|    851|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (378:32): [True: 0, False: 851]
  |  |  ------------------
  |  |  379|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |  237|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |  380|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  189|    851|                    state_stack_.clear();
  190|    851|                    more_ = false;
  191|    851|                    done_ = true;
  192|    851|                    visitor.flush();
  193|    851|                    break;
  194|    851|                }
  195|  35.6M|            }
  196|  35.6M|        }
  197|  4.49k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhEENSt3__19allocatorIcEEE9read_itemERNS_24basic_item_event_visitorIcEERNS4_10error_codeE:
  201|  34.9M|    {
  202|  34.9M|        if (source_.is_error())
  ------------------
  |  Branch (202:13): [True: 0, False: 34.9M]
  ------------------
  203|      0|        {
  204|      0|            ec = msgpack_errc::source_error;
  205|      0|            more_ = false;
  206|      0|            return;
  207|      0|        }   
  208|       |
  209|  34.9M|        uint8_t type;
  210|  34.9M|        if (source_.read(&type, 1) == 0)
  ------------------
  |  Branch (210:13): [True: 2.94k, False: 34.9M]
  ------------------
  211|  2.94k|        {
  212|  2.94k|            ec = msgpack_errc::unexpected_eof;
  213|  2.94k|            more_ = false;
  214|  2.94k|            return;
  215|  2.94k|        }
  216|       |
  217|  34.9M|        if (type <= 0xbf)
  ------------------
  |  Branch (217:13): [True: 19.7M, False: 15.1M]
  ------------------
  218|  19.7M|        {
  219|  19.7M|            if (type <= 0x7f) 
  ------------------
  |  Branch (219:17): [True: 4.19M, False: 15.5M]
  ------------------
  220|  4.19M|            {
  221|       |                // positive fixint
  222|  4.19M|                more_ = visitor.uint64_value(type, semantic_tag::none, *this, ec);
  223|  4.19M|            }
  224|  15.5M|            else if (type <= 0x8f) 
  ------------------
  |  Branch (224:22): [True: 2.44M, False: 13.1M]
  ------------------
  225|  2.44M|            {
  226|  2.44M|                begin_object(visitor,type,ec); // fixmap
  227|  2.44M|            }
  228|  13.1M|            else if (type <= 0x9f) 
  ------------------
  |  Branch (228:22): [True: 7.11M, False: 6.01M]
  ------------------
  229|  7.11M|            {
  230|  7.11M|                begin_array(visitor,type,ec); // fixarray
  231|  7.11M|            }
  232|  6.01M|            else 
  233|  6.01M|            {
  234|       |                // fixstr
  235|  6.01M|                const size_t len = type & 0x1f;
  236|       |
  237|  6.01M|                text_buffer_.clear();
  238|       |
  239|  6.01M|                if (source_reader<Source>::read(source_,text_buffer_,len) != static_cast<std::size_t>(len))
  ------------------
  |  Branch (239:21): [True: 28, False: 6.01M]
  ------------------
  240|     28|                {
  241|     28|                    ec = msgpack_errc::unexpected_eof;
  242|     28|                    more_ = false;
  243|     28|                    return;
  244|     28|                }
  245|       |
  246|  6.01M|                auto result = unicode_traits::validate(text_buffer_.data(),text_buffer_.size());
  247|  6.01M|                if (result.ec != unicode_traits::conv_errc())
  ------------------
  |  Branch (247:21): [True: 70, False: 6.01M]
  ------------------
  248|     70|                {
  249|     70|                    ec = msgpack_errc::invalid_utf8_text_string;
  250|     70|                    more_ = false;
  251|     70|                    return;
  252|     70|                }
  253|  6.01M|                more_ = visitor.string_value(jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()), semantic_tag::none, *this, ec);
  254|  6.01M|            }
  255|  19.7M|        }
  256|  15.1M|        else if (type >= 0xe0) 
  ------------------
  |  Branch (256:18): [True: 3.47M, False: 11.6M]
  ------------------
  257|  3.47M|        {
  258|       |            // negative fixint
  259|  3.47M|            more_ = visitor.int64_value(static_cast<int8_t>(type), semantic_tag::none, *this, ec);
  260|  3.47M|        }
  261|  11.6M|        else
  262|  11.6M|        {
  263|  11.6M|            switch (type)
  264|  11.6M|            {
  265|  78.5k|                case jsoncons::msgpack::msgpack_type::nil_type: 
  ------------------
  |  Branch (265:17): [True: 78.5k, False: 11.6M]
  ------------------
  266|  78.5k|                {
  267|  78.5k|                    more_ = visitor.null_value(semantic_tag::none, *this, ec);
  268|  78.5k|                    break;
  269|      0|                }
  270|  7.56M|                case jsoncons::msgpack::msgpack_type::true_type:
  ------------------
  |  Branch (270:17): [True: 7.56M, False: 4.12M]
  ------------------
  271|  7.56M|                {
  272|  7.56M|                    more_ = visitor.bool_value(true, semantic_tag::none, *this, ec);
  273|  7.56M|                    break;
  274|      0|                }
  275|  3.96M|                case jsoncons::msgpack::msgpack_type::false_type:
  ------------------
  |  Branch (275:17): [True: 3.96M, False: 7.72M]
  ------------------
  276|  3.96M|                {
  277|  3.96M|                    more_ = visitor.bool_value(false, semantic_tag::none, *this, ec);
  278|  3.96M|                    break;
  279|      0|                }
  280|  18.6k|                case jsoncons::msgpack::msgpack_type::float32_type: 
  ------------------
  |  Branch (280:17): [True: 18.6k, False: 11.6M]
  ------------------
  281|  18.6k|                {
  282|  18.6k|                    uint8_t buf[sizeof(float)];
  283|  18.6k|                    if (source_.read(buf, sizeof(float)) != sizeof(float))
  ------------------
  |  Branch (283:25): [True: 7, False: 18.6k]
  ------------------
  284|      7|                    {
  285|      7|                        ec = msgpack_errc::unexpected_eof;
  286|      7|                        more_ = false;
  287|      7|                        return;
  288|      7|                    }
  289|  18.6k|                    float val = binary::big_to_native<float>(buf, sizeof(buf));
  290|  18.6k|                    more_ = visitor.double_value(val, semantic_tag::none, *this, ec);
  291|  18.6k|                    break;
  292|  18.6k|                }
  293|       |
  294|  7.21k|                case jsoncons::msgpack::msgpack_type::float64_type: 
  ------------------
  |  Branch (294:17): [True: 7.21k, False: 11.6M]
  ------------------
  295|  7.21k|                {
  296|  7.21k|                    uint8_t buf[sizeof(double)];
  297|  7.21k|                    if (source_.read(buf, sizeof(double)) != sizeof(double))
  ------------------
  |  Branch (297:25): [True: 6, False: 7.20k]
  ------------------
  298|      6|                    {
  299|      6|                        ec = msgpack_errc::unexpected_eof;
  300|      6|                        more_ = false;
  301|      6|                        return;
  302|      6|                    }
  303|  7.20k|                    double val = binary::big_to_native<double>(buf, sizeof(buf));
  304|  7.20k|                    more_ = visitor.double_value(val, semantic_tag::none, *this, ec);
  305|  7.20k|                    break;
  306|  7.21k|                }
  307|       |
  308|  1.57k|                case jsoncons::msgpack::msgpack_type::uint8_type: 
  ------------------
  |  Branch (308:17): [True: 1.57k, False: 11.6M]
  ------------------
  309|  1.57k|                {
  310|  1.57k|                    uint8_t b;
  311|  1.57k|                    if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (311:25): [True: 1, False: 1.57k]
  ------------------
  312|      1|                    {
  313|      1|                        ec = msgpack_errc::unexpected_eof;
  314|      1|                        more_ = false;
  315|      1|                        return;
  316|      1|                    }
  317|  1.57k|                    more_ = visitor.uint64_value(b, semantic_tag::none, *this, ec);
  318|  1.57k|                    break;
  319|  1.57k|                }
  320|       |
  321|    542|                case jsoncons::msgpack::msgpack_type::uint16_type: 
  ------------------
  |  Branch (321:17): [True: 542, False: 11.6M]
  ------------------
  322|    542|                {
  323|    542|                    uint8_t buf[sizeof(uint16_t)];
  324|    542|                    if (source_.read(buf, sizeof(uint16_t)) !=sizeof(uint16_t)) 
  ------------------
  |  Branch (324:25): [True: 2, False: 540]
  ------------------
  325|      2|                    {
  326|      2|                        ec = msgpack_errc::unexpected_eof;
  327|      2|                        more_ = false;
  328|      2|                        return;
  329|      2|                    }
  330|    540|                    uint16_t val = binary::big_to_native<uint16_t>(buf, sizeof(buf));
  331|    540|                    more_ = visitor.uint64_value(val, semantic_tag::none, *this, ec);
  332|    540|                    break;
  333|    542|                }
  334|       |
  335|    241|                case jsoncons::msgpack::msgpack_type::uint32_type: 
  ------------------
  |  Branch (335:17): [True: 241, False: 11.6M]
  ------------------
  336|    241|                {
  337|    241|                    uint8_t buf[sizeof(uint32_t)];
  338|    241|                    if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (338:25): [True: 3, False: 238]
  ------------------
  339|      3|                    {
  340|      3|                        ec = msgpack_errc::unexpected_eof;
  341|      3|                        more_ = false;
  342|      3|                        return;
  343|      3|                    }
  344|    238|                    uint32_t val = binary::big_to_native<uint32_t>(buf, sizeof(buf));
  345|    238|                    more_ = visitor.uint64_value(val, semantic_tag::none, *this, ec);
  346|    238|                    break;
  347|    241|                }
  348|       |
  349|    789|                case jsoncons::msgpack::msgpack_type::uint64_type: 
  ------------------
  |  Branch (349:17): [True: 789, False: 11.6M]
  ------------------
  350|    789|                {
  351|    789|                    uint8_t buf[sizeof(uint64_t)];
  352|    789|                    if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (352:25): [True: 5, False: 784]
  ------------------
  353|      5|                    {
  354|      5|                        ec = msgpack_errc::unexpected_eof;
  355|      5|                        more_ = false;
  356|      5|                        return;
  357|      5|                    }
  358|    784|                    uint64_t val = binary::big_to_native<uint64_t>(buf, sizeof(buf));
  359|    784|                    more_ = visitor.uint64_value(val, semantic_tag::none, *this, ec);
  360|    784|                    break;
  361|    789|                }
  362|       |
  363|  1.23k|                case jsoncons::msgpack::msgpack_type::int8_type: 
  ------------------
  |  Branch (363:17): [True: 1.23k, False: 11.6M]
  ------------------
  364|  1.23k|                {
  365|  1.23k|                    uint8_t buf[sizeof(int8_t)];
  366|  1.23k|                    if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (366:25): [True: 1, False: 1.23k]
  ------------------
  367|      1|                    {
  368|      1|                        ec = msgpack_errc::unexpected_eof;
  369|      1|                        more_ = false;
  370|      1|                        return;
  371|      1|                    }
  372|  1.23k|                    int8_t val = binary::big_to_native<int8_t>(buf, sizeof(buf));
  373|  1.23k|                    more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);
  374|  1.23k|                    break;
  375|  1.23k|                }
  376|       |
  377|    918|                case jsoncons::msgpack::msgpack_type::int16_type: 
  ------------------
  |  Branch (377:17): [True: 918, False: 11.6M]
  ------------------
  378|    918|                {
  379|    918|                    uint8_t buf[sizeof(int16_t)];
  380|    918|                    if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t))
  ------------------
  |  Branch (380:25): [True: 2, False: 916]
  ------------------
  381|      2|                    {
  382|      2|                        ec = msgpack_errc::unexpected_eof;
  383|      2|                        more_ = false;
  384|      2|                        return;
  385|      2|                    }
  386|    916|                    int16_t val = binary::big_to_native<int16_t>(buf, sizeof(buf));
  387|    916|                    more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);
  388|    916|                    break;
  389|    918|                }
  390|       |
  391|  2.90k|                case jsoncons::msgpack::msgpack_type::int32_type: 
  ------------------
  |  Branch (391:17): [True: 2.90k, False: 11.6M]
  ------------------
  392|  2.90k|                {
  393|  2.90k|                    uint8_t buf[sizeof(int32_t)];
  394|  2.90k|                    if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t))
  ------------------
  |  Branch (394:25): [True: 3, False: 2.90k]
  ------------------
  395|      3|                    {
  396|      3|                        ec = msgpack_errc::unexpected_eof;
  397|      3|                        more_ = false;
  398|      3|                        return;
  399|      3|                    }
  400|  2.90k|                    int32_t val = binary::big_to_native<int32_t>(buf, sizeof(buf));
  401|  2.90k|                    more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);
  402|  2.90k|                    break;
  403|  2.90k|                }
  404|       |
  405|    824|                case jsoncons::msgpack::msgpack_type::int64_type: 
  ------------------
  |  Branch (405:17): [True: 824, False: 11.6M]
  ------------------
  406|    824|                {
  407|    824|                    uint8_t buf[sizeof(int64_t)];
  408|    824|                    if (source_.read(buf, sizeof(int64_t)) != sizeof(int64_t))
  ------------------
  |  Branch (408:25): [True: 2, False: 822]
  ------------------
  409|      2|                    {
  410|      2|                        ec = msgpack_errc::unexpected_eof;
  411|      2|                        more_ = false;
  412|      2|                        return;
  413|      2|                    }
  414|    822|                    int64_t val = binary::big_to_native<int64_t>(buf, sizeof(buf));
  415|    822|                    more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);
  416|    822|                    break;
  417|    824|                }
  418|       |
  419|    526|                case jsoncons::msgpack::msgpack_type::str8_type: 
  ------------------
  |  Branch (419:17): [True: 526, False: 11.6M]
  ------------------
  420|    830|                case jsoncons::msgpack::msgpack_type::str16_type: 
  ------------------
  |  Branch (420:17): [True: 304, False: 11.6M]
  ------------------
  421|  1.49k|                case jsoncons::msgpack::msgpack_type::str32_type: 
  ------------------
  |  Branch (421:17): [True: 666, False: 11.6M]
  ------------------
  422|  1.49k|                {
  423|  1.49k|                    std::size_t len = get_size(type, ec);
  424|  1.49k|                    if (!more_)
  ------------------
  |  Branch (424:25): [True: 24, False: 1.47k]
  ------------------
  425|     24|                    {
  426|     24|                        return;
  427|     24|                    }
  428|       |
  429|  1.47k|                    text_buffer_.clear();
  430|  1.47k|                    if (source_reader<Source>::read(source_,text_buffer_,len) != static_cast<std::size_t>(len))
  ------------------
  |  Branch (430:25): [True: 104, False: 1.36k]
  ------------------
  431|    104|                    {
  432|    104|                        ec = msgpack_errc::unexpected_eof;
  433|    104|                        more_ = false;
  434|    104|                        return;
  435|    104|                    }
  436|       |
  437|  1.36k|                    auto result = unicode_traits::validate(text_buffer_.data(),text_buffer_.size());
  438|  1.36k|                    if (result.ec != unicode_traits::conv_errc())
  ------------------
  |  Branch (438:25): [True: 21, False: 1.34k]
  ------------------
  439|     21|                    {
  440|     21|                        ec = msgpack_errc::invalid_utf8_text_string;
  441|     21|                        more_ = false;
  442|     21|                        return;
  443|     21|                    }
  444|  1.34k|                    more_ = visitor.string_value(jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()), semantic_tag::none, *this, ec);
  445|  1.34k|                    break;
  446|  1.36k|                }
  447|       |
  448|  4.46k|                case jsoncons::msgpack::msgpack_type::bin8_type: 
  ------------------
  |  Branch (448:17): [True: 4.46k, False: 11.6M]
  ------------------
  449|  5.02k|                case jsoncons::msgpack::msgpack_type::bin16_type: 
  ------------------
  |  Branch (449:17): [True: 552, False: 11.6M]
  ------------------
  450|  5.28k|                case jsoncons::msgpack::msgpack_type::bin32_type: 
  ------------------
  |  Branch (450:17): [True: 261, False: 11.6M]
  ------------------
  451|  5.28k|                {
  452|  5.28k|                    std::size_t len = get_size(type,ec);
  453|  5.28k|                    if (!more_)
  ------------------
  |  Branch (453:25): [True: 25, False: 5.25k]
  ------------------
  454|     25|                    {
  455|     25|                        return;
  456|     25|                    }
  457|  5.25k|                    bytes_buffer_.clear();
  458|  5.25k|                    if (source_reader<Source>::read(source_,bytes_buffer_,len) != static_cast<std::size_t>(len))
  ------------------
  |  Branch (458:25): [True: 135, False: 5.12k]
  ------------------
  459|    135|                    {
  460|    135|                        ec = msgpack_errc::unexpected_eof;
  461|    135|                        more_ = false;
  462|    135|                        return;
  463|    135|                    }
  464|       |
  465|  5.12k|                    more_ = visitor.byte_string_value(byte_string_view(bytes_buffer_.data(),bytes_buffer_.size()), 
  466|  5.12k|                                                      semantic_tag::none, 
  467|  5.12k|                                                      *this,
  468|  5.12k|                                                      ec);
  469|  5.12k|                    break;
  470|  5.25k|                }
  471|  5.75k|                case jsoncons::msgpack::msgpack_type::fixext1_type: 
  ------------------
  |  Branch (471:17): [True: 5.75k, False: 11.6M]
  ------------------
  472|  6.26k|                case jsoncons::msgpack::msgpack_type::fixext2_type: 
  ------------------
  |  Branch (472:17): [True: 514, False: 11.6M]
  ------------------
  473|  7.12k|                case jsoncons::msgpack::msgpack_type::fixext4_type: 
  ------------------
  |  Branch (473:17): [True: 860, False: 11.6M]
  ------------------
  474|  13.0k|                case jsoncons::msgpack::msgpack_type::fixext8_type: 
  ------------------
  |  Branch (474:17): [True: 5.96k, False: 11.6M]
  ------------------
  475|  13.3k|                case jsoncons::msgpack::msgpack_type::fixext16_type: 
  ------------------
  |  Branch (475:17): [True: 232, False: 11.6M]
  ------------------
  476|  34.2k|                case jsoncons::msgpack::msgpack_type::ext8_type: 
  ------------------
  |  Branch (476:17): [True: 20.9k, False: 11.6M]
  ------------------
  477|  34.4k|                case jsoncons::msgpack::msgpack_type::ext16_type: 
  ------------------
  |  Branch (477:17): [True: 243, False: 11.6M]
  ------------------
  478|  34.7k|                case jsoncons::msgpack::msgpack_type::ext32_type: 
  ------------------
  |  Branch (478:17): [True: 257, False: 11.6M]
  ------------------
  479|  34.7k|                {
  480|  34.7k|                    std::size_t len = get_size(type,ec);
  481|  34.7k|                    if (!more_)
  ------------------
  |  Branch (481:25): [True: 27, False: 34.7k]
  ------------------
  482|     27|                    {
  483|     27|                        return;
  484|     27|                    }
  485|       |
  486|       |                    // type
  487|  34.7k|                    uint8_t buf[sizeof(int8_t)];
  488|  34.7k|                    if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (488:25): [True: 45, False: 34.6k]
  ------------------
  489|     45|                    {
  490|     45|                        ec = msgpack_errc::unexpected_eof;
  491|     45|                        more_ = false;
  492|     45|                        return;
  493|     45|                    }
  494|       |
  495|  34.6k|                    int8_t ext_type = binary::big_to_native<int8_t>(buf, sizeof(buf));
  496|       |
  497|  34.6k|                    bool is_timestamp = false; 
  498|  34.6k|                    if (ext_type == -1)
  ------------------
  |  Branch (498:25): [True: 24.9k, False: 9.71k]
  ------------------
  499|  24.9k|                    {
  500|  24.9k|                        is_timestamp = true;;
  501|  24.9k|                    }
  502|       |
  503|       |                    // payload
  504|  34.6k|                    if (is_timestamp && len == 4)
  ------------------
  |  Branch (504:25): [True: 24.9k, False: 9.71k]
  |  Branch (504:41): [True: 400, False: 24.5k]
  ------------------
  505|    400|                    {
  506|    400|                        uint8_t buf32[sizeof(uint32_t)];
  507|    400|                        if (source_.read(buf32, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (507:29): [True: 3, False: 397]
  ------------------
  508|      3|                        {
  509|      3|                            ec = msgpack_errc::unexpected_eof;
  510|      3|                            more_ = false;
  511|      3|                            return;
  512|      3|                        }
  513|    397|                        uint32_t val = binary::big_to_native<uint32_t>(buf32, sizeof(buf32));
  514|    397|                        more_ = visitor.uint64_value(val, semantic_tag::epoch_second, *this, ec);
  515|    397|                    }
  516|  34.2k|                    else if (is_timestamp && len == 8)
  ------------------
  |  Branch (516:30): [True: 24.5k, False: 9.71k]
  |  Branch (516:46): [True: 5.47k, False: 19.0k]
  ------------------
  517|  5.47k|                    {
  518|  5.47k|                        uint8_t buf64[sizeof(uint64_t)];
  519|  5.47k|                        if (source_.read(buf64, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (519:29): [True: 6, False: 5.46k]
  ------------------
  520|      6|                        {
  521|      6|                            ec = msgpack_errc::unexpected_eof;
  522|      6|                            more_ = false;
  523|      6|                            return;
  524|      6|                        }
  525|  5.46k|                        uint64_t data64 = binary::big_to_native<uint64_t>(buf64, sizeof(buf64));
  526|  5.46k|                        uint64_t sec = data64 & 0x00000003ffffffffL;
  527|  5.46k|                        uint64_t nsec = data64 >> 34;
  528|       |
  529|  5.46k|                        bigint nano(sec);
  530|  5.46k|                        nano *= uint64_t(nanos_in_second);
  531|  5.46k|                        nano += nsec;
  532|  5.46k|                        text_buffer_.clear();
  533|  5.46k|                        nano.write_string(text_buffer_);
  534|  5.46k|                        more_ = visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);
  535|  5.46k|                        if (!more_) return;
  ------------------
  |  Branch (535:29): [True: 0, False: 5.46k]
  ------------------
  536|  5.46k|                    }
  537|  28.8k|                    else if (is_timestamp && len == 12)
  ------------------
  |  Branch (537:30): [True: 19.0k, False: 9.71k]
  |  Branch (537:46): [True: 18.4k, False: 606]
  ------------------
  538|  18.4k|                    {
  539|  18.4k|                        uint8_t buf1[sizeof(uint32_t)];
  540|  18.4k|                        if (source_.read(buf1, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (540:29): [True: 5, False: 18.4k]
  ------------------
  541|      5|                        {
  542|      5|                            ec = msgpack_errc::unexpected_eof;
  543|      5|                            more_ = false;
  544|      5|                            return;
  545|      5|                        }
  546|  18.4k|                        uint32_t nsec = binary::big_to_native<uint32_t>(buf1, sizeof(buf1));
  547|       |
  548|  18.4k|                        uint8_t buf2[sizeof(int64_t)];
  549|  18.4k|                        if (source_.read(buf2, sizeof(int64_t)) != sizeof(int64_t))
  ------------------
  |  Branch (549:29): [True: 10, False: 18.4k]
  ------------------
  550|     10|                        {
  551|     10|                            ec = msgpack_errc::unexpected_eof;
  552|     10|                            more_ = false;
  553|     10|                            return;
  554|     10|                        }
  555|  18.4k|                        int64_t sec = binary::big_to_native<int64_t>(buf2, sizeof(buf2));
  556|       |
  557|  18.4k|                        bigint nano(sec);
  558|       |
  559|  18.4k|                        nano *= uint64_t(nanos_in_second);
  560|       |
  561|  18.4k|                        if (nano < 0)
  ------------------
  |  Branch (561:29): [True: 8.18k, False: 10.2k]
  ------------------
  562|  8.18k|                        {
  563|  8.18k|                            nano -= nsec;
  564|  8.18k|                        }
  565|  10.2k|                        else
  566|  10.2k|                        {
  567|  10.2k|                            nano += nsec;
  568|  10.2k|                        }
  569|       |
  570|  18.4k|                        text_buffer_.clear();
  571|  18.4k|                        nano.write_string(text_buffer_);
  572|  18.4k|                        more_ = visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);
  573|  18.4k|                        if (!more_) return;
  ------------------
  |  Branch (573:29): [True: 0, False: 18.4k]
  ------------------
  574|  18.4k|                    }
  575|  10.3k|                    else
  576|  10.3k|                    {
  577|  10.3k|                        bytes_buffer_.clear();
  578|  10.3k|                        if (source_reader<Source>::read(source_,bytes_buffer_,len) != static_cast<std::size_t>(len))
  ------------------
  |  Branch (578:29): [True: 124, False: 10.1k]
  ------------------
  579|    124|                        {
  580|    124|                            ec = msgpack_errc::unexpected_eof;
  581|    124|                            more_ = false;
  582|    124|                            return;
  583|    124|                        }
  584|       |
  585|  10.1k|                        more_ = visitor.byte_string_value(byte_string_view(bytes_buffer_.data(),bytes_buffer_.size()), 
  586|  10.1k|                                                          static_cast<uint8_t>(ext_type), 
  587|  10.1k|                                                          *this,
  588|  10.1k|                                                          ec);
  589|  10.1k|                    }
  590|  34.5k|                    break;
  591|  34.6k|                }
  592|       |
  593|  34.5k|                case jsoncons::msgpack::msgpack_type::array16_type: 
  ------------------
  |  Branch (593:17): [True: 711, False: 11.6M]
  ------------------
  594|  1.06k|                case jsoncons::msgpack::msgpack_type::array32_type: 
  ------------------
  |  Branch (594:17): [True: 354, False: 11.6M]
  ------------------
  595|  1.06k|                {
  596|  1.06k|                    begin_array(visitor,type,ec);
  597|  1.06k|                    break;
  598|    711|                }
  599|       |
  600|  2.12k|                case jsoncons::msgpack::msgpack_type::map16_type : 
  ------------------
  |  Branch (600:17): [True: 2.12k, False: 11.6M]
  ------------------
  601|  2.96k|                case jsoncons::msgpack::msgpack_type::map32_type : 
  ------------------
  |  Branch (601:17): [True: 840, False: 11.6M]
  ------------------
  602|  2.96k|                {
  603|  2.96k|                    begin_object(visitor, type, ec);
  604|  2.96k|                    break;
  605|  2.12k|                }
  606|       |
  607|      6|                default:
  ------------------
  |  Branch (607:17): [True: 6, False: 11.6M]
  ------------------
  608|      6|                {
  609|      6|                    ec = msgpack_errc::unknown_type;
  610|      6|                    more_ = false;
  611|      6|                    return;
  612|  2.12k|                }
  613|  11.6M|            }
  614|  11.6M|        }
  615|  34.9M|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhEENSt3__19allocatorIcEEE12begin_objectERNS_24basic_item_event_visitorIcEEhRNS4_10error_codeE:
  643|  2.45M|    {
  644|  2.45M|        if (JSONCONS_UNLIKELY(++nesting_depth_ > options_.max_nesting_depth()))
  ------------------
  |  |   45|  2.45M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 0, False: 2.45M]
  |  |  ------------------
  ------------------
  645|      0|        {
  646|      0|            ec = msgpack_errc::max_nesting_depth_exceeded;
  647|      0|            more_ = false;
  648|      0|            return;
  649|      0|        } 
  650|  2.45M|        std::size_t length = get_size(type, ec);
  651|  2.45M|        if (!more_)
  ------------------
  |  Branch (651:13): [True: 16, False: 2.45M]
  ------------------
  652|     16|        {
  653|     16|            return;
  654|     16|        }
  655|  2.45M|        state_stack_.emplace_back(parse_mode::map_key,length);
  656|  2.45M|        more_ = visitor.begin_object(length, semantic_tag::none, *this, ec);
  657|  2.45M|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhEENSt3__19allocatorIcEEE11begin_arrayERNS_24basic_item_event_visitorIcEEhRNS4_10error_codeE:
  618|  7.11M|    {
  619|  7.11M|        if (JSONCONS_UNLIKELY(++nesting_depth_ > options_.max_nesting_depth()))
  ------------------
  |  |   45|  7.11M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (45:30): [True: 0, False: 7.11M]
  |  |  ------------------
  ------------------
  620|      0|        {
  621|      0|            ec = msgpack_errc::max_nesting_depth_exceeded;
  622|      0|            more_ = false;
  623|      0|            return;
  624|      0|        } 
  625|  7.11M|        std::size_t length = get_size(type, ec);
  626|  7.11M|        if (!more_)
  ------------------
  |  Branch (626:13): [True: 16, False: 7.11M]
  ------------------
  627|     16|        {
  628|     16|            return;
  629|     16|        }
  630|  7.11M|        state_stack_.emplace_back(parse_mode::array,length);
  631|  7.11M|        more_ = visitor.begin_array(length, semantic_tag::none, *this, ec);
  632|  7.11M|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhEENSt3__19allocatorIcEEE8get_sizeEhRNS4_10error_codeE:
  667|  9.60M|    {
  668|  9.60M|        switch (type)
  669|  9.60M|        {
  670|    526|            case jsoncons::msgpack::msgpack_type::str8_type: 
  ------------------
  |  Branch (670:13): [True: 526, False: 9.60M]
  ------------------
  671|  4.99k|            case jsoncons::msgpack::msgpack_type::bin8_type: 
  ------------------
  |  Branch (671:13): [True: 4.46k, False: 9.60M]
  ------------------
  672|  25.9k|            case jsoncons::msgpack::msgpack_type::ext8_type: 
  ------------------
  |  Branch (672:13): [True: 20.9k, False: 9.58M]
  ------------------
  673|  25.9k|            {
  674|  25.9k|                uint8_t buf[sizeof(int8_t)];
  675|  25.9k|                if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (675:21): [True: 25, False: 25.8k]
  ------------------
  676|     25|                {
  677|     25|                    ec = msgpack_errc::unexpected_eof;
  678|     25|                    more_ = false;
  679|     25|                    return 0;
  680|     25|                }
  681|  25.8k|                uint8_t len = binary::big_to_native<uint8_t>(buf, sizeof(buf));
  682|  25.8k|                return static_cast<std::size_t>(len);
  683|  25.9k|            }
  684|       |
  685|    304|            case jsoncons::msgpack::msgpack_type::str16_type: 
  ------------------
  |  Branch (685:13): [True: 304, False: 9.60M]
  ------------------
  686|    856|            case jsoncons::msgpack::msgpack_type::bin16_type: 
  ------------------
  |  Branch (686:13): [True: 552, False: 9.60M]
  ------------------
  687|  1.09k|            case jsoncons::msgpack::msgpack_type::ext16_type: 
  ------------------
  |  Branch (687:13): [True: 243, False: 9.60M]
  ------------------
  688|  1.81k|            case jsoncons::msgpack::msgpack_type::array16_type: 
  ------------------
  |  Branch (688:13): [True: 711, False: 9.60M]
  ------------------
  689|  3.93k|            case jsoncons::msgpack::msgpack_type::map16_type:
  ------------------
  |  Branch (689:13): [True: 2.12k, False: 9.60M]
  ------------------
  690|  3.93k|            {
  691|  3.93k|                uint8_t buf[sizeof(int16_t)];
  692|  3.93k|                if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t))
  ------------------
  |  Branch (692:21): [True: 41, False: 3.89k]
  ------------------
  693|     41|                {
  694|     41|                    ec = msgpack_errc::unexpected_eof;
  695|     41|                    more_ = false;
  696|     41|                    return 0;
  697|     41|                }
  698|  3.89k|                uint16_t len = binary::big_to_native<uint16_t>(buf, sizeof(buf));
  699|  3.89k|                return static_cast<std::size_t>(len);
  700|  3.93k|            }
  701|       |
  702|    666|            case jsoncons::msgpack::msgpack_type::str32_type: 
  ------------------
  |  Branch (702:13): [True: 666, False: 9.60M]
  ------------------
  703|    927|            case jsoncons::msgpack::msgpack_type::bin32_type: 
  ------------------
  |  Branch (703:13): [True: 261, False: 9.60M]
  ------------------
  704|  1.18k|            case jsoncons::msgpack::msgpack_type::ext32_type: 
  ------------------
  |  Branch (704:13): [True: 257, False: 9.60M]
  ------------------
  705|  1.53k|            case jsoncons::msgpack::msgpack_type::array32_type: 
  ------------------
  |  Branch (705:13): [True: 354, False: 9.60M]
  ------------------
  706|  2.37k|            case jsoncons::msgpack::msgpack_type::map32_type : 
  ------------------
  |  Branch (706:13): [True: 840, False: 9.60M]
  ------------------
  707|  2.37k|            {
  708|  2.37k|                uint8_t buf[sizeof(int32_t)];
  709|  2.37k|                if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t))
  ------------------
  |  Branch (709:21): [True: 42, False: 2.33k]
  ------------------
  710|     42|                {
  711|     42|                    ec = msgpack_errc::unexpected_eof;
  712|     42|                    more_ = false;
  713|     42|                    return 0;
  714|     42|                }
  715|  2.33k|                uint32_t len = binary::big_to_native<uint32_t>(buf, sizeof(buf));
  716|  2.33k|                return static_cast<std::size_t>(len);
  717|  2.37k|            }
  718|  5.75k|            case jsoncons::msgpack::msgpack_type::fixext1_type: 
  ------------------
  |  Branch (718:13): [True: 5.75k, False: 9.60M]
  ------------------
  719|  5.75k|                return 1;
  720|    514|            case jsoncons::msgpack::msgpack_type::fixext2_type: 
  ------------------
  |  Branch (720:13): [True: 514, False: 9.60M]
  ------------------
  721|    514|                return 2;
  722|    860|            case jsoncons::msgpack::msgpack_type::fixext4_type: 
  ------------------
  |  Branch (722:13): [True: 860, False: 9.60M]
  ------------------
  723|    860|                return 4;
  724|  5.96k|            case jsoncons::msgpack::msgpack_type::fixext8_type: 
  ------------------
  |  Branch (724:13): [True: 5.96k, False: 9.60M]
  ------------------
  725|  5.96k|                return 8;
  726|    232|            case jsoncons::msgpack::msgpack_type::fixext16_type: 
  ------------------
  |  Branch (726:13): [True: 232, False: 9.60M]
  ------------------
  727|    232|                return 16;
  728|  9.56M|            default:
  ------------------
  |  Branch (728:13): [True: 9.56M, False: 45.5k]
  ------------------
  729|  9.56M|                if ((type > 0x8f && type <= 0x9f) // fixarray
  ------------------
  |  Branch (729:22): [True: 7.11M, False: 2.44M]
  |  Branch (729:37): [True: 7.11M, False: 0]
  ------------------
  730|  9.56M|                    || (type > 0x7f && type <= 0x8f) // fixmap
  ------------------
  |  Branch (730:25): [True: 2.44M, False: 0]
  |  Branch (730:40): [True: 2.44M, False: 0]
  ------------------
  731|  9.56M|                   )
  732|  9.56M|                {
  733|  9.56M|                    return type & 0x0f;
  734|  9.56M|                }
  735|      0|                else
  736|      0|                {
  737|      0|                    ec = msgpack_errc::unknown_type;
  738|      0|                    more_ = false;
  739|      0|                    return 0;
  740|      0|                }
  741|      0|                break;
  742|  9.60M|        }
  743|  9.60M|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhEENSt3__19allocatorIcEEE9end_arrayERNS_24basic_item_event_visitorIcEERNS4_10error_codeE:
  635|   519k|    {
  636|   519k|        --nesting_depth_;
  637|       |
  638|   519k|        more_ = visitor.end_array(*this, ec);
  639|   519k|        state_stack_.pop_back();
  640|   519k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhEENSt3__19allocatorIcEEE10end_objectERNS_24basic_item_event_visitorIcEERNS4_10error_codeE:
  660|   141k|    {
  661|   141k|        --nesting_depth_;
  662|   141k|        more_ = visitor.end_object(*this, ec);
  663|   141k|        state_stack_.pop_back();
  664|   141k|    }

_ZN8jsoncons7msgpack20basic_msgpack_readerINS_13stream_sourceIhEENSt3__19allocatorIcEEEC2IRNS4_19basic_istringstreamIcNS4_11char_traitsIcEES6_EEEEOT_RNS_18basic_json_visitorIcEERKNS0_22msgpack_decode_optionsERKS6_:
   51|  4.49k|    {
   52|  4.49k|    }
_ZN8jsoncons7msgpack20basic_msgpack_readerINS_13stream_sourceIhEENSt3__19allocatorIcEEE4readERNS4_10error_codeE:
   85|  4.49k|    {
   86|  4.49k|        parser_.reset();
   87|  4.49k|        parser_.parse(visitor_, ec);
   88|  4.49k|        if (ec)
  ------------------
  |  Branch (88:13): [True: 3.64k, False: 851]
  ------------------
   89|  3.64k|        {
   90|  3.64k|            return;
   91|  3.64k|        }
   92|  4.49k|    }