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

_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1008|   195k|        {
 1009|   195k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1009:17): [True: 37.8k, False: 157k]
  ------------------
 1010|  37.8k|            {
 1011|  37.8k|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1011:21): [True: 34.1k, False: 3.73k]
  |  Branch (1011:86): [True: 31.0k, False: 3.10k]
  ------------------
 1012|  31.0k|                {
 1013|  31.0k|                    key_buffer_.push_back(',');
 1014|  31.0k|                }
 1015|  37.8k|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
 1016|  37.8k|                key_buffer_.push_back('[');
 1017|  37.8k|            }
 1018|   157k|            else
 1019|   157k|            {
 1020|   157k|                switch (level_stack_.back().target_kind())
 1021|   157k|                {
 1022|   143k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1022:21): [True: 143k, False: 13.6k]
  ------------------
 1023|   143k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1023:29): [True: 110k, False: 33.0k]
  |  Branch (1023:65): [True: 30.5k, False: 80.0k]
  ------------------
 1024|  30.5k|                        {
 1025|  30.5k|                            key_buffer_.push_back(',');
 1026|  30.5k|                        }
 1027|   143k|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
 1028|   143k|                        key_buffer_.push_back('[');
 1029|   143k|                        break;
 1030|  13.6k|                    default:
  ------------------
  |  Branch (1030:21): [True: 13.6k, False: 143k]
  ------------------
 1031|  13.6k|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::array);
 1032|  13.6k|                        destination_->begin_array(length, tag, context, ec);
 1033|  13.6k|                        break;
 1034|   157k|                }
 1035|   157k|            }
 1036|   195k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   195k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1037|   195k|        }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure6is_keyEv:
  815|  95.7M|            {
  816|  95.7M|                return even_odd_ == 0;
  817|  95.7M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure11target_kindEv:
  825|  54.6M|            {
  826|  54.6M|                return target_kind_;
  827|  54.6M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure5countEv:
  830|  22.7M|            {
  831|  22.7M|                return count_;
  832|  22.7M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structureC2ENS4_16json_target_kindENS4_19json_structure_kindE:
  798|   411k|                : target_kind_(state), structure_kind_(type), even_odd_(type == json_structure_kind::object ? 0 : 1)
  ------------------
  |  Branch (798:73): [True: 212k, False: 199k]
  ------------------
  799|   411k|            {
  800|   411k|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure9is_objectEv:
  820|  55.9M|            {
  821|  55.9M|                return structure_kind_ == json_structure_kind::object;
  822|  55.9M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE15visit_end_arrayERKNS_11ser_contextERNS1_10error_codeE:
 1040|   172k|        {
 1041|   172k|            switch (level_stack_.back().target_kind())
 1042|   172k|            {
 1043|   168k|                case json_target_kind::buffer:
  ------------------
  |  Branch (1043:17): [True: 168k, False: 4.62k]
  ------------------
 1044|   168k|                    key_buffer_.push_back(']');
 1045|   168k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   54|   168k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 168k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1046|   168k|                    level_stack_.pop_back();
 1047|   168k|                    if (level_stack_.back().target_kind() == json_target_kind::destination)
  ------------------
  |  Branch (1047:25): [True: 3.08k, False: 164k]
  ------------------
 1048|  3.08k|                    {
 1049|  3.08k|                        destination_->key(key_buffer_, context, ec);
 1050|  3.08k|                        key_buffer_.clear();
 1051|  3.08k|                    }
 1052|   164k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (1052:30): [True: 32.4k, False: 132k]
  ------------------
 1053|  32.4k|                    {
 1054|  32.4k|                        key_buffer_.push_back(':');
 1055|  32.4k|                    }
 1056|   168k|                    level_stack_.back().advance();
 1057|   168k|                    break;
 1058|  4.62k|                default:
  ------------------
  |  Branch (1058:17): [True: 4.62k, False: 168k]
  ------------------
 1059|  4.62k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   54|  4.62k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 4.62k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1060|  4.62k|                    level_stack_.pop_back();
 1061|  4.62k|                    level_stack_.back().advance();
 1062|  4.62k|                    destination_->end_array(context, ec);
 1063|  4.62k|                    break;
 1064|   172k|            }
 1065|   172k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   172k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1066|   172k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure7advanceEv:
  803|  33.2M|            {
  804|  33.2M|                if (!is_key())
  ------------------
  |  Branch (804:21): [True: 23.7M, False: 9.46M]
  ------------------
  805|  23.7M|                {
  806|  23.7M|                    ++count_;
  807|  23.7M|                }
  808|  33.2M|                if (is_object())
  ------------------
  |  Branch (808:21): [True: 18.9M, False: 14.3M]
  ------------------
  809|  18.9M|                {
  810|  18.9M|                    even_odd_ = !even_odd_;
  811|  18.9M|                }
  812|  33.2M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1233|  8.17M|        {
 1234|  8.17M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1234:17): [True: 2.65M, False: 5.51M]
  |  Branch (1234:49): [True: 4.88M, False: 637k]
  ------------------
 1235|  7.54M|            {
 1236|  7.54M|                key_.clear();
 1237|  7.54M|                jsoncons::from_integer(value,key_);
 1238|  7.54M|            }
 1239|       |
 1240|  8.17M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1240:17): [True: 2.65M, False: 5.51M]
  ------------------
 1241|  2.65M|            {
 1242|  2.65M|                switch (level_stack_.back().target_kind())
 1243|  2.65M|                {
 1244|  2.57M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1244:21): [True: 2.57M, False: 89.2k]
  ------------------
 1245|  2.57M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1245:29): [True: 2.54M, False: 26.7k]
  ------------------
 1246|  2.54M|                        {
 1247|  2.54M|                            key_buffer_.push_back(',');
 1248|  2.54M|                        }
 1249|  2.57M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1250|  2.57M|                        key_buffer_.push_back(':');
 1251|  2.57M|                        break;
 1252|  89.2k|                    default:
  ------------------
  |  Branch (1252:21): [True: 89.2k, False: 2.57M]
  ------------------
 1253|  89.2k|                        destination_->key(key_, context, ec);
 1254|  89.2k|                        break;
 1255|  2.65M|                }
 1256|  2.65M|            }
 1257|  5.51M|            else
 1258|  5.51M|            {
 1259|  5.51M|                switch (level_stack_.back().target_kind())
 1260|  5.51M|                {
 1261|  4.88M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1261:21): [True: 4.88M, False: 637k]
  ------------------
 1262|  4.88M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1262:29): [True: 2.30M, False: 2.57M]
  |  Branch (1262:65): [True: 2.29M, False: 5.90k]
  ------------------
 1263|  2.29M|                        {
 1264|  2.29M|                            key_buffer_.push_back(',');
 1265|  2.29M|                        }
 1266|  4.88M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1267|  4.88M|                        break;
 1268|   637k|                    default:
  ------------------
  |  Branch (1268:21): [True: 637k, False: 4.88M]
  ------------------
 1269|   637k|                        destination_->uint64_value(value, tag, context, ec);
 1270|   637k|                        break;
 1271|  5.51M|                }
 1272|  5.51M|            }
 1273|       |
 1274|  8.17M|            level_stack_.back().advance();
 1275|  8.17M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  8.17M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1276|  8.17M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1279|  4.85M|        {
 1280|  4.85M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1280:17): [True: 1.28M, False: 3.57M]
  |  Branch (1280:49): [True: 3.55M, False: 12.4k]
  ------------------
 1281|  4.84M|            {
 1282|  4.84M|                key_.clear();
 1283|  4.84M|                jsoncons::from_integer(value,key_);
 1284|  4.84M|            }
 1285|       |
 1286|  4.85M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1286:17): [True: 1.28M, False: 3.57M]
  ------------------
 1287|  1.28M|            {
 1288|  1.28M|                switch (level_stack_.back().target_kind())
 1289|  1.28M|                {
 1290|  1.27M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1290:21): [True: 1.27M, False: 6.67k]
  ------------------
 1291|  1.27M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1291:29): [True: 1.27M, False: 5.64k]
  ------------------
 1292|  1.27M|                        {
 1293|  1.27M|                            key_buffer_.push_back(',');
 1294|  1.27M|                        }
 1295|  1.27M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1296|  1.27M|                        key_buffer_.push_back(':');
 1297|  1.27M|                        break;
 1298|  6.67k|                    default:
  ------------------
  |  Branch (1298:21): [True: 6.67k, False: 1.27M]
  ------------------
 1299|  6.67k|                        destination_->key(key_, context, ec);
 1300|  6.67k|                        break;
 1301|  1.28M|                }
 1302|  1.28M|            }
 1303|  3.57M|            else
 1304|  3.57M|            {
 1305|  3.57M|                switch (level_stack_.back().target_kind())
 1306|  3.57M|                {
 1307|  3.55M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1307:21): [True: 3.55M, False: 12.4k]
  ------------------
 1308|  3.55M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1308:29): [True: 2.26M, False: 1.29M]
  |  Branch (1308:65): [True: 2.25M, False: 4.80k]
  ------------------
 1309|  2.25M|                        {
 1310|  2.25M|                            key_buffer_.push_back(',');
 1311|  2.25M|                        }
 1312|  3.55M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1313|  3.55M|                        break;
 1314|  12.4k|                    default:
  ------------------
  |  Branch (1314:21): [True: 12.4k, False: 3.55M]
  ------------------
 1315|  12.4k|                        destination_->int64_value(value, tag, context, ec);
 1316|  12.4k|                        break;
 1317|  3.57M|                }
 1318|  3.57M|            }
 1319|       |
 1320|  4.85M|            level_stack_.back().advance();
 1321|  4.85M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  4.85M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1322|  4.85M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1374|  82.9k|        {
 1375|  82.9k|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1375:17): [True: 33.7k, False: 49.2k]
  |  Branch (1375:49): [True: 47.1k, False: 2.09k]
  ------------------
 1376|  80.8k|            {
 1377|  80.8k|                key_.clear();
 1378|  80.8k|                string_sink<string_type> sink(key_);
 1379|  80.8k|                jsoncons::write_double f{float_chars_format::general,0};
 1380|  80.8k|                f(value, sink);
 1381|  80.8k|            }
 1382|       |
 1383|  82.9k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1383:17): [True: 33.7k, False: 49.2k]
  ------------------
 1384|  33.7k|            {
 1385|  33.7k|                switch (level_stack_.back().target_kind())
 1386|  33.7k|                {
 1387|  30.9k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1387:21): [True: 30.9k, False: 2.80k]
  ------------------
 1388|  30.9k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1388:29): [True: 21.7k, False: 9.15k]
  ------------------
 1389|  21.7k|                        {
 1390|  21.7k|                            key_buffer_.push_back(',');
 1391|  21.7k|                        }
 1392|  30.9k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1393|  30.9k|                        key_buffer_.push_back(':');
 1394|  30.9k|                        break;
 1395|  2.80k|                    default:
  ------------------
  |  Branch (1395:21): [True: 2.80k, False: 30.9k]
  ------------------
 1396|  2.80k|                        destination_->key(key_, context, ec);
 1397|  2.80k|                        break;
 1398|  33.7k|                }
 1399|  33.7k|            }
 1400|  49.2k|            else
 1401|  49.2k|            {
 1402|  49.2k|                switch (level_stack_.back().target_kind())
 1403|  49.2k|                {
 1404|  47.1k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1404:21): [True: 47.1k, False: 2.09k]
  ------------------
 1405|  47.1k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1405:29): [True: 23.7k, False: 23.3k]
  |  Branch (1405:65): [True: 20.0k, False: 3.70k]
  ------------------
 1406|  20.0k|                        {
 1407|  20.0k|                            key_buffer_.push_back(',');
 1408|  20.0k|                        }
 1409|  47.1k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1410|  47.1k|                        break;
 1411|  2.09k|                    default:
  ------------------
  |  Branch (1411:21): [True: 2.09k, False: 47.1k]
  ------------------
 1412|  2.09k|                        destination_->double_value(value, tag, context, ec);
 1413|  2.09k|                        break;
 1414|  49.2k|                }
 1415|  49.2k|            }
 1416|       |
 1417|  82.9k|            level_stack_.back().advance();
 1418|  82.9k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  82.9k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1419|  82.9k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE11visit_flushEv:
  881|    958|        {
  882|    958|            destination_->flush();
  883|    958|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  914|   212k|        {
  915|   212k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (915:17): [True: 110k, False: 101k]
  ------------------
  916|   110k|            {
  917|   110k|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (917:21): [True: 106k, False: 3.81k]
  |  Branch (917:86): [True: 29.5k, False: 77.2k]
  ------------------
  918|  29.5k|                {
  919|  29.5k|                    key_buffer_.push_back(',');
  920|  29.5k|                }
  921|   110k|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  922|   110k|                key_buffer_.push_back('{');
  923|   110k|            }
  924|   101k|            else
  925|   101k|            {
  926|   101k|                switch (level_stack_.back().target_kind())
  927|   101k|                {
  928|  92.2k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (928:21): [True: 92.2k, False: 9.16k]
  ------------------
  929|  92.2k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (929:29): [True: 45.6k, False: 46.6k]
  |  Branch (929:65): [True: 43.2k, False: 2.36k]
  ------------------
  930|  43.2k|                        {
  931|  43.2k|                            key_buffer_.push_back(',');
  932|  43.2k|                        }
  933|  92.2k|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  934|  92.2k|                        key_buffer_.push_back('{');
  935|  92.2k|                        break;
  936|  9.16k|                    default:
  ------------------
  |  Branch (936:21): [True: 9.16k, False: 92.2k]
  ------------------
  937|  9.16k|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::object);
  938|  9.16k|                        destination_->begin_object(length, tag, context, ec);
  939|  9.16k|                        break;
  940|   101k|                }
  941|   101k|            }
  942|   212k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   212k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  943|   212k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE16visit_end_objectERKNS_11ser_contextERNS1_10error_codeE:
  946|   182k|        {
  947|   182k|            switch (level_stack_.back().target_kind())
  948|   182k|            {
  949|   178k|                case json_target_kind::buffer:
  ------------------
  |  Branch (949:17): [True: 178k, False: 3.65k]
  ------------------
  950|   178k|                    key_buffer_.push_back('}');
  951|   178k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   54|   178k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 178k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  952|   178k|                    level_stack_.pop_back();
  953|       |                    
  954|   178k|                    if (level_stack_.back().target_kind() == json_target_kind::destination)
  ------------------
  |  Branch (954:25): [True: 2.86k, False: 175k]
  ------------------
  955|  2.86k|                    {
  956|  2.86k|                        destination_->key(key_buffer_,context, ec);
  957|  2.86k|                        key_buffer_.clear();
  958|  2.86k|                    }
  959|   175k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (959:30): [True: 92.8k, False: 83.0k]
  ------------------
  960|  92.8k|                    {
  961|  92.8k|                        key_buffer_.push_back(':');
  962|  92.8k|                    }
  963|   178k|                    level_stack_.back().advance();
  964|   178k|                    break;
  965|  3.65k|                default:
  ------------------
  |  Branch (965:17): [True: 3.65k, False: 178k]
  ------------------
  966|  3.65k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   54|  3.65k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 3.65k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  967|  3.65k|                    level_stack_.pop_back();
  968|  3.65k|                    level_stack_.back().advance();
  969|  3.65k|                    destination_->end_object(context, ec);
  970|  3.65k|                    break;
  971|   182k|            }
  972|   182k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   182k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  973|   182k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1475|   140k|        {
 1476|   140k|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1476:17): [True: 43.9k, False: 96.3k]
  |  Branch (1476:49): [True: 94.9k, False: 1.49k]
  ------------------
 1477|   138k|            {
 1478|   138k|                key_.clear(); 
 1479|   138k|                key_.insert(key_.begin(), json_literals<char_type>::null_literal.begin(), json_literals<char_type>::null_literal.end());
 1480|   138k|            }
 1481|       |
 1482|   140k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1482:17): [True: 43.9k, False: 96.3k]
  ------------------
 1483|  43.9k|            {
 1484|  43.9k|                switch (level_stack_.back().target_kind())
 1485|  43.9k|                {
 1486|  42.9k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1486:21): [True: 42.9k, False: 996]
  ------------------
 1487|  42.9k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1487:29): [True: 39.0k, False: 3.93k]
  ------------------
 1488|  39.0k|                        {
 1489|  39.0k|                            key_buffer_.push_back(',');
 1490|  39.0k|                        }
 1491|  42.9k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1492|  42.9k|                        key_buffer_.push_back(':');
 1493|  42.9k|                        break;
 1494|    996|                    default:
  ------------------
  |  Branch (1494:21): [True: 996, False: 42.9k]
  ------------------
 1495|    996|                        destination_->key(key_, context, ec);
 1496|    996|                        break;
 1497|  43.9k|                }
 1498|  43.9k|            }
 1499|  96.3k|            else
 1500|  96.3k|            {
 1501|  96.3k|                switch (level_stack_.back().target_kind())
 1502|  96.3k|                {
 1503|  94.9k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1503:21): [True: 94.9k, False: 1.49k]
  ------------------
 1504|  94.9k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1504:29): [True: 54.8k, False: 40.0k]
  |  Branch (1504:65): [True: 53.9k, False: 879]
  ------------------
 1505|  53.9k|                        {
 1506|  53.9k|                            key_buffer_.push_back(',');
 1507|  53.9k|                        }
 1508|  94.9k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1509|  94.9k|                        break;
 1510|  1.49k|                    default:
  ------------------
  |  Branch (1510:21): [True: 1.49k, False: 94.9k]
  ------------------
 1511|  1.49k|                        destination_->null_value(tag, context, ec);
 1512|  1.49k|                        break;
 1513|  96.3k|                }
 1514|  96.3k|            }
 1515|       |
 1516|   140k|            level_stack_.back().advance();
 1517|   140k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   140k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1518|   140k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1422|  14.2M|        {
 1423|  14.2M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1423:17): [True: 4.11M, False: 10.1M]
  |  Branch (1423:49): [True: 10.1M, False: 30.0k]
  ------------------
 1424|  14.2M|            {
 1425|  14.2M|                key_.clear(); 
 1426|  14.2M|                if (value)
  ------------------
  |  Branch (1426:21): [True: 10.8M, False: 3.40M]
  ------------------
 1427|  10.8M|                {
 1428|  10.8M|                    key_.insert(key_.begin(), json_literals<char_type>::true_literal.begin(), json_literals<char_type>::true_literal.end());
 1429|  10.8M|                }
 1430|  3.40M|                else
 1431|  3.40M|                {
 1432|  3.40M|                    key_.insert(key_.begin(), json_literals<char_type>::false_literal.begin(), json_literals<char_type>::false_literal.end());
 1433|  3.40M|                }
 1434|  14.2M|            }
 1435|       |
 1436|  14.2M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1436:17): [True: 4.11M, False: 10.1M]
  ------------------
 1437|  4.11M|            {
 1438|  4.11M|                switch (level_stack_.back().target_kind())
 1439|  4.11M|                {
 1440|  4.08M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1440:21): [True: 4.08M, False: 22.8k]
  ------------------
 1441|  4.08M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1441:29): [True: 4.07M, False: 8.96k]
  ------------------
 1442|  4.07M|                        {
 1443|  4.07M|                            key_buffer_.push_back(',');
 1444|  4.07M|                        }
 1445|  4.08M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1446|  4.08M|                        key_buffer_.push_back(':');
 1447|  4.08M|                        break;
 1448|  22.8k|                    default:
  ------------------
  |  Branch (1448:21): [True: 22.8k, False: 4.08M]
  ------------------
 1449|  22.8k|                        destination_->key(key_, context, ec);
 1450|  22.8k|                        break;
 1451|  4.11M|                }
 1452|  4.11M|            }
 1453|  10.1M|            else
 1454|  10.1M|            {
 1455|  10.1M|                switch (level_stack_.back().target_kind())
 1456|  10.1M|                {
 1457|  10.1M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1457:21): [True: 10.1M, False: 30.0k]
  ------------------
 1458|  10.1M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1458:29): [True: 6.01M, False: 4.12M]
  |  Branch (1458:65): [True: 6.01M, False: 4.98k]
  ------------------
 1459|  6.01M|                        {
 1460|  6.01M|                            key_buffer_.push_back(',');
 1461|  6.01M|                        }
 1462|  10.1M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1463|  10.1M|                        break;
 1464|  30.0k|                    default:
  ------------------
  |  Branch (1464:21): [True: 30.0k, False: 10.1M]
  ------------------
 1465|  30.0k|                        destination_->bool_value(value, tag, context, ec);
 1466|  30.0k|                        break;
 1467|  10.1M|                }
 1468|  10.1M|            }
 1469|       |
 1470|  14.2M|            level_stack_.back().advance();
 1471|  14.2M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  14.2M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1472|  14.2M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_stringERKNS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1072|  4.00M|        {
 1073|  4.00M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1073:17): [True: 1.05M, False: 2.95M]
  ------------------
 1074|  1.05M|            {
 1075|  1.05M|                switch (level_stack_.back().target_kind())
 1076|  1.05M|                {
 1077|  1.04M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1077:21): [True: 1.04M, False: 3.53k]
  ------------------
 1078|  1.04M|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1078:29): [True: 1.04M, False: 3.01k]
  ------------------
 1079|  1.04M|                        {
 1080|  1.04M|                            key_buffer_.push_back(',');
 1081|  1.04M|                        }
 1082|  1.04M|                        key_buffer_.push_back('\"');
 1083|  1.04M|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1084|  1.04M|                        key_buffer_.push_back('\"');
 1085|  1.04M|                        key_buffer_.push_back(':');
 1086|  1.04M|                        break;
 1087|  3.53k|                    default:
  ------------------
  |  Branch (1087:21): [True: 3.53k, False: 1.04M]
  ------------------
 1088|  3.53k|                        destination_->key(value, context, ec);
 1089|  3.53k|                        break;
 1090|  1.05M|                }
 1091|  1.05M|            }
 1092|  2.95M|            else
 1093|  2.95M|            {
 1094|  2.95M|                switch (level_stack_.back().target_kind())
 1095|  2.95M|                {
 1096|  2.94M|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1096:21): [True: 2.94M, False: 7.69k]
  ------------------
 1097|  2.94M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1097:29): [True: 1.89M, False: 1.05M]
  |  Branch (1097:65): [True: 1.89M, False: 1.32k]
  ------------------
 1098|  1.89M|                        {
 1099|  1.89M|                            key_buffer_.push_back(',');
 1100|  1.89M|                        }
 1101|  2.94M|                        key_buffer_.push_back('\"');
 1102|  2.94M|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1103|  2.94M|                        key_buffer_.push_back('\"');
 1104|  2.94M|                        break;
 1105|  7.69k|                    default:
  ------------------
  |  Branch (1105:21): [True: 7.69k, False: 2.94M]
  ------------------
 1106|  7.69k|                        destination_->string_value(value, tag, context, ec);
 1107|  7.69k|                        break;
 1108|  2.95M|                }
 1109|  2.95M|            }
 1110|       |
 1111|  4.00M|            level_stack_.back().advance();
 1112|  4.00M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  4.00M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1113|  4.00M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1119|  19.3k|        {
 1120|  19.3k|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1120:17): [True: 8.46k, False: 10.9k]
  |  Branch (1120:49): [True: 10.0k, False: 863]
  ------------------
 1121|  18.5k|            {
 1122|  18.5k|                key_.clear();
 1123|  18.5k|                switch (tag)
 1124|  18.5k|                {
 1125|      0|                    case semantic_tag::base64:
  ------------------
  |  Branch (1125:21): [True: 0, False: 18.5k]
  ------------------
 1126|      0|                        bytes_to_base64(value.begin(), value.end(), key_);
 1127|      0|                        break;
 1128|      0|                    case semantic_tag::base16:
  ------------------
  |  Branch (1128:21): [True: 0, False: 18.5k]
  ------------------
 1129|      0|                        bytes_to_base16(value.begin(), value.end(),key_);
 1130|      0|                        break;
 1131|  18.5k|                    default:
  ------------------
  |  Branch (1131:21): [True: 18.5k, False: 0]
  ------------------
 1132|  18.5k|                        bytes_to_base64url(value.begin(), value.end(),key_);
 1133|  18.5k|                        break;
 1134|  18.5k|                }
 1135|  18.5k|            }
 1136|       |
 1137|  19.3k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1137:17): [True: 8.46k, False: 10.9k]
  ------------------
 1138|  8.46k|            {
 1139|  8.46k|                switch (level_stack_.back().target_kind())
 1140|  8.46k|                {
 1141|  7.39k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1141:21): [True: 7.39k, False: 1.06k]
  ------------------
 1142|  7.39k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1142:29): [True: 4.77k, False: 2.62k]
  ------------------
 1143|  4.77k|                        {
 1144|  4.77k|                            key_buffer_.push_back(',');
 1145|  4.77k|                        }
 1146|  7.39k|                        key_buffer_.push_back('\"');
 1147|  7.39k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1148|  7.39k|                        key_buffer_.push_back('\"');
 1149|  7.39k|                        key_buffer_.push_back(':');
 1150|  7.39k|                        break;
 1151|  1.06k|                    default:
  ------------------
  |  Branch (1151:21): [True: 1.06k, False: 7.39k]
  ------------------
 1152|  1.06k|                        destination_->key(key_, context, ec);
 1153|  1.06k|                        break;
 1154|  8.46k|                }
 1155|  8.46k|            }
 1156|  10.9k|            else
 1157|  10.9k|            {
 1158|  10.9k|                switch (level_stack_.back().target_kind())
 1159|  10.9k|                {
 1160|  10.0k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1160:21): [True: 10.0k, False: 863]
  ------------------
 1161|  10.0k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1161:29): [True: 3.50k, False: 6.54k]
  |  Branch (1161:65): [True: 2.98k, False: 518]
  ------------------
 1162|  2.98k|                        {
 1163|  2.98k|                            key_buffer_.push_back(',');
 1164|  2.98k|                        }
 1165|  10.0k|                        key_buffer_.push_back('\"');
 1166|  10.0k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1167|  10.0k|                        key_buffer_.push_back('\"');
 1168|  10.0k|                        break;
 1169|    863|                    default:
  ------------------
  |  Branch (1169:21): [True: 863, False: 10.0k]
  ------------------
 1170|    863|                        destination_->byte_string_value(value, tag, context, ec);
 1171|    863|                        break;
 1172|  10.9k|                }
 1173|  10.9k|            }
 1174|       |
 1175|  19.3k|            level_stack_.back().advance();
 1176|  19.3k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  19.3k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1177|  19.3k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS1_10error_codeE:
 1183|  1.33M|        {
 1184|  1.33M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1184:17): [True: 136k, False: 1.19M]
  |  Branch (1184:49): [True: 819k, False: 377k]
  ------------------
 1185|   956k|            {
 1186|   956k|                key_.clear();
 1187|   956k|                bytes_to_base64url(value.begin(), value.end(),key_);
 1188|   956k|            }
 1189|       |
 1190|  1.33M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1190:17): [True: 136k, False: 1.19M]
  ------------------
 1191|   136k|            {
 1192|   136k|                switch (level_stack_.back().target_kind())
 1193|   136k|                {
 1194|   135k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1194:21): [True: 135k, False: 1.53k]
  ------------------
 1195|   135k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1195:29): [True: 128k, False: 6.89k]
  ------------------
 1196|   128k|                        {
 1197|   128k|                            key_buffer_.push_back(',');
 1198|   128k|                        }
 1199|   135k|                        key_buffer_.push_back('\"');
 1200|   135k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1201|   135k|                        key_buffer_.push_back('\"');
 1202|   135k|                        key_buffer_.push_back(':');
 1203|   135k|                        break;
 1204|  1.53k|                    default:
  ------------------
  |  Branch (1204:21): [True: 1.53k, False: 135k]
  ------------------
 1205|  1.53k|                        destination_->key(key_, context, ec);
 1206|  1.53k|                        break;
 1207|   136k|                }
 1208|   136k|            }
 1209|  1.19M|            else
 1210|  1.19M|            {
 1211|  1.19M|                switch (level_stack_.back().target_kind())
 1212|  1.19M|                {
 1213|   819k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1213:21): [True: 819k, False: 377k]
  ------------------
 1214|   819k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1214:29): [True: 689k, False: 129k]
  |  Branch (1214:65): [True: 688k, False: 857]
  ------------------
 1215|   688k|                        {
 1216|   688k|                            key_buffer_.push_back(',');
 1217|   688k|                        }
 1218|   819k|                        key_buffer_.push_back('\"');
 1219|   819k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1220|   819k|                        key_buffer_.push_back('\"');
 1221|   819k|                        break;
 1222|   377k|                    default:
  ------------------
  |  Branch (1222:21): [True: 377k, False: 819k]
  ------------------
 1223|   377k|                        destination_->byte_string_value(value, raw_tag, context, ec);
 1224|   377k|                        break;
 1225|  1.19M|                }
 1226|  1.19M|            }
 1227|       |
 1228|  1.33M|            level_stack_.back().advance();
 1229|  1.33M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  1.33M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1230|  1.33M|        }
_ZN8jsoncons21basic_generic_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  294|   195k|    {
  295|   195k|        visit_begin_array(length, tag, context, ec);
  296|   195k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   195k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  297|   195k|    }
_ZN8jsoncons21basic_generic_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  363|  8.17M|    {
  364|  8.17M|        visit_uint64(value, tag, context, ec);
  365|  8.17M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  8.17M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  366|  8.17M|    }
_ZN8jsoncons21basic_generic_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  300|   172k|    {
  301|   172k|        visit_end_array(context, ec);
  302|   172k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   172k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  303|   172k|    }
_ZN8jsoncons21basic_generic_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  372|  4.85M|    {
  373|  4.85M|        visit_int64(value, tag, context, ec);
  374|  4.85M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  4.85M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  375|  4.85M|    }
_ZN8jsoncons21basic_generic_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  390|  82.9k|    {
  391|  82.9k|        visit_double(value, tag, context, ec);
  392|  82.9k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  82.9k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  393|  82.9k|    }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEEC2ERNS_18basic_json_visitorIcEERKS3_:
  855|  4.82k|            : destination_(std::addressof(visitor)), 
  856|  4.82k|              key_(alloc), key_buffer_(alloc), level_stack_(alloc)
  857|  4.82k|        {
  858|  4.82k|            level_stack_.emplace_back(json_target_kind::destination,json_structure_kind::root); // root
  859|  4.82k|        }
_ZN8jsoncons21basic_generic_visitorIcEC2Ev:
   52|  4.82k|    basic_generic_visitor() = default;
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  276|   212k|    {
  277|   212k|        visit_begin_object(length, tag, context, ec);
  278|   212k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   212k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  279|   212k|    }
_ZN8jsoncons21basic_generic_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  332|  4.00M|    {
  333|  4.00M|        visit_string(value, tag, context, ec);
  334|  4.00M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  4.00M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  335|  4.00M|    }
_ZN8jsoncons21basic_generic_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  314|   140k|    {
  315|   140k|        visit_null(tag, context, ec);
  316|   140k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   140k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  317|   140k|    }
_ZN8jsoncons21basic_generic_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  323|  14.2M|    {
  324|  14.2M|        visit_bool(value, tag, context, ec);
  325|  14.2M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  14.2M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  326|  14.2M|    }
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr6nonstd18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  343|  19.3k|    {
  344|  19.3k|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  345|  19.3k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  19.3k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  346|  19.3k|    }
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr6nonstd18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  354|  1.33M|    {
  355|  1.33M|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), raw_tag, context, ec);
  356|  1.33M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  1.33M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  357|  1.33M|    }
_ZN8jsoncons21basic_generic_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  282|   182k|    {
  283|   182k|        visit_end_object(context, ec);
  284|   182k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   182k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  285|   182k|    }
_ZN8jsoncons21basic_generic_visitorIcE5flushEv:
   57|    958|    {
   58|    958|        visit_flush();
   59|    958|    }

_ZN8jsoncons26basic_default_json_visitorIcEC2Ev:
  811|  9.65k|        basic_default_json_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|  9.65k|        basic_json_visitor() = default;
_ZN8jsoncons19typed_array_visitorD2Ev:
   33|  14.4k|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  560|  13.6k|        {
  561|  13.6k|            visit_begin_array(tag, context, ec);
  562|  13.6k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  13.6k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  563|  13.6k|        }
_ZN8jsoncons26basic_default_json_visitorIcE15visit_end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  833|  4.62k|        {
  834|  4.62k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  4.62k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  835|  4.62k|        }
_ZN8jsoncons26basic_default_json_visitorIcE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  858|   637k|        {
  859|   637k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   637k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  860|   637k|        }
_ZN8jsoncons26basic_default_json_visitorIcE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  863|  12.4k|        {
  864|  12.4k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  12.4k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  865|  12.4k|        }
_ZN8jsoncons26basic_default_json_visitorIcE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  873|  2.09k|        {
  874|  2.09k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  2.09k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  875|  2.09k|        }
_ZN8jsoncons26basic_default_json_visitorIcE11visit_flushEv:
  814|    958|        {
  815|    958|        }
_ZN8jsoncons26basic_default_json_visitorIcE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  818|  9.16k|        {
  819|  9.16k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  9.16k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  820|  9.16k|        }
_ZN8jsoncons18basic_json_visitorIcE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  544|  9.16k|        {
  545|  9.16k|            visit_begin_object(tag, context, ec);
  546|  9.16k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  9.16k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  547|  9.16k|        }
_ZN8jsoncons26basic_default_json_visitorIcE16visit_end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  823|  3.65k|        {
  824|  3.65k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  3.65k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  825|  3.65k|        }
_ZN8jsoncons26basic_default_json_visitorIcE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  828|  13.6k|        {
  829|  13.6k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  13.6k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  830|  13.6k|        }
_ZN8jsoncons26basic_default_json_visitorIcE9visit_keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  838|   134k|        {
  839|   134k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   134k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  840|   134k|        }
_ZN8jsoncons26basic_default_json_visitorIcE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  843|  1.49k|        {
  844|  1.49k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  1.49k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  845|  1.49k|        }
_ZN8jsoncons26basic_default_json_visitorIcE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  878|  30.0k|        {
  879|  30.0k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  30.0k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  880|  30.0k|        }
_ZN8jsoncons26basic_default_json_visitorIcE12visit_stringERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  848|  7.69k|        {
  849|  7.69k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  7.69k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  850|  7.69k|        }
_ZN8jsoncons26basic_default_json_visitorIcE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  853|   377k|        {
  854|   377k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   377k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  855|   377k|        }
_ZN8jsoncons18basic_json_visitorIcE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNSt3__110error_codeE:
  595|   377k|        {
  596|   377k|            visit_byte_string(value, semantic_tag::none, context, ec);
  597|   377k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   377k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  598|   377k|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  345|  13.6k|        {
  346|  13.6k|            visit_begin_array(length, tag, context, ec);
  347|  13.6k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  13.6k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  348|  13.6k|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|   637k|        {
  415|   637k|            visit_uint64(value, tag, context, ec);
  416|   637k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   637k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  417|   637k|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  351|  4.62k|        {
  352|  4.62k|            visit_end_array(context, ec);
  353|  4.62k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  4.62k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  354|  4.62k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|  12.4k|        {
  424|  12.4k|            visit_int64(value, tag, context, ec);
  425|  12.4k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  12.4k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  426|  12.4k|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|  2.09k|        {
  442|  2.09k|            visit_double(value, tag, context, ec);
  443|  2.09k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  2.09k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  444|  2.09k|        }
_ZN8jsoncons18basic_json_visitorIcE3keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  357|   134k|        {
  358|   134k|            visit_key(name, context, ec);
  359|   134k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   134k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  360|   134k|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|    958|        {
  109|    958|            visit_flush();
  110|    958|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  327|  9.16k|        {
  328|  9.16k|            visit_begin_object(length, tag, context, ec);
  329|  9.16k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  9.16k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  330|  9.16k|        }
_ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  333|  3.65k|        {
  334|  3.65k|            visit_end_object(context, ec);
  335|  3.65k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  3.65k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  336|  3.65k|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  365|  1.49k|        {
  366|  1.49k|            visit_null(tag, context, ec);
  367|  1.49k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  1.49k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  368|  1.49k|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  374|  30.0k|        {
  375|  30.0k|            visit_bool(value, tag, context, ec);
  376|  30.0k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  30.0k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  377|  30.0k|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  383|  7.69k|        {
  384|  7.69k|            visit_string(value, tag, context, ec);
  385|  7.69k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  7.69k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  386|  7.69k|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr6nonstd18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  394|    863|        {
  395|    863|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  396|    863|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    863|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  397|    863|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr6nonstd18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  405|   377k|        {
  406|   377k|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), raw_tag, context, ec);
  407|   377k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   377k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  408|   377k|        }

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

_ZNK8jsoncons6nonstd4spanIKhLm18446744073709551615EE4sizeEv:
  116|  14.6M|        {
  117|  14.6M|            return size_;
  118|  14.6M|        }
_ZN8jsoncons6nonstd4spanIKhLm18446744073709551615EEC2Ev:
   58|  3.98M|        {
   59|  3.98M|        }
_ZN8jsoncons6nonstd4spanIKhLm18446744073709551615EEC2EPS2_m:
   61|  1.33M|            : data_(data), size_(size)
   62|  1.33M|        {
   63|  1.33M|        }
_ZNK8jsoncons6nonstd4spanIKhLm18446744073709551615EE4dataEv:
  111|  9.28M|        {
  112|  9.28M|            return data_;
  113|  9.28M|        }

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

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

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

_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev:
  193|  4.82k|    {
  194|  4.82k|        if (chunk_)
  ------------------
  |  Branch (194:13): [True: 4.82k, False: 0]
  ------------------
  195|  4.82k|        {
  196|  4.82k|            std::allocator_traits<char_allocator_type>::deallocate(alloc_, chunk_, chunk_size_);
  197|  4.82k|        }
  198|  4.82k|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  176|  4.82k|        : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  177|  4.82k|          chunk_size_(default_max_chunk_size)
  178|  4.82k|    {
  179|  4.82k|        chunk_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, chunk_size_);
  180|  4.82k|        data_end_ = chunk_;
  181|  4.82k|    }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   57|  4.82k|      : std::basic_istream<CharT>(&nb_)
   58|  4.82k|    {
   59|  4.82k|    }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   43|  4.82k|        null_buffer() = default;
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE8is_errorEv:
  276|  33.3M|    {
  277|  33.3M|        return stream_ptr_->bad();  
  278|  33.3M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm:
  377|  35.4M|    {
  378|  35.4M|        std::size_t len = 0;
  379|  35.4M|        if (remaining_ > 0)
  ------------------
  |  Branch (379:13): [True: 35.3M, False: 9.80k]
  ------------------
  380|  35.3M|        {
  381|  35.3M|            len = (std::min)(remaining_, length);
  382|  35.3M|            std::memcpy(p, data_end_, len*sizeof(value_type));
  383|  35.3M|            data_end_ += len;
  384|  35.3M|            remaining_ -= len;
  385|  35.3M|            position_ += len;
  386|  35.3M|        }
  387|  35.4M|        if (length - len == 0)
  ------------------
  |  Branch (387:13): [True: 35.3M, False: 11.5k]
  ------------------
  388|  35.3M|        {
  389|  35.3M|            return len;
  390|  35.3M|        }
  391|  11.5k|        else if (length - len < chunk_size_)
  ------------------
  |  Branch (391:18): [True: 11.5k, False: 0]
  ------------------
  392|  11.5k|        {
  393|  11.5k|            data_end_ = chunk_;
  394|  11.5k|            remaining_ = fill_buffer(chunk_, chunk_size_);
  395|  11.5k|            if (remaining_ > 0)
  ------------------
  |  Branch (395:17): [True: 8.18k, False: 3.35k]
  ------------------
  396|  8.18k|            {
  397|  8.18k|                std::size_t len2 = (std::min)(remaining_, length-len);
  398|  8.18k|                std::memcpy(p+len, data_end_, len2*sizeof(value_type));
  399|  8.18k|                data_end_ += len2;
  400|  8.18k|                remaining_ -= len2;
  401|  8.18k|                position_ += len2;
  402|  8.18k|                len += len2;
  403|  8.18k|            }
  404|  11.5k|            return len;
  405|  11.5k|        }
  406|      0|        else
  407|      0|        {
  408|      0|            if (stream_ptr_->eof())
  ------------------
  |  Branch (408:17): [True: 0, False: 0]
  ------------------
  409|      0|            {
  410|      0|                remaining_ = 0;
  411|      0|                return 0;
  412|      0|            }
  413|      0|            JSONCONS_TRY
  ------------------
  |  |   37|      0|    #define JSONCONS_TRY try
  ------------------
  414|      0|            {
  415|      0|                std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(p+len), length-len);
  416|      0|                std::size_t len2 = static_cast<std::size_t>(count);
  417|      0|                if (len2 < length-len)
  ------------------
  |  Branch (417:21): [True: 0, False: 0]
  ------------------
  418|      0|                {
  419|      0|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  420|      0|                }
  421|      0|                len += len2;
  422|      0|                position_ += len2;
  423|      0|                return len;
  424|      0|            }
  425|      0|            JSONCONS_CATCH(const std::exception&)     
  426|      0|            {
  427|      0|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  428|      0|                return 0;
  429|      0|            }
  430|      0|        }
  431|  35.4M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEPhm:
  442|  12.2k|    {
  443|  12.2k|        if (stream_ptr_->eof())
  ------------------
  |  Branch (443:13): [True: 3.43k, False: 8.76k]
  ------------------
  444|  3.43k|        {
  445|  3.43k|            return 0;
  446|  3.43k|        }
  447|       |
  448|  8.76k|        JSONCONS_TRY
  ------------------
  |  |   37|  8.76k|    #define JSONCONS_TRY try
  ------------------
  449|  8.76k|        {
  450|  8.76k|            std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(chunk), chunk_size);
  451|  8.76k|            std::size_t length = static_cast<std::size_t>(count);
  452|       |
  453|  8.76k|            if (length < chunk_size)
  ------------------
  |  Branch (453:17): [True: 4.82k, False: 3.94k]
  ------------------
  454|  4.82k|            {
  455|  4.82k|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  456|  4.82k|            }
  457|  8.76k|            return length;
  458|  8.76k|        }
  459|  8.76k|        JSONCONS_CATCH(const std::exception&)     
  460|  8.76k|        {
  461|      0|            stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  462|      0|            return 0;
  463|      0|        }
  464|  8.76k|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_6vectorIhS3_EEEENS_6nonstd4spanIKhLm18446744073709551615EEEmOT_:
  352|  5.32M|    {
  353|  5.32M|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   79|  5.32M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3.98M, False: 1.33M]
  |  |  ------------------
  ------------------
  354|  3.98M|        {
  355|  3.98M|            return span<const value_type>{};
  356|  3.98M|        }
  357|  1.33M|        if (remaining_ == 0 && length <= chunk_size_)
  ------------------
  |  Branch (357:13): [True: 349, False: 1.33M]
  |  Branch (357:32): [True: 159, False: 190]
  ------------------
  358|    159|        {
  359|    159|            remaining_ = fill_buffer(chunk_, chunk_size_);
  360|    159|            data_end_ = chunk_;
  361|    159|        }
  362|  1.33M|        if (length > remaining_)
  ------------------
  |  Branch (362:13): [True: 1.08k, False: 1.33M]
  ------------------
  363|  1.08k|        {
  364|  1.08k|            buffer.clear();
  365|  1.08k|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  366|  1.08k|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  367|  1.08k|        }
  368|       |
  369|  1.33M|        const value_type* data = data_end_;
  370|  1.33M|        data_end_ += length;
  371|  1.33M|        remaining_ -= length;
  372|  1.33M|        position_ += length;
  373|  1.33M|        return span<const value_type>(data, length);
  374|  1.33M|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_6vectorIhS4_EEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr6nonstd7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSD_m:
  746|  1.08k|    {
  747|  1.08k|        std::size_t unread = length;
  748|       |
  749|  3.37k|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (749:16): [True: 2.77k, False: 601]
  |  Branch (749:30): [True: 2.29k, False: 480]
  ------------------
  750|  2.29k|        {
  751|  2.29k|            if (source.remaining() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (751:17): [True: 496, False: 1.79k]
  |  Branch (751:44): [True: 494, False: 2]
  ------------------
  752|    494|            {
  753|    494|                std::size_t n = source.chunk_size();
  754|    494|                std::size_t offset = buffer.size();
  755|    494|                buffer.resize(offset+n);
  756|    494|                std::size_t actual = source.read_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  757|    494|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|    494|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 77, False: 417]
  |  |  ------------------
  ------------------
  758|     77|                {
  759|     77|                    buffer.resize(offset+actual);
  760|     77|                }
  761|    494|                unread -= actual;
  762|    494|            }
  763|  1.79k|            else
  764|  1.79k|            {
  765|  1.79k|                std::size_t n = (std::min)(source.chunk_size(), unread);
  766|  1.79k|                std::size_t offset = buffer.size();
  767|  1.79k|                buffer.resize(offset+n);
  768|  1.79k|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  769|  1.79k|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|  1.79k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 206, False: 1.59k]
  |  |  ------------------
  ------------------
  770|    206|                {
  771|    206|                    buffer.resize(offset + actual);
  772|    206|                }
  773|  1.79k|                unread -= actual;
  774|  1.79k|            }
  775|  2.29k|        }
  776|  1.08k|        return length - unread;
  777|  1.08k|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv:
  271|  2.77k|    {
  272|  2.77k|        return remaining_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:16): [True: 976, False: 1.79k]
  |  Branch (272:35): [True: 480, False: 496]
  ------------------
  273|  2.77k|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9remainingEv:
  346|  2.29k|    {
  347|  2.29k|        return remaining_;
  348|  2.29k|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE10chunk_sizeEv:
  261|  2.78k|    {
  262|  2.78k|        return chunk_size_;
  263|  2.78k|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11read_bufferEPhm:
  435|    494|    {
  436|    494|        auto len = fill_buffer(chunk, chunk_size);
  437|    494|        position_ += len;
  438|    494|        return len;
  439|    494|    }

_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ImEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  672|  96.1k|        : storage_(n, alloc)
  673|  96.1k|    {
  674|  96.1k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ImEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  363|  96.1k|        : word_allocator_type(alloc)
  364|  96.1k|    {
  365|  96.1k|        ::new (&inlined_) inlined_storage(n);
  366|  96.1k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ImEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  141|  96.1k|            : is_allocated_(false),
  142|  96.1k|            is_negative_(false),
  143|  96.1k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (143:19): [True: 38.1k, False: 58.0k]
  ------------------
  144|  96.1k|        {
  145|  96.1k|            values_[0] = n;
  146|  96.1k|            values_[1] = 0;
  147|  96.1k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLImEENS1_9enable_ifIXsr6nonstd19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
 1030|  38.8k|    {
 1031|  38.8k|        auto words = get_words();
 1032|  38.8k|        size_type len = words.size();
 1033|  38.8k|        if (len == 0 || m == 0)
  ------------------
  |  Branch (1033:13): [True: 3.81k, False: 35.0k]
  |  Branch (1033:25): [True: 0, False: 35.0k]
  ------------------
 1034|  3.81k|        {
 1035|  3.81k|            resize(0);
 1036|  3.81k|            return *this;
 1037|  3.81k|        }
 1038|       |
 1039|  35.0k|        dword_type carry = 0;
 1040|  35.0k|        size_t i = 0;
 1041|  70.0k|        for (; i < len; ++i) {
  ------------------
  |  Branch (1041:16): [True: 35.0k, False: 35.0k]
  ------------------
 1042|  35.0k|            dword_type x = dword_type(words[i]) * m + carry;
 1043|  35.0k|            words[i] = static_cast<word_type>(x);
 1044|  35.0k|            carry = x >> 64;
 1045|  35.0k|        }
 1046|       |
 1047|  35.0k|        if (carry)
  ------------------
  |  Branch (1047:13): [True: 24.0k, False: 10.9k]
  ------------------
 1048|  24.0k|        {
 1049|  24.0k|            resize(len+1);
 1050|  24.0k|            words = get_words();
 1051|  24.0k|            words[i] = static_cast<word_type>(carry);
 1052|  24.0k|        }
 1053|       |
 1054|       |        /*
 1055|       |        word_type dig = words[0];
 1056|       |        word_type carry = 0;
 1057|       |
 1058|       |        resize(words.size() + 1);
 1059|       |        words = get_words();
 1060|       |
 1061|       |        size_type i = 0;
 1062|       |        for (; i < len; i++ )
 1063|       |        {
 1064|       |            word_type hi;
 1065|       |            word_type lo;
 1066|       |            DDproduct( dig, y, hi, lo );
 1067|       |            words[i] = lo + carry;
 1068|       |            dig = words[i+1];
 1069|       |            carry = hi + (words[i] < lo);
 1070|       |        }
 1071|       |        words[i] = carry;
 1072|       |        reduce(); 
 1073|       |        */ 
 1074|  35.0k|        return *this;
 1075|  38.8k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE9get_wordsEv:
  697|   638k|    {
  698|   638k|        return storage_.get_words();
  699|   638k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE9get_wordsEv:
  523|   885k|    {
  524|   885k|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (524:16): [True: 312k, False: 573k]
  ------------------
  525|   312k|            storage_view<word_type>{allocated_.data_, allocated_.size_} :
  526|   885k|            storage_view<word_type>{inlined_.values_, inlined_.size_};
  527|   885k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEC2EPmm:
   67|   885k|            : data_(data), size_(size)
   68|   885k|        {
   69|   885k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4sizeEv:
   87|  1.45M|        {
   88|  1.45M|            return size_;
   89|  1.45M|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6resizeEm:
  850|  91.1k|    {
  851|  91.1k|        storage_.resize(new_length);
  852|  91.1k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6resizeEm:
  537|   201k|    {
  538|   201k|        size_type old_length = common_.size_;
  539|   201k|        reserve(new_length);
  540|   201k|        common_.size_ = new_length;
  541|       |
  542|   201k|        if (old_length < new_length)
  ------------------
  |  Branch (542:13): [True: 99.5k, False: 102k]
  ------------------
  543|  99.5k|        {
  544|  99.5k|            if (is_allocated())
  ------------------
  |  Branch (544:17): [True: 24.0k, False: 75.5k]
  ------------------
  545|  24.0k|            {
  546|  24.0k|                std::memset(allocated_.data_+old_length, 0, size_type((new_length-old_length)*sizeof(word_type)));
  547|  24.0k|            }
  548|  75.5k|            else
  549|  75.5k|            {
  550|  75.5k|                JSONCONS_ASSERT(new_length <= inlined_capacity);
  ------------------
  |  |   54|  75.5k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 75.5k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  551|   191k|                for (size_type i = old_length; i < inlined_capacity; ++i)
  ------------------
  |  Branch (551:48): [True: 116k, False: 75.5k]
  ------------------
  552|   116k|                {
  553|   116k|                    inlined_.values_[i] = 0;
  554|   116k|                }
  555|  75.5k|            }
  556|  99.5k|        }
  557|   201k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7reserveEm:
  455|   201k|    {
  456|   201k|       if (capacity() < n)
  ------------------
  |  Branch (456:12): [True: 24.0k, False: 177k]
  ------------------
  457|  24.0k|       {
  458|  24.0k|           if (!is_allocated())
  ------------------
  |  Branch (458:16): [True: 24.0k, False: 0]
  ------------------
  459|  24.0k|           {
  460|  24.0k|               size_type size = inlined_.size_;
  461|  24.0k|               size_type is_neg = inlined_.is_negative_;
  462|  24.0k|               word_type values[inlined_capacity] = {inlined_.values_[0], inlined_.values_[1]};
  463|       |
  464|  24.0k|               ::new (&allocated_) allocated_storage();
  465|  24.0k|               allocated_.reserve(n, get_allocator());
  466|  24.0k|               allocated_.size_ = size;
  467|  24.0k|               allocated_.is_negative_ = is_neg;
  468|  24.0k|               if (n >= 1)
  ------------------
  |  Branch (468:20): [True: 24.0k, False: 0]
  ------------------
  469|  24.0k|               {
  470|  24.0k|                   allocated_.data_[0] = values[0];
  471|  24.0k|               }
  472|  24.0k|               if (n >= 2)
  ------------------
  |  Branch (472:20): [True: 24.0k, False: 0]
  ------------------
  473|  24.0k|               {
  474|  24.0k|                   allocated_.data_[1] = values[1];
  475|  24.0k|               }
  476|  24.0k|           }
  477|      0|           else
  478|      0|           {
  479|      0|               allocated_.reserve(n, get_allocator());
  480|      0|           }
  481|  24.0k|       }
  482|   201k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE8capacityEv:
  508|   201k|    {
  509|   201k|        return is_allocated() ? allocated_.capacity_ : inlined_capacity;
  ------------------
  |  Branch (509:16): [True: 48.0k, False: 153k]
  ------------------
  510|   201k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2Ev:
  206|  24.0k|            : is_allocated_(true),
  207|  24.0k|            is_negative_(false)
  208|  24.0k|        {
  209|  24.0k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7reserveEmRKS4_:
  258|  24.0k|        {
  259|  24.0k|            JSONCONS_ASSERT(n < max_size);
  ------------------
  |  |   54|  24.0k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 24.0k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  260|  24.0k|            size_type capacity_new = round_up(n);
  261|       |
  262|  24.0k|            real_allocator_type alloc(a);
  263|  24.0k|            word_type* data_new = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_new);
  264|  24.0k|            if (size_ > 0)
  ------------------
  |  Branch (264:17): [True: 0, False: 24.0k]
  ------------------
  265|      0|            {
  266|      0|                std::memcpy(data_new, data_, size_type(size_ * sizeof(word_type)));
  267|      0|            }
  268|  24.0k|            if (data_ != nullptr)
  ------------------
  |  Branch (268:17): [True: 0, False: 24.0k]
  ------------------
  269|      0|            {
  270|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  271|      0|            }
  272|  24.0k|            capacity_ = capacity_new;
  273|  24.0k|            data_ = data_new;
  274|  24.0k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage8round_upEm:
  278|  24.0k|        {
  279|  24.0k|            size_type remainder = i % mem_unit;
  280|  24.0k|            size_type off = mem_unit - remainder;
  281|  24.0k|            bool testoff = i < max_size - off;
  282|  24.0k|            JSONCONS_ASSERT(testoff);
  ------------------
  |  |   54|  24.0k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 24.0k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  283|       |
  284|  24.0k|            return i + off;
  285|  24.0k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE13get_allocatorEv:
  485|   469k|    {
  486|   469k|        return static_cast<const word_allocator_type&>(*this);
  487|   469k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12is_allocatedEv:
  503|   980k|    {
  504|   980k|        return common_.is_allocated_;
  505|   980k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEixEm:
   72|   539k|        {
   73|   539k|            return data_[i];
   74|   539k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLImEENS1_9enable_ifIXaasr6nonstd19is_unsigned_integerIT_EE5valuelestS7_Lm8EERS4_E4typeES7_:
  921|  10.1k|    {
  922|  10.1k|        if ( is_negative())
  ------------------
  |  Branch (922:14): [True: 0, False: 10.1k]
  ------------------
  923|      0|            return *this -= -basic_bigint<Allocator>(y);
  924|       |
  925|  10.1k|        word_type d;
  926|  10.1k|        word_type carry = 0;
  927|       |
  928|  10.1k|        auto words = get_words();
  929|  10.1k|        resize(words.size() + 1);
  930|       |
  931|  10.1k|        words = get_words();
  932|  10.1k|        const size_type this_size = words.size();
  933|  10.1k|        size_type y_size = 1;
  934|       |
  935|  10.1k|        d = words[0] + carry;
  936|  10.1k|        carry = d < carry;
  937|  10.1k|        words[0] = d + y;
  938|  10.1k|        if (words[0] < d)
  ------------------
  |  Branch (938:13): [True: 0, False: 10.1k]
  ------------------
  939|      0|            carry = 1;
  940|       |
  941|  10.1k|        for (size_type i = y_size; i < this_size && carry != 0; ++i)
  ------------------
  |  Branch (941:36): [True: 8.55k, False: 1.61k]
  |  Branch (941:53): [True: 0, False: 8.55k]
  ------------------
  942|      0|        {
  943|      0|            d = words[i] + carry;
  944|      0|            carry = d < carry;
  945|      0|            words[i] = d;
  946|      0|        }
  947|  10.1k|        reduce();
  948|  10.1k|        return *this;
  949|  10.1k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11is_negativeEv:
  707|   602k|    {
  708|   602k|        return storage_.is_negative();
  709|   602k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE11is_negativeEv:
  513|   602k|    {
  514|   602k|        return common_.is_negative_;
  515|   602k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEEngEv:
  867|  8.53k|    {
  868|  8.53k|        basic_bigint<Allocator> v(*this);
  869|  8.53k|        v.set_negative(!v.is_negative());
  870|  8.53k|        return v;
  871|  8.53k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_:
  650|  44.6k|        : storage_(other.storage_)
  651|  44.6k|    {
  652|  44.6k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_:
  302|  44.6k|        : word_allocator_type(other.get_allocator())
  303|  44.6k|    {
  304|       |#if defined(__GNUC__) && JSONCONS_GCC_AVAILABLE(12,0,0)
  305|       |# pragma GCC diagnostic push
  306|       |# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
  307|       |#endif
  308|  44.6k|        if (!other.is_allocated())
  ------------------
  |  Branch (308:13): [True: 20.6k, False: 24.0k]
  ------------------
  309|  20.6k|        {
  310|  20.6k|            ::new (&inlined_) inlined_storage(other.inlined_);
  311|  20.6k|        }
  312|  24.0k|        else
  313|  24.0k|        {
  314|  24.0k|            ::new (&allocated_) allocated_storage(other.allocated_, get_allocator());
  315|  24.0k|        }
  316|       |#if defined(__GNUC__) && JSONCONS_GCC_AVAILABLE(12,0,0)
  317|       |# pragma GCC diagnostic pop
  318|       |#endif
  319|  44.6k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ERKS6_:
  181|   132k|            : is_allocated_(false),
  182|   132k|            is_negative_(stor.is_negative_),
  183|   132k|            size_(stor.size_)
  184|   132k|        {
  185|   132k|            values_[0] = stor.values_[0];
  186|   132k|            values_[1] = stor.values_[1];
  187|   132k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2ERKS6_RKS4_:
  212|  96.1k|            : is_allocated_(true),
  213|  96.1k|              is_negative_(stor.is_negative_),
  214|  96.1k|              size_(stor.size_),
  215|  96.1k|              capacity_(stor.capacity_)
  216|  96.1k|        {
  217|  96.1k|            real_allocator_type alloc(a);
  218|       |
  219|  96.1k|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_);
  220|  96.1k|            JSONCONS_TRY
  ------------------
  |  |   37|  96.1k|    #define JSONCONS_TRY try
  ------------------
  221|  96.1k|            {
  222|  96.1k|                std::allocator_traits<real_allocator_type>::construct(alloc, nonstd::to_plain_pointer(data_));
  223|  96.1k|            }
  224|  96.1k|            JSONCONS_CATCH(...)
  225|  96.1k|            {
  226|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  227|      0|                data_ = nullptr;
  228|      0|                JSONCONS_RETHROW;
  ------------------
  |  |   36|      0|    #define JSONCONS_RETHROW throw
  ------------------
  229|      0|            }
  230|  96.1k|            JSONCONS_ASSERT(stor.data_ != nullptr);
  ------------------
  |  |   54|  96.1k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 96.1k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  231|  96.1k|            std::memcpy(data_, stor.data_, size_type(stor.size_ * sizeof(word_type)));
  232|  96.1k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE12set_negativeEb:
  728|   278k|    {
  729|   278k|        storage_.set_negative(value);
  730|   278k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12set_negativeEb:
  518|   278k|    {
  519|   278k|        common_.is_negative_ = value;
  520|   278k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6reduceEv:
 2058|   136k|    {
 2059|   136k|        storage_.reduce();
 2060|   136k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6reduceEv:
  432|   136k|    {
  433|   136k|        if (common_.size_ > 0)
  ------------------
  |  Branch (433:13): [True: 136k, False: 0]
  ------------------
  434|   136k|        {
  435|   136k|            auto words = get_words();
  436|   136k|            word_type* p = words.end() - 1;
  437|   136k|            word_type* first = words.begin();
  438|   199k|            while ( p >= first )
  ------------------
  |  Branch (438:21): [True: 195k, False: 3.31k]
  ------------------
  439|   195k|            {
  440|   195k|                if ( *p )
  ------------------
  |  Branch (440:22): [True: 133k, False: 62.3k]
  ------------------
  441|   133k|                {
  442|   133k|                    break;
  443|   133k|                }
  444|  62.3k|                --common_.size_;
  445|  62.3k|                --p;
  446|  62.3k|            }
  447|   136k|        }
  448|   136k|        if (common_.size_ == 0)
  ------------------
  |  Branch (448:13): [True: 3.31k, False: 133k]
  ------------------
  449|  3.31k|        {
  450|  3.31k|            common_.is_negative_ = false;
  451|  3.31k|        }
  452|   136k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE3endEv:
   96|   136k|        {
   97|   136k|            return data_ + size_;
   98|   136k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE5beginEv:
   91|   136k|        {
   92|   136k|            return data_;
   93|   136k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16append_to_bufferIcNS1_11char_traitsIcEENS2_IcEEEEvRNS1_12basic_stringIT_T0_T1_EE:
 1414|  38.8k|    {
 1415|  38.8k|        if (is_zero())
  ------------------
  |  Branch (1415:13): [True: 2.71k, False: 36.1k]
  ------------------
 1416|  2.71k|        {
 1417|  2.71k|            buf.push_back('0');
 1418|  2.71k|            return;
 1419|  2.71k|        }
 1420|  36.1k|        if (is_negative())
  ------------------
  |  Branch (1420:13): [True: 8.53k, False: 27.5k]
  ------------------
 1421|  8.53k|        {
 1422|  8.53k|            buf.push_back('-');
 1423|  8.53k|        }
 1424|  36.1k|        std::size_t pos = buf.size();
 1425|  36.1k|        basic_bigint<Allocator> v(*this);
 1426|  36.1k|        auto v_words = v.get_words();
 1427|       |
 1428|  36.1k|        size_type len = (v_words.size() * word_bits / 3) + 2;
 1429|  36.1k|        buf.reserve(len);
 1430|       |
 1431|  36.1k|        if ( v_words.size() == 0 )
  ------------------
  |  Branch (1431:14): [True: 0, False: 36.1k]
  ------------------
 1432|      0|        {
 1433|      0|            buf.push_back('0');
 1434|      0|        }
 1435|  36.1k|        else
 1436|  36.1k|        {
 1437|  36.1k|            word_type r;
 1438|  36.1k|            basic_bigint<Allocator> R(get_allocator());
 1439|  36.1k|            basic_bigint<Allocator> LP10(max_unsigned_power_10, get_allocator()); 
 1440|       |
 1441|  36.1k|            do
 1442|  67.5k|            {
 1443|  67.5k|                v.divide( LP10, v, R, true );
 1444|  67.5k|                v_words = v.get_words();
 1445|       |
 1446|  67.5k|                auto R_words = R.get_words();
 1447|  67.5k|                r = (R_words.size() ? R_words[0] : 0);
  ------------------
  |  Branch (1447:22): [True: 66.5k, False: 998]
  ------------------
 1448|   886k|                for ( size_type j=0; j < imax_unsigned_power_10; j++ )
  ------------------
  |  Branch (1448:38): [True: 855k, False: 31.3k]
  ------------------
 1449|   855k|                {
 1450|   855k|                    buf.push_back(char(r % 10u + '0'));
 1451|   855k|                    r /= 10u;
 1452|   855k|                    if ( r + v_words.size() == 0 )
  ------------------
  |  Branch (1452:26): [True: 36.1k, False: 818k]
  ------------------
 1453|  36.1k|                        break;
 1454|   855k|                }
 1455|  67.5k|            } 
 1456|  67.5k|            while ( v_words.size() > 0);
  ------------------
  |  Branch (1456:21): [True: 31.3k, False: 36.1k]
  ------------------
 1457|       |
 1458|  36.1k|            std::reverse(buf.begin()+pos,buf.end());
 1459|  36.1k|        }
 1460|  36.1k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7is_zeroEv:
 2179|  38.8k|    bool is_zero() const {
 2180|  38.8k|        return get_words().size() == 0;
 2181|  38.8k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9get_wordsEv:
  702|   279k|    {
  703|   279k|        return storage_.get_words();
  704|   279k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE9get_wordsEv:
  530|   390k|    {
  531|   390k|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (531:16): [True: 144k, False: 245k]
  ------------------
  532|   144k|            storage_view<const word_type>{allocated_.data_, allocated_.size_} :
  533|   390k|            storage_view<const word_type>{inlined_.values_, inlined_.size_};
  534|   390k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEC2EPS7_m:
   67|   390k|            : data_(data), size_(size)
   68|   390k|        {
   69|   390k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4sizeEv:
   87|   757k|        {
   88|   757k|            return size_;
   89|   757k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE13get_allocatorEv:
  692|   256k|    {
  693|   256k|        return storage_.get_allocator();
  694|   256k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS3_:
  623|  36.1k|        : storage_(alloc)
  624|  36.1k|    {
  625|  36.1k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS4_:
  296|  36.1k|        : word_allocator_type(alloc)
  297|  36.1k|    {
  298|  36.1k|        ::new (&inlined_) inlined_storage();
  299|  36.1k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2Ev:
  116|  36.1k|            : is_allocated_(false),
  117|  36.1k|            is_negative_(false),
  118|  36.1k|            size_(0),
  119|  36.1k|            values_{0, 0}
  120|  36.1k|        {
  121|  36.1k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE6divideERKS4_RS4_S7_b:
 1815|  67.5k|    {
 1816|  67.5k|        basic_bigint<Allocator> denom(denom_, get_allocator());
 1817|  67.5k|        auto denom_words = denom.get_words();
 1818|       |
 1819|  67.5k|        if (denom_words.size() == 0)
  ------------------
  |  Branch (1819:13): [True: 0, False: 67.5k]
  ------------------
 1820|      0|        {
 1821|      0|            JSONCONS_THROW(std::runtime_error( "Zero divide." ));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1822|      0|        }
 1823|  67.5k|        bool quot_neg = is_negative() ^ denom.is_negative();
 1824|  67.5k|        bool rem_neg = is_negative();
 1825|  67.5k|        basic_bigint<Allocator> num(*this, get_allocator());
 1826|  67.5k|        num.set_negative(false);
 1827|  67.5k|        denom.set_negative(false);
 1828|  67.5k|        if ( num < denom )
  ------------------
  |  Branch (1828:14): [True: 36.1k, False: 31.3k]
  ------------------
 1829|  36.1k|        {
 1830|  36.1k|            quot = word_type(0);
 1831|  36.1k|            quot.set_negative(quot_neg);
 1832|  36.1k|            rem = num;
 1833|  36.1k|            rem.set_negative(rem_neg);
 1834|  36.1k|            return;
 1835|  36.1k|        }
 1836|       |
 1837|  31.3k|        auto num_words = num.get_words();
 1838|  31.3k|        auto quot_words = quot.get_words();
 1839|  31.3k|        auto words = get_words();
 1840|       |
 1841|  31.3k|        if ( denom_words.size() == 1 && num_words.size() == 1 )
  ------------------
  |  Branch (1841:14): [True: 31.3k, False: 0]
  |  Branch (1841:41): [True: 6.87k, False: 24.5k]
  ------------------
 1842|  6.87k|        {
 1843|  6.87k|            quot = word_type( num_words[0]/denom_words[0] );
 1844|  6.87k|            rem = word_type( num_words[0]%denom_words[0] );
 1845|  6.87k|            quot.set_negative(quot_neg);
 1846|  6.87k|            rem.set_negative(rem_neg);
 1847|  6.87k|            return;
 1848|  6.87k|        }
 1849|  24.5k|        if (denom_words.size() == 1 && (denom_words[0] & l_mask) == 0 )
  ------------------
  |  Branch (1849:13): [True: 24.5k, False: 0]
  |  Branch (1849:40): [True: 0, False: 24.5k]
  ------------------
 1850|      0|        {
 1851|       |            // Denominator fits into a half word
 1852|      0|            word_type divisor = denom_words[0], dHi = 0, q1, r, q2, dividend;
 1853|      0|            quot.resize(words.size());
 1854|      0|            quot_words = quot.get_words();
 1855|      0|            for (size_type i=words.size(); i-- > 0; )
  ------------------
  |  Branch (1855:44): [True: 0, False: 0]
  ------------------
 1856|      0|            {
 1857|      0|                dividend = (dHi << word_half_bits) | (words[i] >> word_half_bits);
 1858|      0|                q1 = dividend/divisor;
 1859|      0|                r = dividend % divisor;
 1860|      0|                dividend = (r << word_half_bits) | (words[i] & r_mask);
 1861|      0|                q2 = dividend/divisor;
 1862|      0|                dHi = dividend % divisor;
 1863|      0|                quot_words[i] = (q1 << word_half_bits) | q2;
 1864|      0|            }
 1865|      0|            quot.reduce();
 1866|      0|            rem = dHi;
 1867|      0|            quot.set_negative(quot_neg);
 1868|      0|            rem.set_negative(rem_neg);
 1869|      0|            return;
 1870|      0|        }
 1871|  24.5k|        basic_bigint<Allocator> num0(num, get_allocator());
 1872|  24.5k|        basic_bigint<Allocator> denom0(denom, get_allocator());
 1873|  24.5k|        int x = 0;
 1874|  24.5k|        bool second_done = normalize(denom, num, x);
 1875|  24.5k|        denom_words = denom.get_words();
 1876|  24.5k|        num_words = num.get_words();
 1877|       |
 1878|  24.5k|        size_type l = denom_words.size() - 1;
 1879|  24.5k|        size_type n = num_words.size() - 1;
 1880|  24.5k|        quot.resize(n - l);
 1881|  24.5k|        quot_words = quot.get_words();
 1882|  49.0k|        for (size_type i = quot_words.size(); i-- > 0; )
  ------------------
  |  Branch (1882:47): [True: 24.5k, False: 24.5k]
  ------------------
 1883|  24.5k|        {
 1884|  24.5k|            quot_words[i] = 0;
 1885|  24.5k|        }
 1886|  24.5k|        rem = num;
 1887|  24.5k|        auto rem_words = rem.get_words();
 1888|  24.5k|        if ( rem_words[n] >= denom_words[l] )
  ------------------
  |  Branch (1888:14): [True: 0, False: 24.5k]
  ------------------
 1889|      0|        {
 1890|      0|            rem.resize(rem_words.size() + 1);
 1891|      0|            rem_words = rem.get_words();
 1892|      0|            n++;
 1893|      0|            quot.resize(quot_words.size() + 1);
 1894|      0|            quot_words = quot.get_words();
 1895|      0|        }
 1896|  24.5k|        word_type d = denom_words[l];
 1897|       |
 1898|  49.0k|        for ( size_type k = n; k > l; k-- )
  ------------------
  |  Branch (1898:32): [True: 24.5k, False: 24.5k]
  ------------------
 1899|  24.5k|        {
 1900|  24.5k|            word_type q = DDquotient(rem_words[k], rem_words[k-1], d);
 1901|  24.5k|            subtractmul( rem_words.data() + (k - l - 1), denom_words.data(), l + 1, q );
 1902|  24.5k|            quot_words[k - l - 1] = q;
 1903|  24.5k|        }
 1904|  24.5k|        quot.reduce();
 1905|  24.5k|        quot.set_negative(quot_neg);
 1906|  24.5k|        if (remDesired)
  ------------------
  |  Branch (1906:13): [True: 24.5k, False: 0]
  ------------------
 1907|  24.5k|        {
 1908|  24.5k|            unnormalize(rem, x, second_done);
 1909|  24.5k|            rem.set_negative(rem_neg);
 1910|  24.5k|        }
 1911|  24.5k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_RKS3_:
  655|   184k|        : storage_(other.storage_, alloc)
  656|   184k|    {
  657|   184k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_RKS4_:
  322|   184k|        : word_allocator_type(alloc)
  323|   184k|    {
  324|   184k|        if (!other.is_allocated())
  ------------------
  |  Branch (324:13): [True: 111k, False: 72.0k]
  ------------------
  325|   111k|        {
  326|   111k|            ::new (&inlined_) inlined_storage(other.inlined_);
  327|   111k|        }
  328|  72.0k|        else
  329|  72.0k|        {
  330|  72.0k|            ::new (&allocated_) allocated_storage(other.allocated_, alloc);
  331|  72.0k|        }
  332|   184k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEES6_:
 1537|  67.5k|    {
 1538|  67.5k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1538:15): [True: 36.1k, False: 31.3k]
  ------------------
 1539|  67.5k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7compareERKS4_:
 1702|  96.1k|    {
 1703|  96.1k|        auto words = get_words();
 1704|  96.1k|        auto y_words = y.get_words();
 1705|       |
 1706|  96.1k|        const size_type y_size = y_words.size();
 1707|  96.1k|        if ( words.size() == 0 && y_size == 0 )
  ------------------
  |  Branch (1707:14): [True: 2.19k, False: 93.9k]
  |  Branch (1707:35): [True: 2.19k, False: 0]
  ------------------
 1708|  2.19k|            return 0;
 1709|  93.9k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (1709:14): [True: 8.53k, False: 85.4k]
  ------------------
 1710|  8.53k|            return y.is_negative() - is_negative();
 1711|  85.4k|        int code = 0;
 1712|  85.4k|        if ( words.size() < y_size)
  ------------------
  |  Branch (1712:14): [True: 0, False: 85.4k]
  ------------------
 1713|      0|            code = -1;
 1714|  85.4k|        else if ( words.size() > y_size)
  ------------------
  |  Branch (1714:19): [True: 42.4k, False: 43.0k]
  ------------------
 1715|  42.4k|            code = +1;
 1716|  43.0k|        else
 1717|  43.0k|        {
 1718|  43.4k|            for (size_type i = words.size(); i-- > 0; )
  ------------------
  |  Branch (1718:46): [True: 43.0k, False: 401]
  ------------------
 1719|  43.0k|            {
 1720|  43.0k|                if (words[i] > y_words[i])
  ------------------
  |  Branch (1720:21): [True: 6.47k, False: 36.5k]
  ------------------
 1721|  6.47k|                {
 1722|  6.47k|                    code = 1;
 1723|  6.47k|                    break;
 1724|  6.47k|                }
 1725|  36.5k|                else if (words[i] < y_words[i])
  ------------------
  |  Branch (1725:26): [True: 36.1k, False: 401]
  ------------------
 1726|  36.1k|                {
 1727|  36.1k|                    code = -1;
 1728|  36.1k|                    break;
 1729|  36.1k|                }
 1730|  43.0k|            }
 1731|  43.0k|        }
 1732|  85.4k|        return is_negative() ? -code : code;
  ------------------
  |  Branch (1732:16): [True: 0, False: 85.4k]
  ------------------
 1733|  93.9k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEaSERKS4_:
  874|   110k|    {
  875|   110k|        storage_ = y.storage_;
  876|   110k|        return *this;
  877|   110k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEaSERKS5_:
  369|   110k|    {
  370|   110k|        if (this != &other)
  ------------------
  |  Branch (370:13): [True: 110k, False: 0]
  ------------------
  371|   110k|        {
  372|   110k|            auto other_words = other.get_words();
  373|   110k|            resize(other_words.size());
  374|   110k|            auto words = get_words();
  375|   110k|            if (other_words.size() > 0)
  ------------------
  |  Branch (375:17): [True: 73.9k, False: 36.5k]
  ------------------
  376|  73.9k|            {
  377|  73.9k|                common_.is_negative_ = other.common_.is_negative_;
  378|  73.9k|                std::memcpy(words.data(), other_words.data(), size_type(other_words.size()*sizeof(word_type)));
  379|  73.9k|            }
  380|   110k|        }
  381|   110k|        return *this;
  382|   110k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4dataEv:
   82|  73.9k|        {
   83|  73.9k|            return data_;
   84|  73.9k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEixEm:
   72|   166k|        {
   73|   166k|            return data_[i];
   74|   166k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9normalizeERS4_S5_Ri:
 2013|  24.5k|    {
 2014|  24.5k|        auto denom_words = denom.get_words();
 2015|  24.5k|        if (denom_words.size() == 0)
  ------------------
  |  Branch (2015:13): [True: 0, False: 24.5k]
  ------------------
 2016|      0|        {
 2017|      0|            return false;
 2018|      0|        }
 2019|  24.5k|        size_type r = denom_words.size() - 1;
 2020|  24.5k|        word_type y = denom_words[r];
 2021|       |
 2022|  24.5k|        x = 0;
 2023|  24.5k|        while ( (y & l_bit) == 0 )
  ------------------
  |  Branch (2023:17): [True: 0, False: 24.5k]
  ------------------
 2024|      0|        {
 2025|      0|            y <<= 1;
 2026|      0|            x++;
 2027|      0|        }
 2028|  24.5k|        denom <<= x;
 2029|  24.5k|        num <<= x;
 2030|       |
 2031|  24.5k|        denom_words = denom.get_words();
 2032|  24.5k|        if ( r > 0 && denom_words[r] < denom_words[r-1] )
  ------------------
  |  Branch (2032:14): [True: 0, False: 24.5k]
  |  Branch (2032:23): [True: 0, False: 0]
  ------------------
 2033|      0|        {
 2034|      0|            denom *= max_word;
 2035|      0|            num *= max_word;
 2036|      0|            return true;
 2037|      0|        }
 2038|  24.5k|        return false;
 2039|  24.5k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEElSEm:
 1172|  49.0k|    {
 1173|  49.0k|        auto words = get_words();
 1174|  49.0k|        size_type q = k / word_bits;
 1175|  49.0k|        if ( q ) // Increase storage_.size() by q:
  ------------------
  |  Branch (1175:14): [True: 0, False: 49.0k]
  ------------------
 1176|      0|        {
 1177|      0|            resize(words.size() + q);
 1178|      0|            words = get_words();
 1179|      0|            for (size_type i = words.size(); i-- > 0; )
  ------------------
  |  Branch (1179:46): [True: 0, False: 0]
  ------------------
 1180|      0|                words[i] = ( i < q ? 0 : words[i - q]);
  ------------------
  |  Branch (1180:30): [True: 0, False: 0]
  ------------------
 1181|      0|            k %= word_bits;
 1182|      0|        }
 1183|  49.0k|        if ( k )  // 0 < k < word_bits:
  ------------------
  |  Branch (1183:14): [True: 0, False: 49.0k]
  ------------------
 1184|      0|        {
 1185|      0|            size_type k1 = word_bits - k;
 1186|      0|            word_type mask = (word_type(1) << k) - word_type(1);
 1187|      0|            resize( words.size() + 1 );
 1188|      0|            words = get_words();
 1189|      0|            for (size_type i = words.size(); i-- > 0; )
  ------------------
  |  Branch (1189:46): [True: 0, False: 0]
  ------------------
 1190|      0|            {
 1191|      0|                words[i] <<= k;
 1192|      0|                if ( i > 0 )
  ------------------
  |  Branch (1192:22): [True: 0, False: 0]
  ------------------
 1193|      0|                    words[i] |= (words[i-1] >> k1) & mask;
 1194|      0|            }
 1195|      0|        }
 1196|  49.0k|        reduce();
 1197|  49.0k|        return *this;
 1198|  49.0k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE10DDquotientEmmm:
 1940|  24.5k|    {
 1941|  24.5k|        word_type left, middle, right, qHi, qLo, x, dLo1,
 1942|  24.5k|                   dHi = d >> word_half_bits, dLo = d & r_mask;
 1943|  24.5k|        qHi = A/(dHi + 1);
 1944|       |        // This initial guess of qHi may be too small.
 1945|  24.5k|        middle = qHi * dLo;
 1946|  24.5k|        left = qHi * dHi;
 1947|  24.5k|        x = B - (middle << word_half_bits);
 1948|  24.5k|        A -= (middle >> word_half_bits) + left + (x > B);
 1949|  24.5k|        B = x;
 1950|  24.5k|        dLo1 = dLo << word_half_bits;
 1951|       |        // Increase qHi if necessary:
 1952|  24.5k|        while ( A > dHi || (A == dHi && B >= dLo1) )
  ------------------
  |  Branch (1952:17): [True: 0, False: 24.5k]
  |  Branch (1952:29): [True: 0, False: 24.5k]
  |  Branch (1952:41): [True: 0, False: 0]
  ------------------
 1953|      0|        {
 1954|      0|            x = B - dLo1;
 1955|      0|            A -= dHi + (x > B);
 1956|      0|            B = x;
 1957|      0|            qHi++;
 1958|      0|        }
 1959|  24.5k|        qLo = ((A << word_half_bits) | (B >> word_half_bits))/(dHi + 1);
 1960|       |        // This initial guess of qLo may be too small.
 1961|  24.5k|        right = qLo * dLo;
 1962|  24.5k|        middle = qLo * dHi;
 1963|  24.5k|        x = B - right;
 1964|  24.5k|        A -= (x > B);
 1965|  24.5k|        B = x;
 1966|  24.5k|        x = B - (middle << word_half_bits);
 1967|  24.5k|            A -= (middle >> word_half_bits) + (x > B);
 1968|  24.5k|        B = x;
 1969|       |        // Increase qLo if necessary:
 1970|  28.5k|        while ( A || B >= d )
  ------------------
  |  Branch (1970:17): [True: 0, False: 28.5k]
  |  Branch (1970:22): [True: 4.08k, False: 24.5k]
  ------------------
 1971|  4.08k|        {
 1972|  4.08k|            x = B - d;
 1973|  4.08k|            A -= (x > B);
 1974|  4.08k|            B = x;
 1975|  4.08k|            qLo++;
 1976|  4.08k|        }
 1977|  24.5k|        return (qHi << word_half_bits) + qLo;
 1978|  24.5k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11subtractmulEPmS5_mRm:
 1982|  24.5k|    {
 1983|  24.5k|        word_type hi, lo, d, carry = 0;
 1984|  24.5k|        size_type i;
 1985|  49.0k|        for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1985:22): [True: 24.5k, False: 24.5k]
  ------------------
 1986|  24.5k|        {
 1987|  24.5k|            DDproduct( b[i], q, hi, lo );
 1988|  24.5k|            d = a[i];
 1989|  24.5k|            a[i] -= lo;
 1990|  24.5k|            if ( a[i] > d )
  ------------------
  |  Branch (1990:18): [True: 13.2k, False: 11.2k]
  ------------------
 1991|  13.2k|                carry++;
 1992|  24.5k|            d = a[i + 1];
 1993|  24.5k|            a[i + 1] -= hi + carry;
 1994|  24.5k|            carry = a[i + 1] > d;
 1995|  24.5k|        }
 1996|  24.5k|        if ( carry ) // q was too large
  ------------------
  |  Branch (1996:14): [True: 0, False: 24.5k]
  ------------------
 1997|      0|        {
 1998|      0|            q--;
 1999|      0|            carry = 0;
 2000|      0|            for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (2000:26): [True: 0, False: 0]
  ------------------
 2001|      0|            {
 2002|      0|                d = a[i] + carry;
 2003|      0|                carry = d < carry;
 2004|      0|                a[i] = d + b[i];
 2005|      0|                if ( a[i] < d )
  ------------------
  |  Branch (2005:22): [True: 0, False: 0]
  ------------------
 2006|      0|                    carry = 1;
 2007|      0|            }
 2008|      0|            a[n] = 0;
 2009|      0|        }
 2010|  24.5k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9DDproductEmmRmS5_:
 1922|  24.5k|    {
 1923|  24.5k|        word_type hiA = A >> word_half_bits, loA = A & r_mask,
 1924|  24.5k|                   hiB = B >> word_half_bits, loB = B & r_mask;
 1925|       |
 1926|  24.5k|        lo = loA * loB;
 1927|  24.5k|        hi = hiA * hiB;
 1928|  24.5k|        word_type mid1 = loA * hiB;
 1929|  24.5k|        word_type mid2 = hiA * loB;
 1930|  24.5k|        word_type old = lo;
 1931|  24.5k|        lo += mid1 << word_half_bits;
 1932|  24.5k|            hi += (lo < old) + (mid1 >> word_half_bits);
 1933|  24.5k|        old = lo;
 1934|  24.5k|        lo += mid2 << word_half_bits;
 1935|  24.5k|            hi += (lo < old) + (mid2 >> word_half_bits);
 1936|  24.5k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4dataEv:
   82|   123k|        {
   83|   123k|            return data_;
   84|   123k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11unnormalizeERS4_ib:
 2042|  24.5k|    {
 2043|  24.5k|        if (secondDone)
  ------------------
  |  Branch (2043:13): [True: 0, False: 24.5k]
  ------------------
 2044|      0|        {
 2045|      0|            rem /= max_word;
 2046|      0|        }
 2047|  24.5k|        if ( x > 0 )
  ------------------
  |  Branch (2047:14): [True: 0, False: 24.5k]
  ------------------
 2048|      0|        {
 2049|      0|            rem >>= x;
 2050|      0|        }
 2051|  24.5k|        else
 2052|  24.5k|        {
 2053|  24.5k|            rem.reduce();
 2054|  24.5k|        }
 2055|  24.5k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEED2Ev:
  687|   426k|    {
  688|   426k|        storage_.destroy();
  689|   426k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7destroyEv:
  490|   426k|    {
  491|   426k|        if (is_allocated())
  ------------------
  |  Branch (491:13): [True: 120k, False: 306k]
  ------------------
  492|   120k|        {
  493|   120k|            allocated_.destroy(get_allocator());
  494|   120k|            allocated_.~allocated_storage();
  495|   120k|        }
  496|   306k|        else
  497|   306k|        {
  498|   306k|            inlined_.~inlined_storage();
  499|   306k|        }
  500|   426k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7destroyERKS4_:
  249|   120k|        {
  250|   120k|            if (data_ != nullptr)
  ------------------
  |  Branch (250:17): [True: 120k, False: 0]
  ------------------
  251|   120k|            {
  252|   120k|                real_allocator_type alloc(a);
  253|   120k|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  254|   120k|            }
  255|   120k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IlEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  672|  57.3k|        : storage_(n, alloc)
  673|  57.3k|    {
  674|  57.3k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IlEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  363|  57.3k|        : word_allocator_type(alloc)
  364|  57.3k|    {
  365|  57.3k|        ::new (&inlined_) inlined_storage(n);
  366|  57.3k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IlEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  128|  57.3k|            : is_allocated_(false),
  129|  57.3k|            is_negative_(n < 0),
  130|  57.3k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (130:19): [True: 30.8k, False: 26.4k]
  ------------------
  131|  57.3k|        {
  132|  57.3k|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (132:26): [True: 8.53k, False: 48.8k]
  ------------------
  133|  57.3k|            values_[1] = 0;
  134|  57.3k|        }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEEl:
 1542|  28.6k|    {
 1543|  28.6k|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1543:15): [True: 8.53k, False: 20.1k]
  ------------------
 1544|  28.6k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IjEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  672|  8.53k|        : storage_(n, alloc)
  673|  8.53k|    {
  674|  8.53k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IjEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  363|  8.53k|        : word_allocator_type(alloc)
  364|  8.53k|    {
  365|  8.53k|        ::new (&inlined_) inlined_storage(n);
  366|  8.53k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IjEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  141|  8.53k|            : is_allocated_(false),
  142|  8.53k|            is_negative_(false),
  143|  8.53k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (143:19): [True: 1.57k, False: 6.95k]
  ------------------
  144|  8.53k|        {
  145|  8.53k|            values_[0] = n;
  146|  8.53k|            values_[1] = 0;
  147|  8.53k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmIERKS4_:
  986|  8.53k|    {
  987|  8.53k|        auto y_words = y.get_words();
  988|       |
  989|  8.53k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (989:14): [True: 8.53k, False: 0]
  ------------------
  990|  8.53k|            return *this += -y;
  991|      0|        if ( (!is_negative() && y > *this) || (is_negative() && y < *this) )
  ------------------
  |  Branch (991:15): [True: 0, False: 0]
  |  Branch (991:33): [True: 0, False: 0]
  |  Branch (991:48): [True: 0, False: 0]
  |  Branch (991:65): [True: 0, False: 0]
  ------------------
  992|      0|            return *this = -(y - *this);
  993|      0|        word_type borrow = 0;
  994|      0|        word_type d;
  995|      0|        auto words = get_words();
  996|      0|        const size_type this_size = words.size();
  997|      0|        const size_type y_size = y_words.size();
  998|       |
  999|      0|        for (size_type i = 0; i < y_size; i++ )
  ------------------
  |  Branch (999:31): [True: 0, False: 0]
  ------------------
 1000|      0|        {
 1001|      0|            d = words[i] - borrow;
 1002|      0|            borrow = d > words[i];
 1003|      0|            words[i] = d - y_words[i];
 1004|      0|            if ( words[i] > d )
  ------------------
  |  Branch (1004:18): [True: 0, False: 0]
  ------------------
 1005|      0|                borrow = 1;
 1006|      0|        }
 1007|      0|        for (size_type i = y_size; i < this_size && borrow != 0; i++ )
  ------------------
  |  Branch (1007:36): [True: 0, False: 0]
  |  Branch (1007:53): [True: 0, False: 0]
  ------------------
 1008|      0|        {
 1009|      0|            d = words[i] - borrow;
 1010|      0|            borrow = d > words[i];
 1011|      0|            words[i] = d;
 1012|      0|        }
 1013|      0|        reduce();
 1014|      0|        return *this;
 1015|      0|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLERKS4_:
  952|  8.53k|    {
  953|  8.53k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (953:14): [True: 0, False: 8.53k]
  ------------------
  954|      0|            return *this -= -y;
  955|       |
  956|  8.53k|        auto y_words = y.get_words();
  957|       |        
  958|  8.53k|        word_type d;
  959|  8.53k|        word_type carry = 0;
  960|       |
  961|  8.53k|        auto words = get_words();
  962|  8.53k|        resize( (std::max)(y_words.size(), words.size()) + 1 );
  963|  8.53k|        words = get_words();
  964|       |
  965|  8.53k|        const size_t this_size = words.size();
  966|  8.53k|        const size_t y_size = y_words.size();
  967|  15.4k|        for (size_type i = 0; i < y_size; i++ )
  ------------------
  |  Branch (967:31): [True: 6.95k, False: 8.53k]
  ------------------
  968|  6.95k|        {
  969|  6.95k|            d = words[i] + carry;
  970|  6.95k|            carry = d < carry;
  971|  6.95k|            words[i] = d + y_words[i];
  972|  6.95k|            if (words[i] < d)
  ------------------
  |  Branch (972:17): [True: 628, False: 6.32k]
  ------------------
  973|    628|                carry = 1;
  974|  6.95k|        }
  975|  9.16k|        for (size_type i = y_size; i < this_size && carry != 0; i++ )
  ------------------
  |  Branch (975:36): [True: 8.70k, False: 462]
  |  Branch (975:53): [True: 628, False: 8.07k]
  ------------------
  976|    628|        {
  977|    628|            d = words[i] + carry;
  978|    628|            carry = d < carry;
  979|    628|            words[i] = d;
  980|    628|        }
  981|  8.53k|        reduce();
  982|  8.53k|        return *this;
  983|  8.53k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLIjEENS1_9enable_ifIXaasr6nonstd19is_unsigned_integerIT_EE5valuelestS7_Lm8EERS4_E4typeES7_:
  921|  20.1k|    {
  922|  20.1k|        if ( is_negative())
  ------------------
  |  Branch (922:14): [True: 0, False: 20.1k]
  ------------------
  923|      0|            return *this -= -basic_bigint<Allocator>(y);
  924|       |
  925|  20.1k|        word_type d;
  926|  20.1k|        word_type carry = 0;
  927|       |
  928|  20.1k|        auto words = get_words();
  929|  20.1k|        resize(words.size() + 1);
  930|       |
  931|  20.1k|        words = get_words();
  932|  20.1k|        const size_type this_size = words.size();
  933|  20.1k|        size_type y_size = 1;
  934|       |
  935|  20.1k|        d = words[0] + carry;
  936|  20.1k|        carry = d < carry;
  937|  20.1k|        words[0] = d + y;
  938|  20.1k|        if (words[0] < d)
  ------------------
  |  Branch (938:13): [True: 9.12k, False: 11.0k]
  ------------------
  939|  9.12k|            carry = 1;
  940|       |
  941|  29.2k|        for (size_type i = y_size; i < this_size && carry != 0; ++i)
  ------------------
  |  Branch (941:36): [True: 27.0k, False: 2.21k]
  |  Branch (941:53): [True: 9.12k, False: 17.9k]
  ------------------
  942|  9.12k|        {
  943|  9.12k|            d = words[i] + carry;
  944|  9.12k|            carry = d < carry;
  945|  9.12k|            words[i] = d;
  946|  9.12k|        }
  947|  20.1k|        reduce();
  948|  20.1k|        return *this;
  949|  20.1k|    }

_ZN8jsoncons6binary13big_to_nativeIfNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  66.8k|    {
  183|  66.8k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 66.8k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  66.8k|        T val;
  188|  66.8k|        std::memcpy(&val,first,sizeof(T));
  189|  66.8k|        return byte_swap(val);
  190|  66.8k|    }
_ZN8jsoncons6binary9byte_swapIfEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   64|  66.8k|    {
   65|  66.8k|        uint32_t x;
   66|  66.8k|        std::memcpy(&x,&val,sizeof(uint32_t));
   67|  66.8k|        uint32_t y = byte_swap(x);
   68|  66.8k|        T val2;
   69|  66.8k|        std::memcpy(&val2,&y,sizeof(uint32_t));
   70|  66.8k|        return val2;
   71|  66.8k|    }
_ZN8jsoncons6binary9byte_swapIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|   164k|    {
   40|   164k|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|   164k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  463|   164k|#  define JSONCONS_BYTE_SWAP_32 __builtin_bswap32
  ------------------
   42|       |    #else
   43|       |        uint32_t tmp = ((static_cast<uint32_t>(val) << 8) & 0xff00ff00) | ((static_cast<uint32_t>(val) >> 8) & 0xff00ff);
   44|       |        return (tmp << 16) | (tmp >> 16);
   45|       |    #endif
   46|   164k|    }
_ZN8jsoncons6binary13big_to_nativeIdNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  16.0k|    {
  183|  16.0k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 16.0k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  16.0k|        T val;
  188|  16.0k|        std::memcpy(&val,first,sizeof(T));
  189|  16.0k|        return byte_swap(val);
  190|  16.0k|    }
_ZN8jsoncons6binary9byte_swapIdEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   76|  16.0k|    {
   77|  16.0k|        uint64_t x;
   78|  16.0k|        std::memcpy(&x,&val,sizeof(uint64_t));
   79|  16.0k|        uint64_t y = byte_swap(x);
   80|  16.0k|        T val2;
   81|  16.0k|        std::memcpy(&val2,&y,sizeof(uint64_t));
   82|  16.0k|        return val2;
   83|  16.0k|    }
_ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|  28.0k|    {
   52|  28.0k|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|  28.0k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  462|  28.0k|#  define JSONCONS_BYTE_SWAP_64 __builtin_bswap64
  ------------------
   54|       |    #else
   55|       |        uint64_t tmp = ((static_cast<uint64_t>(val) & 0x00000000ffffffffull) << 32) | ((static_cast<uint64_t>(val) & 0xffffffff00000000ull) >> 32);
   56|       |        tmp = ((tmp & 0x0000ffff0000ffffull) << 16) | ((tmp & 0xffff0000ffff0000ull) >> 16);
   57|       |        return ((tmp & 0x00ff00ff00ff00ffull) << 8)  | ((tmp & 0xff00ff00ff00ff00ull) >> 8);
   58|       |    #endif
   59|  28.0k|    }
_ZN8jsoncons6binary13big_to_nativeItNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|   218k|    {
  183|   218k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 218k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|   218k|        T val;
  188|   218k|        std::memcpy(&val,first,sizeof(T));
  189|   218k|        return byte_swap(val);
  190|   218k|    }
_ZN8jsoncons6binary9byte_swapItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|   218k|    {
   29|   218k|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|   218k|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  467|   218k|#      define JSONCONS_BYTE_SWAP_16    __builtin_bswap16
  ------------------
   31|       |    #else
   32|       |        return (static_cast<uint16_t>(val) >> 8) | (static_cast<uint16_t>(val) << 8);
   33|       |    #endif
   34|   218k|    }
_ZN8jsoncons6binary13big_to_nativeIjNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  97.5k|    {
  183|  97.5k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 97.5k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  97.5k|        T val;
  188|  97.5k|        std::memcpy(&val,first,sizeof(T));
  189|  97.5k|        return byte_swap(val);
  190|  97.5k|    }
_ZN8jsoncons6binary13big_to_nativeImNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  11.9k|    {
  183|  11.9k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 11.9k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  11.9k|        T val;
  188|  11.9k|        std::memcpy(&val,first,sizeof(T));
  189|  11.9k|        return byte_swap(val);
  190|  11.9k|    }
_ZN8jsoncons6binary13big_to_nativeIaNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  1.58M|    {
  183|  1.58M|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 1.58M]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  1.58M|        T val;
  188|  1.58M|        std::memcpy(&val,first,sizeof(T));
  189|  1.58M|        return byte_swap(val);
  190|  1.58M|    }
_ZN8jsoncons6binary9byte_swapIaEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_:
   21|  1.58M|    {
   22|  1.58M|        return val;
   23|  1.58M|    }
_ZN8jsoncons6binary13big_to_nativeIsNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  2.92k|    {
  183|  2.92k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 2.92k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  2.92k|        T val;
  188|  2.92k|        std::memcpy(&val,first,sizeof(T));
  189|  2.92k|        return byte_swap(val);
  190|  2.92k|    }
_ZN8jsoncons6binary9byte_swapIsEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|  2.92k|    {
   29|  2.92k|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|  2.92k|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  467|  2.92k|#      define JSONCONS_BYTE_SWAP_16    __builtin_bswap16
  ------------------
   31|       |    #else
   32|       |        return (static_cast<uint16_t>(val) >> 8) | (static_cast<uint16_t>(val) << 8);
   33|       |    #endif
   34|  2.92k|    }
_ZN8jsoncons6binary13big_to_nativeIiNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  5.11k|    {
  183|  5.11k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 5.11k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  5.11k|        T val;
  188|  5.11k|        std::memcpy(&val,first,sizeof(T));
  189|  5.11k|        return byte_swap(val);
  190|  5.11k|    }
_ZN8jsoncons6binary9byte_swapIiEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|  5.11k|    {
   40|  5.11k|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|  5.11k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  463|  5.11k|#  define JSONCONS_BYTE_SWAP_32 __builtin_bswap32
  ------------------
   42|       |    #else
   43|       |        uint32_t tmp = ((static_cast<uint32_t>(val) << 8) & 0xff00ff00) | ((static_cast<uint32_t>(val) >> 8) & 0xff00ff);
   44|       |        return (tmp << 16) | (tmp >> 16);
   45|       |    #endif
   46|  5.11k|    }
_ZN8jsoncons6binary13big_to_nativeIlNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  33.5k|    {
  183|  33.5k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 33.5k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  33.5k|        T val;
  188|  33.5k|        std::memcpy(&val,first,sizeof(T));
  189|  33.5k|        return byte_swap(val);
  190|  33.5k|    }
_ZN8jsoncons6binary9byte_swapIlEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|  33.5k|    {
   52|  33.5k|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|  33.5k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  462|  33.5k|#  define JSONCONS_BYTE_SWAP_64 __builtin_bswap64
  ------------------
   54|       |    #else
   55|       |        uint64_t tmp = ((static_cast<uint64_t>(val) & 0x00000000ffffffffull) << 32) | ((static_cast<uint64_t>(val) & 0xffffffff00000000ull) >> 32);
   56|       |        tmp = ((tmp & 0x0000ffff0000ffffull) << 16) | ((tmp & 0xffff0000ffff0000ull) >> 16);
   57|       |        return ((tmp & 0x00ff00ff00ff00ffull) << 8)  | ((tmp & 0xff00ff00ff00ff00ull) >> 8);
   58|       |    #endif
   59|  33.5k|    }
_ZN8jsoncons6binary13big_to_nativeIhNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  48.7k|    {
  183|  48.7k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 48.7k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  48.7k|        T val;
  188|  48.7k|        std::memcpy(&val,first,sizeof(T));
  189|  48.7k|        return byte_swap(val);
  190|  48.7k|    }
_ZN8jsoncons6binary9byte_swapIhEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_:
   21|  48.7k|    {
   22|  48.7k|        return val;
   23|  48.7k|    }

_ZN8jsoncons6detail23bytes_to_base64_genericIPKhNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS4_9enable_ifIXsr3std7is_sameINS4_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESD_SD_PKcRT0_:
   44|   974k|    {
   45|   974k|        std::size_t count = 0;
   46|   974k|        unsigned char a3[3];
   47|   974k|        unsigned char a4[4];
   48|   974k|        unsigned char fill = alphabet[64];
   49|   974k|        int i = 0;
   50|   974k|        int j = 0;
   51|       |
   52|  12.5M|        while (first != last)
  ------------------
  |  Branch (52:16): [True: 11.5M, False: 974k]
  ------------------
   53|  11.5M|        {
   54|  11.5M|            a3[i++] = *first++;
   55|  11.5M|            if (i == 3)
  ------------------
  |  Branch (55:17): [True: 3.22M, False: 8.32M]
  ------------------
   56|  3.22M|            {
   57|  3.22M|                a4[0] = (a3[0] & 0xfc) >> 2;
   58|  3.22M|                a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   59|  3.22M|                a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   60|  3.22M|                a4[3] = a3[2] & 0x3f;
   61|       |
   62|  16.1M|                for (i = 0; i < 4; i++) 
  ------------------
  |  Branch (62:29): [True: 12.8M, False: 3.22M]
  ------------------
   63|  12.8M|                {
   64|  12.8M|                    result.push_back(alphabet[a4[i]]);
   65|  12.8M|                    ++count;
   66|  12.8M|                }
   67|  3.22M|                i = 0;
   68|  3.22M|            }
   69|  11.5M|        }
   70|       |
   71|   974k|        if (i > 0)
  ------------------
  |  Branch (71:13): [True: 949k, False: 24.6k]
  ------------------
   72|   949k|        {
   73|  1.91M|            for (j = i; j < 3; ++j) 
  ------------------
  |  Branch (73:25): [True: 968k, False: 949k]
  ------------------
   74|   968k|            {
   75|   968k|                a3[j] = 0;
   76|   968k|            }
   77|       |
   78|   949k|            a4[0] = (a3[0] & 0xfc) >> 2;
   79|   949k|            a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   80|   949k|            a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   81|       |
   82|  3.78M|            for (j = 0; j < i + 1; ++j) 
  ------------------
  |  Branch (82:25): [True: 2.83M, False: 949k]
  ------------------
   83|  2.83M|            {
   84|  2.83M|                result.push_back(alphabet[a4[j]]);
   85|  2.83M|                ++count;
   86|  2.83M|            }
   87|       |
   88|   949k|            if (fill != 0)
  ------------------
  |  Branch (88:17): [True: 0, False: 949k]
  ------------------
   89|      0|            {
   90|      0|                while (i++ < 3) 
  ------------------
  |  Branch (90:24): [True: 0, False: 0]
  ------------------
   91|      0|                {
   92|      0|                    result.push_back(fill);
   93|      0|                    ++count;
   94|      0|                }
   95|      0|            }
   96|   949k|        }
   97|       |
   98|   974k|        return count;
   99|   974k|    }
_ZNK8jsoncons16byte_string_view5beginEv:
  409|   974k|        {
  410|   974k|            return data_;
  411|   974k|        }
_ZNK8jsoncons16byte_string_view3endEv:
  413|   974k|        {
  414|   974k|            return data_ + size_;
  415|   974k|        }
_ZN8jsoncons18bytes_to_base64urlIPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  177|   974k|    {
  178|   974k|        static constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  179|   974k|                                                      "abcdefghijklmnopqrstuvwxyz"
  180|   974k|                                                      "0123456789-_"
  181|   974k|                                                      "\0";
  182|   974k|        return detail::bytes_to_base64_generic(first, last, alphabet, result);
  183|   974k|    }
_ZNK8jsoncons16byte_string_view4dataEv:
  399|  1.73M|        {
  400|  1.73M|            return data_;
  401|  1.73M|        }
_ZNK8jsoncons16byte_string_view4sizeEv:
  403|  1.73M|        {
  404|  1.73M|            return size_;
  405|  1.73M|        }
_ZN8jsoncons16byte_string_viewC2EPKhm:
  362|  3.08M|            : data_(data), size_(length)
  363|  3.08M|        {
  364|  3.08M|        }

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

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

_ZN8jsoncons12from_integerImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr6nonstd10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  7.54M|{
   43|  7.54M|    using char_type = typename Result::value_type;
   44|       |
   45|  7.54M|    char_type buf[255];
   46|  7.54M|    char_type *p = buf;
   47|  7.54M|    const char_type* last = buf+255;
   48|       |
   49|  7.54M|    bool is_negative = value < 0;
   50|       |
   51|  7.54M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 7.54M]
  ------------------
   52|      0|    {
   53|      0|        do
   54|      0|        {
   55|      0|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|      0|        }
   57|      0|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 0, False: 0]
  |  Branch (57:33): [True: 0, False: 0]
  ------------------
   58|      0|    }
   59|  7.54M|    else
   60|  7.54M|    {
   61|       |
   62|  7.54M|        do
   63|  12.6M|        {
   64|  12.6M|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  12.6M|        }
   66|  12.6M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 5.08M, False: 7.54M]
  |  Branch (66:33): [True: 5.08M, False: 0]
  ------------------
   67|  7.54M|    }
   68|  7.54M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   54|  7.54M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 7.54M]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|  7.54M|    std::size_t count = (p - buf);
   71|  7.54M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 7.54M]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  20.1M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 12.6M, False: 7.54M]
  ------------------
   77|  12.6M|    {
   78|  12.6M|        result.push_back(*p);
   79|  12.6M|    }
   80|       |
   81|  7.54M|    return count;
   82|  7.54M|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr6nonstd10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  4.84M|{
   43|  4.84M|    using char_type = typename Result::value_type;
   44|       |
   45|  4.84M|    char_type buf[255];
   46|  4.84M|    char_type *p = buf;
   47|  4.84M|    const char_type* last = buf+255;
   48|       |
   49|  4.84M|    bool is_negative = value < 0;
   50|       |
   51|  4.84M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 4.83M, False: 6.72k]
  ------------------
   52|  4.83M|    {
   53|  4.83M|        do
   54|  5.25M|        {
   55|  5.25M|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|  5.25M|        }
   57|  5.25M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 412k, False: 4.83M]
  |  Branch (57:33): [True: 412k, False: 0]
  ------------------
   58|  4.83M|    }
   59|  6.72k|    else
   60|  6.72k|    {
   61|       |
   62|  6.72k|        do
   63|  43.2k|        {
   64|  43.2k|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  43.2k|        }
   66|  43.2k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 36.5k, False: 6.72k]
  |  Branch (66:33): [True: 36.5k, False: 0]
  ------------------
   67|  6.72k|    }
   68|  4.84M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   54|  4.84M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 4.84M]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|  4.84M|    std::size_t count = (p - buf);
   71|  4.84M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 4.83M, False: 6.72k]
  ------------------
   72|  4.83M|    {
   73|  4.83M|        result.push_back('-');
   74|  4.83M|        ++count;
   75|  4.83M|    }
   76|  10.1M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 5.29M, False: 4.84M]
  ------------------
   77|  5.29M|    {
   78|  5.29M|        result.push_back(*p);
   79|  5.29M|    }
   80|       |
   81|  4.84M|    return count;
   82|  4.84M|}
_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|  80.8k|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|  80.8k|    {
  489|  80.8k|#if !defined(JSONCONS_NO_LOCALECONV)
  490|  80.8k|        struct lconv *lc = localeconv();
  491|  80.8k|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 80.8k, False: 0]
  |  Branch (491:30): [True: 80.8k, False: 0]
  ------------------
  492|  80.8k|        {
  493|  80.8k|            decimal_point_ = lc->decimal_point[0];
  494|  80.8k|        }
  495|  80.8k|#endif
  496|  80.8k|    }
_ZN8jsoncons12write_doubleclINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEmdRT_:
  503|  80.8k|    {
  504|  80.8k|        std::size_t count = 0;
  505|       |
  506|  80.8k|        char number_buffer[200];
  507|  80.8k|        int length = 0;
  508|       |
  509|  80.8k|        switch (float_format_)
  510|  80.8k|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 80.8k]
  ------------------
  512|      0|            {
  513|      0|                if (precision_ > 0)
  ------------------
  |  Branch (513:21): [True: 0, False: 0]
  ------------------
  514|      0|                {
  515|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*f", precision_, val);
  516|      0|                    if (length < 0)
  ------------------
  |  Branch (516:25): [True: 0, False: 0]
  ------------------
  517|      0|                    {
  518|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  519|      0|                    }
  520|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  521|      0|                }
  522|      0|                else
  523|      0|                {
  524|      0|                    if (!dtoa_fixed(val, decimal_point_, result))
  ------------------
  |  Branch (524:25): [True: 0, False: 0]
  ------------------
  525|      0|                    {
  526|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  527|      0|                    }
  528|      0|                }
  529|      0|            }
  530|      0|            break;
  531|      0|        case float_chars_format::scientific:
  ------------------
  |  Branch (531:9): [True: 0, False: 80.8k]
  ------------------
  532|      0|            {
  533|      0|                if (precision_ > 0)
  ------------------
  |  Branch (533:21): [True: 0, False: 0]
  ------------------
  534|      0|                {
  535|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*e", precision_, val);
  536|      0|                    if (length < 0)
  ------------------
  |  Branch (536:25): [True: 0, False: 0]
  ------------------
  537|      0|                    {
  538|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  539|      0|                    }
  540|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  541|      0|                }
  542|      0|                else
  543|      0|                {
  544|      0|                    if (!dtoa_scientific(val, decimal_point_, result))
  ------------------
  |  Branch (544:25): [True: 0, False: 0]
  ------------------
  545|      0|                    {
  546|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  547|      0|                    }
  548|      0|                }
  549|      0|            }
  550|      0|            break;
  551|  80.8k|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 80.8k, False: 0]
  ------------------
  552|  80.8k|            {
  553|  80.8k|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 80.8k]
  ------------------
  554|      0|                {
  555|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*g", precision_, val);
  556|      0|                    if (length < 0)
  ------------------
  |  Branch (556:25): [True: 0, False: 0]
  ------------------
  557|      0|                    {
  558|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  559|      0|                    }
  560|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  561|      0|                }
  562|  80.8k|                else
  563|  80.8k|                {
  564|  80.8k|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 80.8k]
  ------------------
  565|      0|                    {
  566|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  567|      0|                    }
  568|  80.8k|                }             
  569|  80.8k|                break;
  570|  80.8k|            }
  571|  80.8k|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 80.8k]
  ------------------
  572|      0|                JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  573|      0|                break;
  574|  80.8k|        }
  575|  80.8k|        return count;
  576|  80.8k|    }
_ZN8jsoncons11dump_bufferINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKcmcRT_:
  243|  5.22k|{
  244|  5.22k|    const char *sbeg = buffer;
  245|  5.22k|    const char *send = sbeg + length;
  246|       |
  247|  5.22k|    if (sbeg != send)
  ------------------
  |  Branch (247:9): [True: 5.22k, False: 0]
  ------------------
  248|  5.22k|    {
  249|  5.22k|        bool needs_dot = true;
  250|  96.3k|        for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (250:36): [True: 91.0k, False: 5.22k]
  ------------------
  251|  91.0k|        {
  252|  91.0k|            switch (*q)
  253|  91.0k|            {
  254|  4.24k|            case '-':
  ------------------
  |  Branch (254:13): [True: 4.24k, False: 86.8k]
  ------------------
  255|  12.8k|            case '0':
  ------------------
  |  Branch (255:13): [True: 8.61k, False: 82.4k]
  ------------------
  256|  22.4k|            case '1':
  ------------------
  |  Branch (256:13): [True: 9.60k, False: 81.4k]
  ------------------
  257|  33.1k|            case '2':
  ------------------
  |  Branch (257:13): [True: 10.6k, False: 80.3k]
  ------------------
  258|  40.4k|            case '3':
  ------------------
  |  Branch (258:13): [True: 7.34k, False: 83.7k]
  ------------------
  259|  46.2k|            case '4':
  ------------------
  |  Branch (259:13): [True: 5.74k, False: 85.3k]
  ------------------
  260|  53.5k|            case '5':
  ------------------
  |  Branch (260:13): [True: 7.33k, False: 83.7k]
  ------------------
  261|  62.3k|            case '6':
  ------------------
  |  Branch (261:13): [True: 8.79k, False: 82.2k]
  ------------------
  262|  67.9k|            case '7':
  ------------------
  |  Branch (262:13): [True: 5.62k, False: 85.4k]
  ------------------
  263|  75.3k|            case '8':
  ------------------
  |  Branch (263:13): [True: 7.34k, False: 83.7k]
  ------------------
  264|  80.0k|            case '9':
  ------------------
  |  Branch (264:13): [True: 4.76k, False: 86.3k]
  ------------------
  265|  81.5k|            case '+':
  ------------------
  |  Branch (265:13): [True: 1.41k, False: 89.6k]
  ------------------
  266|  81.5k|                result.push_back(*q);
  267|  81.5k|                break;
  268|  2.61k|            case 'e':
  ------------------
  |  Branch (268:13): [True: 2.61k, False: 88.4k]
  ------------------
  269|  2.61k|            case 'E':
  ------------------
  |  Branch (269:13): [True: 0, False: 91.0k]
  ------------------
  270|  2.61k|                result.push_back('e');
  271|  2.61k|                needs_dot = false;
  272|  2.61k|                break;
  273|  6.95k|            default:
  ------------------
  |  Branch (273:13): [True: 6.95k, False: 84.1k]
  ------------------
  274|  6.95k|                if (*q == decimal_point)
  ------------------
  |  Branch (274:21): [True: 4.09k, False: 2.85k]
  ------------------
  275|  4.09k|                {
  276|  4.09k|                    needs_dot = false;
  277|  4.09k|                    result.push_back('.');
  278|  4.09k|                }
  279|  6.95k|                break;
  280|  91.0k|            }
  281|  91.0k|        }
  282|  5.22k|        if (needs_dot)
  ------------------
  |  Branch (282:13): [True: 1.12k, False: 4.09k]
  ------------------
  283|  1.12k|        {
  284|  1.12k|            result.push_back('.');
  285|  1.12k|            result.push_back('0');
  286|  1.12k|        }
  287|  5.22k|    }
  288|  5.22k|}
_ZN8jsoncons15prettify_stringINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKciiiiRT_:
  171|  74.6k|{
  172|  74.6k|    int nb_digits = length;
  173|  74.6k|    int offset;
  174|       |    /* v = buffer * 10^k
  175|       |       kk is such that 10^(kk-1) <= v < 10^kk
  176|       |       this way kk gives the position of the decimal point.
  177|       |    */
  178|  74.6k|    int kk = nb_digits + k;
  179|       |
  180|  74.6k|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 25.7k, False: 48.9k]
  |  Branch (180:28): [True: 21.5k, False: 4.14k]
  ------------------
  181|  21.5k|    {
  182|       |        /* the first digits are already in. Add some 0s and call it a day. */
  183|       |        /* the max_exp is a personal choice. Only 16 digits could possibly be relevant.
  184|       |         * Basically we want to print 12340000000 rather than 1234.0e7 or 1.234e10 */
  185|   168k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 147k, False: 21.5k]
  ------------------
  186|   147k|        {
  187|   147k|            result.push_back(buffer[i]);
  188|   147k|        }
  189|  46.2k|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 24.6k, False: 21.5k]
  ------------------
  190|  24.6k|        {
  191|  24.6k|            result.push_back('0');
  192|  24.6k|        }
  193|  21.5k|        result.push_back('.');
  194|  21.5k|        result.push_back('0');
  195|  21.5k|    } 
  196|  53.0k|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 27.3k, False: 25.6k]
  |  Branch (196:24): [True: 23.2k, False: 4.14k]
  ------------------
  197|  23.2k|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|   106k|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 83.7k, False: 23.2k]
  ------------------
  200|  83.7k|        {
  201|  83.7k|            result.push_back(buffer[i]);
  202|  83.7k|        }
  203|  23.2k|        result.push_back('.');
  204|   274k|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 251k, False: 23.2k]
  ------------------
  205|   251k|        {
  206|   251k|            result.push_back(buffer[i]);
  207|   251k|        }
  208|  23.2k|    } 
  209|  29.8k|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 7.19k, False: 22.6k]
  |  Branch (209:30): [True: 3.05k, False: 4.14k]
  ------------------
  210|  3.05k|    {
  211|  3.05k|        offset = 2 - kk;
  212|       |
  213|  3.05k|        result.push_back('0');
  214|  3.05k|        result.push_back('.');
  215|  9.04k|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 5.98k, False: 3.05k]
  ------------------
  216|  5.98k|            result.push_back('0');
  217|  47.0k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 43.9k, False: 3.05k]
  ------------------
  218|  43.9k|        {
  219|  43.9k|            result.push_back(buffer[i]);
  220|  43.9k|        }
  221|  3.05k|    } 
  222|  26.7k|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 3.96k, False: 22.7k]
  ------------------
  223|  3.96k|    {
  224|  3.96k|        result.push_back(buffer[0]);
  225|  3.96k|        result.push_back('e');
  226|  3.96k|        fill_exponent(kk - 1, result);
  227|  3.96k|    } 
  228|  22.7k|    else
  229|  22.7k|    {
  230|  22.7k|        result.push_back(buffer[0]);
  231|  22.7k|        result.push_back('.');
  232|   323k|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 300k, False: 22.7k]
  ------------------
  233|   300k|        {
  234|   300k|            result.push_back(buffer[i]);
  235|   300k|        }
  236|  22.7k|        result.push_back('e');
  237|  22.7k|        fill_exponent(kk - 1, result);
  238|  22.7k|    }
  239|  74.6k|}
_ZN8jsoncons13fill_exponentINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEviRT_:
  136|  26.7k|{
  137|  26.7k|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 22.6k, False: 4.14k]
  ------------------
  138|  22.6k|    {
  139|  22.6k|        result.push_back('-');
  140|  22.6k|        K = -K;
  141|  22.6k|    }
  142|  4.14k|    else
  143|  4.14k|    {
  144|  4.14k|        result.push_back('+'); // compatibility with sprintf
  145|  4.14k|    }
  146|       |
  147|  26.7k|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 1.24k, False: 25.5k]
  ------------------
  148|  1.24k|    {
  149|  1.24k|        result.push_back('0'); // compatibility with sprintf
  150|  1.24k|        result.push_back((char)('0' + K));
  151|  1.24k|    }
  152|  25.5k|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 11.1k, False: 14.3k]
  ------------------
  153|  11.1k|    {
  154|  11.1k|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|  11.1k|        result.push_back((char)('0' + K));
  156|  11.1k|    }
  157|  14.3k|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 14.3k, False: 0]
  ------------------
  158|  14.3k|    {
  159|  14.3k|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|  14.3k|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|  14.3k|        result.push_back((char)('0' + K));
  162|  14.3k|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|  26.7k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_:
  475|  80.8k|{
  476|  80.8k|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|  80.8k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb1EEE:
  366|  80.8k|{
  367|  80.8k|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 985, False: 79.8k]
  ------------------
  368|    985|    {
  369|    985|        result.push_back('0');
  370|    985|        result.push_back('.');
  371|    985|        result.push_back('0');
  372|    985|        return true;
  373|    985|    }
  374|       |
  375|  79.8k|    int length = 0;
  376|  79.8k|    int k;
  377|       |
  378|  79.8k|    char buffer[100];
  379|       |
  380|  79.8k|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 55.2k, False: 24.5k]
  ------------------
  381|  79.8k|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 74.6k, False: 5.22k]
  ------------------
  382|  74.6k|    {
  383|  74.6k|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 52.2k, False: 22.4k]
  ------------------
  384|  52.2k|        {
  385|  52.2k|            result.push_back('-');
  386|  52.2k|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|  74.6k|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|  74.6k|        return true;
  391|  74.6k|    }
  392|  5.22k|    else
  393|  5.22k|    {
  394|  5.22k|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|  5.22k|    }
  396|  79.8k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb0EEE:
  329|  5.22k|{
  330|  5.22k|    if (val == 0)
  ------------------
  |  Branch (330:9): [True: 0, False: 5.22k]
  ------------------
  331|      0|    {
  332|      0|        result.push_back('0');
  333|      0|        result.push_back('.');
  334|      0|        result.push_back('0');
  335|      0|        return true;
  336|      0|    }
  337|       |
  338|  5.22k|    char buffer[100];
  339|  5.22k|    int precision = std::numeric_limits<double>::digits10;
  340|  5.22k|    int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  341|  5.22k|    if (length < 0)
  ------------------
  |  Branch (341:9): [True: 0, False: 5.22k]
  ------------------
  342|      0|    {
  343|      0|        return false;
  344|      0|    }
  345|  5.22k|    double x{0};
  346|  5.22k|    auto res = decstr_to_double(buffer, length, x);
  347|  5.22k|    if (res.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (347:9): [True: 0, False: 5.22k]
  ------------------
  348|      0|    {
  349|      0|        return false;
  350|      0|    }
  351|  5.22k|    if (x != val)
  ------------------
  |  Branch (351:9): [True: 4.37k, False: 847]
  ------------------
  352|  4.37k|    {
  353|  4.37k|        const int precision2 = std::numeric_limits<double>::max_digits10;
  354|  4.37k|        length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  355|  4.37k|        if (length < 0)
  ------------------
  |  Branch (355:13): [True: 0, False: 4.37k]
  ------------------
  356|      0|        {
  357|      0|            return false;
  358|      0|        }
  359|  4.37k|    }
  360|  5.22k|    dump_buffer(buffer, length, decimal_point, result);
  361|  5.22k|    return true;
  362|  5.22k|}

_ZN8jsoncons14unicode_traits8validateIhEENSt3__19enable_ifIXsr6nonstd8is_char8IT_EE5valueENS0_14unicode_resultIS4_EEE4typeEPKS4_m:
 1147|  3.96M|    {
 1148|  3.96M|        const uint8_t* it = reinterpret_cast<const uint8_t*>(data);
 1149|  3.96M|        const uint8_t* end = it + length;
 1150|       |
 1151|  3.96M|        unicode_errc  result{};
 1152|  3.98M|        while (it != end) 
  ------------------
  |  Branch (1152:16): [True: 13.8k, False: 3.96M]
  ------------------
 1153|  13.8k|        {
 1154|  13.8k|            if ((end - it) >= 8)
  ------------------
  |  Branch (1154:17): [True: 4.78k, False: 9.07k]
  ------------------
 1155|  4.78k|            {
 1156|  18.5k|                JSONCONS_REPEAT8({if (JSONCONS_LIKELY((*it & 0x80) == 0)) ++it; else goto non_ascii;})
  ------------------
  |  |  326|  9.57k|#define JSONCONS_REPEAT8(x)  { x x x x x x x x }
  |  |  ------------------
  |  |  |  Branch (326:32): [True: 3.75k, False: 1.03k]
  |  |  |  Branch (326:34): [True: 3.31k, False: 435]
  |  |  |  Branch (326:36): [True: 2.87k, False: 443]
  |  |  |  Branch (326:38): [True: 2.53k, False: 337]
  |  |  |  Branch (326:40): [True: 2.26k, False: 270]
  |  |  |  Branch (326:42): [True: 2.03k, False: 234]
  |  |  |  Branch (326:44): [True: 1.81k, False: 213]
  |  |  |  Branch (326:46): [True: 1.45k, False: 366]
  |  |  ------------------
  ------------------
 1157|  1.45k|                continue;
 1158|  18.5k|            }
 1159|  12.4k|    non_ascii:
 1160|  12.4k|            const std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[*it]) + 1;
 1161|  12.4k|            if (len > (std::size_t)(end - it))
  ------------------
  |  Branch (1161:17): [True: 48, False: 12.3k]
  ------------------
 1162|     48|            {
 1163|     48|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it), unicode_errc::source_exhausted};
 1164|     48|            }
 1165|  12.3k|            if ((result=is_legal_utf8(it, len)) != unicode_errc())
  ------------------
  |  Branch (1165:17): [True: 162, False: 12.1k]
  ------------------
 1166|    162|            {
 1167|    162|                return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1168|    162|            }
 1169|  12.1k|            it += len;
 1170|  12.1k|        }
 1171|  3.96M|        return unicode_result<CharT>{reinterpret_cast<const CharT*>(it),result} ;
 1172|  3.96M|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8EPKhm:
  305|  12.3k|    {
  306|  12.3k|        const uint8_t* it = reinterpret_cast<const uint8_t*>(bytes);
  307|  12.3k|        const uint8_t* end = it+length;
  308|       |
  309|  12.3k|        uint8_t byte;
  310|  12.3k|        switch (length) {
  311|     14|        default:
  ------------------
  |  Branch (311:9): [True: 14, False: 12.3k]
  ------------------
  312|     14|            return unicode_errc::over_long_utf8_sequence;
  313|    427|        case 4:
  ------------------
  |  Branch (313:9): [True: 427, False: 11.9k]
  ------------------
  314|    427|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (314:17): [True: 6, False: 421]
  ------------------
  315|      6|                return unicode_errc::bad_continuation_byte;
  316|    421|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  565|    421|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  317|    891|        case 3:
  ------------------
  |  Branch (317:9): [True: 470, False: 11.8k]
  ------------------
  318|    891|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (318:17): [True: 10, False: 881]
  ------------------
  319|     10|                return unicode_errc::bad_continuation_byte;
  320|    881|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  565|    881|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  321|  3.72k|        case 2:
  ------------------
  |  Branch (321:9): [True: 2.84k, False: 9.51k]
  ------------------
  322|  3.72k|            if (((byte = (*--end))& 0xC0) != 0x80)
  ------------------
  |  Branch (322:17): [True: 49, False: 3.67k]
  ------------------
  323|     49|                return unicode_errc::bad_continuation_byte;
  324|       |
  325|  3.67k|            switch (*it) 
  326|  3.67k|            {
  327|       |                // no fall-through in this inner switch
  328|    202|                case 0xE0: if (byte < 0xA0) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (328:17): [True: 202, False: 3.47k]
  |  Branch (328:32): [True: 6, False: 196]
  ------------------
  329|    240|                case 0xED: if (byte > 0x9F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (329:17): [True: 240, False: 3.43k]
  |  Branch (329:32): [True: 2, False: 238]
  ------------------
  330|    238|                case 0xF0: if (byte < 0x90) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (330:17): [True: 206, False: 3.47k]
  |  Branch (330:32): [True: 6, False: 200]
  ------------------
  331|    206|                case 0xF4: if (byte > 0x8F) return unicode_errc::source_illegal; break;
  ------------------
  |  Branch (331:17): [True: 206, False: 3.47k]
  |  Branch (331:32): [True: 6, False: 200]
  ------------------
  332|  2.82k|                default:   if (byte < 0x80) return unicode_errc::source_illegal;
  ------------------
  |  Branch (332:17): [True: 2.82k, False: 854]
  |  Branch (332:32): [True: 0, False: 2.82k]
  ------------------
  333|  3.67k|            }
  334|       |
  335|  3.65k|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  565|  3.65k|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  336|  12.2k|        case 1:
  ------------------
  |  Branch (336:9): [True: 8.60k, False: 3.75k]
  ------------------
  337|  12.2k|            if (*it >= 0x80 && *it < 0xC2)
  ------------------
  |  Branch (337:17): [True: 3.71k, False: 8.54k]
  |  Branch (337:32): [True: 62, False: 3.65k]
  ------------------
  338|     62|                return unicode_errc::source_illegal;
  339|  12.1k|            break;
  340|  12.3k|        }
  341|  12.1k|        if (*it > 0xF4) 
  ------------------
  |  Branch (341:13): [True: 1, False: 12.1k]
  ------------------
  342|      1|            return unicode_errc::source_illegal;
  343|       |
  344|  12.1k|        return unicode_errc();
  345|  12.1k|    }

_ZN8jsoncons7msgpack15make_error_codeENS0_12msgpack_errcE:
   88|  3.86k|{
   89|  3.86k|    return std::error_code(static_cast<int>(e),msgpack_error_category());
   90|  3.86k|}
_ZN8jsoncons7msgpack22msgpack_error_categoryEv:
   81|  3.86k|{
   82|  3.86k|  static msgpack_error_category_impl instance;
   83|  3.86k|  return instance;
   84|  3.86k|}

_ZN8jsoncons7msgpack22msgpack_decode_optionsC1Ev:
   40|  4.82k|    msgpack_decode_options() = default;
_ZN8jsoncons7msgpack22msgpack_options_commonC2Ev:
   23|  4.82k|    msgpack_options_common() = default;
_ZN8jsoncons7msgpack22msgpack_options_commonD2Ev:
   26|  4.82k|    virtual ~msgpack_options_common() = default;
_ZNK8jsoncons7msgpack22msgpack_options_common17max_nesting_depthEv:
   31|  4.82k|    {
   32|  4.82k|        return max_nesting_depth_;
   33|  4.82k|    }

_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RKNS0_22msgpack_decode_optionsERKS7_:
   86|  4.82k|       : source_(std::forward<Sourceable>(source)),
   87|  4.82k|         max_nesting_depth_(options.max_nesting_depth()),
   88|  4.82k|         text_buffer_(alloc),
   89|  4.82k|         bytes_buffer_(alloc),
   90|  4.82k|         state_stack_(alloc)
   91|  4.82k|    {
   92|  4.82k|        state_stack_.emplace_back(parse_mode::root,0);
   93|  4.82k|    }
_ZN8jsoncons7msgpack11parse_stateC2ENS0_10parse_modeEm:
   46|   416k|        : mode(mode), length(length)
   47|   416k|    {
   48|   416k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5resetEv:
  101|  4.82k|    {
  102|  4.82k|        more_ = true;
  103|  4.82k|        done_ = false;
  104|  4.82k|        text_buffer_.clear();
  105|  4.82k|        bytes_buffer_.clear();
  106|  4.82k|        state_stack_.clear();
  107|  4.82k|        state_stack_.emplace_back(parse_mode::root,0);
  108|  4.82k|        nesting_depth_ = 0;
  109|  4.82k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  159|  4.82k|    {
  160|  33.6M|        while (!done_ && more_)
  ------------------
  |  Branch (160:16): [True: 33.6M, False: 958]
  |  Branch (160:26): [True: 33.6M, False: 0]
  ------------------
  161|  33.6M|        {
  162|  33.6M|            switch (state_stack_.back().mode)
  ------------------
  |  Branch (162:21): [True: 33.6M, False: 0]
  ------------------
  163|  33.6M|            {
  164|  14.5M|                case parse_mode::array:
  ------------------
  |  Branch (164:17): [True: 14.5M, False: 19.1M]
  ------------------
  165|  14.5M|                {
  166|  14.5M|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (166:25): [True: 14.3M, False: 172k]
  ------------------
  167|  14.3M|                    {
  168|  14.3M|                        ++state_stack_.back().index;
  169|  14.3M|                        read_item(visitor, ec);
  170|  14.3M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  14.3M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 814, False: 14.3M]
  |  |  ------------------
  ------------------
  171|    814|                        {
  172|    814|                            return;
  173|    814|                        }
  174|  14.3M|                    }
  175|   172k|                    else
  176|   172k|                    {
  177|   172k|                        end_array(visitor, ec);
  178|   172k|                    }
  179|  14.5M|                    break;
  180|  14.5M|                }
  181|  14.5M|                case parse_mode::map_key:
  ------------------
  |  Branch (181:17): [True: 9.66M, False: 24.0M]
  ------------------
  182|  9.66M|                {
  183|  9.66M|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (183:25): [True: 9.48M, False: 182k]
  ------------------
  184|  9.48M|                    {
  185|  9.48M|                        ++state_stack_.back().index;
  186|  9.48M|                        state_stack_.back().mode = parse_mode::map_value;
  187|  9.48M|                        read_item(visitor, ec);
  188|  9.48M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  9.48M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 666, False: 9.47M]
  |  |  ------------------
  ------------------
  189|    666|                        {
  190|    666|                            return;
  191|    666|                        }
  192|  9.48M|                    }
  193|   182k|                    else
  194|   182k|                    {
  195|   182k|                        end_object(visitor, ec);
  196|   182k|                    }
  197|  9.66M|                    break;
  198|  9.66M|                }
  199|  9.66M|                case parse_mode::map_value:
  ------------------
  |  Branch (199:17): [True: 9.46M, False: 24.2M]
  ------------------
  200|  9.46M|                {
  201|  9.46M|                    state_stack_.back().mode = parse_mode::map_key;
  202|  9.46M|                    read_item(visitor, ec);
  203|  9.46M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  9.46M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1.93k, False: 9.46M]
  |  |  ------------------
  ------------------
  204|  1.93k|                    {
  205|  1.93k|                        return;
  206|  1.93k|                    }
  207|  9.46M|                    break;
  208|  9.46M|                }
  209|  9.46M|                case parse_mode::root:
  ------------------
  |  Branch (209:17): [True: 4.82k, False: 33.6M]
  ------------------
  210|  4.82k|                {
  211|  4.82k|                    state_stack_.back().mode = parse_mode::accept;
  212|  4.82k|                    read_item(visitor, ec);
  213|  4.82k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  4.82k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 457, False: 4.36k]
  |  |  ------------------
  ------------------
  214|    457|                    {
  215|    457|                        return;
  216|    457|                    }
  217|  4.36k|                    break;
  218|  4.82k|                }
  219|  4.36k|                case parse_mode::accept:
  ------------------
  |  Branch (219:17): [True: 958, False: 33.6M]
  ------------------
  220|    958|                {
  221|    958|                    JSONCONS_ASSERT(state_stack_.size() == 1);
  ------------------
  |  |   54|    958|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 958]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  222|    958|                    state_stack_.clear();
  223|    958|                    more_ = false;
  224|    958|                    done_ = true;
  225|    958|                    visitor.flush();
  226|    958|                    break;
  227|    958|                }
  228|  33.6M|            }
  229|  33.6M|        }
  230|  4.82k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_itemERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  234|  33.3M|    {
  235|  33.3M|        if (source_.is_error())
  ------------------
  |  Branch (235:13): [True: 0, False: 33.3M]
  ------------------
  236|      0|        {
  237|      0|            ec = msgpack_errc::source_error;
  238|      0|            more_ = false;
  239|      0|            return;
  240|      0|        }   
  241|       |
  242|  33.3M|        uint8_t type;
  243|  33.3M|        if (source_.read(&type, 1) == 0)
  ------------------
  |  Branch (243:13): [True: 2.95k, False: 33.3M]
  ------------------
  244|  2.95k|        {
  245|  2.95k|            ec = msgpack_errc::unexpected_eof;
  246|  2.95k|            more_ = false;
  247|  2.95k|            return;
  248|  2.95k|        }
  249|       |
  250|  33.3M|        if (type <= 0xbf)
  ------------------
  |  Branch (250:13): [True: 12.2M, False: 21.0M]
  ------------------
  251|  12.2M|        {
  252|  12.2M|            if (type <= 0x7f) 
  ------------------
  |  Branch (252:17): [True: 7.90M, False: 4.36M]
  ------------------
  253|  7.90M|            {
  254|       |                // positive fixint
  255|  7.90M|                visitor.uint64_value(type, semantic_tag::none, *this, ec);
  256|  7.90M|                more_ = !cursor_mode_;
  257|  7.90M|            }
  258|  4.36M|            else if (type <= 0x8f) 
  ------------------
  |  Branch (258:22): [True: 207k, False: 4.15M]
  ------------------
  259|   207k|            {
  260|   207k|                begin_object(visitor,type,ec); // fixmap
  261|   207k|            }
  262|  4.15M|            else if (type <= 0x9f) 
  ------------------
  |  Branch (262:22): [True: 191k, False: 3.96M]
  ------------------
  263|   191k|            {
  264|   191k|                begin_array(visitor,type,ec); // fixarray
  265|   191k|            }
  266|  3.96M|            else 
  267|  3.96M|            {
  268|       |                // fixstr
  269|  3.96M|                const size_t len = type & 0x1f;
  270|       |
  271|  3.96M|                auto data = source_.read_span(len, bytes_buffer_);
  272|  3.96M|                if (data.size() != static_cast<std::size_t>(len))
  ------------------
  |  Branch (272:21): [True: 29, False: 3.96M]
  ------------------
  273|     29|                {
  274|     29|                    ec = msgpack_errc::unexpected_eof;
  275|     29|                    more_ = false;
  276|     29|                    return;
  277|     29|                }
  278|       |
  279|  3.96M|                auto result = unicode_traits::validate(data.data(), data.size());
  280|  3.96M|                if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (280:21): [True: 175, False: 3.96M]
  ------------------
  281|    175|                {
  282|    175|                    ec = msgpack_errc::invalid_utf8_text_string;
  283|    175|                    more_ = false;
  284|    175|                    return;
  285|    175|                }
  286|  3.96M|                visitor.string_value(jsoncons::string_view(reinterpret_cast<const char*>(data.data()),data.size()), 
  287|  3.96M|                    semantic_tag::none, *this, ec);
  288|  3.96M|                more_ = !cursor_mode_;
  289|  3.96M|            }
  290|  12.2M|        }
  291|  21.0M|        else if (type >= 0xe0) 
  ------------------
  |  Branch (291:18): [True: 4.62M, False: 16.4M]
  ------------------
  292|  4.62M|        {
  293|       |            // negative fixint
  294|  4.62M|            visitor.int64_value(static_cast<int8_t>(type), semantic_tag::none, *this, ec);
  295|  4.62M|            more_ = !cursor_mode_;
  296|  4.62M|        }
  297|  16.4M|        else
  298|  16.4M|        {
  299|  16.4M|            switch (type)
  300|  16.4M|            {
  301|   140k|                case jsoncons::msgpack::msgpack_type::nil_type: 
  ------------------
  |  Branch (301:17): [True: 140k, False: 16.2M]
  ------------------
  302|   140k|                {
  303|   140k|                    visitor.null_value(semantic_tag::none, *this, ec);
  304|   140k|                    more_ = !cursor_mode_;
  305|   140k|                    break;
  306|      0|                }
  307|  10.8M|                case jsoncons::msgpack::msgpack_type::true_type:
  ------------------
  |  Branch (307:17): [True: 10.8M, False: 5.55M]
  ------------------
  308|  10.8M|                {
  309|  10.8M|                    visitor.bool_value(true, semantic_tag::none, *this, ec);
  310|  10.8M|                    more_ = !cursor_mode_;
  311|  10.8M|                    break;
  312|      0|                }
  313|  3.43M|                case jsoncons::msgpack::msgpack_type::false_type:
  ------------------
  |  Branch (313:17): [True: 3.43M, False: 12.9M]
  ------------------
  314|  3.43M|                {
  315|  3.43M|                    visitor.bool_value(false, semantic_tag::none, *this, ec);
  316|  3.43M|                    more_ = !cursor_mode_;
  317|  3.43M|                    break;
  318|      0|                }
  319|  66.8k|                case jsoncons::msgpack::msgpack_type::float32_type: 
  ------------------
  |  Branch (319:17): [True: 66.8k, False: 16.3M]
  ------------------
  320|  66.8k|                {
  321|  66.8k|                    uint8_t buf[sizeof(float)];
  322|  66.8k|                    if (source_.read(buf, sizeof(float)) != sizeof(float))
  ------------------
  |  Branch (322:25): [True: 5, False: 66.8k]
  ------------------
  323|      5|                    {
  324|      5|                        ec = msgpack_errc::unexpected_eof;
  325|      5|                        more_ = false;
  326|      5|                        return;
  327|      5|                    }
  328|  66.8k|                    float val = binary::big_to_native<float>(buf, sizeof(buf));
  329|  66.8k|                    visitor.double_value(val, semantic_tag::none, *this, ec);
  330|  66.8k|                    more_ = !cursor_mode_;
  331|  66.8k|                    break;
  332|  66.8k|                }
  333|       |
  334|  16.1k|                case jsoncons::msgpack::msgpack_type::float64_type: 
  ------------------
  |  Branch (334:17): [True: 16.1k, False: 16.3M]
  ------------------
  335|  16.1k|                {
  336|  16.1k|                    uint8_t buf[sizeof(double)];
  337|  16.1k|                    if (source_.read(buf, sizeof(double)) != sizeof(double))
  ------------------
  |  Branch (337:25): [True: 9, False: 16.0k]
  ------------------
  338|      9|                    {
  339|      9|                        ec = msgpack_errc::unexpected_eof;
  340|      9|                        more_ = false;
  341|      9|                        return;
  342|      9|                    }
  343|  16.0k|                    double val = binary::big_to_native<double>(buf, sizeof(buf));
  344|  16.0k|                    visitor.double_value(val, semantic_tag::none, *this, ec);
  345|  16.0k|                    more_ = !cursor_mode_;
  346|  16.0k|                    break;
  347|  16.1k|                }
  348|       |
  349|  3.62k|                case jsoncons::msgpack::msgpack_type::uint8_type: 
  ------------------
  |  Branch (349:17): [True: 3.62k, False: 16.4M]
  ------------------
  350|  3.62k|                {
  351|  3.62k|                    uint8_t b;
  352|  3.62k|                    if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (352:25): [True: 1, False: 3.62k]
  ------------------
  353|      1|                    {
  354|      1|                        ec = msgpack_errc::unexpected_eof;
  355|      1|                        more_ = false;
  356|      1|                        return;
  357|      1|                    }
  358|  3.62k|                    visitor.uint64_value(b, semantic_tag::none, *this, ec);
  359|  3.62k|                    more_ = !cursor_mode_;
  360|  3.62k|                    break;
  361|  3.62k|                }
  362|       |
  363|   205k|                case jsoncons::msgpack::msgpack_type::uint16_type: 
  ------------------
  |  Branch (363:17): [True: 205k, False: 16.2M]
  ------------------
  364|   205k|                {
  365|   205k|                    uint8_t buf[sizeof(uint16_t)];
  366|   205k|                    if (source_.read(buf, sizeof(uint16_t)) !=sizeof(uint16_t)) 
  ------------------
  |  Branch (366:25): [True: 3, False: 205k]
  ------------------
  367|      3|                    {
  368|      3|                        ec = msgpack_errc::unexpected_eof;
  369|      3|                        more_ = false;
  370|      3|                        return;
  371|      3|                    }
  372|   205k|                    uint16_t val = binary::big_to_native<uint16_t>(buf, sizeof(buf));
  373|   205k|                    visitor.uint64_value(val, semantic_tag::none, *this, ec);
  374|   205k|                    more_ = !cursor_mode_;
  375|   205k|                    break;
  376|   205k|                }
  377|       |
  378|  63.3k|                case jsoncons::msgpack::msgpack_type::uint32_type: 
  ------------------
  |  Branch (378:17): [True: 63.3k, False: 16.3M]
  ------------------
  379|  63.3k|                {
  380|  63.3k|                    uint8_t buf[sizeof(uint32_t)];
  381|  63.3k|                    if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (381:25): [True: 3, False: 63.3k]
  ------------------
  382|      3|                    {
  383|      3|                        ec = msgpack_errc::unexpected_eof;
  384|      3|                        more_ = false;
  385|      3|                        return;
  386|      3|                    }
  387|  63.3k|                    uint32_t val = binary::big_to_native<uint32_t>(buf, sizeof(buf));
  388|  63.3k|                    visitor.uint64_value(val, semantic_tag::none, *this, ec);
  389|  63.3k|                    more_ = !cursor_mode_;
  390|  63.3k|                    break;
  391|  63.3k|                }
  392|       |
  393|  1.81k|                case jsoncons::msgpack::msgpack_type::uint64_type: 
  ------------------
  |  Branch (393:17): [True: 1.81k, False: 16.4M]
  ------------------
  394|  1.81k|                {
  395|  1.81k|                    uint8_t buf[sizeof(uint64_t)];
  396|  1.81k|                    if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (396:25): [True: 3, False: 1.81k]
  ------------------
  397|      3|                    {
  398|      3|                        ec = msgpack_errc::unexpected_eof;
  399|      3|                        more_ = false;
  400|      3|                        return;
  401|      3|                    }
  402|  1.81k|                    uint64_t val = binary::big_to_native<uint64_t>(buf, sizeof(buf));
  403|  1.81k|                    visitor.uint64_value(val, semantic_tag::none, *this, ec);
  404|  1.81k|                    more_ = !cursor_mode_;
  405|  1.81k|                    break;
  406|  1.81k|                }
  407|       |
  408|   215k|                case jsoncons::msgpack::msgpack_type::int8_type: 
  ------------------
  |  Branch (408:17): [True: 215k, False: 16.1M]
  ------------------
  409|   215k|                {
  410|   215k|                    uint8_t buf[sizeof(int8_t)];
  411|   215k|                    if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (411:25): [True: 1, False: 215k]
  ------------------
  412|      1|                    {
  413|      1|                        ec = msgpack_errc::unexpected_eof;
  414|      1|                        more_ = false;
  415|      1|                        return;
  416|      1|                    }
  417|   215k|                    int8_t val = binary::big_to_native<int8_t>(buf, sizeof(buf));
  418|   215k|                    visitor.int64_value(val, semantic_tag::none, *this, ec);
  419|   215k|                    more_ = !cursor_mode_;
  420|   215k|                    break;
  421|   215k|                }
  422|       |
  423|  2.92k|                case jsoncons::msgpack::msgpack_type::int16_type: 
  ------------------
  |  Branch (423:17): [True: 2.92k, False: 16.4M]
  ------------------
  424|  2.92k|                {
  425|  2.92k|                    uint8_t buf[sizeof(int16_t)];
  426|  2.92k|                    if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t))
  ------------------
  |  Branch (426:25): [True: 2, False: 2.92k]
  ------------------
  427|      2|                    {
  428|      2|                        ec = msgpack_errc::unexpected_eof;
  429|      2|                        more_ = false;
  430|      2|                        return;
  431|      2|                    }
  432|  2.92k|                    int16_t val = binary::big_to_native<int16_t>(buf, sizeof(buf));
  433|  2.92k|                    visitor.int64_value(val, semantic_tag::none, *this, ec);
  434|  2.92k|                    more_ = !cursor_mode_;
  435|  2.92k|                    break;
  436|  2.92k|                }
  437|       |
  438|  5.11k|                case jsoncons::msgpack::msgpack_type::int32_type: 
  ------------------
  |  Branch (438:17): [True: 5.11k, False: 16.4M]
  ------------------
  439|  5.11k|                {
  440|  5.11k|                    uint8_t buf[sizeof(int32_t)];
  441|  5.11k|                    if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t))
  ------------------
  |  Branch (441:25): [True: 3, False: 5.11k]
  ------------------
  442|      3|                    {
  443|      3|                        ec = msgpack_errc::unexpected_eof;
  444|      3|                        more_ = false;
  445|      3|                        return;
  446|      3|                    }
  447|  5.11k|                    int32_t val = binary::big_to_native<int32_t>(buf, sizeof(buf));
  448|  5.11k|                    visitor.int64_value(val, semantic_tag::none, *this, ec);
  449|  5.11k|                    more_ = !cursor_mode_;
  450|  5.11k|                    break;
  451|  5.11k|                }
  452|       |
  453|  4.84k|                case jsoncons::msgpack::msgpack_type::int64_type: 
  ------------------
  |  Branch (453:17): [True: 4.84k, False: 16.4M]
  ------------------
  454|  4.84k|                {
  455|  4.84k|                    uint8_t buf[sizeof(int64_t)];
  456|  4.84k|                    if (source_.read(buf, sizeof(int64_t)) != sizeof(int64_t))
  ------------------
  |  Branch (456:25): [True: 4, False: 4.83k]
  ------------------
  457|      4|                    {
  458|      4|                        ec = msgpack_errc::unexpected_eof;
  459|      4|                        more_ = false;
  460|      4|                        return;
  461|      4|                    }
  462|  4.83k|                    int64_t val = binary::big_to_native<int64_t>(buf, sizeof(buf));
  463|  4.83k|                    visitor.int64_value(val, semantic_tag::none, *this, ec);
  464|  4.83k|                    more_ = !cursor_mode_;
  465|  4.83k|                    break;
  466|  4.84k|                }
  467|       |
  468|    812|                case jsoncons::msgpack::msgpack_type::str8_type: 
  ------------------
  |  Branch (468:17): [True: 812, False: 16.4M]
  ------------------
  469|  1.27k|                case jsoncons::msgpack::msgpack_type::str16_type: 
  ------------------
  |  Branch (469:17): [True: 460, False: 16.4M]
  ------------------
  470|  1.64k|                case jsoncons::msgpack::msgpack_type::str32_type: 
  ------------------
  |  Branch (470:17): [True: 374, False: 16.4M]
  ------------------
  471|  1.64k|                {
  472|  1.64k|                    std::size_t len = get_size(type, ec);
  473|  1.64k|                    if (!more_)
  ------------------
  |  Branch (473:25): [True: 23, False: 1.62k]
  ------------------
  474|     23|                    {
  475|     23|                        return;
  476|     23|                    }
  477|       |
  478|  1.62k|                    auto data = source_.read_span(len, bytes_buffer_);
  479|  1.62k|                    if (data.size() != static_cast<std::size_t>(len))
  ------------------
  |  Branch (479:25): [True: 119, False: 1.50k]
  ------------------
  480|    119|                    {
  481|    119|                        ec = msgpack_errc::unexpected_eof;
  482|    119|                        more_ = false;
  483|    119|                        return;
  484|    119|                    }
  485|       |
  486|  1.50k|                    auto result = unicode_traits::validate(data.data(), data.size());
  487|  1.50k|                    if (result.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (487:25): [True: 35, False: 1.46k]
  ------------------
  488|     35|                    {
  489|     35|                        ec = msgpack_errc::invalid_utf8_text_string;
  490|     35|                        more_ = false;
  491|     35|                        return;
  492|     35|                    }
  493|  1.46k|                    visitor.string_value(jsoncons::string_view(reinterpret_cast<const char*>(data.data()),data.size()), 
  494|  1.46k|                        semantic_tag::none, *this, ec);
  495|  1.46k|                    more_ = !cursor_mode_;
  496|  1.46k|                    break;
  497|  1.50k|                }
  498|       |
  499|  12.8k|                case jsoncons::msgpack::msgpack_type::bin8_type: 
  ------------------
  |  Branch (499:17): [True: 12.8k, False: 16.3M]
  ------------------
  500|  19.0k|                case jsoncons::msgpack::msgpack_type::bin16_type: 
  ------------------
  |  Branch (500:17): [True: 6.15k, False: 16.4M]
  ------------------
  501|  19.5k|                case jsoncons::msgpack::msgpack_type::bin32_type: 
  ------------------
  |  Branch (501:17): [True: 526, False: 16.4M]
  ------------------
  502|  19.5k|                {
  503|  19.5k|                    std::size_t len = get_size(type,ec);
  504|  19.5k|                    if (!more_)
  ------------------
  |  Branch (504:25): [True: 29, False: 19.5k]
  ------------------
  505|     29|                    {
  506|     29|                        return;
  507|     29|                    }
  508|  19.5k|                    auto data = source_.read_span(len, bytes_buffer_);
  509|  19.5k|                    if (JSONCONS_UNLIKELY(data.size() != static_cast<std::size_t>(len)))
  ------------------
  |  |   79|  19.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 136, False: 19.3k]
  |  |  ------------------
  ------------------
  510|    136|                    {
  511|    136|                        ec = msgpack_errc::unexpected_eof;
  512|    136|                        more_ = false;
  513|    136|                        return;
  514|    136|                    }
  515|       |
  516|  19.3k|                    visitor.byte_string_value(byte_string_view(data.data(),data.size()), 
  517|  19.3k|                        semantic_tag::none, 
  518|  19.3k|                        *this,
  519|  19.3k|                        ec);
  520|  19.3k|                    more_ = !cursor_mode_;
  521|  19.3k|                    break;
  522|  19.5k|                }
  523|  14.3k|                case jsoncons::msgpack::msgpack_type::fixext1_type: 
  ------------------
  |  Branch (523:17): [True: 14.3k, False: 16.3M]
  ------------------
  524|  1.31M|                case jsoncons::msgpack::msgpack_type::fixext2_type: 
  ------------------
  |  Branch (524:17): [True: 1.30M, False: 15.1M]
  ------------------
  525|  1.32M|                case jsoncons::msgpack::msgpack_type::fixext4_type: 
  ------------------
  |  Branch (525:17): [True: 5.16k, False: 16.4M]
  ------------------
  526|  1.33M|                case jsoncons::msgpack::msgpack_type::fixext8_type: 
  ------------------
  |  Branch (526:17): [True: 12.7k, False: 16.3M]
  ------------------
  527|  1.33M|                case jsoncons::msgpack::msgpack_type::fixext16_type: 
  ------------------
  |  Branch (527:17): [True: 707, False: 16.4M]
  ------------------
  528|  1.37M|                case jsoncons::msgpack::msgpack_type::ext8_type: 
  ------------------
  |  Branch (528:17): [True: 35.1k, False: 16.3M]
  ------------------
  529|  1.37M|                case jsoncons::msgpack::msgpack_type::ext16_type: 
  ------------------
  |  Branch (529:17): [True: 890, False: 16.4M]
  ------------------
  530|  1.37M|                case jsoncons::msgpack::msgpack_type::ext32_type: 
  ------------------
  |  Branch (530:17): [True: 910, False: 16.4M]
  ------------------
  531|  1.37M|                {
  532|  1.37M|                    std::size_t len = get_size(type,ec);
  533|  1.37M|                    if (!more_)
  ------------------
  |  Branch (533:25): [True: 26, False: 1.37M]
  ------------------
  534|     26|                    {
  535|     26|                        return;
  536|     26|                    }
  537|       |
  538|       |                    // type
  539|  1.37M|                    uint8_t buf[sizeof(int8_t)];
  540|  1.37M|                    if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (540:25): [True: 46, False: 1.37M]
  ------------------
  541|     46|                    {
  542|     46|                        ec = msgpack_errc::unexpected_eof;
  543|     46|                        more_ = false;
  544|     46|                        return;
  545|     46|                    }
  546|       |
  547|  1.37M|                    int8_t ext_type = binary::big_to_native<int8_t>(buf, sizeof(buf));
  548|       |
  549|  1.37M|                    bool is_timestamp = false; 
  550|  1.37M|                    if (ext_type == -1)
  ------------------
  |  Branch (550:25): [True: 41.1k, False: 1.33M]
  ------------------
  551|  41.1k|                    {
  552|  41.1k|                        is_timestamp = true;;
  553|  41.1k|                    }
  554|       |
  555|       |                    // payload
  556|  1.37M|                    if (is_timestamp && len == 4)
  ------------------
  |  Branch (556:25): [True: 41.1k, False: 1.33M]
  |  Branch (556:41): [True: 1.07k, False: 40.1k]
  ------------------
  557|  1.07k|                    {
  558|  1.07k|                        uint8_t buf32[sizeof(uint32_t)];
  559|  1.07k|                        if (source_.read(buf32, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (559:29): [True: 4, False: 1.07k]
  ------------------
  560|      4|                        {
  561|      4|                            ec = msgpack_errc::unexpected_eof;
  562|      4|                            more_ = false;
  563|      4|                            return;
  564|      4|                        }
  565|  1.07k|                        uint32_t val = binary::big_to_native<uint32_t>(buf32, sizeof(buf32));
  566|  1.07k|                        visitor.uint64_value(val, semantic_tag::epoch_second, *this, ec);
  567|  1.07k|                        more_ = !cursor_mode_;
  568|  1.07k|                    }
  569|  1.37M|                    else if (is_timestamp && len == 8)
  ------------------
  |  Branch (569:30): [True: 40.1k, False: 1.33M]
  |  Branch (569:46): [True: 10.1k, False: 29.9k]
  ------------------
  570|  10.1k|                    {
  571|  10.1k|                        uint8_t buf64[sizeof(uint64_t)];
  572|  10.1k|                        if (source_.read(buf64, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (572:29): [True: 7, False: 10.1k]
  ------------------
  573|      7|                        {
  574|      7|                            ec = msgpack_errc::unexpected_eof;
  575|      7|                            more_ = false;
  576|      7|                            return;
  577|      7|                        }
  578|  10.1k|                        uint64_t data64 = binary::big_to_native<uint64_t>(buf64, sizeof(buf64));
  579|  10.1k|                        uint64_t sec = data64 & 0x00000003ffffffffL;
  580|  10.1k|                        uint64_t nsec = data64 >> 34;
  581|       |
  582|  10.1k|                        bigint nano(sec);
  583|  10.1k|                        nano *= uint64_t(nanos_in_second);
  584|  10.1k|                        nano += nsec;
  585|  10.1k|                        text_buffer_.clear();
  586|  10.1k|                        nano.append_to_buffer(text_buffer_);
  587|  10.1k|                        visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);
  588|  10.1k|                        more_ = !cursor_mode_;
  589|  10.1k|                        if (!more_) return;
  ------------------
  |  Branch (589:29): [True: 0, False: 10.1k]
  ------------------
  590|  10.1k|                    }
  591|  1.36M|                    else if (is_timestamp && len == 12)
  ------------------
  |  Branch (591:30): [True: 29.9k, False: 1.33M]
  |  Branch (591:46): [True: 28.6k, False: 1.25k]
  ------------------
  592|  28.6k|                    {
  593|  28.6k|                        uint8_t buf1[sizeof(uint32_t)];
  594|  28.6k|                        if (source_.read(buf1, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (594:29): [True: 4, False: 28.6k]
  ------------------
  595|      4|                        {
  596|      4|                            ec = msgpack_errc::unexpected_eof;
  597|      4|                            more_ = false;
  598|      4|                            return;
  599|      4|                        }
  600|  28.6k|                        uint32_t nsec = binary::big_to_native<uint32_t>(buf1, sizeof(buf1));
  601|       |
  602|  28.6k|                        uint8_t buf2[sizeof(int64_t)];
  603|  28.6k|                        if (source_.read(buf2, sizeof(int64_t)) != sizeof(int64_t))
  ------------------
  |  Branch (603:29): [True: 4, False: 28.6k]
  ------------------
  604|      4|                        {
  605|      4|                            ec = msgpack_errc::unexpected_eof;
  606|      4|                            more_ = false;
  607|      4|                            return;
  608|      4|                        }
  609|  28.6k|                        int64_t sec = binary::big_to_native<int64_t>(buf2, sizeof(buf2));
  610|       |
  611|  28.6k|                        bigint nano(sec);
  612|       |
  613|  28.6k|                        nano *= uint64_t(nanos_in_second);
  614|       |
  615|  28.6k|                        if (nano < 0)
  ------------------
  |  Branch (615:29): [True: 8.53k, False: 20.1k]
  ------------------
  616|  8.53k|                        {
  617|  8.53k|                            nano -= nsec;
  618|  8.53k|                        }
  619|  20.1k|                        else
  620|  20.1k|                        {
  621|  20.1k|                            nano += nsec;
  622|  20.1k|                        }
  623|       |
  624|  28.6k|                        text_buffer_.clear();
  625|  28.6k|                        nano.append_to_buffer(text_buffer_);
  626|  28.6k|                        visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);
  627|  28.6k|                        more_ = !cursor_mode_;
  628|  28.6k|                        if (!more_) return;
  ------------------
  |  Branch (628:29): [True: 0, False: 28.6k]
  ------------------
  629|  28.6k|                    }
  630|  1.33M|                    else
  631|  1.33M|                    {
  632|  1.33M|                        auto data = source_.read_span(len, bytes_buffer_);
  633|  1.33M|                        if (JSONCONS_UNLIKELY(data.size() != static_cast<std::size_t>(len)))
  ------------------
  |  |   79|  1.33M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 196, False: 1.33M]
  |  |  ------------------
  ------------------
  634|    196|                        {
  635|    196|                            ec = msgpack_errc::unexpected_eof;
  636|    196|                            more_ = false;
  637|    196|                            return;
  638|    196|                        }
  639|       |
  640|  1.33M|                        visitor.byte_string_value(byte_string_view(data.data(),data.size()), 
  641|  1.33M|                                                          static_cast<uint8_t>(ext_type), 
  642|  1.33M|                                                          *this,
  643|  1.33M|                                                          ec);
  644|  1.33M|                        more_ = !cursor_mode_;
  645|  1.33M|                    }
  646|  1.37M|                    break;
  647|  1.37M|                }
  648|       |
  649|  1.37M|                case jsoncons::msgpack::msgpack_type::array16_type: 
  ------------------
  |  Branch (649:17): [True: 2.62k, False: 16.4M]
  ------------------
  650|  3.68k|                case jsoncons::msgpack::msgpack_type::array32_type: 
  ------------------
  |  Branch (650:17): [True: 1.05k, False: 16.4M]
  ------------------
  651|  3.68k|                {
  652|  3.68k|                    begin_array(visitor,type,ec);
  653|  3.68k|                    break;
  654|  2.62k|                }
  655|       |
  656|  2.46k|                case jsoncons::msgpack::msgpack_type::map16_type : 
  ------------------
  |  Branch (656:17): [True: 2.46k, False: 16.4M]
  ------------------
  657|  4.08k|                case jsoncons::msgpack::msgpack_type::map32_type : 
  ------------------
  |  Branch (657:17): [True: 1.62k, False: 16.4M]
  ------------------
  658|  4.08k|                {
  659|  4.08k|                    begin_object(visitor, type, ec);
  660|  4.08k|                    break;
  661|  2.46k|                }
  662|       |
  663|      4|                default:
  ------------------
  |  Branch (663:17): [True: 4, False: 16.4M]
  ------------------
  664|      4|                {
  665|      4|                    ec = msgpack_errc::unknown_type;
  666|      4|                    more_ = false;
  667|      4|                    return;
  668|  2.46k|                }
  669|  16.4M|            }
  670|  16.4M|        }
  671|  33.3M|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12begin_objectERNS_21basic_generic_visitorIcEEhRNS3_10error_codeE:
  701|   212k|    {
  702|   212k|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   79|   212k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 212k]
  |  |  ------------------
  ------------------
  703|      1|        {
  704|      1|            ec = msgpack_errc::max_nesting_depth_exceeded;
  705|      1|            more_ = false;
  706|      1|            return;
  707|      1|        } 
  708|   212k|        std::size_t length = get_size(type, ec);
  709|   212k|        if (!more_)
  ------------------
  |  Branch (709:13): [True: 18, False: 212k]
  ------------------
  710|     18|        {
  711|     18|            return;
  712|     18|        }
  713|   212k|        state_stack_.emplace_back(parse_mode::map_key,length);
  714|   212k|        visitor.begin_object(length, semantic_tag::none, *this, ec);
  715|   212k|        more_ = !cursor_mode_;
  716|   212k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayERNS_21basic_generic_visitorIcEEhRNS3_10error_codeE:
  674|   195k|    {
  675|   195k|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   79|   195k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 195k]
  |  |  ------------------
  ------------------
  676|      3|        {
  677|      3|            ec = msgpack_errc::max_nesting_depth_exceeded;
  678|      3|            more_ = false;
  679|      3|            return;
  680|      3|        } 
  681|   195k|        std::size_t length = get_size(type, ec);
  682|   195k|        if (!more_)
  ------------------
  |  Branch (682:13): [True: 17, False: 195k]
  ------------------
  683|     17|        {
  684|     17|            return;
  685|     17|        }
  686|   195k|        state_stack_.emplace_back(parse_mode::array,length);
  687|   195k|        visitor.begin_array(length, semantic_tag::none, *this, ec);
  688|   195k|        more_ = !cursor_mode_;
  689|   195k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE8get_sizeEhRNS3_10error_codeE:
  727|  1.80M|    {
  728|  1.80M|        switch (type)
  729|  1.80M|        {
  730|    812|            case jsoncons::msgpack::msgpack_type::str8_type: 
  ------------------
  |  Branch (730:13): [True: 812, False: 1.80M]
  ------------------
  731|  13.6k|            case jsoncons::msgpack::msgpack_type::bin8_type: 
  ------------------
  |  Branch (731:13): [True: 12.8k, False: 1.78M]
  ------------------
  732|  48.7k|            case jsoncons::msgpack::msgpack_type::ext8_type: 
  ------------------
  |  Branch (732:13): [True: 35.1k, False: 1.76M]
  ------------------
  733|  48.7k|            {
  734|  48.7k|                uint8_t buf[sizeof(int8_t)];
  735|  48.7k|                if (source_.read(buf, sizeof(int8_t)) != sizeof(int8_t))
  ------------------
  |  Branch (735:21): [True: 24, False: 48.7k]
  ------------------
  736|     24|                {
  737|     24|                    ec = msgpack_errc::unexpected_eof;
  738|     24|                    more_ = false;
  739|     24|                    return 0;
  740|     24|                }
  741|  48.7k|                uint8_t len = binary::big_to_native<uint8_t>(buf, sizeof(buf));
  742|  48.7k|                return static_cast<std::size_t>(len);
  743|  48.7k|            }
  744|       |
  745|    460|            case jsoncons::msgpack::msgpack_type::str16_type: 
  ------------------
  |  Branch (745:13): [True: 460, False: 1.80M]
  ------------------
  746|  6.61k|            case jsoncons::msgpack::msgpack_type::bin16_type: 
  ------------------
  |  Branch (746:13): [True: 6.15k, False: 1.79M]
  ------------------
  747|  7.50k|            case jsoncons::msgpack::msgpack_type::ext16_type: 
  ------------------
  |  Branch (747:13): [True: 890, False: 1.80M]
  ------------------
  748|  10.1k|            case jsoncons::msgpack::msgpack_type::array16_type: 
  ------------------
  |  Branch (748:13): [True: 2.62k, False: 1.79M]
  ------------------
  749|  12.5k|            case jsoncons::msgpack::msgpack_type::map16_type:
  ------------------
  |  Branch (749:13): [True: 2.46k, False: 1.79M]
  ------------------
  750|  12.5k|            {
  751|  12.5k|                uint8_t buf[sizeof(int16_t)];
  752|  12.5k|                if (source_.read(buf, sizeof(int16_t)) != sizeof(int16_t))
  ------------------
  |  Branch (752:21): [True: 42, False: 12.5k]
  ------------------
  753|     42|                {
  754|     42|                    ec = msgpack_errc::unexpected_eof;
  755|     42|                    more_ = false;
  756|     42|                    return 0;
  757|     42|                }
  758|  12.5k|                uint16_t len = binary::big_to_native<uint16_t>(buf, sizeof(buf));
  759|  12.5k|                return static_cast<std::size_t>(len);
  760|  12.5k|            }
  761|       |
  762|    374|            case jsoncons::msgpack::msgpack_type::str32_type: 
  ------------------
  |  Branch (762:13): [True: 374, False: 1.80M]
  ------------------
  763|    900|            case jsoncons::msgpack::msgpack_type::bin32_type: 
  ------------------
  |  Branch (763:13): [True: 526, False: 1.80M]
  ------------------
  764|  1.81k|            case jsoncons::msgpack::msgpack_type::ext32_type: 
  ------------------
  |  Branch (764:13): [True: 910, False: 1.80M]
  ------------------
  765|  2.86k|            case jsoncons::msgpack::msgpack_type::array32_type: 
  ------------------
  |  Branch (765:13): [True: 1.05k, False: 1.80M]
  ------------------
  766|  4.49k|            case jsoncons::msgpack::msgpack_type::map32_type : 
  ------------------
  |  Branch (766:13): [True: 1.62k, False: 1.80M]
  ------------------
  767|  4.49k|            {
  768|  4.49k|                uint8_t buf[sizeof(int32_t)];
  769|  4.49k|                if (source_.read(buf, sizeof(int32_t)) != sizeof(int32_t))
  ------------------
  |  Branch (769:21): [True: 47, False: 4.44k]
  ------------------
  770|     47|                {
  771|     47|                    ec = msgpack_errc::unexpected_eof;
  772|     47|                    more_ = false;
  773|     47|                    return 0;
  774|     47|                }
  775|  4.44k|                uint32_t len = binary::big_to_native<uint32_t>(buf, sizeof(buf));
  776|  4.44k|                return static_cast<std::size_t>(len);
  777|  4.49k|            }
  778|  14.3k|            case jsoncons::msgpack::msgpack_type::fixext1_type: 
  ------------------
  |  Branch (778:13): [True: 14.3k, False: 1.78M]
  ------------------
  779|  14.3k|                return 1;
  780|  1.30M|            case jsoncons::msgpack::msgpack_type::fixext2_type: 
  ------------------
  |  Branch (780:13): [True: 1.30M, False: 498k]
  ------------------
  781|  1.30M|                return 2;
  782|  5.16k|            case jsoncons::msgpack::msgpack_type::fixext4_type: 
  ------------------
  |  Branch (782:13): [True: 5.16k, False: 1.79M]
  ------------------
  783|  5.16k|                return 4;
  784|  12.7k|            case jsoncons::msgpack::msgpack_type::fixext8_type: 
  ------------------
  |  Branch (784:13): [True: 12.7k, False: 1.78M]
  ------------------
  785|  12.7k|                return 8;
  786|    707|            case jsoncons::msgpack::msgpack_type::fixext16_type: 
  ------------------
  |  Branch (786:13): [True: 707, False: 1.80M]
  ------------------
  787|    707|                return 16;
  788|   399k|            default:
  ------------------
  |  Branch (788:13): [True: 399k, False: 1.40M]
  ------------------
  789|   399k|                if ((type > 0x8f && type <= 0x9f) // fixarray
  ------------------
  |  Branch (789:22): [True: 191k, False: 207k]
  |  Branch (789:37): [True: 191k, False: 0]
  ------------------
  790|   207k|                    || (type > 0x7f && type <= 0x8f) // fixmap
  ------------------
  |  Branch (790:25): [True: 207k, False: 0]
  |  Branch (790:40): [True: 207k, False: 0]
  ------------------
  791|   399k|        )
  792|   399k|                {
  793|   399k|                    return type & 0x0f;
  794|   399k|                }
  795|      0|                else
  796|      0|                {
  797|      0|                    ec = msgpack_errc::unknown_type;
  798|      0|                    more_ = false;
  799|      0|                    return 0;
  800|      0|                }
  801|      0|                break;
  802|  1.80M|        }
  803|  1.80M|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9end_arrayERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  692|   172k|    {
  693|   172k|        --nesting_depth_;
  694|       |
  695|   172k|        visitor.end_array(*this, ec);
  696|   172k|        more_ = !cursor_mode_;
  697|   172k|        state_stack_.pop_back();
  698|   172k|    }
_ZN8jsoncons7msgpack20basic_msgpack_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10end_objectERNS_21basic_generic_visitorIcEERNS3_10error_codeE:
  719|   182k|    {
  720|   182k|        --nesting_depth_;
  721|   182k|        visitor.end_object(*this, ec);
  722|   182k|        more_ = !cursor_mode_;
  723|   182k|        state_stack_.pop_back();
  724|   182k|    }

_ZN8jsoncons7msgpack20basic_msgpack_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RNS_18basic_json_visitorIcEERKNS0_22msgpack_decode_optionsERKS7_:
   51|  4.82k|       : parser_(std::forward<Sourceable>(source), options, alloc),
   52|  4.82k|         adaptor_(visitor, alloc), visitor_(adaptor_)
   53|  4.82k|    {
   54|  4.82k|    }
_ZN8jsoncons7msgpack20basic_msgpack_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4readERNS3_10error_codeE:
   87|  4.82k|    {
   88|  4.82k|        parser_.reset();
   89|  4.82k|        parser_.parse(visitor_, ec);
   90|  4.82k|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|  4.82k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3.86k, False: 958]
  |  |  ------------------
  ------------------
   91|  3.86k|        {
   92|  3.86k|            return;
   93|  3.86k|        }
   94|  4.82k|    }