LLVMFuzzerTestOneInput:
   12|     21|{
   13|     21|    std::string s(reinterpret_cast<const char*>(data), size);
   14|     21|    std::istringstream is(s);
   15|     21|    std::vector<uint8_t> s1;
   16|     21|    cbor_bytes_encoder encoder(s1);
   17|     21|    cbor_stream_reader reader(is, encoder);
   18|       |
   19|     21|    std::error_code ec;
   20|     21|    reader.read(ec);
   21|       |
   22|     21|    return 0;
   23|     21|}

_ZN8jsoncons11countr_zeroImEEiT_:
  294|      2|{
  295|      2|    return jsoncons::nonstd::countr_zero(x);
  296|      2|}

_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1008|  3.25k|        {
 1009|  3.25k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1009:17): [True: 792, False: 2.46k]
  ------------------
 1010|    792|            {
 1011|    792|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1011:21): [True: 725, False: 67]
  |  Branch (1011:86): [True: 710, False: 15]
  ------------------
 1012|    710|                {
 1013|    710|                    key_buffer_.push_back(',');
 1014|    710|                }
 1015|    792|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
 1016|    792|                key_buffer_.push_back('[');
 1017|    792|            }
 1018|  2.46k|            else
 1019|  2.46k|            {
 1020|  2.46k|                switch (level_stack_.back().target_kind())
 1021|  2.46k|                {
 1022|  2.23k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1022:21): [True: 2.23k, False: 231]
  ------------------
 1023|  2.23k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1023:29): [True: 1.50k, False: 736]
  |  Branch (1023:65): [True: 879, False: 621]
  ------------------
 1024|    879|                        {
 1025|    879|                            key_buffer_.push_back(',');
 1026|    879|                        }
 1027|  2.23k|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
 1028|  2.23k|                        key_buffer_.push_back('[');
 1029|  2.23k|                        break;
 1030|    231|                    default:
  ------------------
  |  Branch (1030:21): [True: 231, False: 2.23k]
  ------------------
 1031|    231|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::array);
 1032|    231|                        destination_->begin_array(length, tag, context, ec);
 1033|    231|                        break;
 1034|  2.46k|                }
 1035|  2.46k|            }
 1036|  3.25k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  3.25k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1037|  3.25k|        }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure6is_keyEv:
  815|  10.6M|            {
  816|  10.6M|                return even_odd_ == 0;
  817|  10.6M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure11target_kindEv:
  825|  6.44M|            {
  826|  6.44M|                return target_kind_;
  827|  6.44M|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure5countEv:
  830|  1.44M|            {
  831|  1.44M|                return count_;
  832|  1.44M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structureC2ENS4_16json_target_kindENS4_19json_structure_kindE:
  798|  4.43k|                : target_kind_(state), structure_kind_(type), even_odd_(type == json_structure_kind::object ? 0 : 1)
  ------------------
  |  Branch (798:73): [True: 1.12k, False: 3.30k]
  ------------------
  799|  4.43k|            {
  800|  4.43k|            }
_ZNK8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure9is_objectEv:
  820|  5.10M|            {
  821|  5.10M|                return structure_kind_ == json_structure_kind::object;
  822|  5.10M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE15visit_end_arrayERKNS_11ser_contextERNS1_10error_codeE:
 1040|  3.15k|        {
 1041|  3.15k|            switch (level_stack_.back().target_kind())
 1042|  3.15k|            {
 1043|  2.95k|                case json_target_kind::buffer:
  ------------------
  |  Branch (1043:17): [True: 2.95k, False: 200]
  ------------------
 1044|  2.95k|                    key_buffer_.push_back(']');
 1045|  2.95k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   54|  2.95k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 2.95k]
  |  |  ------------------
  |  |   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|  2.95k|                    level_stack_.pop_back();
 1047|  2.95k|                    if (level_stack_.back().target_kind() == json_target_kind::destination)
  ------------------
  |  Branch (1047:25): [True: 65, False: 2.88k]
  ------------------
 1048|     65|                    {
 1049|     65|                        destination_->key(key_buffer_, context, ec);
 1050|     65|                        key_buffer_.clear();
 1051|     65|                    }
 1052|  2.88k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (1052:30): [True: 712, False: 2.17k]
  ------------------
 1053|    712|                    {
 1054|    712|                        key_buffer_.push_back(':');
 1055|    712|                    }
 1056|  2.95k|                    level_stack_.back().advance();
 1057|  2.95k|                    break;
 1058|    200|                default:
  ------------------
  |  Branch (1058:17): [True: 200, False: 2.95k]
  ------------------
 1059|    200|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   54|    200|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 200]
  |  |  ------------------
  |  |   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|    200|                    level_stack_.pop_back();
 1061|    200|                    level_stack_.back().advance();
 1062|    200|                    destination_->end_array(context, ec);
 1063|    200|                    break;
 1064|  3.15k|            }
 1065|  3.15k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  3.15k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1066|  3.15k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE14json_structure7advanceEv:
  803|  3.66M|            {
  804|  3.66M|                if (!is_key())
  ------------------
  |  Branch (804:21): [True: 3.07M, False: 592k]
  ------------------
  805|  3.07M|                {
  806|  3.07M|                    ++count_;
  807|  3.07M|                }
  808|  3.66M|                if (is_object())
  ------------------
  |  Branch (808:21): [True: 1.18M, False: 2.48M]
  ------------------
  809|  1.18M|                {
  810|  1.18M|                    even_odd_ = !even_odd_;
  811|  1.18M|                }
  812|  3.66M|            }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1233|  2.31M|        {
 1234|  2.31M|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1234:17): [True: 524k, False: 1.79M]
  |  Branch (1234:49): [True: 529k, False: 1.26M]
  ------------------
 1235|  1.05M|            {
 1236|  1.05M|                key_.clear();
 1237|  1.05M|                jsoncons::from_integer(value,key_);
 1238|  1.05M|            }
 1239|       |
 1240|  2.31M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1240:17): [True: 524k, False: 1.79M]
  ------------------
 1241|   524k|            {
 1242|   524k|                switch (level_stack_.back().target_kind())
 1243|   524k|                {
 1244|   524k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1244:21): [True: 524k, False: 68]
  ------------------
 1245|   524k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1245:29): [True: 524k, False: 21]
  ------------------
 1246|   524k|                        {
 1247|   524k|                            key_buffer_.push_back(',');
 1248|   524k|                        }
 1249|   524k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1250|   524k|                        key_buffer_.push_back(':');
 1251|   524k|                        break;
 1252|     68|                    default:
  ------------------
  |  Branch (1252:21): [True: 68, False: 524k]
  ------------------
 1253|     68|                        destination_->key(key_, context, ec);
 1254|     68|                        break;
 1255|   524k|                }
 1256|   524k|            }
 1257|  1.79M|            else
 1258|  1.79M|            {
 1259|  1.79M|                switch (level_stack_.back().target_kind())
 1260|  1.79M|                {
 1261|   529k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1261:21): [True: 529k, False: 1.26M]
  ------------------
 1262|   529k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1262:29): [True: 4.55k, False: 524k]
  |  Branch (1262:65): [True: 4.29k, False: 263]
  ------------------
 1263|  4.29k|                        {
 1264|  4.29k|                            key_buffer_.push_back(',');
 1265|  4.29k|                        }
 1266|   529k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1267|   529k|                        break;
 1268|  1.26M|                    default:
  ------------------
  |  Branch (1268:21): [True: 1.26M, False: 529k]
  ------------------
 1269|  1.26M|                        destination_->uint64_value(value, tag, context, ec);
 1270|  1.26M|                        break;
 1271|  1.79M|                }
 1272|  1.79M|            }
 1273|       |
 1274|  2.31M|            level_stack_.back().advance();
 1275|  2.31M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  2.31M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1276|  2.31M|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1279|    334|        {
 1280|    334|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1280:17): [True: 108, False: 226]
  |  Branch (1280:49): [True: 211, False: 15]
  ------------------
 1281|    319|            {
 1282|    319|                key_.clear();
 1283|    319|                jsoncons::from_integer(value,key_);
 1284|    319|            }
 1285|       |
 1286|    334|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1286:17): [True: 108, False: 226]
  ------------------
 1287|    108|            {
 1288|    108|                switch (level_stack_.back().target_kind())
 1289|    108|                {
 1290|     99|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1290:21): [True: 99, False: 9]
  ------------------
 1291|     99|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1291:29): [True: 55, False: 44]
  ------------------
 1292|     55|                        {
 1293|     55|                            key_buffer_.push_back(',');
 1294|     55|                        }
 1295|     99|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1296|     99|                        key_buffer_.push_back(':');
 1297|     99|                        break;
 1298|      9|                    default:
  ------------------
  |  Branch (1298:21): [True: 9, False: 99]
  ------------------
 1299|      9|                        destination_->key(key_, context, ec);
 1300|      9|                        break;
 1301|    108|                }
 1302|    108|            }
 1303|    226|            else
 1304|    226|            {
 1305|    226|                switch (level_stack_.back().target_kind())
 1306|    226|                {
 1307|    211|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1307:21): [True: 211, False: 15]
  ------------------
 1308|    211|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1308:29): [True: 145, False: 66]
  |  Branch (1308:65): [True: 137, False: 8]
  ------------------
 1309|    137|                        {
 1310|    137|                            key_buffer_.push_back(',');
 1311|    137|                        }
 1312|    211|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1313|    211|                        break;
 1314|     15|                    default:
  ------------------
  |  Branch (1314:21): [True: 15, False: 211]
  ------------------
 1315|     15|                        destination_->int64_value(value, tag, context, ec);
 1316|     15|                        break;
 1317|    226|                }
 1318|    226|            }
 1319|       |
 1320|    334|            level_stack_.back().advance();
 1321|    334|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    334|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1322|    334|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1374|   453k|        {
 1375|   453k|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1375:17): [True: 34, False: 453k]
  |  Branch (1375:49): [True: 384k, False: 69.6k]
  ------------------
 1376|   384k|            {
 1377|   384k|                key_.clear();
 1378|   384k|                string_sink<string_type> sink(key_);
 1379|   384k|                jsoncons::write_double f{float_chars_format::general,0};
 1380|   384k|                f(value, sink);
 1381|   384k|            }
 1382|       |
 1383|   453k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1383:17): [True: 34, False: 453k]
  ------------------
 1384|     34|            {
 1385|     34|                switch (level_stack_.back().target_kind())
 1386|     34|                {
 1387|     34|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1387:21): [True: 34, False: 0]
  ------------------
 1388|     34|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1388:29): [True: 4, False: 30]
  ------------------
 1389|      4|                        {
 1390|      4|                            key_buffer_.push_back(',');
 1391|      4|                        }
 1392|     34|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1393|     34|                        key_buffer_.push_back(':');
 1394|     34|                        break;
 1395|      0|                    default:
  ------------------
  |  Branch (1395:21): [True: 0, False: 34]
  ------------------
 1396|      0|                        destination_->key(key_, context, ec);
 1397|      0|                        break;
 1398|     34|                }
 1399|     34|            }
 1400|   453k|            else
 1401|   453k|            {
 1402|   453k|                switch (level_stack_.back().target_kind())
 1403|   453k|                {
 1404|   384k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1404:21): [True: 384k, False: 69.6k]
  ------------------
 1405|   384k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1405:29): [True: 384k, False: 0]
  |  Branch (1405:65): [True: 383k, False: 302]
  ------------------
 1406|   383k|                        {
 1407|   383k|                            key_buffer_.push_back(',');
 1408|   383k|                        }
 1409|   384k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1410|   384k|                        break;
 1411|  69.6k|                    default:
  ------------------
  |  Branch (1411:21): [True: 69.6k, False: 384k]
  ------------------
 1412|  69.6k|                        destination_->double_value(value, tag, context, ec);
 1413|  69.6k|                        break;
 1414|   453k|                }
 1415|   453k|            }
 1416|       |
 1417|   453k|            level_stack_.back().advance();
 1418|   453k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   453k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1419|   453k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE11visit_flushEv:
  881|      4|        {
  882|      4|            destination_->flush();
  883|      4|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  886|     65|        {
  887|     65|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (887:17): [True: 9, False: 56]
  ------------------
  888|      9|            {
  889|      9|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (889:21): [True: 8, False: 1]
  |  Branch (889:86): [True: 8, False: 0]
  ------------------
  890|      8|                {
  891|      8|                    key_buffer_.push_back(',');
  892|      8|                }
  893|      9|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  894|      9|                key_buffer_.push_back('{');
  895|      9|            }
  896|     56|            else
  897|     56|            {
  898|     56|                switch (level_stack_.back().target_kind())
  899|     56|                {
  900|     50|                    case json_target_kind::buffer:
  ------------------
  |  Branch (900:21): [True: 50, False: 6]
  ------------------
  901|     50|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  902|     50|                        key_buffer_.push_back('{');
  903|     50|                        break;
  904|      6|                    default:
  ------------------
  |  Branch (904:21): [True: 6, False: 50]
  ------------------
  905|      6|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::object);
  906|      6|                        destination_->begin_object(tag, context, ec);
  907|      6|                        break;
  908|     56|                }
  909|     56|            }
  910|     65|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     65|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  911|     65|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  914|  1.06k|        {
  915|  1.06k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (915:17): [True: 444, False: 617]
  ------------------
  916|    444|            {
  917|    444|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (917:21): [True: 411, False: 33]
  |  Branch (917:86): [True: 281, False: 130]
  ------------------
  918|    281|                {
  919|    281|                    key_buffer_.push_back(',');
  920|    281|                }
  921|    444|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  922|    444|                key_buffer_.push_back('{');
  923|    444|            }
  924|    617|            else
  925|    617|            {
  926|    617|                switch (level_stack_.back().target_kind())
  927|    617|                {
  928|    553|                    case json_target_kind::buffer:
  ------------------
  |  Branch (928:21): [True: 553, False: 64]
  ------------------
  929|    553|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (929:29): [True: 226, False: 327]
  |  Branch (929:65): [True: 215, False: 11]
  ------------------
  930|    215|                        {
  931|    215|                            key_buffer_.push_back(',');
  932|    215|                        }
  933|    553|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::object);
  934|    553|                        key_buffer_.push_back('{');
  935|    553|                        break;
  936|     64|                    default:
  ------------------
  |  Branch (936:21): [True: 64, False: 553]
  ------------------
  937|     64|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::object);
  938|     64|                        destination_->begin_object(length, tag, context, ec);
  939|     64|                        break;
  940|    617|                }
  941|    617|            }
  942|  1.06k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  1.06k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  943|  1.06k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE16visit_end_objectERKNS_11ser_contextERNS1_10error_codeE:
  946|    989|        {
  947|    989|            switch (level_stack_.back().target_kind())
  948|    989|            {
  949|    932|                case json_target_kind::buffer:
  ------------------
  |  Branch (949:17): [True: 932, False: 57]
  ------------------
  950|    932|                    key_buffer_.push_back('}');
  951|    932|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   54|    932|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 932]
  |  |  ------------------
  |  |   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|    932|                    level_stack_.pop_back();
  953|       |                    
  954|    932|                    if (level_stack_.back().target_kind() == json_target_kind::destination)
  ------------------
  |  Branch (954:25): [True: 32, False: 900]
  ------------------
  955|     32|                    {
  956|     32|                        destination_->key(key_buffer_,context, ec);
  957|     32|                        key_buffer_.clear();
  958|     32|                    }
  959|    900|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (959:30): [True: 402, False: 498]
  ------------------
  960|    402|                    {
  961|    402|                        key_buffer_.push_back(':');
  962|    402|                    }
  963|    932|                    level_stack_.back().advance();
  964|    932|                    break;
  965|     57|                default:
  ------------------
  |  Branch (965:17): [True: 57, False: 932]
  ------------------
  966|     57|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   54|     57|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 57]
  |  |  ------------------
  |  |   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|     57|                    level_stack_.pop_back();
  968|     57|                    level_stack_.back().advance();
  969|     57|                    destination_->end_object(context, ec);
  970|     57|                    break;
  971|    989|            }
  972|    989|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    989|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  973|    989|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  976|     24|        {
  977|     24|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (977:17): [True: 2, False: 22]
  ------------------
  978|      2|            {
  979|      2|                if (level_stack_.back().target_kind() == json_target_kind::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (979:21): [True: 2, False: 0]
  |  Branch (979:86): [True: 1, False: 1]
  ------------------
  980|      1|                {
  981|      1|                    key_buffer_.push_back(',');
  982|      1|                }
  983|      2|                level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
  984|      2|                key_buffer_.push_back('[');
  985|      2|            }
  986|     22|            else
  987|     22|            {
  988|     22|                switch (level_stack_.back().target_kind())
  989|     22|                {
  990|     15|                    case json_target_kind::buffer:
  ------------------
  |  Branch (990:21): [True: 15, False: 7]
  ------------------
  991|     15|                        if (level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (991:29): [True: 14, False: 1]
  |  Branch (991:64): [True: 0, False: 14]
  ------------------
  992|      0|                        {
  993|      0|                            key_buffer_.push_back(',');
  994|      0|                        }
  995|     15|                        level_stack_.emplace_back(json_target_kind::buffer, json_structure_kind::array);
  996|     15|                        key_buffer_.push_back('[');
  997|     15|                        break;
  998|      7|                    default:
  ------------------
  |  Branch (998:21): [True: 7, False: 15]
  ------------------
  999|      7|                        level_stack_.emplace_back(json_target_kind::destination, json_structure_kind::array);
 1000|      7|                        destination_->begin_array(tag, context, ec);
 1001|      7|                        break;
 1002|     22|                }
 1003|     22|            }
 1004|     24|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     24|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1005|     24|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1475|    278|        {
 1476|    278|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1476:17): [True: 86, False: 192]
  |  Branch (1476:49): [True: 192, False: 0]
  ------------------
 1477|    278|            {
 1478|    278|                key_.clear(); 
 1479|    278|                key_.insert(key_.begin(), json_literals<char_type>::null_literal.begin(), json_literals<char_type>::null_literal.end());
 1480|    278|            }
 1481|       |
 1482|    278|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1482:17): [True: 86, False: 192]
  ------------------
 1483|     86|            {
 1484|     86|                switch (level_stack_.back().target_kind())
 1485|     86|                {
 1486|     86|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1486:21): [True: 86, False: 0]
  ------------------
 1487|     86|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1487:29): [True: 47, False: 39]
  ------------------
 1488|     47|                        {
 1489|     47|                            key_buffer_.push_back(',');
 1490|     47|                        }
 1491|     86|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1492|     86|                        key_buffer_.push_back(':');
 1493|     86|                        break;
 1494|      0|                    default:
  ------------------
  |  Branch (1494:21): [True: 0, False: 86]
  ------------------
 1495|      0|                        destination_->key(key_, context, ec);
 1496|      0|                        break;
 1497|     86|                }
 1498|     86|            }
 1499|    192|            else
 1500|    192|            {
 1501|    192|                switch (level_stack_.back().target_kind())
 1502|    192|                {
 1503|    192|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1503:21): [True: 192, False: 0]
  ------------------
 1504|    192|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1504:29): [True: 120, False: 72]
  |  Branch (1504:65): [True: 96, False: 24]
  ------------------
 1505|     96|                        {
 1506|     96|                            key_buffer_.push_back(',');
 1507|     96|                        }
 1508|    192|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1509|    192|                        break;
 1510|      0|                    default:
  ------------------
  |  Branch (1510:21): [True: 0, False: 192]
  ------------------
 1511|      0|                        destination_->null_value(tag, context, ec);
 1512|      0|                        break;
 1513|    192|                }
 1514|    192|            }
 1515|       |
 1516|    278|            level_stack_.back().advance();
 1517|    278|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    278|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1518|    278|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE12visit_stringERKNS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1072|   366k|        {
 1073|   366k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1073:17): [True: 65.6k, False: 301k]
  ------------------
 1074|  65.6k|            {
 1075|  65.6k|                switch (level_stack_.back().target_kind())
 1076|  65.6k|                {
 1077|     84|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1077:21): [True: 84, False: 65.5k]
  ------------------
 1078|     84|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1078:29): [True: 84, False: 0]
  ------------------
 1079|     84|                        {
 1080|     84|                            key_buffer_.push_back(',');
 1081|     84|                        }
 1082|     84|                        key_buffer_.push_back('\"');
 1083|     84|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1084|     84|                        key_buffer_.push_back('\"');
 1085|     84|                        key_buffer_.push_back(':');
 1086|     84|                        break;
 1087|  65.5k|                    default:
  ------------------
  |  Branch (1087:21): [True: 65.5k, False: 84]
  ------------------
 1088|  65.5k|                        destination_->key(value, context, ec);
 1089|  65.5k|                        break;
 1090|  65.6k|                }
 1091|  65.6k|            }
 1092|   301k|            else
 1093|   301k|            {
 1094|   301k|                switch (level_stack_.back().target_kind())
 1095|   301k|                {
 1096|    341|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1096:21): [True: 341, False: 300k]
  ------------------
 1097|    341|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1097:29): [True: 155, False: 186]
  |  Branch (1097:65): [True: 106, False: 49]
  ------------------
 1098|    106|                        {
 1099|    106|                            key_buffer_.push_back(',');
 1100|    106|                        }
 1101|    341|                        key_buffer_.push_back('\"');
 1102|    341|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1103|    341|                        key_buffer_.push_back('\"');
 1104|    341|                        break;
 1105|   300k|                    default:
  ------------------
  |  Branch (1105:21): [True: 300k, False: 341]
  ------------------
 1106|   300k|                        destination_->string_value(value, tag, context, ec);
 1107|   300k|                        break;
 1108|   301k|                }
 1109|   301k|            }
 1110|       |
 1111|   366k|            level_stack_.back().advance();
 1112|   366k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   366k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1113|   366k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1119|   524k|        {
 1120|   524k|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1120:17): [True: 143, False: 524k]
  |  Branch (1120:49): [True: 524k, False: 29]
  ------------------
 1121|   524k|            {
 1122|   524k|                key_.clear();
 1123|   524k|                switch (tag)
 1124|   524k|                {
 1125|      0|                    case semantic_tag::base64:
  ------------------
  |  Branch (1125:21): [True: 0, False: 524k]
  ------------------
 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: 524k]
  ------------------
 1129|      0|                        bytes_to_base16(value.begin(), value.end(),key_);
 1130|      0|                        break;
 1131|   524k|                    default:
  ------------------
  |  Branch (1131:21): [True: 524k, False: 0]
  ------------------
 1132|   524k|                        bytes_to_base64url(value.begin(), value.end(),key_);
 1133|   524k|                        break;
 1134|   524k|                }
 1135|   524k|            }
 1136|       |
 1137|   524k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1137:17): [True: 143, False: 524k]
  ------------------
 1138|    143|            {
 1139|    143|                switch (level_stack_.back().target_kind())
 1140|    143|                {
 1141|    139|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1141:21): [True: 139, False: 4]
  ------------------
 1142|    139|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1142:29): [True: 60, False: 79]
  ------------------
 1143|     60|                        {
 1144|     60|                            key_buffer_.push_back(',');
 1145|     60|                        }
 1146|    139|                        key_buffer_.push_back('\"');
 1147|    139|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1148|    139|                        key_buffer_.push_back('\"');
 1149|    139|                        key_buffer_.push_back(':');
 1150|    139|                        break;
 1151|      4|                    default:
  ------------------
  |  Branch (1151:21): [True: 4, False: 139]
  ------------------
 1152|      4|                        destination_->key(key_, context, ec);
 1153|      4|                        break;
 1154|    143|                }
 1155|    143|            }
 1156|   524k|            else
 1157|   524k|            {
 1158|   524k|                switch (level_stack_.back().target_kind())
 1159|   524k|                {
 1160|   524k|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1160:21): [True: 524k, False: 29]
  ------------------
 1161|   524k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1161:29): [True: 524k, False: 60]
  |  Branch (1161:65): [True: 524k, False: 21]
  ------------------
 1162|   524k|                        {
 1163|   524k|                            key_buffer_.push_back(',');
 1164|   524k|                        }
 1165|   524k|                        key_buffer_.push_back('\"');
 1166|   524k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1167|   524k|                        key_buffer_.push_back('\"');
 1168|   524k|                        break;
 1169|     29|                    default:
  ------------------
  |  Branch (1169:21): [True: 29, False: 524k]
  ------------------
 1170|     29|                        destination_->byte_string_value(value, tag, context, ec);
 1171|     29|                        break;
 1172|   524k|                }
 1173|   524k|            }
 1174|       |
 1175|   524k|            level_stack_.back().advance();
 1176|   524k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   524k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1177|   524k|        }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS1_10error_codeE:
 1183|     42|        {
 1184|     42|            if (level_stack_.back().is_key() || level_stack_.back().target_kind() == json_target_kind::buffer)
  ------------------
  |  Branch (1184:17): [True: 17, False: 25]
  |  Branch (1184:49): [True: 23, False: 2]
  ------------------
 1185|     40|            {
 1186|     40|                key_.clear();
 1187|     40|                bytes_to_base64url(value.begin(), value.end(),key_);
 1188|     40|            }
 1189|       |
 1190|     42|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1190:17): [True: 17, False: 25]
  ------------------
 1191|     17|            {
 1192|     17|                switch (level_stack_.back().target_kind())
 1193|     17|                {
 1194|     16|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1194:21): [True: 16, False: 1]
  ------------------
 1195|     16|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1195:29): [True: 16, False: 0]
  ------------------
 1196|     16|                        {
 1197|     16|                            key_buffer_.push_back(',');
 1198|     16|                        }
 1199|     16|                        key_buffer_.push_back('\"');
 1200|     16|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1201|     16|                        key_buffer_.push_back('\"');
 1202|     16|                        key_buffer_.push_back(':');
 1203|     16|                        break;
 1204|      1|                    default:
  ------------------
  |  Branch (1204:21): [True: 1, False: 16]
  ------------------
 1205|      1|                        destination_->key(key_, context, ec);
 1206|      1|                        break;
 1207|     17|                }
 1208|     17|            }
 1209|     25|            else
 1210|     25|            {
 1211|     25|                switch (level_stack_.back().target_kind())
 1212|     25|                {
 1213|     23|                    case json_target_kind::buffer:
  ------------------
  |  Branch (1213:21): [True: 23, False: 2]
  ------------------
 1214|     23|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1214:29): [True: 5, False: 18]
  |  Branch (1214:65): [True: 4, False: 1]
  ------------------
 1215|      4|                        {
 1216|      4|                            key_buffer_.push_back(',');
 1217|      4|                        }
 1218|     23|                        key_buffer_.push_back('\"');
 1219|     23|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1220|     23|                        key_buffer_.push_back('\"');
 1221|     23|                        break;
 1222|      2|                    default:
  ------------------
  |  Branch (1222:21): [True: 2, False: 23]
  ------------------
 1223|      2|                        destination_->byte_string_value(value, raw_tag, context, ec);
 1224|      2|                        break;
 1225|     25|                }
 1226|     25|            }
 1227|       |
 1228|     42|            level_stack_.back().advance();
 1229|     42|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     42|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1230|     42|        }
_ZN8jsoncons21basic_generic_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  294|  3.25k|    {
  295|  3.25k|        visit_begin_array(length, tag, context, ec);
  296|  3.25k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  3.25k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  297|  3.25k|    }
_ZN8jsoncons21basic_generic_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  363|  2.31M|    {
  364|  2.31M|        visit_uint64(value, tag, context, ec);
  365|  2.31M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  2.31M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  366|  2.31M|    }
_ZN8jsoncons21basic_generic_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  300|  3.15k|    {
  301|  3.15k|        visit_end_array(context, ec);
  302|  3.15k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  3.15k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  303|  3.15k|    }
_ZN8jsoncons21basic_generic_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  372|    334|    {
  373|    334|        visit_int64(value, tag, context, ec);
  374|    334|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    334|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  375|    334|    }
_ZN8jsoncons21basic_generic_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  390|   453k|    {
  391|   453k|        visit_double(value, tag, context, ec);
  392|   453k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   453k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  393|   453k|    }
_ZN8jsoncons29basic_generic_to_json_visitorIcNSt3__19allocatorIcEEEC2ERNS_18basic_json_visitorIcEERKS3_:
  855|     21|            : destination_(std::addressof(visitor)), 
  856|     21|              key_(alloc), key_buffer_(alloc), level_stack_(alloc)
  857|     21|        {
  858|     21|            level_stack_.emplace_back(json_target_kind::destination,json_structure_kind::root); // root
  859|     21|        }
_ZN8jsoncons21basic_generic_visitorIcEC2Ev:
   52|     21|    basic_generic_visitor() = default;
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr6nonstd18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  343|   524k|    {
  344|   524k|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  345|   524k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   524k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  346|   524k|    }
_ZN8jsoncons21basic_generic_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr6nonstd18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  354|     42|    {
  355|     42|        visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), raw_tag, context, ec);
  356|     42|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     42|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  357|     42|    }
_ZN8jsoncons21basic_generic_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  314|    278|    {
  315|    278|        visit_null(tag, context, ec);
  316|    278|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    278|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  317|    278|    }
_ZN8jsoncons21basic_generic_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  332|   366k|    {
  333|   366k|        visit_string(value, tag, context, ec);
  334|   366k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   366k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  335|   366k|    }
_ZN8jsoncons21basic_generic_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  288|     24|    {
  289|     24|        visit_begin_array(tag, context, ec);
  290|     24|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     24|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  291|     24|    }
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  267|     65|    {
  268|     65|        visit_begin_object(tag, context, ec);
  269|     65|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     65|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  270|     65|    }
_ZN8jsoncons21basic_generic_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  276|  1.06k|    {
  277|  1.06k|        visit_begin_object(length, tag, context, ec);
  278|  1.06k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  1.06k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  279|  1.06k|    }
_ZN8jsoncons21basic_generic_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  282|    989|    {
  283|    989|        visit_end_object(context, ec);
  284|    989|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    989|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  285|    989|    }
_ZN8jsoncons21basic_generic_visitorIcE5flushEv:
   57|      4|    {
   58|      4|        visit_flush();
   59|      4|    }

_ZN8jsoncons19typed_array_visitorD2Ev:
   33|     63|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  345|    231|        {
  346|    231|            visit_begin_array(length, tag, context, ec);
  347|    231|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    231|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  348|    231|        }
_ZN8jsoncons18basic_json_visitorIcE3keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  357|  65.7k|        {
  358|  65.7k|            visit_key(name, context, ec);
  359|  65.7k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  65.7k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  360|  65.7k|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  351|    200|        {
  352|    200|            visit_end_array(context, ec);
  353|    200|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    200|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  354|    200|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|  1.26M|        {
  415|  1.26M|            visit_uint64(value, tag, context, ec);
  416|  1.26M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  1.26M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  417|  1.26M|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|     15|        {
  424|     15|            visit_int64(value, tag, context, ec);
  425|     15|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     15|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  426|     15|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|  69.6k|        {
  442|  69.6k|            visit_double(value, tag, context, ec);
  443|  69.6k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  69.6k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  444|  69.6k|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|      4|        {
  109|      4|            visit_flush();
  110|      4|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  318|      6|        {
  319|      6|            visit_begin_object(tag, context, ec);
  320|      6|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  321|      6|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  327|     64|        {
  328|     64|            visit_begin_object(length, tag, context, ec);
  329|     64|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     64|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  330|     64|        }
_ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  333|     57|        {
  334|     57|            visit_end_object(context, ec);
  335|     57|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     57|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  336|     57|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  339|      7|        {
  340|      7|            visit_begin_array(tag, context, ec);
  341|      7|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      7|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  342|      7|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  383|   300k|        {
  384|   300k|            visit_string(value, tag, context, ec);
  385|   300k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   300k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  386|   300k|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr6nonstd18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  394|     29|        {
  395|     29|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  396|     29|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     29|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  397|     29|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr6nonstd18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  405|      2|        {
  406|      2|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), raw_tag, context, ec);
  407|      2|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  408|      2|        }
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|     42|        basic_json_visitor() = default;
_ZN8jsoncons26basic_default_json_visitorIcEC2Ev:
  811|     21|        basic_default_json_visitor() = default;

_ZN8jsoncons6nonstd11countr_zeroImEEiT_:
   75|      2|int countr_zero(T value) {
   76|      2|    static_assert(std::is_integral<T>::value && std::is_unsigned<T>::value, "Type must be unsigned integer");
   77|       |    
   78|      2|    if (value == 0) {
  ------------------
  |  Branch (78:9): [True: 0, False: 2]
  ------------------
   79|      0|        return sizeof(T) * 8; // Or std::numeric_limits<T>::digits
   80|      0|    }
   81|       |    
   82|      2|    #if defined(__GNUC__) || defined(__clang__)
   83|      2|        if (sizeof(T) <= sizeof(unsigned int)) {
  ------------------
  |  Branch (83:13): [Folded, False: 2]
  ------------------
   84|      0|            return __builtin_ctz(static_cast<unsigned int>(value));
   85|      2|        } else if (sizeof(T) <= sizeof(unsigned long)) {
  ------------------
  |  Branch (85:20): [True: 2, Folded]
  ------------------
   86|      2|            return __builtin_ctzl(static_cast<unsigned long>(value));
   87|      2|        } else {
   88|      0|            return __builtin_ctzll(static_cast<unsigned long long>(value));
   89|      0|        }
   90|       |    #elif defined(_MSC_VER)
   91|       |        unsigned long index;
   92|       |        #if defined(_M_X64) || defined(_M_ARM64)
   93|       |            JSONCONS_IF_CONSTEXPR (sizeof(T) == 8) 
   94|       |            {
   95|       |                _BitScanForward64(&index, static_cast<unsigned __int64>(value));
   96|       |                return static_cast<int>(index);
   97|       |            }
   98|       |            else
   99|       |            {
  100|       |                _BitScanForward(&index, static_cast<unsigned long>(value));
  101|       |                return static_cast<int>(index);
  102|       |            }
  103|       |        #else
  104|       |            _BitScanForward(&index, static_cast<unsigned long>(value));
  105|       |            return static_cast<int>(index);
  106|       |        #endif
  107|       |    #else
  108|       |        int count = 0;
  109|       |        while ((value & 1) == 0) {
  110|       |            count++;
  111|       |            value >>= 1;
  112|       |        }
  113|       |        return count;
  114|       |    #endif
  115|      2|}

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

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

_ZN8jsoncons6nonstd16to_plain_pointerImEEPT_S3_:
  265|      3|    {       
  266|      3|        return (ptr);
  267|      3|    }  
_ZN8jsoncons6nonstd14integer_limitsIlvE6lowestEv:
  111|      1|        {
  112|      1|            return std::numeric_limits<T>::lowest();
  113|      1|        }
_ZN8jsoncons6nonstd14integer_limitsIlvE3maxEv:
  103|     13|        {
  104|     13|            return (std::numeric_limits<T>::max)();
  105|     13|        }

_ZNK8jsoncons6nonstd4spanIKhLm18446744073709551615EE4sizeEv:
  116|  1.78M|        {
  117|  1.78M|            return size_;
  118|  1.78M|        }
_ZNK8jsoncons6nonstd4spanIKtLm18446744073709551615EE4sizeEv:
  116|  4.81k|        {
  117|  4.81k|            return size_;
  118|  4.81k|        }
_ZNK8jsoncons6nonstd4spanIKjLm18446744073709551615EE4sizeEv:
  116|    504|        {
  117|    504|            return size_;
  118|    504|        }
_ZNK8jsoncons6nonstd4spanIKmLm18446744073709551615EE4sizeEv:
  116|      9|        {
  117|      9|            return size_;
  118|      9|        }
_ZNK8jsoncons6nonstd4spanIKiLm18446744073709551615EE4sizeEv:
  116|     63|        {
  117|     63|            return size_;
  118|     63|        }
_ZNK8jsoncons6nonstd4spanIKlLm18446744073709551615EE4sizeEv:
  116|    264|        {
  117|    264|            return size_;
  118|    264|        }
_ZNK8jsoncons6nonstd4spanIKfLm18446744073709551615EE4sizeEv:
  116|   391k|        {
  117|   391k|            return size_;
  118|   391k|        }
_ZNK8jsoncons6nonstd4spanIKdLm18446744073709551615EE4sizeEv:
  116|  63.5k|        {
  117|  63.5k|            return size_;
  118|  63.5k|        }
_ZNK8jsoncons6nonstd4spanIKhLm18446744073709551615EE4dataEv:
  111|   891k|        {
  112|   891k|            return data_;
  113|   891k|        }
_ZN8jsoncons6nonstd4spanIKhLm18446744073709551615EEC2EPS2_m:
   61|   890k|            : data_(data), size_(size)
   62|   890k|        {
   63|   890k|        }
_ZNK8jsoncons6nonstd4spanIhLm18446744073709551615EE4dataEv:
  111|  4.35k|        {
  112|  4.35k|            return data_;
  113|  4.35k|        }
_ZNK8jsoncons6nonstd4spanIhLm18446744073709551615EE4sizeEv:
  116|  4.35k|        {
  117|  4.35k|            return size_;
  118|  4.35k|        }
_ZN8jsoncons6nonstd4spanIhLm18446744073709551615EEC2INSt3__16vectorIhNS4_9allocatorIhEEEEEERT_PNS4_9enable_ifIXaaaaaantsr7is_spanIS9_EE5valuentsr6nonstd12is_std_arrayIS9_EE5valuesr6nonstd21is_compatible_elementIS9_hEE5valuesr6nonstd17has_data_and_sizeIS9_EE5valueEvE4typeE:
   68|  4.35k|            : data_(c.data()), size_(c.size())
   69|  4.35k|        {
   70|  4.35k|        }
_ZN8jsoncons6nonstd4spanIKhLm18446744073709551615EEC2IhLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|     35|            : data_(s.data()), size_(s.size())
  103|     35|        {
  104|     35|        }
_ZNK8jsoncons6nonstd4spanIKhLm18446744073709551615EEixEm:
  126|  2.67k|         {
  127|  2.67k|             return data_[index];
  128|  2.67k|         }
_ZN8jsoncons6nonstd4spanItLm18446744073709551615EEC2EPtm:
   61|  3.15k|            : data_(data), size_(size)
   62|  3.15k|        {
   63|  3.15k|        }
_ZNK8jsoncons6nonstd4spanItLm18446744073709551615EE4sizeEv:
  116|  4.82k|        {
  117|  4.82k|            return size_;
  118|  4.82k|        }
_ZNK8jsoncons6nonstd4spanItLm18446744073709551615EEixEm:
  126|    192|         {
  127|    192|             return data_[index];
  128|    192|         }
_ZN8jsoncons6nonstd4spanIKtLm18446744073709551615EEC2ItLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|  1.57k|            : data_(s.data()), size_(s.size())
  103|  1.57k|        {
  104|  1.57k|        }
_ZNK8jsoncons6nonstd4spanItLm18446744073709551615EE4dataEv:
  111|  1.57k|        {
  112|  1.57k|            return data_;
  113|  1.57k|        }
_ZNK8jsoncons6nonstd4spanIKtLm18446744073709551615EEixEm:
  126|    106|         {
  127|    106|             return data_[index];
  128|    106|         }
_ZN8jsoncons6nonstd4spanIjLm18446744073709551615EEC2EPjm:
   61|    252|            : data_(data), size_(size)
   62|    252|        {
   63|    252|        }
_ZNK8jsoncons6nonstd4spanIjLm18446744073709551615EE4sizeEv:
  116|    504|        {
  117|    504|            return size_;
  118|    504|        }
_ZNK8jsoncons6nonstd4spanIjLm18446744073709551615EEixEm:
  126|    252|         {
  127|    252|             return data_[index];
  128|    252|         }
_ZN8jsoncons6nonstd4spanIKjLm18446744073709551615EEC2IjLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|    126|            : data_(s.data()), size_(s.size())
  103|    126|        {
  104|    126|        }
_ZNK8jsoncons6nonstd4spanIjLm18446744073709551615EE4dataEv:
  111|    126|        {
  112|    126|            return data_;
  113|    126|        }
_ZNK8jsoncons6nonstd4spanIKjLm18446744073709551615EEixEm:
  126|    126|         {
  127|    126|             return data_[index];
  128|    126|         }
_ZN8jsoncons6nonstd4spanImLm18446744073709551615EEC2EPmm:
   61|      4|            : data_(data), size_(size)
   62|      4|        {
   63|      4|        }
_ZNK8jsoncons6nonstd4spanImLm18446744073709551615EE4sizeEv:
  116|      6|        {
  117|      6|            return size_;
  118|      6|        }
_ZN8jsoncons6nonstd4spanIKmLm18446744073709551615EEC2ImLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|      2|            : data_(s.data()), size_(s.size())
  103|      2|        {
  104|      2|        }
_ZNK8jsoncons6nonstd4spanImLm18446744073709551615EE4dataEv:
  111|      2|        {
  112|      2|            return data_;
  113|      2|        }
_ZNK8jsoncons6nonstd4spanIKmLm18446744073709551615EEixEm:
  126|      7|         {
  127|      7|             return data_[index];
  128|      7|         }
_ZN8jsoncons6nonstd4spanIiLm18446744073709551615EEC2EPim:
   61|      2|            : data_(data), size_(size)
   62|      2|        {
   63|      2|        }
_ZNK8jsoncons6nonstd4spanIiLm18446744073709551615EE4sizeEv:
  116|     63|        {
  117|     63|            return size_;
  118|     63|        }
_ZNK8jsoncons6nonstd4spanIiLm18446744073709551615EEixEm:
  126|    120|         {
  127|    120|             return data_[index];
  128|    120|         }
_ZN8jsoncons6nonstd4spanIKiLm18446744073709551615EEC2IiLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|      1|            : data_(s.data()), size_(s.size())
  103|      1|        {
  104|      1|        }
_ZNK8jsoncons6nonstd4spanIiLm18446744073709551615EE4dataEv:
  111|      1|        {
  112|      1|            return data_;
  113|      1|        }
_ZNK8jsoncons6nonstd4spanIKiLm18446744073709551615EEixEm:
  126|     60|         {
  127|     60|             return data_[index];
  128|     60|         }
_ZN8jsoncons6nonstd4spanIlLm18446744073709551615EEC2EPlm:
   61|    176|            : data_(data), size_(size)
   62|    176|        {
   63|    176|        }
_ZNK8jsoncons6nonstd4spanIlLm18446744073709551615EE4sizeEv:
  116|    176|        {
  117|    176|            return size_;
  118|    176|        }
_ZN8jsoncons6nonstd4spanIKlLm18446744073709551615EEC2IlLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|     88|            : data_(s.data()), size_(s.size())
  103|     88|        {
  104|     88|        }
_ZNK8jsoncons6nonstd4spanIlLm18446744073709551615EE4dataEv:
  111|     88|        {
  112|     88|            return data_;
  113|     88|        }
_ZN8jsoncons6nonstd4spanIfLm18446744073709551615EEC2EPfm:
   61|    522|            : data_(data), size_(size)
   62|    522|        {
   63|    522|        }
_ZNK8jsoncons6nonstd4spanIfLm18446744073709551615EE4sizeEv:
  116|    599|        {
  117|    599|            return size_;
  118|    599|        }
_ZNK8jsoncons6nonstd4spanIfLm18446744073709551615EEixEm:
  126|    140|         {
  127|    140|             return data_[index];
  128|    140|         }
_ZN8jsoncons6nonstd4spanIKfLm18446744073709551615EEC2IfLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|    261|            : data_(s.data()), size_(s.size())
  103|    261|        {
  104|    261|        }
_ZNK8jsoncons6nonstd4spanIfLm18446744073709551615EE4dataEv:
  111|    261|        {
  112|    261|            return data_;
  113|    261|        }
_ZNK8jsoncons6nonstd4spanIKfLm18446744073709551615EEixEm:
  126|   390k|         {
  127|   390k|             return data_[index];
  128|   390k|         }
_ZN8jsoncons6nonstd4spanIdLm18446744073709551615EEC2EPdm:
   61|    180|            : data_(data), size_(size)
   62|    180|        {
   63|    180|        }
_ZNK8jsoncons6nonstd4spanIdLm18446744073709551615EE4sizeEv:
  116|    309|        {
  117|    309|            return size_;
  118|    309|        }
_ZNK8jsoncons6nonstd4spanIdLm18446744073709551615EEixEm:
  126|    242|         {
  127|    242|             return data_[index];
  128|    242|         }
_ZN8jsoncons6nonstd4spanIKdLm18446744073709551615EEC2IdLm18446744073709551615EEERKNS1_IT_XT0_EEEPNSt3__19enable_ifIXaaooeqT0_L_ZNS0_L14dynamic_extentEEeqT0_L_ZNS3_6extentEEsr3std14is_convertibleIPA_S5_PA_S2_EE5valueEvE4typeE:
  102|     90|            : data_(s.data()), size_(s.size())
  103|     90|        {
  104|     90|        }
_ZNK8jsoncons6nonstd4spanIdLm18446744073709551615EE4dataEv:
  111|     90|        {
  112|     90|            return data_;
  113|     90|        }
_ZNK8jsoncons6nonstd4spanIKdLm18446744073709551615EEixEm:
  126|  63.3k|         {
  127|  63.3k|             return data_[index];
  128|  63.3k|         }
_ZN8jsoncons6nonstd4spanIKhLm18446744073709551615EEC2Ev:
   58|    707|        {
   59|    707|        }
_ZNK8jsoncons6nonstd4spanIKmLm18446744073709551615EE5emptyEv:
  121|      1|        { 
  122|      1|            return size_ == 0; 
  123|      1|        }
_ZN8jsoncons6nonstd4spanIKmLm18446744073709551615EEC2INSt3__16vectorImNS5_9allocatorImEEEEEERT_PNS5_9enable_ifIXaaaaaantsr7is_spanISA_EE5valuentsr6nonstd12is_std_arrayISA_EE5valuesr6nonstd21is_compatible_elementISA_S2_EE5valuesr6nonstd17has_data_and_sizeISA_EE5valueEvE4typeE:
   68|      1|            : data_(c.data()), size_(c.size())
   69|      1|        {
   70|      1|        }

_ZN8jsoncons6nonstd4u128C2Em:
   29|    501|    constexpr u128(uint64_t lo) : hi(0), lo(lo) {}
_ZNK8jsoncons6nonstd4u128mlERKS1_:
  111|    171|    u128 operator*(const u128& rhs) const {
  112|       |        // Split components into 32-bit chunks to avoid 64-bit overflow during multiplication
  113|    171|        uint64_t a3 = hi >> 32;
  114|    171|        uint64_t a2 = hi & 0xFFFFFFFFFFFFFFULL; // lower 32 bits of hi
  115|    171|        uint64_t a1 = lo >> 32;
  116|    171|        uint64_t a0 = lo & 0xFFFFFFFFULL;
  117|       |
  118|    171|        uint64_t b3 = rhs.hi >> 32;
  119|    171|        uint64_t b2 = rhs.hi & 0xFFFFFFFFFFFFFFULL;
  120|    171|        uint64_t b1 = rhs.lo >> 32;
  121|    171|        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|    171|        uint64_t c0 = a0 * b0;
  128|    171|        uint64_t c1 = a0 * b1 + a1 * b0;
  129|    171|        uint64_t c2 = a0 * b2 + a1 * b1 + a2 * b0;
  130|    171|        uint64_t c3 = a0 * b3 + a1 * b2 + a2 * b1 + a3 * b0;
  131|       |
  132|       |        // Carry propagation
  133|    171|        c1 += (c0 >> 32);
  134|    171|        c2 += (c1 >> 32);
  135|    171|        c3 += (c2 >> 32);
  136|       |
  137|       |        // Reconstruct hi and lo 64-bit values
  138|    171|        uint64_t new_low = (c0 & 0xFFFFFFFFULL) | (c1 << 32);
  139|    171|        uint64_t new_high = (c2 & 0xFFFFFFFFULL) | (c3 << 32);
  140|       |
  141|    171|        return {new_high, new_low};
  142|    171|    }
_ZN8jsoncons6nonstd4u128C2Emm:
   30|    511|    constexpr u128(uint64_t hi, uint64_t lo) : hi(hi), lo(lo) {}
_ZNK8jsoncons6nonstd4u128plERKS1_:
   41|    171|    u128 operator+(const u128& rhs) const {
   42|    171|        uint64_t new_low = lo + rhs.lo;
   43|       |        // Carry occurs if the result wrapped around and is less than one of the inputs
   44|    171|        uint64_t carry = (new_low < lo) ? 1 : 0;
  ------------------
  |  Branch (44:26): [True: 0, False: 171]
  ------------------
   45|    171|        uint64_t new_high = hi + rhs.hi + carry;
   46|    171|        return {new_high, new_low};
   47|    171|    }
_ZNK8jsoncons6nonstd4u128cvmEv:
  154|    177|    explicit operator uint64_t() const {
  155|    177|        return lo;
  156|    177|    }
_ZNK8jsoncons6nonstd4u128rsEj:
   95|    169|    u128 operator>>(unsigned int shift) const {
   96|    169|        if (shift == 0) return *this;
  ------------------
  |  Branch (96:13): [True: 0, False: 169]
  ------------------
   97|    169|        if (shift >= 128) return {0, 0};
  ------------------
  |  Branch (97:13): [True: 0, False: 169]
  ------------------
   98|       |
   99|    169|        if (shift >= 64) {
  ------------------
  |  Branch (99:13): [True: 169, False: 0]
  ------------------
  100|    169|            return {0, hi >> (shift - 64)};
  101|    169|        }
  102|      0|        else {
  103|      0|            return {
  104|      0|                hi >> shift,
  105|      0|                (lo >> shift) | (hi << (64 - shift))
  106|      0|            };
  107|      0|        }
  108|    169|    }
_ZNK8jsoncons6nonstd4u128cvbEv:
   32|    155|    explicit operator bool() const {
   33|    155|        return hi != 0 || lo != 0;
  ------------------
  |  Branch (33:16): [True: 0, False: 155]
  |  Branch (33:27): [True: 7, False: 148]
  ------------------
   34|    155|    }
_ZNK8jsoncons6nonstd4u128geERKS1_:
   71|      2|    {
   72|      2|        if (hi != rhs.hi)
  ------------------
  |  Branch (72:13): [True: 0, False: 2]
  ------------------
   73|      0|            return hi > rhs.hi;
   74|       |
   75|      2|        return lo >= rhs.lo;
   76|      2|    }

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

_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERS7_:
  256|   384k|            : buf_ptr(std::addressof(buf))
  257|   384k|        {
  258|   384k|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9push_backEc:
  287|  7.55M|        {
  288|  7.55M|            buf_ptr->push_back(ch);
  289|  7.55M|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvEC2ERS5_:
  315|     21|            : buf_ptr(std::addressof(buf))
  316|     21|        {
  317|     21|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE9push_backEh:
  334|  1.98M|        {
  335|  1.98M|            buf_ptr->push_back(static_cast<value_type>(ch));
  336|  1.98M|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE5flushEv:
  325|     25|        {
  326|     25|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE6appendEPKhm:
  329|   366k|        {
  330|   366k|            append_impl(*buf_ptr, s, length, 0);
  331|   366k|        }
_ZN8jsoncons10bytes_sinkINSt3__16vectorIhNS1_9allocatorIhEEEEvE11append_implIS5_EEDTcmcldtfp_6insertcldtfp_3endEfp0_plfp0_fp1_Ecvv_EERT_PKhml:
  349|   366k|        {
  350|   366k|            c.insert(c.end(), s, s + length);
  351|   366k|        }

_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev:
  193|     21|    {
  194|     21|        if (chunk_)
  ------------------
  |  Branch (194:13): [True: 21, False: 0]
  ------------------
  195|     21|        {
  196|     21|            std::allocator_traits<char_allocator_type>::deallocate(alloc_, chunk_, chunk_size_);
  197|     21|        }
  198|     21|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  176|     21|        : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  177|     21|          chunk_size_(default_max_chunk_size)
  178|     21|    {
  179|     21|        chunk_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, chunk_size_);
  180|     21|        data_end_ = chunk_;
  181|     21|    }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   57|     21|      : std::basic_istream<CharT>(&nb_)
   58|     21|    {
   59|     21|    }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   43|     21|        null_buffer() = default;
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm:
  377|  1.05M|    {
  378|  1.05M|        std::size_t len = 0;
  379|  1.05M|        if (remaining_ > 0)
  ------------------
  |  Branch (379:13): [True: 1.05M, False: 64]
  ------------------
  380|  1.05M|        {
  381|  1.05M|            len = (std::min)(remaining_, length);
  382|  1.05M|            std::memcpy(p, data_end_, len*sizeof(value_type));
  383|  1.05M|            data_end_ += len;
  384|  1.05M|            remaining_ -= len;
  385|  1.05M|            position_ += len;
  386|  1.05M|        }
  387|  1.05M|        if (length - len == 0)
  ------------------
  |  Branch (387:13): [True: 1.05M, False: 499]
  ------------------
  388|  1.05M|        {
  389|  1.05M|            return len;
  390|  1.05M|        }
  391|    499|        else if (length - len < chunk_size_)
  ------------------
  |  Branch (391:18): [True: 499, False: 0]
  ------------------
  392|    499|        {
  393|    499|            data_end_ = chunk_;
  394|    499|            remaining_ = fill_buffer(chunk_, chunk_size_);
  395|    499|            if (remaining_ > 0)
  ------------------
  |  Branch (395:17): [True: 491, False: 8]
  ------------------
  396|    491|            {
  397|    491|                std::size_t len2 = (std::min)(remaining_, length-len);
  398|    491|                std::memcpy(p+len, data_end_, len2*sizeof(value_type));
  399|    491|                data_end_ += len2;
  400|    491|                remaining_ -= len2;
  401|    491|                position_ += len2;
  402|    491|                len += len2;
  403|    491|            }
  404|    499|            return len;
  405|    499|        }
  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|  1.05M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEPhm:
  442|    981|    {
  443|    981|        if (stream_ptr_->eof())
  ------------------
  |  Branch (443:13): [True: 0, False: 981]
  ------------------
  444|      0|        {
  445|      0|            return 0;
  446|      0|        }
  447|       |
  448|    981|        JSONCONS_TRY
  ------------------
  |  |   37|    981|    #define JSONCONS_TRY try
  ------------------
  449|    981|        {
  450|    981|            std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(chunk), chunk_size);
  451|    981|            std::size_t length = static_cast<std::size_t>(count);
  452|       |
  453|    981|            if (length < chunk_size)
  ------------------
  |  Branch (453:17): [True: 15, False: 966]
  ------------------
  454|     15|            {
  455|     15|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  456|     15|            }
  457|    981|            return length;
  458|    981|        }
  459|    981|        JSONCONS_CATCH(const std::exception&)     
  460|    981|        {
  461|      0|            stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  462|      0|            return 0;
  463|      0|        }
  464|    981|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_6vectorIhS4_EEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr6nonstd7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSD_m:
  746|  1.05M|    {
  747|  1.05M|        std::size_t unread = length;
  748|       |
  749|  2.09M|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (749:16): [True: 1.04M, False: 1.05M]
  |  Branch (749:30): [True: 1.04M, False: 7]
  ------------------
  750|  1.04M|        {
  751|  1.04M|            if (source.remaining() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (751:17): [True: 128, False: 1.04M]
  |  Branch (751:44): [True: 64, False: 64]
  ------------------
  752|     64|            {
  753|     64|                std::size_t n = source.chunk_size();
  754|     64|                std::size_t offset = buffer.size();
  755|     64|                buffer.resize(offset+n);
  756|     64|                std::size_t actual = source.read_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  757|     64|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|     64|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 63]
  |  |  ------------------
  ------------------
  758|      1|                {
  759|      1|                    buffer.resize(offset+actual);
  760|      1|                }
  761|     64|                unread -= actual;
  762|     64|            }
  763|  1.04M|            else
  764|  1.04M|            {
  765|  1.04M|                std::size_t n = (std::min)(source.chunk_size(), unread);
  766|  1.04M|                std::size_t offset = buffer.size();
  767|  1.04M|                buffer.resize(offset+n);
  768|  1.04M|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  769|  1.04M|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|  1.04M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 5, False: 1.04M]
  |  |  ------------------
  ------------------
  770|      5|                {
  771|      5|                    buffer.resize(offset + actual);
  772|      5|                }
  773|  1.04M|                unread -= actual;
  774|  1.04M|            }
  775|  1.04M|        }
  776|  1.05M|        return length - unread;
  777|  1.05M|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv:
  271|  1.04M|    {
  272|  1.04M|        return remaining_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:16): [True: 139, False: 1.04M]
  |  Branch (272:35): [True: 11, False: 128]
  ------------------
  273|  1.04M|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9remainingEv:
  346|  1.04M|    {
  347|  1.04M|        return remaining_;
  348|  1.04M|    }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE10chunk_sizeEv:
  261|  1.04M|    {
  262|  1.04M|        return chunk_size_;
  263|  1.04M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11read_bufferEPhm:
  435|     64|    {
  436|     64|        auto len = fill_buffer(chunk, chunk_size);
  437|     64|        position_ += len;
  438|     64|        return len;
  439|     64|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_6vectorIhS3_EEEENS_6nonstd4spanIKhLm18446744073709551615EEEmOT_:
  352|   525k|    {
  353|   525k|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   79|   525k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 705, False: 524k]
  |  |  ------------------
  ------------------
  354|    705|        {
  355|    705|            return span<const value_type>{};
  356|    705|        }
  357|   524k|        if (remaining_ == 0 && length <= chunk_size_)
  ------------------
  |  Branch (357:13): [True: 65, False: 524k]
  |  Branch (357:32): [True: 64, False: 1]
  ------------------
  358|     64|        {
  359|     64|            remaining_ = fill_buffer(chunk_, chunk_size_);
  360|     64|            data_end_ = chunk_;
  361|     64|        }
  362|   524k|        if (length > remaining_)
  ------------------
  |  Branch (362:13): [True: 6, False: 524k]
  ------------------
  363|      6|        {
  364|      6|            buffer.clear();
  365|      6|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  366|      6|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  367|      6|        }
  368|       |
  369|   524k|        const value_type* data = data_end_;
  370|   524k|        data_end_ += length;
  371|   524k|        remaining_ -= length;
  372|   524k|        position_ += length;
  373|   524k|        return span<const value_type>(data, length);
  374|   524k|    }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_12basic_stringIcNS2_11char_traitsIcEENS3_IcEEEEEENS2_9enable_ifIXaaL_ZNS2_17integral_constantIbLb1EE5valueEEsr6nonstd7is_byteINT_10value_typeEEE5valueEmE4typeERS5_RSG_m:
  746|    117|    {
  747|    117|        std::size_t unread = length;
  748|       |
  749|    296|        while (unread > 0 && !source.eof())
  ------------------
  |  Branch (749:16): [True: 183, False: 113]
  |  Branch (749:30): [True: 179, False: 4]
  ------------------
  750|    179|        {
  751|    179|            if (source.remaining() == 0 && unread >= source.chunk_size())
  ------------------
  |  Branch (751:17): [True: 0, False: 179]
  |  Branch (751:44): [True: 0, False: 0]
  ------------------
  752|      0|            {
  753|      0|                std::size_t n = source.chunk_size();
  754|      0|                std::size_t offset = buffer.size();
  755|      0|                buffer.resize(offset+n);
  756|      0|                std::size_t actual = source.read_buffer(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  757|      0|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  758|      0|                {
  759|      0|                    buffer.resize(offset+actual);
  760|      0|                }
  761|      0|                unread -= actual;
  762|      0|            }
  763|    179|            else
  764|    179|            {
  765|    179|                std::size_t n = (std::min)(source.chunk_size(), unread);
  766|    179|                std::size_t offset = buffer.size();
  767|    179|                buffer.resize(offset+n);
  768|    179|                std::size_t actual = source.read(reinterpret_cast<value_type*>(&buffer[0]) + offset, n);
  769|    179|                if (JSONCONS_UNLIKELY(actual != n))
  ------------------
  |  |   79|    179|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 3, False: 176]
  |  |  ------------------
  ------------------
  770|      3|                {
  771|      3|                    buffer.resize(offset + actual);
  772|      3|                }
  773|    179|                unread -= actual;
  774|    179|            }
  775|    179|        }
  776|    117|        return length - unread;
  777|    117|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE9read_spanIRNS1_12basic_stringIcNS1_11char_traitsIcEENS2_IcEEEEEENS_6nonstd4spanIKhLm18446744073709551615EEEmOT_:
  352|   366k|    {
  353|   366k|        if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   79|   366k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 366k]
  |  |  ------------------
  ------------------
  354|      2|        {
  355|      2|            return span<const value_type>{};
  356|      2|        }
  357|   366k|        if (remaining_ == 0 && length <= chunk_size_)
  ------------------
  |  Branch (357:13): [True: 64, False: 366k]
  |  Branch (357:32): [True: 64, False: 0]
  ------------------
  358|     64|        {
  359|     64|            remaining_ = fill_buffer(chunk_, chunk_size_);
  360|     64|            data_end_ = chunk_;
  361|     64|        }
  362|   366k|        if (length > remaining_)
  ------------------
  |  Branch (362:13): [True: 117, False: 366k]
  ------------------
  363|    117|        {
  364|    117|            buffer.clear();
  365|    117|            source_reader<stream_source_type>::read(*this, std::forward<Buffer>(buffer), length);
  366|    117|            return span<const value_type>(reinterpret_cast<const value_type*>(buffer.data()), buffer.size());
  367|    117|        }
  368|       |
  369|   366k|        const value_type* data = data_end_;
  370|   366k|        data_end_ += length;
  371|   366k|        remaining_ -= length;
  372|   366k|        position_ += length;
  373|   366k|        return span<const value_type>(data, length);
  374|   366k|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4peekEv:
  312|  11.6M|    {
  313|  11.6M|        if (remaining_ == 0)
  ------------------
  |  Branch (313:13): [True: 290, False: 11.6M]
  ------------------
  314|    290|        {
  315|    290|            data_end_ = chunk_;
  316|    290|            remaining_ = fill_buffer(chunk_, chunk_size_);
  317|    290|        }
  318|  11.6M|        if (remaining_ > 0)
  ------------------
  |  Branch (318:13): [True: 11.6M, False: 4]
  ------------------
  319|  11.6M|        {
  320|  11.6M|            value_type c = *data_end_;
  321|  11.6M|            return char_result<value_type>{c, false};
  322|  11.6M|        }
  323|      4|        else
  324|      4|        {
  325|      4|            return char_result<value_type>{0, true};
  326|      4|        }
  327|  11.6M|    }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE6ignoreEm:
  286|  5.31M|    {
  287|  5.31M|        std::size_t len = 0;
  288|  5.31M|        if (remaining_ > 0)
  ------------------
  |  Branch (288:13): [True: 5.31M, False: 0]
  ------------------
  289|  5.31M|        {
  290|  5.31M|            len = (std::min)(remaining_, length);
  291|  5.31M|            position_ += len;
  292|  5.31M|            data_end_ += len;
  293|  5.31M|            remaining_ -= len;
  294|  5.31M|        }
  295|  5.31M|        while (len < length)
  ------------------
  |  Branch (295:16): [True: 0, False: 5.31M]
  ------------------
  296|      0|        {
  297|      0|            data_end_ = chunk_;
  298|      0|            remaining_ = fill_buffer(chunk_, chunk_size_);
  299|      0|            if (remaining_ == 0)
  ------------------
  |  Branch (299:17): [True: 0, False: 0]
  ------------------
  300|      0|            {
  301|      0|                break;
  302|      0|            }
  303|      0|            std::size_t len2 = (std::min)(remaining_, length-len);
  304|      0|            position_ += len2;
  305|      0|            data_end_ += len2;
  306|      0|            remaining_ -= len2;
  307|      0|            len += len2;
  308|      0|        }
  309|  5.31M|    }

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

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

_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IcEEPKT_mRKS3_:
  640|      7|        : storage_(alloc)
  641|      7|    {
  642|      7|        auto r = jsoncons::to_bigint(s, length, *this, alloc);
  643|      7|        if (r.ec != bignum_errc{})
  ------------------
  |  Branch (643:13): [True: 0, False: 7]
  ------------------
  644|      0|        {
  645|      0|            JSONCONS_THROW(std::system_error((int)r.ec, std::system_category()));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  646|      0|        }
  647|      7|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS4_:
  296|    558|        : word_allocator_type(alloc)
  297|    558|    {
  298|    558|        ::new (&inlined_) inlined_storage();
  299|    558|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2Ev:
  116|    558|            : is_allocated_(false),
  117|    558|            is_negative_(false),
  118|    558|            size_(0),
  119|    558|            values_{0, 0}
  120|    558|        {
  121|    558|        }
_ZN8jsoncons9to_bigintIcNSt3__19allocatorImEEEENS_16to_bignum_resultIT_EEPKS5_mRNS_12basic_bigintIT0_EERKSA_:
 2372|      7|{
 2373|      7|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   79|      7|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 7]
  |  |  ------------------
  ------------------
 2374|      0|    {
 2375|      0|        return to_bignum_result<CharT>(data, bignum_errc::invalid_argument);
 2376|      0|    }
 2377|       |
 2378|      7|    if (*data == '-')
  ------------------
  |  Branch (2378:9): [True: 5, False: 2]
  ------------------
 2379|      5|    {
 2380|      5|        return jsoncons::detail::to_bigint(data + 1, length - 1, true, value, alloc);
 2381|      5|    }
 2382|      2|    else
 2383|      2|    {
 2384|      2|        return jsoncons::detail::to_bigint(data, length, false, value, alloc);
 2385|      2|    }
 2386|      7|}
_ZN8jsoncons6detail9to_bigintIcNSt3__19allocatorImEEEENS_16to_bignum_resultIT_EEPKS6_mbRNS_12basic_bigintIT0_EERKSB_:
 2306|      7|{
 2307|      7|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   79|      7|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 7]
  |  |  ------------------
  ------------------
 2308|      0|    {
 2309|      0|        return to_bignum_result<CharT>(data, bignum_errc::invalid_argument);
 2310|      0|    }
 2311|       |
 2312|      7|    using word_type = typename basic_bigint<Allocator>::word_type;
 2313|       |
 2314|      7|    const CharT* last = data + length;
 2315|      7|    const CharT* p = data;
 2316|       |
 2317|      8|    while (p < last && *p == '0')
  ------------------
  |  Branch (2317:12): [True: 7, False: 1]
  |  Branch (2317:24): [True: 1, False: 6]
  ------------------
 2318|      1|    {
 2319|      1|        ++p;
 2320|      1|    }
 2321|      7|    if (p == last)
  ------------------
  |  Branch (2321:9): [True: 1, False: 6]
  ------------------
 2322|      1|    {
 2323|      1|        value = std::move(basic_bigint<Allocator>{0, alloc});
 2324|      1|        return to_bignum_result<CharT>(last, bignum_errc{});
 2325|      1|    }
 2326|      6|    std::size_t num_digits = last - data;
 2327|      6|    std::size_t num_words;
 2328|      6|    if (length < 10)
  ------------------
  |  Branch (2328:9): [True: 0, False: 6]
  ------------------
 2329|      0|    {
 2330|      0|        num_words = 1;
 2331|      0|    }
 2332|      6|    else
 2333|      6|    {
 2334|      6|        std::size_t num_bits = (std::size_t)(((num_digits * detail::bits_per_digit[10]) >> 10) + 1);
 2335|      6|        num_words = (num_bits + 63) >> 6;
 2336|      6|    }
 2337|       |
 2338|      6|    basic_bigint<Allocator> v(0, alloc);
 2339|      6|    v.reserve(num_words);
 2340|    140|    for (std::size_t i = 0; i < length; i++)
  ------------------
  |  Branch (2340:29): [True: 134, False: 6]
  ------------------
 2341|    134|    {
 2342|    134|        CharT c = data[i];
 2343|    134|        if (JSONCONS_LIKELY(c >= '0' && c <= '9'))
  ------------------
  |  |   78|    268|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 134, False: 0]
  |  |  |  Branch (78:48): [True: 134, False: 0]
  |  |  |  Branch (78:48): [True: 134, False: 0]
  |  |  ------------------
  ------------------
 2344|    134|        {
 2345|    134|            v *= 10u;
 2346|    134|            word_type d = static_cast<word_type>(c - '0');
 2347|    134|            if (d != 0)
  ------------------
  |  Branch (2347:17): [True: 123, False: 11]
  ------------------
 2348|    123|            {
 2349|    123|                v += d;
 2350|    123|            }
 2351|    134|        }
 2352|      0|        else
 2353|      0|        {
 2354|      0|            return to_bignum_result<CharT>(data + i, bignum_errc::invalid_argument);
 2355|      0|        }
 2356|    134|    }
 2357|       |
 2358|      6|    if (neg)
  ------------------
  |  Branch (2358:9): [True: 5, False: 1]
  ------------------
 2359|      5|    {
 2360|      5|        v.set_negative(true);
 2361|      5|    }
 2362|       |
 2363|      6|    value = std::move(v);
 2364|      6|    return to_bignum_result<CharT>(last, bignum_errc{});
 2365|      6|}
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IiEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  672|    897|        : storage_(n, alloc)
  673|    897|    {
  674|    897|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IiEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  363|    897|        : word_allocator_type(alloc)
  364|    897|    {
  365|    897|        ::new (&inlined_) inlined_storage(n);
  366|    897|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IiEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  128|    897|            : is_allocated_(false),
  129|    897|            is_negative_(n < 0),
  130|    897|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (130:19): [True: 454, False: 443]
  ------------------
  131|    897|        {
  132|    897|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (132:26): [True: 377, False: 520]
  ------------------
  133|    897|            values_[1] = 0;
  134|    897|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEaSERKS4_:
  874|  1.37k|    {
  875|  1.37k|        storage_ = y.storage_;
  876|  1.37k|        return *this;
  877|  1.37k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEaSERKS5_:
  369|  1.37k|    {
  370|  1.37k|        if (this != &other)
  ------------------
  |  Branch (370:13): [True: 1.37k, False: 0]
  ------------------
  371|  1.37k|        {
  372|  1.37k|            auto other_words = other.get_words();
  373|  1.37k|            resize(other_words.size());
  374|  1.37k|            auto words = get_words();
  375|  1.37k|            if (other_words.size() > 0)
  ------------------
  |  Branch (375:17): [True: 929, False: 450]
  ------------------
  376|    929|            {
  377|    929|                common_.is_negative_ = other.common_.is_negative_;
  378|    929|                std::memcpy(words.data(), other_words.data(), size_type(other_words.size()*sizeof(word_type)));
  379|    929|            }
  380|  1.37k|        }
  381|  1.37k|        return *this;
  382|  1.37k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE9get_wordsEv:
  530|  3.78k|    {
  531|  3.78k|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (531:16): [True: 10, False: 3.77k]
  ------------------
  532|     10|            storage_view<const word_type>{allocated_.data_, allocated_.size_} :
  533|  3.78k|            storage_view<const word_type>{inlined_.values_, inlined_.size_};
  534|  3.78k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEC2EPS7_m:
   67|  3.78k|            : data_(data), size_(size)
   68|  3.78k|        {
   69|  3.78k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6resizeEm:
  537|  1.96k|    {
  538|  1.96k|        size_type old_length = common_.size_;
  539|  1.96k|        reserve(new_length);
  540|  1.96k|        common_.size_ = new_length;
  541|       |
  542|  1.96k|        if (old_length < new_length)
  ------------------
  |  Branch (542:13): [True: 1.42k, False: 542]
  ------------------
  543|  1.42k|        {
  544|  1.42k|            if (is_allocated())
  ------------------
  |  Branch (544:17): [True: 23, False: 1.39k]
  ------------------
  545|     23|            {
  546|     23|                std::memset(allocated_.data_+old_length, 0, size_type((new_length-old_length)*sizeof(word_type)));
  547|     23|            }
  548|  1.39k|            else
  549|  1.39k|            {
  550|  1.39k|                JSONCONS_ASSERT(new_length <= inlined_capacity);
  ------------------
  |  |   54|  1.39k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 1.39k]
  |  |  ------------------
  |  |   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|  3.68k|                for (size_type i = old_length; i < inlined_capacity; ++i)
  ------------------
  |  Branch (551:48): [True: 2.28k, False: 1.39k]
  ------------------
  552|  2.28k|                {
  553|  2.28k|                    inlined_.values_[i] = 0;
  554|  2.28k|                }
  555|  1.39k|            }
  556|  1.42k|        }
  557|  1.96k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7reserveEm:
  455|  2.39k|    {
  456|  2.39k|       if (capacity() < n)
  ------------------
  |  Branch (456:12): [True: 10, False: 2.38k]
  ------------------
  457|     10|       {
  458|     10|           if (!is_allocated())
  ------------------
  |  Branch (458:16): [True: 10, False: 0]
  ------------------
  459|     10|           {
  460|     10|               size_type size = inlined_.size_;
  461|     10|               size_type is_neg = inlined_.is_negative_;
  462|     10|               word_type values[inlined_capacity] = {inlined_.values_[0], inlined_.values_[1]};
  463|       |
  464|     10|               ::new (&allocated_) allocated_storage();
  465|     10|               allocated_.reserve(n, get_allocator());
  466|     10|               allocated_.size_ = size;
  467|     10|               allocated_.is_negative_ = is_neg;
  468|     10|               if (n >= 1)
  ------------------
  |  Branch (468:20): [True: 10, False: 0]
  ------------------
  469|     10|               {
  470|     10|                   allocated_.data_[0] = values[0];
  471|     10|               }
  472|     10|               if (n >= 2)
  ------------------
  |  Branch (472:20): [True: 10, False: 0]
  ------------------
  473|     10|               {
  474|     10|                   allocated_.data_[1] = values[1];
  475|     10|               }
  476|     10|           }
  477|      0|           else
  478|      0|           {
  479|      0|               allocated_.reserve(n, get_allocator());
  480|      0|           }
  481|     10|       }
  482|  2.39k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE8capacityEv:
  508|  2.39k|    {
  509|  2.39k|        return is_allocated() ? allocated_.capacity_ : inlined_capacity;
  ------------------
  |  Branch (509:16): [True: 13, False: 2.38k]
  ------------------
  510|  2.39k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2Ev:
  206|     10|            : is_allocated_(true),
  207|     10|            is_negative_(false)
  208|     10|        {
  209|     10|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7reserveEmRKS4_:
  258|     10|        {
  259|     10|            JSONCONS_ASSERT(n < max_size);
  ------------------
  |  |   54|     10|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 10]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  260|     10|            size_type capacity_new = round_up(n);
  261|       |
  262|     10|            real_allocator_type alloc(a);
  263|     10|            word_type* data_new = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_new);
  264|     10|            if (size_ > 0)
  ------------------
  |  Branch (264:17): [True: 0, False: 10]
  ------------------
  265|      0|            {
  266|      0|                std::memcpy(data_new, data_, size_type(size_ * sizeof(word_type)));
  267|      0|            }
  268|     10|            if (data_ != nullptr)
  ------------------
  |  Branch (268:17): [True: 0, False: 10]
  ------------------
  269|      0|            {
  270|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  271|      0|            }
  272|     10|            capacity_ = capacity_new;
  273|     10|            data_ = data_new;
  274|     10|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage8round_upEm:
  278|     10|        {
  279|     10|            size_type remainder = i % mem_unit;
  280|     10|            size_type off = mem_unit - remainder;
  281|     10|            bool testoff = i < max_size - off;
  282|     10|            JSONCONS_ASSERT(testoff);
  ------------------
  |  |   54|     10|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 10]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  283|       |
  284|     10|            return i + off;
  285|     10|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE13get_allocatorEv:
  485|  3.11k|    {
  486|  3.11k|        return static_cast<const word_allocator_type&>(*this);
  487|  3.11k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12is_allocatedEv:
  503|  10.7k|    {
  504|  10.7k|        return common_.is_allocated_;
  505|  10.7k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4sizeEv:
   87|  7.60k|        {
   88|  7.60k|            return size_;
   89|  7.60k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE9get_wordsEv:
  523|  5.04k|    {
  524|  5.04k|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (524:16): [True: 72, False: 4.97k]
  ------------------
  525|     72|            storage_view<word_type>{allocated_.data_, allocated_.size_} :
  526|  5.04k|            storage_view<word_type>{inlined_.values_, inlined_.size_};
  527|  5.04k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEC2EPmm:
   67|  5.04k|            : data_(data), size_(size)
   68|  5.04k|        {
   69|  5.04k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4dataEv:
   82|    937|        {
   83|    937|            return data_;
   84|    937|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4dataEv:
   82|    929|        {
   83|    929|            return data_;
   84|    929|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE7reserveEm:
  855|    437|    {
  856|    437|        storage_.reserve(n);
  857|    437|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLIjEENS1_9enable_ifIXsr6nonstd19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
 1030|    134|    {
 1031|    134|        auto words = get_words();
 1032|    134|        size_type len = words.size();
 1033|    134|        if (len == 0 || m == 0)
  ------------------
  |  Branch (1033:13): [True: 6, False: 128]
  |  Branch (1033:25): [True: 0, False: 128]
  ------------------
 1034|      6|        {
 1035|      6|            resize(0);
 1036|      6|            return *this;
 1037|      6|        }
 1038|       |
 1039|    128|        dword_type carry = 0;
 1040|    128|        size_t i = 0;
 1041|    270|        for (; i < len; ++i) {
  ------------------
  |  Branch (1041:16): [True: 142, False: 128]
  ------------------
 1042|    142|            dword_type x = dword_type(words[i]) * m + carry;
 1043|    142|            words[i] = static_cast<word_type>(x);
 1044|    142|            carry = x >> 64;
 1045|    142|        }
 1046|       |
 1047|    128|        if (carry)
  ------------------
  |  Branch (1047:13): [True: 4, False: 124]
  ------------------
 1048|      4|        {
 1049|      4|            resize(len+1);
 1050|      4|            words = get_words();
 1051|      4|            words[i] = static_cast<word_type>(carry);
 1052|      4|        }
 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|    128|        return *this;
 1075|    134|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE9get_wordsEv:
  697|  3.09k|    {
  698|  3.09k|        return storage_.get_words();
  699|  3.09k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4sizeEv:
   87|  4.02k|        {
   88|  4.02k|            return size_;
   89|  4.02k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6resizeEm:
  850|    583|    {
  851|    583|        storage_.resize(new_length);
  852|    583|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEixEm:
   72|  1.56k|        {
   73|  1.56k|            return data_[i];
   74|  1.56k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLImEENS1_9enable_ifIXaasr6nonstd19is_unsigned_integerIT_EE5valuelestS7_Lm8EERS4_E4typeES7_:
  921|    165|    {
  922|    165|        if ( is_negative())
  ------------------
  |  Branch (922:14): [True: 0, False: 165]
  ------------------
  923|      0|            return *this -= -basic_bigint<Allocator>(y);
  924|       |
  925|    165|        word_type d;
  926|    165|        word_type carry = 0;
  927|       |
  928|    165|        auto words = get_words();
  929|    165|        resize(words.size() + 1);
  930|       |
  931|    165|        words = get_words();
  932|    165|        const size_type this_size = words.size();
  933|    165|        size_type y_size = 1;
  934|       |
  935|    165|        d = words[0] + carry;
  936|    165|        carry = d < carry;
  937|    165|        words[0] = d + y;
  938|    165|        if (words[0] < d)
  ------------------
  |  Branch (938:13): [True: 0, False: 165]
  ------------------
  939|      0|            carry = 1;
  940|       |
  941|    165|        for (size_type i = y_size; i < this_size && carry != 0; ++i)
  ------------------
  |  Branch (941:36): [True: 144, False: 21]
  |  Branch (941:53): [True: 0, False: 144]
  ------------------
  942|      0|        {
  943|      0|            d = words[i] + carry;
  944|      0|            carry = d < carry;
  945|      0|            words[i] = d;
  946|      0|        }
  947|    165|        reduce();
  948|    165|        return *this;
  949|    165|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11is_negativeEv:
  707|  5.62k|    {
  708|  5.62k|        return storage_.is_negative();
  709|  5.62k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE11is_negativeEv:
  513|  5.62k|    {
  514|  5.62k|        return common_.is_negative_;
  515|  5.62k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ImEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  672|    895|        : storage_(n, alloc)
  673|    895|    {
  674|    895|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ImEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  363|    895|        : word_allocator_type(alloc)
  364|    895|    {
  365|    895|        ::new (&inlined_) inlined_storage(n);
  366|    895|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ImEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  141|    895|            : is_allocated_(false),
  142|    895|            is_negative_(false),
  143|    895|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (143:19): [True: 410, False: 485]
  ------------------
  144|    895|        {
  145|    895|            values_[0] = n;
  146|    895|            values_[1] = 0;
  147|    895|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEEngEv:
  867|    386|    {
  868|    386|        basic_bigint<Allocator> v(*this);
  869|    386|        v.set_negative(!v.is_negative());
  870|    386|        return v;
  871|    386|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_:
  650|  1.38k|        : storage_(other.storage_)
  651|  1.38k|    {
  652|  1.38k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_:
  302|  1.38k|        : word_allocator_type(other.get_allocator())
  303|  1.38k|    {
  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|  1.38k|        if (!other.is_allocated())
  ------------------
  |  Branch (308:13): [True: 1.38k, False: 3]
  ------------------
  309|  1.38k|        {
  310|  1.38k|            ::new (&inlined_) inlined_storage(other.inlined_);
  311|  1.38k|        }
  312|      3|        else
  313|      3|        {
  314|      3|            ::new (&allocated_) allocated_storage(other.allocated_, get_allocator());
  315|      3|        }
  316|       |#if defined(__GNUC__) && JSONCONS_GCC_AVAILABLE(12,0,0)
  317|       |# pragma GCC diagnostic pop
  318|       |#endif
  319|  1.38k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ERKS6_:
  181|  2.29k|            : is_allocated_(false),
  182|  2.29k|            is_negative_(stor.is_negative_),
  183|  2.29k|            size_(stor.size_)
  184|  2.29k|        {
  185|  2.29k|            values_[0] = stor.values_[0];
  186|  2.29k|            values_[1] = stor.values_[1];
  187|  2.29k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2ERKS6_RKS4_:
  212|      3|            : is_allocated_(true),
  213|      3|              is_negative_(stor.is_negative_),
  214|      3|              size_(stor.size_),
  215|      3|              capacity_(stor.capacity_)
  216|      3|        {
  217|      3|            real_allocator_type alloc(a);
  218|       |
  219|      3|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_);
  220|      3|            JSONCONS_TRY
  ------------------
  |  |   37|      3|    #define JSONCONS_TRY try
  ------------------
  221|      3|            {
  222|      3|                std::allocator_traits<real_allocator_type>::construct(alloc, nonstd::to_plain_pointer(data_));
  223|      3|            }
  224|      3|            JSONCONS_CATCH(...)
  225|      3|            {
  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|      3|            JSONCONS_ASSERT(stor.data_ != nullptr);
  ------------------
  |  |   54|      3|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 3]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  231|      3|            std::memcpy(data_, stor.data_, size_type(stor.size_ * sizeof(word_type)));
  232|      3|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmIERKS4_:
  986|    382|    {
  987|    382|        auto y_words = y.get_words();
  988|       |
  989|    382|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (989:14): [True: 377, False: 5]
  ------------------
  990|    377|            return *this += -y;
  991|      5|        if ( (!is_negative() && y > *this) || (is_negative() && y < *this) )
  ------------------
  |  Branch (991:15): [True: 5, False: 0]
  |  Branch (991:33): [True: 0, False: 5]
  |  Branch (991:48): [True: 0, False: 5]
  |  Branch (991:65): [True: 0, False: 0]
  ------------------
  992|      0|            return *this = -(y - *this);
  993|      5|        word_type borrow = 0;
  994|      5|        word_type d;
  995|      5|        auto words = get_words();
  996|      5|        const size_type this_size = words.size();
  997|      5|        const size_type y_size = y_words.size();
  998|       |
  999|     10|        for (size_type i = 0; i < y_size; i++ )
  ------------------
  |  Branch (999:31): [True: 5, False: 5]
  ------------------
 1000|      5|        {
 1001|      5|            d = words[i] - borrow;
 1002|      5|            borrow = d > words[i];
 1003|      5|            words[i] = d - y_words[i];
 1004|      5|            if ( words[i] > d )
  ------------------
  |  Branch (1004:18): [True: 0, False: 5]
  ------------------
 1005|      0|                borrow = 1;
 1006|      5|        }
 1007|      5|        for (size_type i = y_size; i < this_size && borrow != 0; i++ )
  ------------------
  |  Branch (1007:36): [True: 3, False: 2]
  |  Branch (1007:53): [True: 0, False: 3]
  ------------------
 1008|      0|        {
 1009|      0|            d = words[i] - borrow;
 1010|      0|            borrow = d > words[i];
 1011|      0|            words[i] = d;
 1012|      0|        }
 1013|      5|        reduce();
 1014|      5|        return *this;
 1015|      5|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9get_wordsEv:
  702|  2.40k|    {
  703|  2.40k|        return storage_.get_words();
  704|  2.40k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLERKS4_:
  952|    377|    {
  953|    377|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (953:14): [True: 0, False: 377]
  ------------------
  954|      0|            return *this -= -y;
  955|       |
  956|    377|        auto y_words = y.get_words();
  957|       |        
  958|    377|        word_type d;
  959|    377|        word_type carry = 0;
  960|       |
  961|    377|        auto words = get_words();
  962|    377|        resize( (std::max)(y_words.size(), words.size()) + 1 );
  963|    377|        words = get_words();
  964|       |
  965|    377|        const size_t this_size = words.size();
  966|    377|        const size_t y_size = y_words.size();
  967|    386|        for (size_type i = 0; i < y_size; i++ )
  ------------------
  |  Branch (967:31): [True: 9, False: 377]
  ------------------
  968|      9|        {
  969|      9|            d = words[i] + carry;
  970|      9|            carry = d < carry;
  971|      9|            words[i] = d + y_words[i];
  972|      9|            if (words[i] < d)
  ------------------
  |  Branch (972:17): [True: 0, False: 9]
  ------------------
  973|      0|                carry = 1;
  974|      9|        }
  975|    377|        for (size_type i = y_size; i < this_size && carry != 0; i++ )
  ------------------
  |  Branch (975:36): [True: 377, False: 0]
  |  Branch (975:53): [True: 0, False: 377]
  ------------------
  976|      0|        {
  977|      0|            d = words[i] + carry;
  978|      0|            carry = d < carry;
  979|      0|            words[i] = d;
  980|      0|        }
  981|    377|        reduce();
  982|    377|        return *this;
  983|    377|    }
_ZN8jsonconsgtERKNS_12basic_bigintINSt3__19allocatorImEEEES6_:
 1547|      5|    {
 1548|      5|        return x.compare(y) > 0 ? true : false;
  ------------------
  |  Branch (1548:16): [True: 0, False: 5]
  ------------------
 1549|      5|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7compareERKS4_:
 1702|    543|    {
 1703|    543|        auto words = get_words();
 1704|    543|        auto y_words = y.get_words();
 1705|       |
 1706|    543|        const size_type y_size = y_words.size();
 1707|    543|        if ( words.size() == 0 && y_size == 0 )
  ------------------
  |  Branch (1707:14): [True: 5, False: 538]
  |  Branch (1707:35): [True: 4, False: 1]
  ------------------
 1708|      4|            return 0;
 1709|    539|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (1709:14): [True: 5, False: 534]
  ------------------
 1710|      5|            return y.is_negative() - is_negative();
 1711|    534|        int code = 0;
 1712|    534|        if ( words.size() < y_size)
  ------------------
  |  Branch (1712:14): [True: 4, False: 530]
  ------------------
 1713|      4|            code = -1;
 1714|    530|        else if ( words.size() > y_size)
  ------------------
  |  Branch (1714:19): [True: 41, False: 489]
  ------------------
 1715|     41|            code = +1;
 1716|    489|        else
 1717|    489|        {
 1718|    489|            for (size_type i = words.size(); i-- > 0; )
  ------------------
  |  Branch (1718:46): [True: 489, False: 0]
  ------------------
 1719|    489|            {
 1720|    489|                if (words[i] > y_words[i])
  ------------------
  |  Branch (1720:21): [True: 86, False: 403]
  ------------------
 1721|     86|                {
 1722|     86|                    code = 1;
 1723|     86|                    break;
 1724|     86|                }
 1725|    403|                else if (words[i] < y_words[i])
  ------------------
  |  Branch (1725:26): [True: 403, False: 0]
  ------------------
 1726|    403|                {
 1727|    403|                    code = -1;
 1728|    403|                    break;
 1729|    403|                }
 1730|    489|            }
 1731|    489|        }
 1732|    534|        return is_negative() ? -code : code;
  ------------------
  |  Branch (1732:16): [True: 0, False: 534]
  ------------------
 1733|    539|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEES6_:
 1537|    453|    {
 1538|    453|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1538:15): [True: 395, False: 58]
  ------------------
 1539|    453|    }
_ZN8jsonconsmiENS_12basic_bigintINSt3__19allocatorImEEEERKS4_:
 1587|    377|    {
 1588|    377|        return x -= y;
 1589|    377|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEixEm:
   72|  1.87k|        {
   73|  1.87k|            return data_[i];
   74|  1.87k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6reduceEv:
 2058|    572|    {
 2059|    572|        storage_.reduce();
 2060|    572|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6reduceEv:
  432|    572|    {
  433|    572|        if (common_.size_ > 0)
  ------------------
  |  Branch (433:13): [True: 572, False: 0]
  ------------------
  434|    572|        {
  435|    572|            auto words = get_words();
  436|    572|            word_type* p = words.end() - 1;
  437|    572|            word_type* first = words.begin();
  438|  1.10k|            while ( p >= first )
  ------------------
  |  Branch (438:21): [True: 1.10k, False: 0]
  ------------------
  439|  1.10k|            {
  440|  1.10k|                if ( *p )
  ------------------
  |  Branch (440:22): [True: 572, False: 529]
  ------------------
  441|    572|                {
  442|    572|                    break;
  443|    572|                }
  444|    529|                --common_.size_;
  445|    529|                --p;
  446|    529|            }
  447|    572|        }
  448|    572|        if (common_.size_ == 0)
  ------------------
  |  Branch (448:13): [True: 0, False: 572]
  ------------------
  449|      0|        {
  450|      0|            common_.is_negative_ = false;
  451|      0|        }
  452|    572|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE3endEv:
   96|    572|        {
   97|    572|            return data_ + size_;
   98|    572|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE5beginEv:
   91|    572|        {
   92|    572|            return data_;
   93|    572|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE12set_negativeEb:
  728|  2.20k|    {
  729|  2.20k|        storage_.set_negative(value);
  730|  2.20k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12set_negativeEb:
  518|  2.20k|    {
  519|  2.20k|        common_.is_negative_ = value;
  520|  2.20k|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEEl:
 1542|     14|    {
 1543|     14|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1543:15): [True: 5, False: 9]
  ------------------
 1544|     14|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IlEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  672|     19|        : storage_(n, alloc)
  673|     19|    {
  674|     19|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IlEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  363|     19|        : word_allocator_type(alloc)
  364|     19|    {
  365|     19|        ::new (&inlined_) inlined_storage(n);
  366|     19|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IlEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  128|     19|            : is_allocated_(false),
  129|     19|            is_negative_(n < 0),
  130|     19|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (130:19): [True: 14, False: 5]
  ------------------
  131|     19|        {
  132|     19|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (132:26): [True: 0, False: 19]
  ------------------
  133|     19|            values_[1] = 0;
  134|     19|        }
_ZN8jsonconsmiENS_12basic_bigintINSt3__19allocatorImEEEEl:
 1592|      5|    {
 1593|      5|        return x -= y;
 1594|      5|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE14write_bytes_beINS2_IhEEEEvRiRNS1_6vectorIhT_EE:
 1383|      7|    {
 1384|      7|        basic_bigint<Allocator> n(*this);
 1385|      7|        signum = (n < 0) ? -1 : (n > 0 ? 1 : 0); 
  ------------------
  |  Branch (1385:18): [True: 0, False: 7]
  |  Branch (1385:34): [True: 6, False: 1]
  ------------------
 1386|       |
 1387|      7|        basic_bigint<Allocator> divisor(256);
 1388|       |
 1389|     57|        while (n >= 256)
  ------------------
  |  Branch (1389:16): [True: 50, False: 7]
  ------------------
 1390|     50|        {
 1391|     50|            basic_bigint<Allocator> q;
 1392|     50|            basic_bigint<Allocator> r;
 1393|     50|            n.divide(divisor, q, r, true);
 1394|     50|            n = q;
 1395|     50|            data.push_back((uint8_t)(word_type)r);
 1396|     50|        }
 1397|      7|        if (n >= 0)
  ------------------
  |  Branch (1397:13): [True: 7, False: 0]
  ------------------
 1398|      7|        {
 1399|      7|            data.push_back((uint8_t)(word_type)n);
 1400|      7|        }
 1401|       |
 1402|      7|        std::reverse(data.begin(),data.end());
 1403|      7|    }
_ZN8jsonconsgtERKNS_12basic_bigintINSt3__19allocatorImEEEEi:
 1552|      7|    {
 1553|      7|        return x.compare(basic_bigint<Allocator>(y)) > 0 ? true : false;
  ------------------
  |  Branch (1553:16): [True: 6, False: 1]
  ------------------
 1554|      7|    }
_ZN8jsonconsgeERKNS_12basic_bigintINSt3__19allocatorImEEEEi:
 1572|     64|    {
 1573|     64|        return x.compare(y) >= 0 ? true : false;
  ------------------
  |  Branch (1573:16): [True: 57, False: 7]
  ------------------
 1574|     64|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2Ev:
  620|    156|    basic_bigint() = default;
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE6divideERKS4_RS4_S7_b:
 1815|    451|    {
 1816|    451|        basic_bigint<Allocator> denom(denom_, get_allocator());
 1817|    451|        auto denom_words = denom.get_words();
 1818|       |
 1819|    451|        if (denom_words.size() == 0)
  ------------------
  |  Branch (1819:13): [True: 0, False: 451]
  ------------------
 1820|      0|        {
 1821|      0|            JSONCONS_THROW(std::runtime_error( "Zero divide." ));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1822|      0|        }
 1823|    451|        bool quot_neg = is_negative() ^ denom.is_negative();
 1824|    451|        bool rem_neg = is_negative();
 1825|    451|        basic_bigint<Allocator> num(*this, get_allocator());
 1826|    451|        num.set_negative(false);
 1827|    451|        denom.set_negative(false);
 1828|    451|        if ( num < denom )
  ------------------
  |  Branch (1828:14): [True: 395, False: 56]
  ------------------
 1829|    395|        {
 1830|    395|            quot = word_type(0);
 1831|    395|            quot.set_negative(quot_neg);
 1832|    395|            rem = num;
 1833|    395|            rem.set_negative(rem_neg);
 1834|    395|            return;
 1835|    395|        }
 1836|       |
 1837|     56|        auto num_words = num.get_words();
 1838|     56|        auto quot_words = quot.get_words();
 1839|     56|        auto words = get_words();
 1840|       |
 1841|     56|        if ( denom_words.size() == 1 && num_words.size() == 1 )
  ------------------
  |  Branch (1841:14): [True: 56, False: 0]
  |  Branch (1841:41): [True: 44, False: 12]
  ------------------
 1842|     44|        {
 1843|     44|            quot = word_type( num_words[0]/denom_words[0] );
 1844|     44|            rem = word_type( num_words[0]%denom_words[0] );
 1845|     44|            quot.set_negative(quot_neg);
 1846|     44|            rem.set_negative(rem_neg);
 1847|     44|            return;
 1848|     44|        }
 1849|     12|        if (denom_words.size() == 1 && (denom_words[0] & l_mask) == 0 )
  ------------------
  |  Branch (1849:13): [True: 12, False: 0]
  |  Branch (1849:40): [True: 8, False: 4]
  ------------------
 1850|      8|        {
 1851|       |            // Denominator fits into a half word
 1852|      8|            word_type divisor = denom_words[0], dHi = 0, q1, r, q2, dividend;
 1853|      8|            quot.resize(words.size());
 1854|      8|            quot_words = quot.get_words();
 1855|     24|            for (size_type i=words.size(); i-- > 0; )
  ------------------
  |  Branch (1855:44): [True: 16, False: 8]
  ------------------
 1856|     16|            {
 1857|     16|                dividend = (dHi << word_half_bits) | (words[i] >> word_half_bits);
 1858|     16|                q1 = dividend/divisor;
 1859|     16|                r = dividend % divisor;
 1860|     16|                dividend = (r << word_half_bits) | (words[i] & r_mask);
 1861|     16|                q2 = dividend/divisor;
 1862|     16|                dHi = dividend % divisor;
 1863|     16|                quot_words[i] = (q1 << word_half_bits) | q2;
 1864|     16|            }
 1865|      8|            quot.reduce();
 1866|      8|            rem = dHi;
 1867|      8|            quot.set_negative(quot_neg);
 1868|      8|            rem.set_negative(rem_neg);
 1869|      8|            return;
 1870|      8|        }
 1871|      4|        basic_bigint<Allocator> num0(num, get_allocator());
 1872|      4|        basic_bigint<Allocator> denom0(denom, get_allocator());
 1873|      4|        int x = 0;
 1874|      4|        bool second_done = normalize(denom, num, x);
 1875|      4|        denom_words = denom.get_words();
 1876|      4|        num_words = num.get_words();
 1877|       |
 1878|      4|        size_type l = denom_words.size() - 1;
 1879|      4|        size_type n = num_words.size() - 1;
 1880|      4|        quot.resize(n - l);
 1881|      4|        quot_words = quot.get_words();
 1882|      8|        for (size_type i = quot_words.size(); i-- > 0; )
  ------------------
  |  Branch (1882:47): [True: 4, False: 4]
  ------------------
 1883|      4|        {
 1884|      4|            quot_words[i] = 0;
 1885|      4|        }
 1886|      4|        rem = num;
 1887|      4|        auto rem_words = rem.get_words();
 1888|      4|        if ( rem_words[n] >= denom_words[l] )
  ------------------
  |  Branch (1888:14): [True: 0, False: 4]
  ------------------
 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|      4|        word_type d = denom_words[l];
 1897|       |
 1898|      8|        for ( size_type k = n; k > l; k-- )
  ------------------
  |  Branch (1898:32): [True: 4, False: 4]
  ------------------
 1899|      4|        {
 1900|      4|            word_type q = DDquotient(rem_words[k], rem_words[k-1], d);
 1901|      4|            subtractmul( rem_words.data() + (k - l - 1), denom_words.data(), l + 1, q );
 1902|      4|            quot_words[k - l - 1] = q;
 1903|      4|        }
 1904|      4|        quot.reduce();
 1905|      4|        quot.set_negative(quot_neg);
 1906|      4|        if (remDesired)
  ------------------
  |  Branch (1906:13): [True: 4, False: 0]
  ------------------
 1907|      4|        {
 1908|      4|            unnormalize(rem, x, second_done);
 1909|      4|            rem.set_negative(rem_neg);
 1910|      4|        }
 1911|      4|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE13get_allocatorEv:
  692|  1.70k|    {
  693|  1.70k|        return storage_.get_allocator();
  694|  1.70k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_RKS3_:
  655|    910|        : storage_(other.storage_, alloc)
  656|    910|    {
  657|    910|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_RKS4_:
  322|    910|        : word_allocator_type(alloc)
  323|    910|    {
  324|    910|        if (!other.is_allocated())
  ------------------
  |  Branch (324:13): [True: 910, False: 0]
  ------------------
  325|    910|        {
  326|    910|            ::new (&inlined_) inlined_storage(other.inlined_);
  327|    910|        }
  328|      0|        else
  329|      0|        {
  330|      0|            ::new (&allocated_) allocated_storage(other.allocated_, alloc);
  331|      0|        }
  332|    910|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9normalizeERS4_S5_Ri:
 2013|      4|    {
 2014|      4|        auto denom_words = denom.get_words();
 2015|      4|        if (denom_words.size() == 0)
  ------------------
  |  Branch (2015:13): [True: 0, False: 4]
  ------------------
 2016|      0|        {
 2017|      0|            return false;
 2018|      0|        }
 2019|      4|        size_type r = denom_words.size() - 1;
 2020|      4|        word_type y = denom_words[r];
 2021|       |
 2022|      4|        x = 0;
 2023|      4|        while ( (y & l_bit) == 0 )
  ------------------
  |  Branch (2023:17): [True: 0, False: 4]
  ------------------
 2024|      0|        {
 2025|      0|            y <<= 1;
 2026|      0|            x++;
 2027|      0|        }
 2028|      4|        denom <<= x;
 2029|      4|        num <<= x;
 2030|       |
 2031|      4|        denom_words = denom.get_words();
 2032|      4|        if ( r > 0 && denom_words[r] < denom_words[r-1] )
  ------------------
  |  Branch (2032:14): [True: 0, False: 4]
  |  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|      4|        return false;
 2039|      4|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEElSEm:
 1172|      8|    {
 1173|      8|        auto words = get_words();
 1174|      8|        size_type q = k / word_bits;
 1175|      8|        if ( q ) // Increase storage_.size() by q:
  ------------------
  |  Branch (1175:14): [True: 0, False: 8]
  ------------------
 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|      8|        if ( k )  // 0 < k < word_bits:
  ------------------
  |  Branch (1183:14): [True: 0, False: 8]
  ------------------
 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|      8|        reduce();
 1197|      8|        return *this;
 1198|      8|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLImEENS1_9enable_ifIXsr6nonstd19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
 1030|     42|    {
 1031|     42|        auto words = get_words();
 1032|     42|        size_type len = words.size();
 1033|     42|        if (len == 0 || m == 0)
  ------------------
  |  Branch (1033:13): [True: 15, False: 27]
  |  Branch (1033:25): [True: 0, False: 27]
  ------------------
 1034|     15|        {
 1035|     15|            resize(0);
 1036|     15|            return *this;
 1037|     15|        }
 1038|       |
 1039|     27|        dword_type carry = 0;
 1040|     27|        size_t i = 0;
 1041|     54|        for (; i < len; ++i) {
  ------------------
  |  Branch (1041:16): [True: 27, False: 27]
  ------------------
 1042|     27|            dword_type x = dword_type(words[i]) * m + carry;
 1043|     27|            words[i] = static_cast<word_type>(x);
 1044|     27|            carry = x >> 64;
 1045|     27|        }
 1046|       |
 1047|     27|        if (carry)
  ------------------
  |  Branch (1047:13): [True: 3, False: 24]
  ------------------
 1048|      3|        {
 1049|      3|            resize(len+1);
 1050|      3|            words = get_words();
 1051|      3|            words[i] = static_cast<word_type>(carry);
 1052|      3|        }
 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|     27|        return *this;
 1075|     42|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE10DDquotientEmmm:
 1940|      4|    {
 1941|      4|        word_type left, middle, right, qHi, qLo, x, dLo1,
 1942|      4|                   dHi = d >> word_half_bits, dLo = d & r_mask;
 1943|      4|        qHi = A/(dHi + 1);
 1944|       |        // This initial guess of qHi may be too small.
 1945|      4|        middle = qHi * dLo;
 1946|      4|        left = qHi * dHi;
 1947|      4|        x = B - (middle << word_half_bits);
 1948|      4|        A -= (middle >> word_half_bits) + left + (x > B);
 1949|      4|        B = x;
 1950|      4|        dLo1 = dLo << word_half_bits;
 1951|       |        // Increase qHi if necessary:
 1952|      4|        while ( A > dHi || (A == dHi && B >= dLo1) )
  ------------------
  |  Branch (1952:17): [True: 0, False: 4]
  |  Branch (1952:29): [True: 0, False: 4]
  |  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|      4|        qLo = ((A << word_half_bits) | (B >> word_half_bits))/(dHi + 1);
 1960|       |        // This initial guess of qLo may be too small.
 1961|      4|        right = qLo * dLo;
 1962|      4|        middle = qLo * dHi;
 1963|      4|        x = B - right;
 1964|      4|        A -= (x > B);
 1965|      4|        B = x;
 1966|      4|        x = B - (middle << word_half_bits);
 1967|      4|            A -= (middle >> word_half_bits) + (x > B);
 1968|      4|        B = x;
 1969|       |        // Increase qLo if necessary:
 1970|      4|        while ( A || B >= d )
  ------------------
  |  Branch (1970:17): [True: 0, False: 4]
  |  Branch (1970:22): [True: 0, False: 4]
  ------------------
 1971|      0|        {
 1972|      0|            x = B - d;
 1973|      0|            A -= (x > B);
 1974|      0|            B = x;
 1975|      0|            qLo++;
 1976|      0|        }
 1977|      4|        return (qHi << word_half_bits) + qLo;
 1978|      4|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11subtractmulEPmS5_mRm:
 1982|      4|    {
 1983|      4|        word_type hi, lo, d, carry = 0;
 1984|      4|        size_type i;
 1985|      8|        for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1985:22): [True: 4, False: 4]
  ------------------
 1986|      4|        {
 1987|      4|            DDproduct( b[i], q, hi, lo );
 1988|      4|            d = a[i];
 1989|      4|            a[i] -= lo;
 1990|      4|            if ( a[i] > d )
  ------------------
  |  Branch (1990:18): [True: 4, False: 0]
  ------------------
 1991|      4|                carry++;
 1992|      4|            d = a[i + 1];
 1993|      4|            a[i + 1] -= hi + carry;
 1994|      4|            carry = a[i + 1] > d;
 1995|      4|        }
 1996|      4|        if ( carry ) // q was too large
  ------------------
  |  Branch (1996:14): [True: 0, False: 4]
  ------------------
 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|      4|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9DDproductEmmRmS5_:
 1922|      5|    {
 1923|      5|        word_type hiA = A >> word_half_bits, loA = A & r_mask,
 1924|      5|                   hiB = B >> word_half_bits, loB = B & r_mask;
 1925|       |
 1926|      5|        lo = loA * loB;
 1927|      5|        hi = hiA * hiB;
 1928|      5|        word_type mid1 = loA * hiB;
 1929|      5|        word_type mid2 = hiA * loB;
 1930|      5|        word_type old = lo;
 1931|      5|        lo += mid1 << word_half_bits;
 1932|      5|            hi += (lo < old) + (mid1 >> word_half_bits);
 1933|      5|        old = lo;
 1934|      5|        lo += mid2 << word_half_bits;
 1935|      5|            hi += (lo < old) + (mid2 >> word_half_bits);
 1936|      5|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11unnormalizeERS4_ib:
 2042|      4|    {
 2043|      4|        if (secondDone)
  ------------------
  |  Branch (2043:13): [True: 0, False: 4]
  ------------------
 2044|      0|        {
 2045|      0|            rem /= max_word;
 2046|      0|        }
 2047|      4|        if ( x > 0 )
  ------------------
  |  Branch (2047:14): [True: 0, False: 4]
  ------------------
 2048|      0|        {
 2049|      0|            rem >>= x;
 2050|      0|        }
 2051|      4|        else
 2052|      4|        {
 2053|      4|            rem.reduce();
 2054|      4|        }
 2055|      4|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEErSEm:
 1201|      1|    {
 1202|      1|        auto words = get_words();
 1203|      1|        size_type q = k / word_bits;
 1204|      1|        if ( q >= words.size())
  ------------------
  |  Branch (1204:14): [True: 0, False: 1]
  ------------------
 1205|      0|        {
 1206|      0|            resize( 0 );
 1207|      0|            return *this;
 1208|      0|        }
 1209|      1|        if (q > 0)
  ------------------
  |  Branch (1209:13): [True: 0, False: 1]
  ------------------
 1210|      0|        {
 1211|      0|            memmove( words.data(), words.data()+q, size_type((words.size() - q)*sizeof(word_type)) );
 1212|      0|            resize( size_type(words.size() - q) );
 1213|      0|            k %= word_bits;
 1214|      0|            if ( k == 0 )
  ------------------
  |  Branch (1214:18): [True: 0, False: 0]
  ------------------
 1215|      0|            {
 1216|      0|                reduce();
 1217|      0|                return *this;
 1218|      0|            }
 1219|      0|        }
 1220|       |
 1221|      1|        words = get_words();
 1222|      1|        size_type n = size_type(words.size() - 1);
 1223|      1|        ssize_type k1 = word_bits - k;
 1224|      1|        word_type mask = (word_type(1) << k) - 1;
 1225|      2|        for (size_type i = 0; i <= n; i++)
  ------------------
  |  Branch (1225:31): [True: 1, False: 1]
  ------------------
 1226|      1|        {
 1227|      1|            words[i] >>= k;
 1228|      1|            if ( i < n )
  ------------------
  |  Branch (1228:18): [True: 0, False: 1]
  ------------------
 1229|      0|                words[i] |= ((words[i+1] & mask) << k1);
 1230|      1|        }
 1231|      1|        reduce();
 1232|      1|        return *this;
 1233|      1|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEEcvT_ImvEEv:
 1330|     57|    {
 1331|     57|        auto words = get_words();
 1332|     57|        Integer x = 0;
 1333|     57|        if (words.size() > 0)
  ------------------
  |  Branch (1333:13): [True: 41, False: 16]
  ------------------
 1334|     41|        {
 1335|     41|            x = static_cast<Integer>(words[0]);
 1336|     41|        }
 1337|       |
 1338|     57|        return is_negative() ? x*(-1) : x;
  ------------------
  |  Branch (1338:16): [True: 0, False: 57]
  ------------------
 1339|     57|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEED2Ev:
  687|  4.66k|    {
  688|  4.66k|        storage_.destroy();
  689|  4.66k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7destroyEv:
  490|  4.66k|    {
  491|  4.66k|        if (is_allocated())
  ------------------
  |  Branch (491:13): [True: 13, False: 4.65k]
  ------------------
  492|     13|        {
  493|     13|            allocated_.destroy(get_allocator());
  494|     13|            allocated_.~allocated_storage();
  495|     13|        }
  496|  4.65k|        else
  497|  4.65k|        {
  498|  4.65k|            inlined_.~inlined_storage();
  499|  4.65k|        }
  500|  4.66k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7destroyERKS4_:
  249|     13|        {
  250|     13|            if (data_ != nullptr)
  ------------------
  |  Branch (250:17): [True: 13, False: 0]
  ------------------
  251|     13|            {
  252|     13|                real_allocator_type alloc(a);
  253|     13|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  254|     13|            }
  255|     13|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE13from_bytes_beEiPKhm:
  824|    431|    {
  825|    431|        static const double radix_log2 = std::log2(next_power_of_two(256));
  826|       |        // Estimate how big the result will be, so we can pre-allocate it.
  827|    431|        double bits = radix_log2 * n;
  828|    431|        double big_digits = std::ceil(bits / 64.0);
  829|       |        //std::cout << "ESTIMATED: " << big_digits << "\n";
  830|       |
  831|    431|        basic_bigint<Allocator> v = 0;
  832|    431|        v.reserve(static_cast<size_type>(big_digits));
  833|       |
  834|    473|        for (size_type i = 0; i < n; i++)
  ------------------
  |  Branch (834:31): [True: 42, False: 431]
  ------------------
  835|     42|        {
  836|     42|            v *= 256;
  837|     42|            v += (word_type)(bytes[i]);
  838|     42|        }
  839|       |        //std::cout << "ACTUAL: " << v.size() << "\n";
  840|       |
  841|    431|        if (signum < 0)
  ------------------
  |  Branch (841:13): [True: 0, False: 431]
  ------------------
  842|      0|        {
  843|      0|            v.set_negative(true);
  844|      0|        }
  845|       |
  846|    431|        return v;
  847|    431|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE17next_power_of_twoEm:
 2062|      1|    static word_type next_power_of_two(word_type n) {
 2063|      1|        n = n - 1;
 2064|      1|        n |= n >> 1u;
 2065|      1|        n |= n >> 2u;
 2066|      1|        n |= n >> 4u;
 2067|      1|        n |= n >> 8u;
 2068|      1|        n |= n >> 16u;
 2069|      1|        n |= n >> 32u;
 2070|      1|        return n + 1;
 2071|      1|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLIiEENS1_9enable_ifIXsr6nonstd17is_signed_integerIT_EE5valueERS4_E4typeES7_:
 1020|     42|    {
 1021|     42|        *this *= word_type(y < 0 ? -y : y);
  ------------------
  |  Branch (1021:28): [True: 0, False: 42]
  ------------------
 1022|     42|        if ( y < 0 )
  ------------------
  |  Branch (1022:14): [True: 0, False: 42]
  ------------------
 1023|      0|            set_negative(!is_negative());
 1024|     42|        return *this;
 1025|     42|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16append_to_bufferIcNS1_11char_traitsIcEENS2_IcEEEEvRNS1_12basic_stringIT_T0_T1_EE:
 1414|    390|    {
 1415|    390|        if (is_zero())
  ------------------
  |  Branch (1415:13): [True: 6, False: 384]
  ------------------
 1416|      6|        {
 1417|      6|            buf.push_back('0');
 1418|      6|            return;
 1419|      6|        }
 1420|    384|        if (is_negative())
  ------------------
  |  Branch (1420:13): [True: 373, False: 11]
  ------------------
 1421|    373|        {
 1422|    373|            buf.push_back('-');
 1423|    373|        }
 1424|    384|        std::size_t pos = buf.size();
 1425|    384|        basic_bigint<Allocator> v(*this);
 1426|    384|        auto v_words = v.get_words();
 1427|       |
 1428|    384|        size_type len = (v_words.size() * word_bits / 3) + 2;
 1429|    384|        buf.reserve(len);
 1430|       |
 1431|    384|        if ( v_words.size() == 0 )
  ------------------
  |  Branch (1431:14): [True: 0, False: 384]
  ------------------
 1432|      0|        {
 1433|      0|            buf.push_back('0');
 1434|      0|        }
 1435|    384|        else
 1436|    384|        {
 1437|    384|            word_type r;
 1438|    384|            basic_bigint<Allocator> R(get_allocator());
 1439|    384|            basic_bigint<Allocator> LP10(max_unsigned_power_10, get_allocator()); 
 1440|       |
 1441|    384|            do
 1442|    385|            {
 1443|    385|                v.divide( LP10, v, R, true );
 1444|    385|                v_words = v.get_words();
 1445|       |
 1446|    385|                auto R_words = R.get_words();
 1447|    385|                r = (R_words.size() ? R_words[0] : 0);
  ------------------
  |  Branch (1447:22): [True: 385, False: 0]
  ------------------
 1448|    418|                for ( size_type j=0; j < imax_unsigned_power_10; j++ )
  ------------------
  |  Branch (1448:38): [True: 417, False: 1]
  ------------------
 1449|    417|                {
 1450|    417|                    buf.push_back(char(r % 10u + '0'));
 1451|    417|                    r /= 10u;
 1452|    417|                    if ( r + v_words.size() == 0 )
  ------------------
  |  Branch (1452:26): [True: 384, False: 33]
  ------------------
 1453|    384|                        break;
 1454|    417|                }
 1455|    385|            } 
 1456|    385|            while ( v_words.size() > 0);
  ------------------
  |  Branch (1456:21): [True: 1, False: 384]
  ------------------
 1457|       |
 1458|    384|            std::reverse(buf.begin()+pos,buf.end());
 1459|    384|        }
 1460|    384|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7is_zeroEv:
 2179|    445|    bool is_zero() const {
 2180|    445|        return get_words().size() == 0;
 2181|    445|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS3_:
  623|    395|        : storage_(alloc)
  624|    395|    {
  625|    395|    }
_ZN8jsoncons16append_to_bufferIcNSt3__19allocatorIcEEEEvRKNS_12basic_bigintINS2_ImEEEERNS1_12basic_stringIT_NS1_11char_traitsISA_EET0_EE:
 2137|     53|    {
 2138|     53|        if (value.is_zero())
  ------------------
  |  Branch (2138:13): [True: 42, False: 11]
  ------------------
 2139|     42|        {
 2140|     42|            buf.push_back('0');
 2141|     42|            return;
 2142|     42|        }
 2143|     11|        if (value.is_negative())
  ------------------
  |  Branch (2143:13): [True: 0, False: 11]
  ------------------
 2144|      0|        {
 2145|      0|            buf.push_back('-');
 2146|      0|        }
 2147|       |
 2148|     11|        size_type start = buf.size();
 2149|     11|        basic_bigint v(value);
 2150|     11|        auto v_words = v.get_words();
 2151|       |
 2152|     11|        size_type len = (v_words.size() * word_bits / 3) + 2;
 2153|     11|        buf.reserve(start+len);
 2154|       |
 2155|     11|        word_type r;
 2156|     11|        basic_bigint R(value.get_allocator());
 2157|     11|        basic_bigint LP10(max_unsigned_power_10, value.get_allocator());
 2158|       |
 2159|     11|        do
 2160|     16|        {
 2161|     16|            v.divide(LP10, v, R, true);
 2162|     16|            v_words = v.get_words();
 2163|       |
 2164|     16|            auto R_words = R.get_words();
 2165|     16|            r = (R_words.size() ? R_words[0] : 0);
  ------------------
  |  Branch (2165:18): [True: 16, False: 0]
  ------------------
 2166|    139|            for (size_type j = 0; j < imax_unsigned_power_10; j++)
  ------------------
  |  Branch (2166:35): [True: 134, False: 5]
  ------------------
 2167|    134|            {
 2168|    134|                buf.push_back(CharT(r % 10u + '0'));
 2169|    134|                r /= 10u;
 2170|    134|                if (r + v_words.size() == 0)
  ------------------
  |  Branch (2170:21): [True: 11, False: 123]
  ------------------
 2171|     11|                    break;
 2172|    134|            }
 2173|     16|        } while (v_words.size() > 0);
  ------------------
  |  Branch (2173:18): [True: 5, False: 11]
  ------------------
 2174|       |
 2175|     11|        std::reverse(buf.begin()+start, buf.end());
 2176|       |        
 2177|     11|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE18trailing_zero_bitsEv:
 1736|      2|    {
 1737|       |        // Assumes words contains the absolute magnitude,
 1738|       |        // even when BigInt is negative.
 1739|       |
 1740|      2|        auto words = get_words();
 1741|      2|        for (size_t i = 0; i < words.size(); ++i) {
  ------------------
  |  Branch (1741:28): [True: 2, False: 0]
  ------------------
 1742|      2|            const uint64_t w = words[i];
 1743|       |
 1744|      2|            if (w != 0) {
  ------------------
  |  Branch (1744:17): [True: 2, False: 0]
  ------------------
 1745|      2|                return static_cast<u128>(i) * 64
 1746|      2|                     + jsoncons::countr_zero(w);
 1747|      2|            }
 1748|      2|        }
 1749|       |
 1750|       |        // Zero has no finite number of trailing zero bits.
 1751|      0|        return (jsoncons::nonstd::integer_limits<u128>::max)();
 1752|      2|    }
_ZN8jsoncons4powbINSt3__19allocatorImEEEENS_12basic_bigintIT_EES6_m:
 2261|      1|{
 2262|      1|    basic_bigint<Allocator> result{1};
 2263|       |
 2264|      5|    while ( n )
  ------------------
  |  Branch (2264:13): [True: 4, False: 1]
  ------------------
 2265|      4|    {
 2266|      4|        if ( n & 1 )
  ------------------
  |  Branch (2266:14): [True: 4, False: 0]
  ------------------
 2267|      4|        {
 2268|      4|            result *= base;
 2269|      4|        }
 2270|      4|        n >>= 1;
 2271|       |
 2272|      4|        if (n)
  ------------------
  |  Branch (2272:13): [True: 3, False: 1]
  ------------------
 2273|      3|        {
 2274|      3|            base *= base;
 2275|      3|        }
 2276|      4|    }
 2277|       |
 2278|      1|    return result;
 2279|      1|}
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLES4_:
 1078|      8|    {
 1079|      8|        auto words = get_words();
 1080|      8|        auto y_words = y.get_words();
 1081|       |
 1082|      8|        if (words.size() == 0 || y_words.size() == 0)
  ------------------
  |  Branch (1082:13): [True: 0, False: 8]
  |  Branch (1082:34): [True: 0, False: 8]
  ------------------
 1083|      0|        {
 1084|      0|            return *this = 0;
 1085|      0|        }
 1086|       |
 1087|      8|        bool difSigns = is_negative() != y.is_negative();
 1088|      8|        const size_type y_size = y_words.size();
 1089|      8|        if ( words.size() + y_size == 2 ) // size() = y.size() = 1
  ------------------
  |  Branch (1089:14): [True: 8, False: 0]
  ------------------
 1090|      8|        {
 1091|      8|            word_type a = words[0], b = y_words[0];
 1092|      8|            words[0] = a * b;
 1093|      8|            if ( words[0] / a != b )
  ------------------
  |  Branch (1093:18): [True: 1, False: 7]
  ------------------
 1094|      1|            {
 1095|      1|                resize(2);
 1096|      1|                words = get_words();
 1097|      1|                DDproduct( a, b, words[1], words[0] );
 1098|      1|            }
 1099|      8|            set_negative(difSigns);
 1100|      8|            return *this;
 1101|      8|        }
 1102|       |
 1103|      0|        if ( words.size() == 1 )  //  && y.size() > 1
  ------------------
  |  Branch (1103:14): [True: 0, False: 0]
  ------------------
 1104|      0|        {
 1105|      0|            word_type digit = words[0];
 1106|      0|            *this = y;
 1107|      0|            *this *= digit;
 1108|      0|        }
 1109|      0|        else
 1110|      0|        {
 1111|      0|            if (y_words.size() == 1)
  ------------------
  |  Branch (1111:17): [True: 0, False: 0]
  ------------------
 1112|      0|            {
 1113|      0|                *this *= y_words[0];
 1114|      0|            }
 1115|      0|            else
 1116|      0|            {
 1117|      0|                size_type lenProd = words.size() + y_words.size();
 1118|      0|                word_type sumHi = 0, sumLo, hi, lo,
 1119|      0|                sumLo_old, sumHi_old, carry=0;
 1120|      0|                basic_bigint<Allocator> x = *this;
 1121|      0|                auto x_words = x.get_words();
 1122|      0|                resize( lenProd ); // Give *this length lenProd
 1123|      0|                words = get_words();
 1124|       |
 1125|      0|                for (size_type i = 0; i < lenProd; i++ )
  ------------------
  |  Branch (1125:39): [True: 0, False: 0]
  ------------------
 1126|      0|                {
 1127|      0|                    sumLo = sumHi;
 1128|      0|                    sumHi = carry;
 1129|      0|                    carry = 0;
 1130|      0|                    for (size_type jA=0; jA < x_words.size(); jA++)
  ------------------
  |  Branch (1130:42): [True: 0, False: 0]
  ------------------
 1131|      0|                    {
 1132|      0|                        if (JSONCONS_LIKELY(i >= jA))
  ------------------
  |  |   78|      0|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1133|      0|                        {
 1134|      0|                            size_type jB = i - jA;
 1135|      0|                            if (jB < y_words.size())
  ------------------
  |  Branch (1135:33): [True: 0, False: 0]
  ------------------
 1136|      0|                            {
 1137|      0|                                DDproduct( x_words[jA], y_words[jB], hi, lo );
 1138|      0|                                sumLo_old = sumLo;
 1139|      0|                                sumHi_old = sumHi;
 1140|      0|                                sumLo += lo;
 1141|      0|                                if ( sumLo < sumLo_old )
  ------------------
  |  Branch (1141:38): [True: 0, False: 0]
  ------------------
 1142|      0|                                    sumHi++;
 1143|      0|                                sumHi += hi;
 1144|      0|                                carry += (sumHi < sumHi_old);
 1145|      0|                            }
 1146|      0|                        }
 1147|      0|                    }
 1148|      0|                    words[i] = sumLo;
 1149|      0|                }
 1150|      0|            }
 1151|      0|        }
 1152|      0|       reduce();
 1153|      0|       set_negative(difSigns);
 1154|      0|       return *this;
 1155|      8|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2EOS4_:
  660|      2|        : storage_(std::move(other.storage_))
  661|      2|    {
  662|      2|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2EOS5_:
  335|      2|        : word_allocator_type(other.get_allocator())
  336|      2|    {
  337|      2|        if (!other.is_allocated())
  ------------------
  |  Branch (337:13): [True: 2, False: 0]
  ------------------
  338|      2|        {
  339|      2|            ::new (&inlined_) inlined_storage(other.inlined_);
  340|      2|        }
  341|      0|        else
  342|      0|        {
  343|      0|            ::new (&allocated_) allocated_storage(std::move(other.allocated_));
  344|      0|        }
  345|      2|    }

_ZN8jsoncons16to_bignum_resultIcEC2EPKcNS_11bignum_errcE:
  100|      7|        : ptr(ptr_), ec(ec_)
  101|      7|    {
  102|      7|    }

_ZN8jsoncons6binary13native_to_bigItNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6nonstd6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|     53|    {
  128|     53|        T val2 = byte_swap(val);
  129|     53|        uint8_t buf[sizeof(T)];
  130|     53|        std::memcpy(buf, &val2, sizeof(T));
  131|     53|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 106, False: 53]
  ------------------
  132|    106|        {
  133|    106|            *d_first++ = item;
  134|    106|        }
  135|     53|    }
_ZN8jsoncons6binary9byte_swapItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|    245|    {
   29|    245|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|    245|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  467|    245|#      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|    245|    }
_ZN8jsoncons6binary13native_to_bigIjNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6nonstd6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|     19|    {
  128|     19|        T val2 = byte_swap(val);
  129|     19|        uint8_t buf[sizeof(T)];
  130|     19|        std::memcpy(buf, &val2, sizeof(T));
  131|     19|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 76, False: 19]
  ------------------
  132|     76|        {
  133|     76|            *d_first++ = item;
  134|     76|        }
  135|     19|    }
_ZN8jsoncons6binary9byte_swapIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|  67.2k|    {
   40|  67.2k|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|  67.2k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  463|  67.2k|#  define JSONCONS_BYTE_SWAP_32 __builtin_bswap32
  ------------------
   42|       |    #else
   43|       |        uint32_t tmp = ((static_cast<uint32_t>(val) << 8) & 0xff00ff00) | ((static_cast<uint32_t>(val) >> 8) & 0xff00ff);
   44|       |        return (tmp << 16) | (tmp >> 16);
   45|       |    #endif
   46|  67.2k|    }
_ZN8jsoncons6binary13native_to_bigImNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6nonstd6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|      3|    {
  128|      3|        T val2 = byte_swap(val);
  129|      3|        uint8_t buf[sizeof(T)];
  130|      3|        std::memcpy(buf, &val2, sizeof(T));
  131|      3|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 24, False: 3]
  ------------------
  132|     24|        {
  133|     24|            *d_first++ = item;
  134|     24|        }
  135|      3|    }
_ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|  2.71k|    {
   52|  2.71k|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|  2.71k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  462|  2.71k|#  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|  2.71k|    }
_ZN8jsoncons6binary13native_to_bigIhNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6nonstd6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  69.6k|    {
  128|  69.6k|        T val2 = byte_swap(val);
  129|  69.6k|        uint8_t buf[sizeof(T)];
  130|  69.6k|        std::memcpy(buf, &val2, sizeof(T));
  131|  69.6k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 69.6k, False: 69.6k]
  ------------------
  132|  69.6k|        {
  133|  69.6k|            *d_first++ = item;
  134|  69.6k|        }
  135|  69.6k|    }
_ZN8jsoncons6binary9byte_swapIhEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm1EES4_E4typeES4_:
   21|  69.6k|    {
   22|  69.6k|        return val;
   23|  69.6k|    }
_ZN8jsoncons6binary13native_to_bigIfNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6nonstd6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  67.0k|    {
  128|  67.0k|        T val2 = byte_swap(val);
  129|  67.0k|        uint8_t buf[sizeof(T)];
  130|  67.0k|        std::memcpy(buf, &val2, sizeof(T));
  131|  67.0k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 268k, False: 67.0k]
  ------------------
  132|   268k|        {
  133|   268k|            *d_first++ = item;
  134|   268k|        }
  135|  67.0k|    }
_ZN8jsoncons6binary9byte_swapIfEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   64|  67.1k|    {
   65|  67.1k|        uint32_t x;
   66|  67.1k|        std::memcpy(&x,&val,sizeof(uint32_t));
   67|  67.1k|        uint32_t y = byte_swap(x);
   68|  67.1k|        T val2;
   69|  67.1k|        std::memcpy(&val2,&y,sizeof(uint32_t));
   70|  67.1k|        return val2;
   71|  67.1k|    }
_ZN8jsoncons6binary13native_to_bigIdNSt3__120back_insert_iteratorINS_10bytes_sinkINS2_6vectorIhNS2_9allocatorIhEEEEvEEEENS_6nonstd6endianEEENS2_9enable_ifIXeqsrT1_6nativesrSE_6littleEvE4typeET_T0_:
  127|  2.56k|    {
  128|  2.56k|        T val2 = byte_swap(val);
  129|  2.56k|        uint8_t buf[sizeof(T)];
  130|  2.56k|        std::memcpy(buf, &val2, sizeof(T));
  131|  2.56k|        for (auto item : buf)
  ------------------
  |  Branch (131:24): [True: 20.5k, False: 2.56k]
  ------------------
  132|  20.5k|        {
  133|  20.5k|            *d_first++ = item;
  134|  20.5k|        }
  135|  2.56k|    }
_ZN8jsoncons6binary9byte_swapIdEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   76|  2.68k|    {
   77|  2.68k|        uint64_t x;
   78|  2.68k|        std::memcpy(&x,&val,sizeof(uint64_t));
   79|  2.68k|        uint64_t y = byte_swap(x);
   80|  2.68k|        T val2;
   81|  2.68k|        std::memcpy(&val2,&y,sizeof(uint64_t));
   82|  2.68k|        return val2;
   83|  2.68k|    }
_ZN8jsoncons6binary13big_to_nativeItNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|     96|    {
  183|     96|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 96]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     96|        T val;
  188|     96|        std::memcpy(&val,first,sizeof(T));
  189|     96|        return byte_swap(val);
  190|     96|    }
_ZN8jsoncons6binary13big_to_nativeImNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|     24|    {
  183|     24|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 24]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     24|        T val;
  188|     24|        std::memcpy(&val,first,sizeof(T));
  189|     24|        return byte_swap(val);
  190|     24|    }
_ZN8jsoncons6binary9byte_swapIiEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|     60|    {
   40|     60|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|     60|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  463|     60|#  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|     60|    }
_ZN8jsoncons6binary13big_to_nativeIfNS_6nonstd6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|     44|    {
  183|     44|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 44]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|     44|        T val;
  188|     44|        std::memcpy(&val,first,sizeof(T));
  189|     44|        return byte_swap(val);
  190|     44|    }

_ZN8jsoncons6detail23bytes_to_base64_genericIPKhNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS4_9enable_ifIXsr3std7is_sameINS4_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESD_SD_PKcRT0_:
   44|   524k|    {
   45|   524k|        std::size_t count = 0;
   46|   524k|        unsigned char a3[3];
   47|   524k|        unsigned char a4[4];
   48|   524k|        unsigned char fill = alphabet[64];
   49|   524k|        int i = 0;
   50|   524k|        int j = 0;
   51|       |
   52|  1.08M|        while (first != last)
  ------------------
  |  Branch (52:16): [True: 558k, False: 524k]
  ------------------
   53|   558k|        {
   54|   558k|            a3[i++] = *first++;
   55|   558k|            if (i == 3)
  ------------------
  |  Branch (55:17): [True: 11.3k, False: 547k]
  ------------------
   56|  11.3k|            {
   57|  11.3k|                a4[0] = (a3[0] & 0xfc) >> 2;
   58|  11.3k|                a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   59|  11.3k|                a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   60|  11.3k|                a4[3] = a3[2] & 0x3f;
   61|       |
   62|  56.8k|                for (i = 0; i < 4; i++) 
  ------------------
  |  Branch (62:29): [True: 45.4k, False: 11.3k]
  ------------------
   63|  45.4k|                {
   64|  45.4k|                    result.push_back(alphabet[a4[i]]);
   65|  45.4k|                    ++count;
   66|  45.4k|                }
   67|  11.3k|                i = 0;
   68|  11.3k|            }
   69|   558k|        }
   70|       |
   71|   524k|        if (i > 0)
  ------------------
  |  Branch (71:13): [True: 524k, False: 373]
  ------------------
   72|   524k|        {
   73|  1.57M|            for (j = i; j < 3; ++j) 
  ------------------
  |  Branch (73:25): [True: 1.04M, False: 524k]
  ------------------
   74|  1.04M|            {
   75|  1.04M|                a3[j] = 0;
   76|  1.04M|            }
   77|       |
   78|   524k|            a4[0] = (a3[0] & 0xfc) >> 2;
   79|   524k|            a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
   80|   524k|            a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
   81|       |
   82|  1.57M|            for (j = 0; j < i + 1; ++j) 
  ------------------
  |  Branch (82:25): [True: 1.04M, False: 524k]
  ------------------
   83|  1.04M|            {
   84|  1.04M|                result.push_back(alphabet[a4[j]]);
   85|  1.04M|                ++count;
   86|  1.04M|            }
   87|       |
   88|   524k|            if (fill != 0)
  ------------------
  |  Branch (88:17): [True: 0, False: 524k]
  ------------------
   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|   524k|        }
   97|       |
   98|   524k|        return count;
   99|   524k|    }
_ZNK8jsoncons16byte_string_view5beginEv:
  409|   525k|        {
  410|   525k|            return data_;
  411|   525k|        }
_ZNK8jsoncons16byte_string_view3endEv:
  413|   525k|        {
  414|   525k|            return data_ + size_;
  415|   525k|        }
_ZN8jsoncons18bytes_to_base64urlIPKhNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_9enable_ifIXsr3std7is_sameINS3_15iterator_traitsIT_E10value_typeEhEE5valueEmE4typeESC_SC_RT0_:
  177|   524k|    {
  178|   524k|        static constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  179|   524k|                                                      "abcdefghijklmnopqrstuvwxyz"
  180|   524k|                                                      "0123456789-_"
  181|   524k|                                                      "\0";
  182|   524k|        return detail::bytes_to_base64_generic(first, last, alphabet, result);
  183|   524k|    }
_ZNK8jsoncons16byte_string_view4dataEv:
  399|   525k|        {
  400|   525k|            return data_;
  401|   525k|        }
_ZNK8jsoncons16byte_string_view4sizeEv:
  403|   526k|        {
  404|   526k|            return size_;
  405|   526k|        }
_ZN8jsoncons16byte_string_viewC2EPKhm:
  362|  1.04M|            : data_(data), size_(length)
  363|  1.04M|        {
  364|  1.04M|        }
_ZN8jsoncons16byte_string_viewC2INSt3__16vectorIhNS2_9allocatorIhEEEEEERKT_NS2_9enable_ifIXsr6nonstd18is_bytes_view_likeIS7_EE5valueEiE4typeE:
  369|    352|            : data_(reinterpret_cast<const uint8_t*>(cont.data())), size_(cont.size())
  370|    352|        {
  371|    352|        }
_ZN8jsoncons16byte_string_viewC2Ev:
  358|      6|        {
  359|      6|        }

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

_ZNK8jsoncons8identityclIRKhEEOT_S5_:
   19|  2.67k|    {
   20|  2.67k|        return std::forward<T>(val);
   21|  2.67k|    }
_ZNK8jsoncons8identityclIRKtEEOT_S5_:
   19|     96|    {
   20|     96|        return std::forward<T>(val);
   21|     96|    }
_ZNK8jsoncons8identityclIRKjEEOT_S5_:
   19|    126|    {
   20|    126|        return std::forward<T>(val);
   21|    126|    }
_ZNK8jsoncons8identityclIRKiEEOT_S5_:
   19|     60|    {
   20|     60|        return std::forward<T>(val);
   21|     60|    }
_ZNK8jsoncons11decode_halfclEt:
   36|     10|    {
   37|     10|        return binary::decode_half(val);
   38|     10|    }
_ZNK8jsoncons8identityclIRKfEEOT_S5_:
   19|   390k|    {
   20|   390k|        return std::forward<T>(val);
   21|   390k|    }
_ZNK8jsoncons8identityclIRKdEEOT_S5_:
   19|  63.3k|    {
   20|  63.3k|        return std::forward<T>(val);
   21|  63.3k|    }

_ZN8jsoncons16decstr_to_doubleEPKcmRd:
  889|  1.11k|{
  890|  1.11k|    const char* cur = s+length;
  891|  1.11k|    char *end = nullptr;
  892|  1.11k|    val = strtod(s, &end);
  893|  1.11k|    const char* str_end = end;
  894|  1.11k|    if (JSONCONS_UNLIKELY(end < cur))
  ------------------
  |  |   79|  1.11k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1.11k]
  |  |  ------------------
  ------------------
  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|  1.11k|    if (JSONCONS_UNLIKELY(val <= -HUGE_VAL || val >= HUGE_VAL))
  ------------------
  |  |   79|  2.23k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 1.11k]
  |  |  |  Branch (79:50): [True: 0, False: 1.11k]
  |  |  |  Branch (79:50): [True: 0, False: 1.11k]
  |  |  ------------------
  ------------------
  911|      0|    {
  912|      0|        return to_number_result<char>{str_end, std::errc::result_out_of_range};
  913|      0|    }
  914|  1.11k|    return to_number_result<char>{str_end};
  915|  1.11k|}
_ZN8jsoncons16to_number_resultIcEC2EPKcNSt3__14errcE:
  164|     36|        : ptr(ptr_), ec(ec_)
  165|     36|    {
  166|     36|    }
_ZN8jsoncons16to_number_resultIcEC2EPKc:
  160|  1.11k|        : ptr(ptr_), ec(std::errc{})
  161|  1.11k|    {
  162|  1.11k|    }
_ZN8jsoncons14dec_to_integerIlcEENSt3__19enable_ifIXaasr6nonstd14integer_limitsIT_EE14is_specializedsr6nonstd14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  350|     18|{
  351|     18|    if (length == 0)
  ------------------
  |  Branch (351:9): [True: 0, False: 18]
  ------------------
  352|      0|    {
  353|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  354|      0|    }
  355|       |
  356|     18|    bool sign = *s == '-';
  357|     18|    s += sign;
  358|     18|    length -= sign;
  359|       |
  360|     18|    using U = typename nonstd::make_unsigned<T>::type;
  361|       |
  362|     18|    U num;
  363|     18|    auto ru = dec_to_integer(s, length, num);
  364|     18|    if (ru.ec != std::errc{})
  ------------------
  |  Branch (364:9): [True: 4, False: 14]
  ------------------
  365|      4|    {
  366|      4|        return to_number_result<CharT>(ru.ptr, ru.ec);
  367|      4|    }
  368|     14|    if (sign)
  ------------------
  |  Branch (368:9): [True: 1, False: 13]
  ------------------
  369|      1|    {
  370|      1|        if (num > static_cast<U>(-((nonstd::integer_limits<T>::lowest)()+T(1))) + U(1))
  ------------------
  |  Branch (370:13): [True: 1, False: 0]
  ------------------
  371|      1|        {
  372|      1|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  373|      1|        }
  374|      0|        else
  375|      0|        {
  376|      0|            value = static_cast<T>(U(0) - num);
  377|      0|            return to_number_result<CharT>(ru.ptr, std::errc{});
  378|      0|        }
  379|      1|    }
  380|     13|    else
  381|     13|    {
  382|     13|        if (num > static_cast<U>((nonstd::integer_limits<T>::max)()))
  ------------------
  |  Branch (382:13): [True: 0, False: 13]
  ------------------
  383|      0|        {
  384|      0|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  385|      0|        }
  386|     13|        else
  387|     13|        {
  388|     13|            value = static_cast<T>(num);
  389|     13|            return to_number_result<CharT>(ru.ptr, std::errc{});
  390|     13|        }
  391|     13|    }
  392|     14|}
_ZN8jsoncons14dec_to_integerImcEENSt3__19enable_ifIXaasr6nonstd14integer_limitsIT_EE14is_specializedntsr6nonstd14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  288|     18|{
  289|     18|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   79|     18|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 18]
  |  |  ------------------
  ------------------
  290|      0|    {
  291|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  292|      0|    }
  293|       |
  294|     18|    static constexpr T max_value = (nonstd::integer_limits<T>::max)();
  295|     18|    static constexpr T max_value_div_10 = max_value / 10;
  296|       |
  297|     18|    T num = 0;
  298|     18|    const CharT* cur = s;
  299|     18|    const CharT* last = s + length;
  300|     18|    static constexpr std::size_t digits10 = static_cast<std::size_t>(nonstd::integer_limits<T>::digits10);
  301|     18|    const std::size_t n = (std::min)(digits10, length);
  302|     18|    const CharT* stop = s + n;
  303|       |     
  304|    160|    while (cur < stop)
  ------------------
  |  Branch (304:12): [True: 142, False: 18]
  ------------------
  305|    142|    {
  306|    142|        uint8_t d;
  307|    142|        if (JSONCONS_LIKELY((d = static_cast<uint8_t>(*cur - '0')) <= 9) )
  ------------------
  |  |   78|    142|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 142, False: 0]
  |  |  ------------------
  ------------------
  308|    142|        {
  309|    142|            num = static_cast<T>(d) + num*10;
  310|    142|        }
  311|      0|        else
  312|      0|        {
  313|      0|            return to_number_result<CharT>(cur, std::errc::invalid_argument);
  314|      0|        }
  315|    142|        ++cur;
  316|    142|    }
  317|     18|    if (cur == last)
  ------------------
  |  Branch (317:9): [True: 13, False: 5]
  ------------------
  318|     13|    {
  319|     13|        value = num;
  320|     13|        return to_number_result<CharT>(cur, std::errc{});
  321|     13|    }
  322|      5|    if (cur+1 != last)
  ------------------
  |  Branch (322:9): [True: 3, False: 2]
  ------------------
  323|      3|    {
  324|      3|        return to_number_result<CharT>(cur, std::errc::result_out_of_range);
  325|      3|    }
  326|      2|    if (is_char_digit(*cur))
  ------------------
  |  Branch (326:9): [True: 2, False: 0]
  ------------------
  327|      2|    {
  328|      2|        if (num > max_value_div_10)
  ------------------
  |  Branch (328:13): [True: 1, False: 1]
  ------------------
  329|      1|        {
  330|      1|            return to_number_result<CharT>(cur, std::errc::result_out_of_range);
  331|      1|        }
  332|      1|        uint8_t d = static_cast<uint8_t>(*cur - '0');
  333|      1|        num = num*10;
  334|      1|        if (num > max_value - d)
  ------------------
  |  Branch (334:13): [True: 0, False: 1]
  ------------------
  335|      0|        {
  336|      0|            return to_number_result<CharT>(s, std::errc::result_out_of_range);
  337|      0|        }
  338|      1|        num += d;
  339|      1|        ++cur;
  340|      1|        value = num;
  341|      1|        return to_number_result<CharT>(cur, std::errc{});
  342|      1|    }
  343|       |    
  344|      0|    return to_number_result<CharT>(cur, std::errc::invalid_argument);
  345|      2|}
_ZN8jsoncons13is_char_digitEc:
   83|      2|constexpr bool is_char_digit(char d) {
   84|      2|    return is_type(static_cast<uint8_t>(d), (uint8_t)(digit_type_zero | digit_type_nonzero));
   85|      2|}
_ZN8jsoncons7is_typeEhh:
   68|      2|constexpr bool is_type(uint8_t d, uint8_t type) {
   69|      2|    return (digi_table[d] & type) != 0;
   70|      2|}
_ZNK8jsoncons16to_number_resultIcEcvbEv:
  173|     18|    {
  174|     18|        return ec == std::errc{};
  175|     18|    }
_ZNK8jsoncons16to_number_resultIcE10error_codeEv:
  177|      5|    {
  178|      5|        return make_error_code(ec);
  179|      5|    }

_ZN8jsoncons12from_integerImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr6nonstd10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  1.05M|{
   43|  1.05M|    using char_type = typename Result::value_type;
   44|       |
   45|  1.05M|    char_type buf[255];
   46|  1.05M|    char_type *p = buf;
   47|  1.05M|    const char_type* last = buf+255;
   48|       |
   49|  1.05M|    bool is_negative = value < 0;
   50|       |
   51|  1.05M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 1.05M]
  ------------------
   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|  1.05M|    else
   60|  1.05M|    {
   61|       |
   62|  1.05M|        do
   63|  1.06M|        {
   64|  1.06M|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  1.06M|        }
   66|  1.06M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 6.89k, False: 1.05M]
  |  Branch (66:33): [True: 6.89k, False: 0]
  ------------------
   67|  1.05M|    }
   68|  1.05M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   54|  1.05M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 1.05M]
  |  |  ------------------
  |  |   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|  1.05M|    std::size_t count = (p - buf);
   71|  1.05M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 1.05M]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  2.11M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 1.06M, False: 1.05M]
  ------------------
   77|  1.06M|    {
   78|  1.06M|        result.push_back(*p);
   79|  1.06M|    }
   80|       |
   81|  1.05M|    return count;
   82|  1.05M|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr6nonstd10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|    319|{
   43|    319|    using char_type = typename Result::value_type;
   44|       |
   45|    319|    char_type buf[255];
   46|    319|    char_type *p = buf;
   47|    319|    const char_type* last = buf+255;
   48|       |
   49|    319|    bool is_negative = value < 0;
   50|       |
   51|    319|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 280, False: 39]
  ------------------
   52|    280|    {
   53|    280|        do
   54|    586|        {
   55|    586|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|    586|        }
   57|    586|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 306, False: 280]
  |  Branch (57:33): [True: 306, False: 0]
  ------------------
   58|    280|    }
   59|     39|    else
   60|     39|    {
   61|       |
   62|     39|        do
   63|    345|        {
   64|    345|            *p++ = static_cast<char_type>(48 + value % 10);
   65|    345|        }
   66|    345|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 306, False: 39]
  |  Branch (66:33): [True: 306, False: 0]
  ------------------
   67|     39|    }
   68|    319|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   54|    319|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 319]
  |  |  ------------------
  |  |   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|    319|    std::size_t count = (p - buf);
   71|    319|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 280, False: 39]
  ------------------
   72|    280|    {
   73|    280|        result.push_back('-');
   74|    280|        ++count;
   75|    280|    }
   76|  1.25k|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 931, False: 319]
  ------------------
   77|    931|    {
   78|    931|        result.push_back(*p);
   79|    931|    }
   80|       |
   81|    319|    return count;
   82|    319|}
_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|   384k|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|   384k|    {
  489|   384k|#if !defined(JSONCONS_NO_LOCALECONV)
  490|   384k|        struct lconv *lc = localeconv();
  491|   384k|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 384k, False: 0]
  |  Branch (491:30): [True: 384k, False: 0]
  ------------------
  492|   384k|        {
  493|   384k|            decimal_point_ = lc->decimal_point[0];
  494|   384k|        }
  495|   384k|#endif
  496|   384k|    }
_ZN8jsoncons12write_doubleclINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEmdRT_:
  503|   384k|    {
  504|   384k|        std::size_t count = 0;
  505|       |
  506|   384k|        char number_buffer[200];
  507|   384k|        int length = 0;
  508|       |
  509|   384k|        switch (float_format_)
  510|   384k|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 384k]
  ------------------
  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: 384k]
  ------------------
  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|   384k|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 384k, False: 0]
  ------------------
  552|   384k|            {
  553|   384k|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 384k]
  ------------------
  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|   384k|                else
  563|   384k|                {
  564|   384k|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 384k]
  ------------------
  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|   384k|                }             
  569|   384k|                break;
  570|   384k|            }
  571|   384k|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 384k]
  ------------------
  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|   384k|        }
  575|   384k|        return count;
  576|   384k|    }
_ZN8jsoncons11dump_bufferINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKcmcRT_:
  243|  1.11k|{
  244|  1.11k|    const char *sbeg = buffer;
  245|  1.11k|    const char *send = sbeg + length;
  246|       |
  247|  1.11k|    if (sbeg != send)
  ------------------
  |  Branch (247:9): [True: 1.11k, False: 0]
  ------------------
  248|  1.11k|    {
  249|  1.11k|        bool needs_dot = true;
  250|  25.7k|        for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (250:36): [True: 24.6k, False: 1.11k]
  ------------------
  251|  24.6k|        {
  252|  24.6k|            switch (*q)
  253|  24.6k|            {
  254|    913|            case '-':
  ------------------
  |  Branch (254:13): [True: 913, False: 23.7k]
  ------------------
  255|  1.82k|            case '0':
  ------------------
  |  Branch (255:13): [True: 914, False: 23.7k]
  ------------------
  256|  3.85k|            case '1':
  ------------------
  |  Branch (256:13): [True: 2.02k, False: 22.6k]
  ------------------
  257|  5.68k|            case '2':
  ------------------
  |  Branch (257:13): [True: 1.82k, False: 22.8k]
  ------------------
  258|  8.51k|            case '3':
  ------------------
  |  Branch (258:13): [True: 2.83k, False: 21.7k]
  ------------------
  259|  10.5k|            case '4':
  ------------------
  |  Branch (259:13): [True: 2.02k, False: 22.6k]
  ------------------
  260|  12.0k|            case '5':
  ------------------
  |  Branch (260:13): [True: 1.52k, False: 23.1k]
  ------------------
  261|  15.2k|            case '6':
  ------------------
  |  Branch (261:13): [True: 3.14k, False: 21.4k]
  ------------------
  262|  17.0k|            case '7':
  ------------------
  |  Branch (262:13): [True: 1.82k, False: 22.8k]
  ------------------
  263|  20.1k|            case '8':
  ------------------
  |  Branch (263:13): [True: 3.14k, False: 21.4k]
  ------------------
  264|  22.6k|            case '9':
  ------------------
  |  Branch (264:13): [True: 2.43k, False: 22.2k]
  ------------------
  265|  22.6k|            case '+':
  ------------------
  |  Branch (265:13): [True: 0, False: 24.6k]
  ------------------
  266|  22.6k|                result.push_back(*q);
  267|  22.6k|                break;
  268|    913|            case 'e':
  ------------------
  |  Branch (268:13): [True: 913, False: 23.7k]
  ------------------
  269|    913|            case 'E':
  ------------------
  |  Branch (269:13): [True: 0, False: 24.6k]
  ------------------
  270|    913|                result.push_back('e');
  271|    913|                needs_dot = false;
  272|    913|                break;
  273|  1.11k|            default:
  ------------------
  |  Branch (273:13): [True: 1.11k, False: 23.5k]
  ------------------
  274|  1.11k|                if (*q == decimal_point)
  ------------------
  |  Branch (274:21): [True: 1.11k, False: 0]
  ------------------
  275|  1.11k|                {
  276|  1.11k|                    needs_dot = false;
  277|  1.11k|                    result.push_back('.');
  278|  1.11k|                }
  279|  1.11k|                break;
  280|  24.6k|            }
  281|  24.6k|        }
  282|  1.11k|        if (needs_dot)
  ------------------
  |  Branch (282:13): [True: 0, False: 1.11k]
  ------------------
  283|      0|        {
  284|      0|            result.push_back('.');
  285|      0|            result.push_back('0');
  286|      0|        }
  287|  1.11k|    }
  288|  1.11k|}
_ZN8jsoncons15prettify_stringINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKciiiiRT_:
  171|   379k|{
  172|   379k|    int nb_digits = length;
  173|   379k|    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|   379k|    int kk = nb_digits + k;
  179|       |
  180|   379k|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 132k, False: 246k]
  |  Branch (180:28): [True: 100k, False: 31.7k]
  ------------------
  181|   100k|    {
  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|  1.55M|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 1.45M, False: 100k]
  ------------------
  186|  1.45M|        {
  187|  1.45M|            result.push_back(buffer[i]);
  188|  1.45M|        }
  189|   109k|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 8.88k, False: 100k]
  ------------------
  190|  8.88k|        {
  191|  8.88k|            result.push_back('0');
  192|  8.88k|        }
  193|   100k|        result.push_back('.');
  194|   100k|        result.push_back('0');
  195|   100k|    } 
  196|   278k|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 71.5k, False: 207k]
  |  Branch (196:24): [True: 39.7k, False: 31.7k]
  ------------------
  197|  39.7k|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|   174k|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 134k, False: 39.7k]
  ------------------
  200|   134k|        {
  201|   134k|            result.push_back(buffer[i]);
  202|   134k|        }
  203|  39.7k|        result.push_back('.');
  204|   513k|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 473k, False: 39.7k]
  ------------------
  205|   473k|        {
  206|   473k|            result.push_back(buffer[i]);
  207|   473k|        }
  208|  39.7k|    } 
  209|   238k|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 34.7k, False: 204k]
  |  Branch (209:30): [True: 3.03k, False: 31.7k]
  ------------------
  210|  3.03k|    {
  211|  3.03k|        offset = 2 - kk;
  212|       |
  213|  3.03k|        result.push_back('0');
  214|  3.03k|        result.push_back('.');
  215|  9.10k|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 6.06k, False: 3.03k]
  ------------------
  216|  6.06k|            result.push_back('0');
  217|  52.8k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 49.8k, False: 3.03k]
  ------------------
  218|  49.8k|        {
  219|  49.8k|            result.push_back(buffer[i]);
  220|  49.8k|        }
  221|  3.03k|    } 
  222|   235k|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 76, False: 235k]
  ------------------
  223|     76|    {
  224|     76|        result.push_back(buffer[0]);
  225|     76|        result.push_back('e');
  226|     76|        fill_exponent(kk - 1, result);
  227|     76|    } 
  228|   235k|    else
  229|   235k|    {
  230|   235k|        result.push_back(buffer[0]);
  231|   235k|        result.push_back('.');
  232|  3.77M|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 3.53M, False: 235k]
  ------------------
  233|  3.53M|        {
  234|  3.53M|            result.push_back(buffer[i]);
  235|  3.53M|        }
  236|   235k|        result.push_back('e');
  237|   235k|        fill_exponent(kk - 1, result);
  238|   235k|    }
  239|   379k|}
_ZN8jsoncons13fill_exponentINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEviRT_:
  136|   235k|{
  137|   235k|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 204k, False: 31.7k]
  ------------------
  138|   204k|    {
  139|   204k|        result.push_back('-');
  140|   204k|        K = -K;
  141|   204k|    }
  142|  31.7k|    else
  143|  31.7k|    {
  144|  31.7k|        result.push_back('+'); // compatibility with sprintf
  145|  31.7k|    }
  146|       |
  147|   235k|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 2, False: 235k]
  ------------------
  148|      2|    {
  149|      2|        result.push_back('0'); // compatibility with sprintf
  150|      2|        result.push_back((char)('0' + K));
  151|      2|    }
  152|   235k|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 182k, False: 52.9k]
  ------------------
  153|   182k|    {
  154|   182k|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|   182k|        result.push_back((char)('0' + K));
  156|   182k|    }
  157|  52.9k|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 52.9k, False: 0]
  ------------------
  158|  52.9k|    {
  159|  52.9k|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|  52.9k|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|  52.9k|        result.push_back((char)('0' + K));
  162|  52.9k|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|   235k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_:
  475|   384k|{
  476|   384k|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|   384k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb1EEE:
  366|   384k|{
  367|   384k|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 3.67k, False: 380k]
  ------------------
  368|  3.67k|    {
  369|  3.67k|        result.push_back('0');
  370|  3.67k|        result.push_back('.');
  371|  3.67k|        result.push_back('0');
  372|  3.67k|        return true;
  373|  3.67k|    }
  374|       |
  375|   380k|    int length = 0;
  376|   380k|    int k;
  377|       |
  378|   380k|    char buffer[100];
  379|       |
  380|   380k|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 131k, False: 249k]
  ------------------
  381|   380k|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 379k, False: 1.11k]
  ------------------
  382|   379k|    {
  383|   379k|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 131k, False: 248k]
  ------------------
  384|   131k|        {
  385|   131k|            result.push_back('-');
  386|   131k|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|   379k|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|   379k|        return true;
  391|   379k|    }
  392|  1.11k|    else
  393|  1.11k|    {
  394|  1.11k|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|  1.11k|    }
  396|   380k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb0EEE:
  329|  1.11k|{
  330|  1.11k|    if (val == 0)
  ------------------
  |  Branch (330:9): [True: 0, False: 1.11k]
  ------------------
  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|  1.11k|    char buffer[100];
  339|  1.11k|    int precision = std::numeric_limits<double>::digits10;
  340|  1.11k|    int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  341|  1.11k|    if (length < 0)
  ------------------
  |  Branch (341:9): [True: 0, False: 1.11k]
  ------------------
  342|      0|    {
  343|      0|        return false;
  344|      0|    }
  345|  1.11k|    double x{0};
  346|  1.11k|    auto res = decstr_to_double(buffer, length, x);
  347|  1.11k|    if (res.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (347:9): [True: 0, False: 1.11k]
  ------------------
  348|      0|    {
  349|      0|        return false;
  350|      0|    }
  351|  1.11k|    if (x != val)
  ------------------
  |  Branch (351:9): [True: 1.11k, False: 0]
  ------------------
  352|  1.11k|    {
  353|  1.11k|        const int precision2 = std::numeric_limits<double>::max_digits10;
  354|  1.11k|        length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  355|  1.11k|        if (length < 0)
  ------------------
  |  Branch (355:13): [True: 0, False: 1.11k]
  ------------------
  356|      0|        {
  357|      0|            return false;
  358|      0|        }
  359|  1.11k|    }
  360|  1.11k|    dump_buffer(buffer, length, decimal_point, result);
  361|  1.11k|    return true;
  362|  1.11k|}

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

_ZN8jsoncons4cbor6detail24min_length_for_stringrefEm:
   58|   237k|{
   59|   237k|    std::size_t n;
   60|   237k|    if (index <= 23)
  ------------------
  |  Branch (60:9): [True: 1.37k, False: 236k]
  ------------------
   61|  1.37k|    {
   62|  1.37k|        n = 3;
   63|  1.37k|    }
   64|   236k|    else if (index <= 255)
  ------------------
  |  Branch (64:14): [True: 1.50k, False: 234k]
  ------------------
   65|  1.50k|    {
   66|  1.50k|        n = 4;
   67|  1.50k|    }
   68|   234k|    else if (index <= 65535)
  ------------------
  |  Branch (68:14): [True: 130k, False: 104k]
  ------------------
   69|   130k|    {
   70|   130k|        n = 5;
   71|   130k|    }
   72|   104k|    else if (index <= 4294967295)
  ------------------
  |  Branch (72:14): [True: 104k, False: 0]
  ------------------
   73|   104k|    {
   74|   104k|        n = 7;
   75|   104k|    }
   76|      0|    else 
   77|      0|    {
   78|      0|        n = 11;
   79|      0|    }
   80|   237k|    return n;
   81|   237k|}

_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEEC2EOS8_RKS9_:
  128|     21|       : basic_cbor_encoder(std::forward<Sink>(sink), cbor_encode_options(), alloc)
  129|     21|    {
  130|     21|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEEC2EOS8_RKNS0_19cbor_encode_optionsERKS9_:
  134|     21|       : sink_(std::forward<Sink>(sink)), 
  135|     21|         max_nesting_depth_(static_cast<std::size_t>(options.max_nesting_depth())), 
  136|     21|         pack_strings_(options.pack_strings()),
  137|     21|         use_typed_arrays_(options.use_typed_arrays()),
  138|     21|         alloc_(alloc),
  139|     21|         stack_(alloc),
  140|     21|         stringref_map_(alloc),
  141|     21|         bytestringref_map_(alloc)
  142|     21|    {
  143|     21|        if (options.pack_strings())
  ------------------
  |  Branch (143:13): [True: 0, False: 21]
  ------------------
  144|      0|        {
  145|      0|            write_tag(256);
  146|      0|        }
  147|     21|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9write_tagEm:
 1101|     27|    {
 1102|     27|        write_type_and_length(0xc0, value);
 1103|     27|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE21write_type_and_lengthEhm:
  433|  1.62M|    {
  434|  1.62M|        if (length <= 0x17)
  ------------------
  |  Branch (434:13): [True: 1.62M, False: 82]
  ------------------
  435|  1.62M|        {
  436|  1.62M|            sink_.push_back(static_cast<uint8_t>(major_type + length));
  437|  1.62M|        }
  438|     82|        else if (length <= 0xff)
  ------------------
  |  Branch (438:18): [True: 7, False: 75]
  ------------------
  439|      7|        {
  440|      7|            sink_.push_back(static_cast<uint8_t>(major_type + 0x18));
  441|      7|            sink_.push_back(static_cast<uint8_t>(length));
  442|      7|        }
  443|     75|        else if (length <= 0xffff)
  ------------------
  |  Branch (443:18): [True: 53, False: 22]
  ------------------
  444|     53|        {
  445|     53|            sink_.push_back(static_cast<uint8_t>(major_type + 0x19));
  446|     53|            binary::native_to_big(static_cast<uint16_t>(length),
  447|     53|                                            std::back_inserter(sink_));
  448|     53|        }
  449|     22|        else if (length <= 0xffffffff)
  ------------------
  |  Branch (449:18): [True: 19, False: 3]
  ------------------
  450|     19|        {
  451|     19|            sink_.push_back(static_cast<uint8_t>(major_type + 0x1a));
  452|     19|            binary::native_to_big(static_cast<uint32_t>(length),
  453|     19|                                            std::back_inserter(sink_));
  454|     19|        }
  455|      3|        else
  456|      3|        {
  457|      3|            sink_.push_back(static_cast<uint8_t>(major_type + 0x1b));
  458|      3|            binary::native_to_big(static_cast<uint64_t>(length),
  459|      3|                                            std::back_inserter(sink_));
  460|      3|        }
  461|  1.62M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  339|    247|    {
  340|    247|        if (JSONCONS_UNLIKELY(stack_.size() >= max_nesting_depth_))
  ------------------
  |  |   79|    247|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 247]
  |  |  ------------------
  ------------------
  341|      0|        {
  342|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  343|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  344|      0|        } 
  345|    247|        stack_.emplace_back(container_type::array, length);
  346|    247|        write_type_and_length(0x80, length);
  347|    247|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    247|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  348|    247|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_itemC2ENS0_14container_typeEm:
   74|    324|           : type_(type), length_(length)
   75|    324|        {
   76|    324|        }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE15visit_end_arrayERKNS_11ser_contextERNS3_10error_codeE:
  351|    216|    {
  352|    216|        if (JSONCONS_UNLIKELY(stack_.empty() || !stack_.back().is_array()))
  ------------------
  |  |   79|    432|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 216]
  |  |  |  Branch (79:50): [True: 0, False: 216]
  |  |  |  Branch (79:50): [True: 0, False: 216]
  |  |  ------------------
  ------------------
  353|      0|        {
  354|      0|            ec = cbor_errc::unmatched_end_array;
  355|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  356|      0|        }
  357|       |
  358|    216|        if (stack_.back().is_indefinite_length())
  ------------------
  |  Branch (358:13): [True: 0, False: 216]
  ------------------
  359|      0|        {
  360|      0|            sink_.push_back(0xff);
  361|      0|        }
  362|    216|        else
  363|    216|        {
  364|    216|            if (stack_.back().count() < stack_.back().length())
  ------------------
  |  Branch (364:17): [True: 0, False: 216]
  ------------------
  365|      0|            {
  366|      0|                ec = cbor_errc::too_few_items;
  367|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  368|      0|            }
  369|    216|            if (stack_.back().count() > stack_.back().length())
  ------------------
  |  Branch (369:17): [True: 0, False: 216]
  ------------------
  370|      0|            {
  371|      0|                ec = cbor_errc::too_many_items;
  372|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  373|      0|            }
  374|    216|        }
  375|       |
  376|    216|        stack_.pop_back();
  377|    216|        end_value();
  378|       |
  379|    216|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|    216|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  380|    216|    }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item8is_arrayEv:
   96|    216|        {
   97|    216|            return type_ == container_type::array || type_ == container_type::indefinite_length_array;
  ------------------
  |  Branch (97:20): [True: 216, False: 0]
  |  Branch (97:54): [True: 0, False: 0]
  ------------------
   98|    216|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item20is_indefinite_lengthEv:
  101|    273|        {
  102|    273|            return type_ == container_type::indefinite_length_array || type_ == container_type::indefinite_length_object;
  ------------------
  |  Branch (102:20): [True: 0, False: 273]
  |  Branch (102:72): [True: 0, False: 273]
  ------------------
  103|    273|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item5countEv:
   86|    546|        {
   87|    546|            return is_object() ? index_/2 : index_;
  ------------------
  |  Branch (87:20): [True: 114, False: 432]
  ------------------
   88|    546|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item9is_objectEv:
   91|    603|        {
   92|    603|            return type_ == container_type::object || type_ == container_type::indefinite_length_object;
  ------------------
  |  Branch (92:20): [True: 171, False: 432]
  |  Branch (92:55): [True: 0, False: 432]
  ------------------
   93|    603|        }
_ZNK8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE10stack_item6lengthEv:
   81|    546|        {
   82|    546|            return length_;
   83|    546|        }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9end_valueEv:
 1618|  1.69M|    {
 1619|  1.69M|        if (!stack_.empty())
  ------------------
  |  Branch (1619:13): [True: 1.69M, False: 4]
  ------------------
 1620|  1.69M|        {
 1621|  1.69M|            ++stack_.back().index_;
 1622|  1.69M|        }
 1623|  1.69M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1082|  1.26M|    {
 1083|  1.26M|        switch (tag)
 1084|  1.26M|        {
 1085|      0|            case semantic_tag::epoch_milli:
  ------------------
  |  Branch (1085:13): [True: 0, False: 1.26M]
  ------------------
 1086|      0|            case semantic_tag::epoch_nano:
  ------------------
  |  Branch (1086:13): [True: 0, False: 1.26M]
  ------------------
 1087|      0|                return visit_double(static_cast<double>(value), tag, context, ec);
 1088|      0|            case semantic_tag::epoch_second:
  ------------------
  |  Branch (1088:13): [True: 0, False: 1.26M]
  ------------------
 1089|      0|                write_tag(1);
 1090|      0|                break;
 1091|  1.26M|            default:
  ------------------
  |  Branch (1091:13): [True: 1.26M, False: 0]
  ------------------
 1092|  1.26M|                break;
 1093|  1.26M|        }
 1094|       |
 1095|  1.26M|        write_uint64_value(value);
 1096|  1.26M|        end_value();
 1097|  1.26M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  1.26M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1098|  1.26M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18write_uint64_valueEm:
 1106|  1.26M|    {
 1107|  1.26M|        write_type_and_length(0x00, value);
 1108|  1.26M|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1061|     42|    {
 1062|     42|        switch (tag)
 1063|     42|        {
 1064|      0|            case semantic_tag::epoch_milli:
  ------------------
  |  Branch (1064:13): [True: 0, False: 42]
  ------------------
 1065|      0|            case semantic_tag::epoch_nano:
  ------------------
  |  Branch (1065:13): [True: 0, False: 42]
  ------------------
 1066|      0|                return visit_double(static_cast<double>(value), tag, context, ec);
 1067|      0|            case semantic_tag::epoch_second:
  ------------------
  |  Branch (1067:13): [True: 0, False: 42]
  ------------------
 1068|      0|                write_tag(1);
 1069|      0|                break;
 1070|     42|            default:
  ------------------
  |  Branch (1070:13): [True: 42, False: 0]
  ------------------
 1071|     42|                break;
 1072|     42|        }
 1073|     42|        write_int64_value(value);
 1074|     42|        end_value();
 1075|     42|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     42|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1076|     42|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17write_int64_valueEl:
 1111|     42|    {
 1112|     42|        if (value >= 0)
  ------------------
  |  Branch (1112:13): [True: 14, False: 28]
  ------------------
 1113|     14|        {
 1114|     14|            write_type_and_length(0x00, static_cast<uint64_t>(value));
 1115|     14|        }
 1116|     28|        else
 1117|     28|        {
 1118|     28|            write_type_and_length(0x20, static_cast<uint64_t>(-1 - value));
 1119|     28|        }
 1120|     42|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1013|  69.6k|    {
 1014|  69.6k|        switch (tag)
 1015|  69.6k|        {
 1016|      2|            case semantic_tag::epoch_second:
  ------------------
  |  Branch (1016:13): [True: 2, False: 69.6k]
  ------------------
 1017|      2|                write_tag(1);
 1018|      2|                break;
 1019|      0|            case semantic_tag::epoch_milli:
  ------------------
  |  Branch (1019:13): [True: 0, False: 69.6k]
  ------------------
 1020|      0|                write_tag(1);
 1021|      0|                if (val != 0)
  ------------------
  |  Branch (1021:21): [True: 0, False: 0]
  ------------------
 1022|      0|                {
 1023|      0|                    val /= millis_in_second;
 1024|      0|                }
 1025|      0|                break;
 1026|      0|            case semantic_tag::epoch_nano:
  ------------------
  |  Branch (1026:13): [True: 0, False: 69.6k]
  ------------------
 1027|      0|                write_tag(1);
 1028|      0|                if (val != 0)
  ------------------
  |  Branch (1028:21): [True: 0, False: 0]
  ------------------
 1029|      0|                {
 1030|      0|                    val /= nanos_in_second;
 1031|      0|                }
 1032|      0|                break;
 1033|  69.6k|            default:
  ------------------
  |  Branch (1033:13): [True: 69.6k, False: 2]
  ------------------
 1034|  69.6k|                break;
 1035|  69.6k|        }
 1036|       |
 1037|  69.6k|        float valf = (float)val;
 1038|  69.6k|        if ((double)valf == val)
  ------------------
  |  Branch (1038:13): [True: 67.0k, False: 2.56k]
  ------------------
 1039|  67.0k|        {
 1040|  67.0k|            binary::native_to_big(static_cast<uint8_t>(0xfa), 
 1041|  67.0k|                                  std::back_inserter(sink_));
 1042|  67.0k|            binary::native_to_big(valf, std::back_inserter(sink_));
 1043|  67.0k|        }
 1044|  2.56k|        else
 1045|  2.56k|        {
 1046|  2.56k|            binary::native_to_big(static_cast<uint8_t>(0xfb), 
 1047|  2.56k|                                  std::back_inserter(sink_));
 1048|  2.56k|            binary::native_to_big(val, std::back_inserter(sink_));
 1049|  2.56k|        }
 1050|       |
 1051|       |        // write double
 1052|       |
 1053|  69.6k|        end_value();
 1054|  69.6k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  69.6k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1055|  69.6k|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE11visit_flushEv:
  263|      4|    {
  264|      4|        sink_.flush();
  265|      4|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  268|      6|    {
  269|      6|        if (JSONCONS_UNLIKELY(stack_.size() >= max_nesting_depth_))
  ------------------
  |  |   79|      6|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 6]
  |  |  ------------------
  ------------------
  270|      0|        {
  271|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  272|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  273|      0|        } 
  274|      6|        stack_.emplace_back(container_type::indefinite_length_object);
  275|       |        
  276|      6|        sink_.push_back(0xbf);
  277|      6|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      6|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  278|      6|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  281|     64|    {
  282|     64|        if (JSONCONS_UNLIKELY(stack_.size() >= max_nesting_depth_))
  ------------------
  |  |   79|     64|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 64]
  |  |  ------------------
  ------------------
  283|      0|        {
  284|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  285|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  286|      0|        } 
  287|     64|        stack_.emplace_back(container_type::object, length);
  288|       |
  289|     64|        write_type_and_length(0xa0, length);
  290|       |
  291|     64|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     64|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  292|     64|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE16visit_end_objectERKNS_11ser_contextERNS3_10error_codeE:
  295|     57|    {
  296|     57|        if (JSONCONS_UNLIKELY(stack_.empty() || !stack_.back().is_object()))
  ------------------
  |  |   79|    114|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 57]
  |  |  |  Branch (79:50): [True: 0, False: 57]
  |  |  |  Branch (79:50): [True: 0, False: 57]
  |  |  ------------------
  ------------------
  297|      0|        {
  298|      0|            ec = cbor_errc::unmatched_end_object;
  299|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  300|      0|        }
  301|       |
  302|     57|        if (stack_.back().is_indefinite_length())
  ------------------
  |  Branch (302:13): [True: 0, False: 57]
  ------------------
  303|      0|        {
  304|      0|            sink_.push_back(0xff);
  305|      0|        }
  306|     57|        else
  307|     57|        {
  308|     57|            if (stack_.back().count() < stack_.back().length())
  ------------------
  |  Branch (308:17): [True: 0, False: 57]
  ------------------
  309|      0|            {
  310|      0|                ec = cbor_errc::too_few_items;
  311|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  312|      0|            }
  313|     57|            if (stack_.back().count() > stack_.back().length())
  ------------------
  |  Branch (313:17): [True: 0, False: 57]
  ------------------
  314|      0|            {
  315|      0|                ec = cbor_errc::too_many_items;
  316|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  317|      0|            }
  318|     57|        }
  319|       |
  320|     57|        stack_.pop_back();
  321|     57|        end_value();
  322|       |
  323|     57|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     57|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  324|     57|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  327|      7|    {
  328|      7|        if (JSONCONS_UNLIKELY(stack_.size() >= max_nesting_depth_))
  ------------------
  |  |   79|      7|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 7]
  |  |  ------------------
  ------------------
  329|      0|        {
  330|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
  331|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  332|      0|        } 
  333|      7|        stack_.emplace_back(container_type::indefinite_length_array);
  334|      7|        sink_.push_back(0x9f);
  335|      7|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      7|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  336|      7|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE9visit_keyERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKNS_11ser_contextERNS3_10error_codeE:
  383|  65.7k|    {
  384|  65.7k|        visit_string(name, semantic_tag::none, context, ec);
  385|  65.7k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  65.7k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  386|  65.7k|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12visit_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  858|   366k|    {
  859|   366k|        switch (tag)
  860|   366k|        {
  861|      2|            case semantic_tag::bigint:
  ------------------
  |  Branch (861:13): [True: 2, False: 366k]
  ------------------
  862|      2|            {
  863|      2|                bigint n(sv.data(), sv.length());
  864|      2|                write_bignum(n);
  865|      2|                end_value();
  866|      2|                break;
  867|      0|            }
  868|     16|            case semantic_tag::bigdec:
  ------------------
  |  Branch (868:13): [True: 16, False: 366k]
  ------------------
  869|     16|            {
  870|     16|                write_decimal_value(sv, context, ec);
  871|     16|                break;
  872|      0|            }
  873|      0|            case semantic_tag::datetime:
  ------------------
  |  Branch (873:13): [True: 0, False: 366k]
  ------------------
  874|      0|            {
  875|      0|                write_tag(0);
  876|       |
  877|      0|                write_string(sv);
  878|      0|                end_value();
  879|      0|                break;
  880|      0|            }
  881|      0|            case semantic_tag::uri:
  ------------------
  |  Branch (881:13): [True: 0, False: 366k]
  ------------------
  882|      0|            {
  883|      0|                write_tag(32);
  884|      0|                write_string(sv);
  885|      0|                end_value();
  886|      0|                break;
  887|      0|            }
  888|      0|            case semantic_tag::base64url:
  ------------------
  |  Branch (888:13): [True: 0, False: 366k]
  ------------------
  889|      0|            {
  890|      0|                write_tag(33);
  891|      0|                write_string(sv);
  892|      0|                end_value();
  893|      0|                break;
  894|      0|            }
  895|      0|            case semantic_tag::base64:
  ------------------
  |  Branch (895:13): [True: 0, False: 366k]
  ------------------
  896|      0|            {
  897|      0|                write_tag(34);
  898|      0|                write_string(sv);
  899|      0|                end_value();
  900|      0|                break;
  901|      0|            }
  902|   366k|            default:
  ------------------
  |  Branch (902:13): [True: 366k, False: 18]
  ------------------
  903|   366k|            {
  904|   366k|                write_string(sv);
  905|   366k|                end_value();
  906|   366k|                break;
  907|      0|            }
  908|   366k|        }
  909|   366k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   366k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  910|   366k|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12write_bignumERNS_12basic_bigintINS5_ImEEEE:
  471|      7|    {
  472|      7|        bool is_neg = n < 0;
  473|      7|        if (is_neg)
  ------------------
  |  Branch (473:13): [True: 5, False: 2]
  ------------------
  474|      5|        {
  475|      5|            n = - n -1;
  476|      5|        }
  477|       |
  478|      7|        int signum;
  479|      7|        std::vector<uint8_t> data;
  480|      7|        n.write_bytes_be(signum, data);
  481|      7|        std::size_t length = data.size();
  482|       |
  483|      7|        if (is_neg)
  ------------------
  |  Branch (483:13): [True: 5, False: 2]
  ------------------
  484|      5|        {
  485|      5|            write_tag(3);
  486|      5|        }
  487|      2|        else
  488|      2|        {
  489|      2|            write_tag(2);
  490|      2|        }
  491|       |
  492|      7|        if (length <= 0x17)
  ------------------
  |  Branch (492:13): [True: 7, False: 0]
  ------------------
  493|      7|        {
  494|       |            // fixstr stores a byte array whose length is upto 31 bytes
  495|      7|            binary::native_to_big(static_cast<uint8_t>(0x40 + length), 
  496|      7|                                  std::back_inserter(sink_));
  497|      7|        }
  498|      0|        else if (length <= 0xff)
  ------------------
  |  Branch (498:18): [True: 0, False: 0]
  ------------------
  499|      0|        {
  500|      0|            binary::native_to_big(static_cast<uint8_t>(0x58), 
  501|      0|                                  std::back_inserter(sink_));
  502|      0|            binary::native_to_big(static_cast<uint8_t>(length), 
  503|      0|                                  std::back_inserter(sink_));
  504|      0|        }
  505|      0|        else if (length <= 0xffff)
  ------------------
  |  Branch (505:18): [True: 0, False: 0]
  ------------------
  506|      0|        {
  507|      0|            binary::native_to_big(static_cast<uint8_t>(0x59), 
  508|      0|                                  std::back_inserter(sink_));
  509|      0|            binary::native_to_big(static_cast<uint16_t>(length), 
  510|      0|                                  std::back_inserter(sink_));
  511|      0|        }
  512|      0|        else if (length <= 0xffffffff)
  ------------------
  |  Branch (512:18): [True: 0, False: 0]
  ------------------
  513|      0|        {
  514|      0|            binary::native_to_big(static_cast<uint8_t>(0x5a), 
  515|      0|                                  std::back_inserter(sink_));
  516|      0|            binary::native_to_big(static_cast<uint32_t>(length), 
  517|      0|                                  std::back_inserter(sink_));
  518|      0|        }
  519|      0|        else if (uint64_t(length) <= (std::numeric_limits<std::uint64_t>::max)())
  ------------------
  |  Branch (519:18): [True: 0, False: 0]
  ------------------
  520|      0|        {
  521|      0|            binary::native_to_big(static_cast<uint8_t>(0x5b), 
  522|      0|                                  std::back_inserter(sink_));
  523|      0|            binary::native_to_big(static_cast<uint64_t>(length), 
  524|      0|                                  std::back_inserter(sink_));
  525|      0|        }
  526|       |
  527|      7|        for (auto c : data)
  ------------------
  |  Branch (527:21): [True: 57, False: 7]
  ------------------
  528|     57|        {
  529|     57|            sink_.push_back(c);
  530|     57|        }
  531|      7|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE19write_decimal_valueERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKNS_11ser_contextERNS3_10error_codeE:
  534|     16|    {
  535|     16|        decimal_parse_state state = decimal_parse_state::start;
  536|     16|        std::basic_string<char> s;
  537|     16|        std::basic_string<char> exponent;
  538|     16|        int64_t scale = 0;
  539|     16|        for (auto c : sv)
  ------------------
  |  Branch (539:21): [True: 180, False: 16]
  ------------------
  540|    180|        {
  541|    180|            switch (state)
  ------------------
  |  Branch (541:21): [True: 180, False: 0]
  ------------------
  542|    180|            {
  543|     16|                case decimal_parse_state::start:
  ------------------
  |  Branch (543:17): [True: 16, False: 164]
  ------------------
  544|     16|                {
  545|     16|                    switch (c)
  546|     16|                    {
  547|      4|                        case '-':
  ------------------
  |  Branch (547:25): [True: 4, False: 12]
  ------------------
  548|     16|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (548:25): [True: 8, False: 8]
  |  Branch (548:34): [True: 1, False: 15]
  |  Branch (548:43): [True: 0, False: 16]
  |  Branch (548:52): [True: 1, False: 15]
  |  Branch (548:61): [True: 0, False: 16]
  |  Branch (548:70): [True: 0, False: 16]
  |  Branch (548:79): [True: 0, False: 16]
  |  Branch (548:88): [True: 0, False: 16]
  |  Branch (548:97): [True: 2, False: 14]
  |  Branch (548:107): [True: 0, False: 16]
  ------------------
  549|     16|                            s.push_back(c);
  550|     16|                            state = decimal_parse_state::integer;
  551|     16|                            break;
  552|      0|                        case '+':
  ------------------
  |  Branch (552:25): [True: 0, False: 16]
  ------------------
  553|      0|                            state = decimal_parse_state::integer;
  554|      0|                            break;
  555|      0|                        case '.':
  ------------------
  |  Branch (555:25): [True: 0, False: 16]
  ------------------
  556|      0|                            state = decimal_parse_state::fraction1;
  557|      0|                            break;
  558|      0|                        default:
  ------------------
  |  Branch (558:25): [True: 0, False: 16]
  ------------------
  559|      0|                        {
  560|      0|                            ec = cbor_errc::invalid_bigdecimal;
  561|      0|                            return;
  562|     16|                        }
  563|     16|                    }
  564|     16|                    break;
  565|     16|                }
  566|     87|                case decimal_parse_state::integer:
  ------------------
  |  Branch (566:17): [True: 87, False: 93]
  ------------------
  567|     87|                {
  568|     87|                    switch (c)
  569|     87|                    {
  570|     72|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (570:25): [True: 8, False: 79]
  |  Branch (570:34): [True: 10, False: 77]
  |  Branch (570:43): [True: 8, False: 79]
  |  Branch (570:52): [True: 4, False: 83]
  |  Branch (570:61): [True: 14, False: 73]
  |  Branch (570:70): [True: 6, False: 81]
  |  Branch (570:79): [True: 7, False: 80]
  |  Branch (570:88): [True: 4, False: 83]
  |  Branch (570:97): [True: 5, False: 82]
  |  Branch (570:107): [True: 6, False: 81]
  ------------------
  571|     72|                            s.push_back(c);
  572|     72|                            break;
  573|      2|                        case 'e': case 'E':
  ------------------
  |  Branch (573:25): [True: 2, False: 85]
  |  Branch (573:35): [True: 0, False: 87]
  ------------------
  574|      2|                            state = decimal_parse_state::exp1;
  575|      2|                            break;
  576|     13|                        case '.':
  ------------------
  |  Branch (576:25): [True: 13, False: 74]
  ------------------
  577|     13|                            state = decimal_parse_state::fraction1;
  578|     13|                            break;
  579|      0|                        default:
  ------------------
  |  Branch (579:25): [True: 0, False: 87]
  ------------------
  580|      0|                        {
  581|      0|                            ec = cbor_errc::invalid_bigdecimal;
  582|      0|                            return;
  583|      2|                        }
  584|     87|                    }
  585|     87|                    break;
  586|     87|                }
  587|     87|                case decimal_parse_state::exp1:
  ------------------
  |  Branch (587:17): [True: 2, False: 178]
  ------------------
  588|      2|                {
  589|      2|                    switch (c)
  590|      2|                    {
  591|      0|                        case '+':
  ------------------
  |  Branch (591:25): [True: 0, False: 2]
  ------------------
  592|      0|                            state = decimal_parse_state::exp2;
  593|      0|                            break;
  594|      0|                        case '-':
  ------------------
  |  Branch (594:25): [True: 0, False: 2]
  ------------------
  595|      2|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (595:25): [True: 0, False: 2]
  |  Branch (595:34): [True: 2, False: 0]
  |  Branch (595:43): [True: 0, False: 2]
  |  Branch (595:52): [True: 0, False: 2]
  |  Branch (595:61): [True: 0, False: 2]
  |  Branch (595:70): [True: 0, False: 2]
  |  Branch (595:79): [True: 0, False: 2]
  |  Branch (595:88): [True: 0, False: 2]
  |  Branch (595:97): [True: 0, False: 2]
  |  Branch (595:107): [True: 0, False: 2]
  ------------------
  596|      2|                            exponent.push_back(c);
  597|      2|                            state = decimal_parse_state::exp2;
  598|      2|                            break;
  599|      0|                        default:
  ------------------
  |  Branch (599:25): [True: 0, False: 2]
  ------------------
  600|      0|                        {
  601|      0|                            ec = cbor_errc::invalid_bigdecimal;
  602|      0|                            return;
  603|      2|                        }
  604|      2|                    }
  605|      2|                    break;
  606|      2|                }
  607|      2|                case decimal_parse_state::exp2:
  ------------------
  |  Branch (607:17): [True: 0, False: 180]
  ------------------
  608|      0|                {
  609|      0|                    switch (c)
  610|      0|                    {
  611|      0|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (611:25): [True: 0, False: 0]
  |  Branch (611:34): [True: 0, False: 0]
  |  Branch (611:43): [True: 0, False: 0]
  |  Branch (611:52): [True: 0, False: 0]
  |  Branch (611:61): [True: 0, False: 0]
  |  Branch (611:70): [True: 0, False: 0]
  |  Branch (611:79): [True: 0, False: 0]
  |  Branch (611:88): [True: 0, False: 0]
  |  Branch (611:97): [True: 0, False: 0]
  |  Branch (611:107): [True: 0, False: 0]
  ------------------
  612|      0|                            exponent.push_back(c);
  613|      0|                            break;
  614|      0|                        default:
  ------------------
  |  Branch (614:25): [True: 0, False: 0]
  ------------------
  615|      0|                        {
  616|      0|                            ec = cbor_errc::invalid_bigdecimal;
  617|      0|                            return;
  618|      0|                        }
  619|      0|                    }
  620|      0|                    break;
  621|      0|                }
  622|     75|                case decimal_parse_state::fraction1:
  ------------------
  |  Branch (622:17): [True: 75, False: 105]
  ------------------
  623|     75|                {
  624|     75|                    switch (c)
  625|     75|                    {
  626|     75|                        case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
  ------------------
  |  Branch (626:25): [True: 20, False: 55]
  |  Branch (626:34): [True: 7, False: 68]
  |  Branch (626:43): [True: 4, False: 71]
  |  Branch (626:52): [True: 6, False: 69]
  |  Branch (626:61): [True: 5, False: 70]
  |  Branch (626:70): [True: 4, False: 71]
  |  Branch (626:79): [True: 5, False: 70]
  |  Branch (626:88): [True: 4, False: 71]
  |  Branch (626:97): [True: 7, False: 68]
  |  Branch (626:107): [True: 13, False: 62]
  ------------------
  627|     75|                            s.push_back(c);
  628|     75|                            --scale;
  629|     75|                            break;
  630|      0|                        case 'e': case 'E':
  ------------------
  |  Branch (630:25): [True: 0, False: 75]
  |  Branch (630:35): [True: 0, False: 75]
  ------------------
  631|      0|                            state = decimal_parse_state::exp1;
  632|      0|                            break;
  633|      0|                        default:
  ------------------
  |  Branch (633:25): [True: 0, False: 75]
  ------------------
  634|      0|                        {
  635|      0|                            ec = cbor_errc::invalid_bigdecimal;
  636|      0|                            return;
  637|      0|                        }
  638|     75|                    }
  639|     75|                    break;
  640|     75|                }
  641|    180|            }
  642|    180|        }
  643|       |
  644|     16|        write_tag(4);
  645|     16|        visit_begin_array((std::size_t)2, semantic_tag::none, context, ec);
  646|     16|        if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   79|     16|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 16]
  |  |  ------------------
  ------------------
  647|     16|        if (exponent.length() > 0)
  ------------------
  |  Branch (647:13): [True: 2, False: 14]
  ------------------
  648|      2|        {
  649|      2|            int64_t val{};
  650|      2|            auto r = jsoncons::dec_to_integer(exponent.data(), exponent.length(), val);
  651|      2|            if (!r)
  ------------------
  |  Branch (651:17): [True: 0, False: 2]
  ------------------
  652|      0|            {
  653|      0|                ec = r.error_code();
  654|      0|                return;
  655|      0|            }
  656|      2|            scale += val;
  657|      2|        }
  658|     16|        visit_int64(scale, semantic_tag::none, context, ec);
  659|     16|        if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   79|     16|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 16]
  |  |  ------------------
  ------------------
  660|       |
  661|     16|        int64_t val{ 0 };
  662|     16|        auto r = jsoncons::dec_to_integer(s.data(),s.length(), val);
  663|     16|        if (r)
  ------------------
  |  Branch (663:13): [True: 11, False: 5]
  ------------------
  664|     11|        {
  665|     11|            visit_int64(val, semantic_tag::none, context, ec);
  666|     11|            if (JSONCONS_UNLIKELY(ec)) {return;}
  ------------------
  |  |   79|     11|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 11]
  |  |  ------------------
  ------------------
  667|     11|        }
  668|      5|        else if (r.error_code() == std::errc::result_out_of_range)
  ------------------
  |  Branch (668:18): [True: 5, False: 0]
  ------------------
  669|      5|        {
  670|      5|            bigint n(s.data(), s.length());
  671|      5|            write_bignum(n);
  672|      5|            end_value();
  673|      5|        }
  674|      0|        else
  675|      0|        {
  676|      0|            ec = r.error_code();
  677|      0|            return;
  678|      0|        }
  679|     16|        visit_end_array(context, ec);
  680|     16|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE12write_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEE:
  404|   366k|    {
  405|   366k|        auto sink = unicode_traits::validate(sv.data(), sv.size());
  406|   366k|        if (sink.ec != unicode_traits::unicode_errc())
  ------------------
  |  Branch (406:13): [True: 0, False: 366k]
  ------------------
  407|      0|        {
  408|      0|            JSONCONS_THROW(ser_error(cbor_errc::invalid_utf8_text_string));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  409|      0|        }
  410|       |
  411|   366k|        if (pack_strings_ && sv.size() >= jsoncons::cbor::detail::min_length_for_stringref(next_stringref_))
  ------------------
  |  Branch (411:13): [True: 0, False: 366k]
  |  Branch (411:30): [True: 0, False: 0]
  ------------------
  412|      0|        {
  413|      0|            string_type s(sv.data(), sv.size(), alloc_);
  414|      0|            auto it = stringref_map_.find(s);
  415|      0|            if (it == stringref_map_.end())
  ------------------
  |  Branch (415:17): [True: 0, False: 0]
  ------------------
  416|      0|            {
  417|      0|                stringref_map_.emplace(std::make_pair(std::move(s), next_stringref_++));
  418|      0|                write_utf8_string(sv);
  419|      0|            }
  420|      0|            else
  421|      0|            {
  422|      0|                write_tag(25);
  423|      0|                write_uint64_value((*it).second);
  424|      0|            }
  425|      0|        }
  426|   366k|        else
  427|   366k|        {
  428|   366k|            write_utf8_string(sv);
  429|   366k|        }
  430|   366k|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17write_utf8_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEE:
  464|   366k|    {
  465|   366k|        write_type_and_length(0x60, sv.size());
  466|       |
  467|   366k|        sink_.append(reinterpret_cast<const uint8_t*>(sv.data()), sv.size());
  468|   366k|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  916|     29|    {
  917|     29|        byte_string_chars_format encoding_hint;
  918|     29|        switch (tag)
  919|     29|        {
  920|      0|            case semantic_tag::base16:
  ------------------
  |  Branch (920:13): [True: 0, False: 29]
  ------------------
  921|      0|                encoding_hint = byte_string_chars_format::base16;
  922|      0|                break;
  923|      0|            case semantic_tag::base64:
  ------------------
  |  Branch (923:13): [True: 0, False: 29]
  ------------------
  924|      0|                encoding_hint = byte_string_chars_format::base64;
  925|      0|                break;
  926|      0|            case semantic_tag::base64url:
  ------------------
  |  Branch (926:13): [True: 0, False: 29]
  ------------------
  927|      0|                encoding_hint = byte_string_chars_format::base64url;
  928|      0|                break;
  929|     29|            default:
  ------------------
  |  Branch (929:13): [True: 29, False: 0]
  ------------------
  930|     29|                encoding_hint = byte_string_chars_format::none;
  931|     29|                break;
  932|     29|        }
  933|     29|        switch (encoding_hint)
  934|     29|        {
  935|      0|            case byte_string_chars_format::base64url:
  ------------------
  |  Branch (935:13): [True: 0, False: 29]
  ------------------
  936|      0|                write_tag(21);
  937|      0|                break;
  938|      0|            case byte_string_chars_format::base64:
  ------------------
  |  Branch (938:13): [True: 0, False: 29]
  ------------------
  939|      0|                write_tag(22);
  940|      0|                break;
  941|      0|            case byte_string_chars_format::base16:
  ------------------
  |  Branch (941:13): [True: 0, False: 29]
  ------------------
  942|      0|                write_tag(23);
  943|      0|                break;
  944|     29|            default:
  ------------------
  |  Branch (944:13): [True: 29, False: 0]
  ------------------
  945|     29|                break;
  946|     29|        }
  947|     29|        if (pack_strings_ && b.size() >= jsoncons::cbor::detail::min_length_for_stringref(next_stringref_))
  ------------------
  |  Branch (947:13): [True: 0, False: 29]
  |  Branch (947:30): [True: 0, False: 0]
  ------------------
  948|      0|        {
  949|      0|            byte_string_type bs(b.data(), b.size(), alloc_);
  950|      0|            auto it = bytestringref_map_.find(bs);
  951|      0|            if (it == bytestringref_map_.end())
  ------------------
  |  Branch (951:17): [True: 0, False: 0]
  ------------------
  952|      0|            {
  953|      0|                bytestringref_map_.emplace(std::make_pair(bs, next_stringref_++));
  954|      0|                write_byte_string(bs);
  955|      0|            }
  956|      0|            else
  957|      0|            {
  958|      0|                write_tag(25);
  959|      0|                write_uint64_value((*it).second);
  960|      0|            }
  961|      0|        }
  962|     29|        else
  963|     29|        {
  964|     29|            write_byte_string(b);
  965|     29|        }
  966|       |
  967|     29|        end_value();
  968|     29|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|     29|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  969|     29|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17write_byte_stringERKNS_16byte_string_viewE:
 1003|     31|    {
 1004|     31|        write_type_and_length(0x40, b.size());
 1005|       |
 1006|     31|        sink_.append(b.data(), b.size());
 1007|     31|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS3_10error_codeE:
  975|      2|    {
  976|      2|        if (pack_strings_ && b.size() >= jsoncons::cbor::detail::min_length_for_stringref(next_stringref_))
  ------------------
  |  Branch (976:13): [True: 0, False: 2]
  |  Branch (976:30): [True: 0, False: 0]
  ------------------
  977|      0|        {
  978|      0|            byte_string_type bs(b.data(), b.size(), alloc_);
  979|      0|            auto it = bytestringref_map_.find(bs);
  980|      0|            if (it == bytestringref_map_.end())
  ------------------
  |  Branch (980:17): [True: 0, False: 0]
  ------------------
  981|      0|            {
  982|      0|                bytestringref_map_.emplace(std::make_pair(bs, next_stringref_++));
  983|      0|                write_tag(raw_tag);
  984|      0|                write_byte_string(bs);
  985|      0|            }
  986|      0|            else
  987|      0|            {
  988|      0|                write_tag(25);
  989|      0|                write_uint64_value((*it).second);
  990|      0|            }
  991|      0|        }
  992|      2|        else
  993|      2|        {
  994|      2|            write_tag(raw_tag);
  995|      2|            write_byte_string(b);
  996|      2|        }
  997|       |
  998|      2|        end_value();
  999|      2|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      2|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1000|      2|    }
_ZN8jsoncons4cbor18basic_cbor_encoderINS_10bytes_sinkINSt3__16vectorIhNS3_9allocatorIhEEEEvEENS5_IcEEED2Ev:
  150|     21|    {
  151|     21|        JSONCONS_TRY
  ------------------
  |  |   37|     21|    #define JSONCONS_TRY try
  ------------------
  152|     21|        {
  153|     21|            sink_.flush();
  154|     21|        }
  155|     21|        JSONCONS_CATCH(...)
  156|     21|        {
  157|      0|        }
  158|     21|    }

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

_ZN8jsoncons4cbor19cbor_decode_optionsC1Ev:
   43|     21|    cbor_decode_options() = default;
_ZN8jsoncons4cbor19cbor_options_commonC2Ev:
   25|     42|    cbor_options_common() = default;
_ZN8jsoncons4cbor19cbor_options_commonD2Ev:
   27|     42|    virtual ~cbor_options_common() = default;
_ZN8jsoncons4cbor19cbor_encode_optionsC1Ev:
   61|     21|    cbor_encode_options() = default;
_ZNK8jsoncons4cbor19cbor_options_common17max_nesting_depthEv:
   33|     42|    {
   34|     42|        return max_nesting_depth_;
   35|     42|    }
_ZNK8jsoncons4cbor19cbor_encode_options12pack_stringsEv:
   67|     42|    {
   68|     42|        return use_stringref_;
   69|     42|    }
_ZNK8jsoncons4cbor19cbor_encode_options16use_typed_arraysEv:
   72|     21|    {
   73|     21|        return use_typed_arrays_;
   74|     21|    }
_ZNK8jsoncons4cbor19cbor_decode_options18bigfloat_precisionEv:
   49|     21|    {
   50|     21|        return bigfloat_precision_;
   51|     21|    }

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

_ZN8jsoncons4cbor17basic_cbor_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES7_EEEEOT_RNS_18basic_json_visitorIcEERKNS0_19cbor_decode_optionsERKS7_:
   52|     21|       : parser_(std::forward<Sourceable>(source), options, alloc),
   53|     21|         adaptor_(visitor, alloc), visitor_(adaptor_)
   54|     21|    {
   55|     21|    }
_ZN8jsoncons4cbor17basic_cbor_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4readERNS3_10error_codeE:
   88|     21|    {
   89|     21|        parser_.reset();
   90|     21|        parser_.parse(visitor_, ec);
   91|     21|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|     21|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 17, False: 4]
  |  |  ------------------
  ------------------
   92|     17|        {
   93|     17|            return;
   94|     17|        }
   95|     21|    }

_ZN8jsoncons4cbor20typed_array_iteratorD2Ev:
   43|  2.17k|    virtual ~typed_array_iterator() = default;
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIhEENSt3__19enable_ifIXsr6nonstd19is_unsigned_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   72|  2.67k|    {
   73|  2.67k|        visitor.uint64_value(val, tag, context, ec);
   74|  2.67k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|     35|        : data_(std::move(data), alloc), 
  107|     35|          span_(typed_array_cast<ValueType>(data_)), 
  108|     35|          array_tag_(array_tag), 
  109|     35|          extent_(span_.size()), 
  110|     35|          tag_(tag), 
  111|     35|          func_(Func{})
  112|     35|    {
  113|     35|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|  5.42k|    {
  142|  5.42k|        return done_;
  143|  5.42k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIhNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|  2.74k|    {
  148|  2.74k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|  2.74k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 35, False: 2.71k]
  |  |  ------------------
  ------------------
  149|     35|        {
  150|     35|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|     35|            first_ = false;
  152|     35|        }
  153|  2.71k|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|  2.71k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 2.67k, False: 35]
  |  |  ------------------
  ------------------
  154|  2.67k|        {
  155|  2.67k|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|  2.67k|            ++index_;
  157|  2.67k|        }
  158|     35|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 35, False: 0]
  ------------------
  159|     35|        {
  160|     35|            visitor.end_array(context, ec);
  161|     35|            done_ = true;
  162|     35|        }
  163|  2.74k|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueItEENSt3__19enable_ifIXsr6nonstd19is_unsigned_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   72|     96|    {
   73|     96|        visitor.uint64_value(val, tag, context, ec);
   74|     96|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|  1.57k|        : data_(std::move(data), alloc), 
  107|  1.57k|          span_(typed_array_cast<ValueType>(data_)), 
  108|  1.57k|          array_tag_(array_tag), 
  109|  1.57k|          extent_(span_.size()), 
  110|  1.57k|          tag_(tag), 
  111|  1.57k|          func_(Func{})
  112|  1.57k|    {
  113|  1.57k|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|  3.34k|    {
  142|  3.34k|        return done_;
  143|  3.34k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorItNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|  3.24k|    {
  148|  3.24k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|  3.24k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1.57k, False: 1.67k]
  |  |  ------------------
  ------------------
  149|  1.57k|        {
  150|  1.57k|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|  1.57k|            first_ = false;
  152|  1.57k|        }
  153|  1.67k|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|  1.67k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 96, False: 1.57k]
  |  |  ------------------
  ------------------
  154|     96|        {
  155|     96|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|     96|            ++index_;
  157|     96|        }
  158|  1.57k|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 1.57k, False: 0]
  ------------------
  159|  1.57k|        {
  160|  1.57k|            visitor.end_array(context, ec);
  161|  1.57k|            done_ = true;
  162|  1.57k|        }
  163|  3.24k|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIjEENSt3__19enable_ifIXsr6nonstd19is_unsigned_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   72|    126|    {
   73|    126|        visitor.uint64_value(val, tag, context, ec);
   74|    126|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIjNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|    126|        : data_(std::move(data), alloc), 
  107|    126|          span_(typed_array_cast<ValueType>(data_)), 
  108|    126|          array_tag_(array_tag), 
  109|    126|          extent_(span_.size()), 
  110|    126|          tag_(tag), 
  111|    126|          func_(Func{})
  112|    126|    {
  113|    126|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIjNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|    504|    {
  142|    504|        return done_;
  143|    504|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIjNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|    378|    {
  148|    378|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|    378|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 126, False: 252]
  |  |  ------------------
  ------------------
  149|    126|        {
  150|    126|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|    126|            first_ = false;
  152|    126|        }
  153|    252|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|    252|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 126, False: 126]
  |  |  ------------------
  ------------------
  154|    126|        {
  155|    126|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|    126|            ++index_;
  157|    126|        }
  158|    126|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 126, False: 0]
  ------------------
  159|    126|        {
  160|    126|            visitor.end_array(context, ec);
  161|    126|            done_ = true;
  162|    126|        }
  163|    378|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|      2|        : data_(std::move(data), alloc), 
  107|      2|          span_(typed_array_cast<ValueType>(data_)), 
  108|      2|          array_tag_(array_tag), 
  109|      2|          extent_(span_.size()), 
  110|      2|          tag_(tag), 
  111|      2|          func_(Func{})
  112|      2|    {
  113|      2|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|      4|    {
  142|      4|        return done_;
  143|      4|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorImNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|      4|    {
  148|      4|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 2, False: 2]
  |  |  ------------------
  ------------------
  149|      2|        {
  150|      2|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|      2|            first_ = false;
  152|      2|        }
  153|      2|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|      2|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|      2|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 2, False: 0]
  ------------------
  159|      2|        {
  160|      2|            visitor.end_array(context, ec);
  161|      2|            done_ = true;
  162|      2|        }
  163|      4|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIiEENSt3__19enable_ifIXsr6nonstd17is_signed_integerIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   64|     60|    {
   65|     60|        visitor.int64_value(val, tag, context, ec);
   66|     60|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIiNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|      1|        : data_(std::move(data), alloc), 
  107|      1|          span_(typed_array_cast<ValueType>(data_)), 
  108|      1|          array_tag_(array_tag), 
  109|      1|          extent_(span_.size()), 
  110|      1|          tag_(tag), 
  111|      1|          func_(Func{})
  112|      1|    {
  113|      1|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIiNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|    122|    {
  142|    122|        return done_;
  143|    122|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIiNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|     62|    {
  148|     62|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|     62|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 1, False: 61]
  |  |  ------------------
  ------------------
  149|      1|        {
  150|      1|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|      1|            first_ = false;
  152|      1|        }
  153|     61|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|     61|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 60, False: 1]
  |  |  ------------------
  ------------------
  154|     60|        {
  155|     60|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|     60|            ++index_;
  157|     60|        }
  158|      1|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 1, False: 0]
  ------------------
  159|      1|        {
  160|      1|            visitor.end_array(context, ec);
  161|      1|            done_ = true;
  162|      1|        }
  163|     62|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|     88|        : data_(std::move(data), alloc), 
  107|     88|          span_(typed_array_cast<ValueType>(data_)), 
  108|     88|          array_tag_(array_tag), 
  109|     88|          extent_(span_.size()), 
  110|     88|          tag_(tag), 
  111|     88|          func_(Func{})
  112|     88|    {
  113|     88|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|    176|    {
  142|    176|        return done_;
  143|    176|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIlNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|    176|    {
  148|    176|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|    176|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 88, False: 88]
  |  |  ------------------
  ------------------
  149|     88|        {
  150|     88|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|     88|            first_ = false;
  152|     88|        }
  153|     88|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|     88|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 0, False: 88]
  |  |  ------------------
  ------------------
  154|      0|        {
  155|      0|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|      0|            ++index_;
  157|      0|        }
  158|     88|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 88, False: 0]
  ------------------
  159|     88|        {
  160|     88|            visitor.end_array(context, ec);
  161|     88|            done_ = true;
  162|     88|        }
  163|    176|    }
_ZN8jsoncons4cbor16mdarray_iteratorItNS_11decode_halfENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsERKNS7_ImNS4_ImEEEENS_13mdarray_orderERKS5_:
  199|      1|        : data_(std::move(data), alloc), 
  200|      1|          span_(typed_array_cast<ValueType>(data_)), 
  201|      1|        array_tag_(array_tag), extents_(extents,alloc), order_(order), func_(Func{}), 
  202|      1|        dimensions_(extents.size(), mdarray_dimension{}, alloc)
  203|      1|    {
  204|      1|        std::vector<std::size_t> strides(extents.size(), 0);
  205|      1|        if (order == mdarray_order::column_major)
  ------------------
  |  Branch (205:13): [True: 0, False: 1]
  ------------------
  206|      0|        {
  207|      0|            std::size_t stride = 1;
  208|      0|            const size_t num_extents = extents.size();
  209|      0|            for (size_t i = 0; i < num_extents; ++i)
  ------------------
  |  Branch (209:32): [True: 0, False: 0]
  ------------------
  210|      0|            {
  211|      0|                strides[i] = stride;
  212|      0|                stride *= extents[i];
  213|      0|            }
  214|      0|        }
  215|      1|        else
  216|      1|        {
  217|      1|            std::size_t stride = 1;
  218|      1|            const size_t num_extents = extents.size();
  219|      4|            for (size_t i = 0; i < num_extents; ++i)
  ------------------
  |  Branch (219:32): [True: 3, False: 1]
  ------------------
  220|      3|            {
  221|      3|                strides[num_extents-i-1] = stride;
  222|      3|                stride *= extents[num_extents-i-1];
  223|      3|            }
  224|      1|        }
  225|      4|        for (std::size_t i = 0; i < strides.size(); ++i)
  ------------------
  |  Branch (225:33): [True: 3, False: 1]
  ------------------
  226|      3|        {
  227|      3|            dimensions_[i].extent = extents[i];
  228|      3|            dimensions_[i].stride = strides[i];
  229|      3|            dimensions_[i].index = 0;
  230|      3|            dimensions_[i].end = strides[i]*extents[i];
  231|      3|        }
  232|      1|    }
_ZNK8jsoncons4cbor16mdarray_iteratorItNS_11decode_halfENSt3__19allocatorIcEEE4doneEv:
  260|     30|    {
  261|     30|        return done_;
  262|     30|    }
_ZN8jsoncons4cbor16mdarray_iteratorItNS_11decode_halfENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  266|     16|    {
  267|     16|        JSONCONS_ASSERT(!dimensions_.empty());
  ------------------
  |  |   54|     16|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 16]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  268|       |
  269|     16|        if (dim_ == 0)
  ------------------
  |  Branch (269:13): [True: 3, False: 13]
  ------------------
  270|      3|        {
  271|      3|            if (first_)
  ------------------
  |  Branch (271:17): [True: 1, False: 2]
  ------------------
  272|      1|            {
  273|      1|                visitor.begin_array(dimensions_[dim_].extent, tag_, context, ec);
  274|      1|                first_ = false;
  275|      1|                return;
  276|      1|            }
  277|      2|            if (dimensions_[dim_].index == dimensions_[dim_].end)
  ------------------
  |  Branch (277:17): [True: 1, False: 1]
  ------------------
  278|      1|            {
  279|      1|                visitor.end_array(context, ec);
  280|      1|                done_ = true;
  281|      1|                return;
  282|      1|            }
  283|      2|        }
  284|     14|        if (dim_+1 < dimensions_.size() && dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (284:13): [True: 3, False: 11]
  |  Branch (284:44): [True: 2, False: 1]
  ------------------
  285|      2|        {
  286|      2|            visitor.begin_array(dimensions_[dim_].extent, semantic_tag::none, context, ec);
  287|      2|            ++dim_;
  288|      2|            return;
  289|      2|        }
  290|     12|        if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (290:13): [True: 10, False: 2]
  ------------------
  291|     10|        {
  292|     10|            this->write_value(func_(span_[dimensions_[dim_].index]), semantic_tag::none, visitor, context, ec);
  293|     10|            dimensions_[dim_].index += dimensions_[dim_].stride;
  294|     10|            ++count_;
  295|     10|            return;
  296|     10|        }
  297|      2|        if (dimensions_[dim_].index + dimensions_[dim_].stride >= dimensions_[dim_].end)
  ------------------
  |  Branch (297:13): [True: 2, False: 0]
  ------------------
  298|      2|        {
  299|      2|            visitor.end_array(context, ec);
  300|      2|            if (dim_ > 0)
  ------------------
  |  Branch (300:17): [True: 2, False: 0]
  ------------------
  301|      2|            {
  302|      2|                --dim_;
  303|      2|                dimensions_[dim_].index += dimensions_[dim_].stride;
  304|      2|                if (dimensions_[dim_].index < dimensions_[dim_].end)
  ------------------
  |  Branch (304:21): [True: 0, False: 2]
  ------------------
  305|      0|                {
  306|      0|                    for (std::size_t i = dim_+1; i < dimensions_.size(); ++i)
  ------------------
  |  Branch (306:50): [True: 0, False: 0]
  ------------------
  307|      0|                    {
  308|      0|                        dimensions_[i].index = dimensions_[i-1].index;
  309|      0|                        dimensions_[i].end = dimensions_[i].index + dimensions_[i].stride*dimensions_[i].extent;
  310|      0|                    }
  311|      0|                }
  312|      2|            }
  313|      2|        }
  314|      2|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIdEENSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   80|  63.3k|    {
   81|  63.3k|        visitor.double_value(val, tag, context, ec);
   82|  63.3k|    }
_ZN8jsoncons4cbor20typed_array_iterator11write_valueIfEENSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEvE4typeES5_NS_12semantic_tagERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
   80|   390k|    {
   81|   390k|        visitor.double_value(val, tag, context, ec);
   82|   390k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|    261|        : data_(std::move(data), alloc), 
  107|    261|          span_(typed_array_cast<ValueType>(data_)), 
  108|    261|          array_tag_(array_tag), 
  109|    261|          extent_(span_.size()), 
  110|    261|          tag_(tag), 
  111|    261|          func_(Func{})
  112|    261|    {
  113|    261|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|   781k|    {
  142|   781k|        return done_;
  143|   781k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIfNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|   391k|    {
  148|   391k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|   391k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 261, False: 390k]
  |  |  ------------------
  ------------------
  149|    261|        {
  150|    261|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|    261|            first_ = false;
  152|    261|        }
  153|   390k|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|   390k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 390k, False: 261]
  |  |  ------------------
  ------------------
  154|   390k|        {
  155|   390k|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|   390k|            ++index_;
  157|   390k|        }
  158|    261|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 261, False: 0]
  ------------------
  159|    261|        {
  160|    261|            visitor.end_array(context, ec);
  161|    261|            done_ = true;
  162|    261|        }
  163|   391k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIdNS_8identityENSt3__19allocatorIcEEEC2EONS3_6vectorIhNS4_IhEEEENS_16typed_array_tagsENS_12semantic_tagERKS5_:
  106|     90|        : data_(std::move(data), alloc), 
  107|     90|          span_(typed_array_cast<ValueType>(data_)), 
  108|     90|          array_tag_(array_tag), 
  109|     90|          extent_(span_.size()), 
  110|     90|          tag_(tag), 
  111|     90|          func_(Func{})
  112|     90|    {
  113|     90|    }
_ZNK8jsoncons4cbor25oned_typed_array_iteratorIdNS_8identityENSt3__19allocatorIcEEE4doneEv:
  141|   126k|    {
  142|   126k|        return done_;
  143|   126k|    }
_ZN8jsoncons4cbor25oned_typed_array_iteratorIdNS_8identityENSt3__19allocatorIcEEE4nextERNS_21basic_generic_visitorIcEERKNS_11ser_contextERNS3_10error_codeE:
  147|  63.5k|    {
  148|  63.5k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   79|  63.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 90, False: 63.4k]
  |  |  ------------------
  ------------------
  149|     90|        {
  150|     90|            visitor.begin_array(span_.size(), tag_, context, ec);
  151|     90|            first_ = false;
  152|     90|        }
  153|  63.4k|        else if (JSONCONS_LIKELY(index_ < span_.size()))
  ------------------
  |  |   78|  63.4k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 63.3k, False: 90]
  |  |  ------------------
  ------------------
  154|  63.3k|        {
  155|  63.3k|            this->write_value(func_(span_[index_]), semantic_tag::none, visitor, context, ec);
  156|  63.3k|            ++index_;
  157|  63.3k|        }
  158|     90|        else if (!done_)
  ------------------
  |  Branch (158:18): [True: 90, False: 0]
  ------------------
  159|     90|        {
  160|     90|            visitor.end_array(context, ec);
  161|     90|            done_ = true;
  162|     90|        }
  163|  63.5k|    }