LLVMFuzzerTestOneInput:
   12|     43|{
   13|     43|        std::string input(reinterpret_cast<const char*>(data), size);
   14|     43|        std::istringstream is(input);
   15|     43|        try {
   16|     43|                json j2 = decode_cbor<json>(is);
   17|     43|        }
   18|     43|        catch(const jsoncons::ser_error&) {}
   19|     43|        catch(jsoncons::json_runtime_error<std::runtime_error> e2) {}
   20|       |
   21|     43|        return 0;
   22|     43|}

_ZNK8jsoncons16allocator_holderINSt3__19allocatorIcEEE13get_allocatorEv:
   30|  3.18M|    {
   31|  3.18M|        return alloc_;
   32|  3.18M|    }
_ZN8jsoncons16allocator_holderINSt3__19allocatorIcEEEC2ERKS3_:
   25|    191|        : alloc_(alloc)
   26|    191|        {}
_ZN8jsoncons16allocator_holderINSt3__19allocatorIcEEEC2Ev:
   20|  3.18M|    allocator_holder() = default;

_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEED2Ev:
 2779|  40.3M|        {
 2780|  40.3M|             destroy();
 2781|  40.3M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE7destroyEv:
  903|  40.3M|        {
  904|  40.3M|            switch (storage_kind())
  905|  40.3M|            {
  906|      9|                case json_storage_kind::long_str:
  ------------------
  |  Branch (906:17): [True: 9, False: 40.3M]
  ------------------
  907|      9|                {
  908|      9|                    if (cast<long_string_storage>().ptr_ != nullptr)
  ------------------
  |  Branch (908:25): [True: 9, False: 0]
  ------------------
  909|      9|                    {
  910|      9|                        long_string_storage::heap_string_factory_type::destroy(cast<long_string_storage>().ptr_);
  911|      9|                    }
  912|      9|                    break;
  913|      0|                }
  914|  2.12M|                case json_storage_kind::byte_str:
  ------------------
  |  Branch (914:17): [True: 2.12M, False: 38.2M]
  ------------------
  915|  2.12M|                    if (cast<byte_string_storage>().ptr_ != nullptr)
  ------------------
  |  Branch (915:25): [True: 2.12M, False: 0]
  ------------------
  916|  2.12M|                    {
  917|  2.12M|                        byte_string_storage::heap_string_factory_type::destroy(cast<byte_string_storage>().ptr_);
  918|  2.12M|                    }
  919|  2.12M|                    break;
  920|  1.46k|                case json_storage_kind::array:
  ------------------
  |  Branch (920:17): [True: 1.46k, False: 40.3M]
  ------------------
  921|  1.46k|                {
  922|  1.46k|                    if (cast<array_storage>().ptr_ != nullptr)
  ------------------
  |  Branch (922:25): [True: 1.46k, False: 0]
  ------------------
  923|  1.46k|                    {
  924|  1.46k|                        auto& stor = cast<array_storage>();
  925|  1.46k|                        typename array_storage::allocator_type alloc{stor.ptr_->get_allocator()};
  926|  1.46k|                        std::allocator_traits<typename array_storage::allocator_type>::destroy(alloc, ext_traits::to_plain_pointer(stor.ptr_));
  927|  1.46k|                        std::allocator_traits<typename array_storage::allocator_type>::deallocate(alloc, stor.ptr_,1);
  928|  1.46k|                    }
  929|  1.46k|                    break;
  930|      0|                }
  931|  3.18M|                case json_storage_kind::object:
  ------------------
  |  Branch (931:17): [True: 3.18M, False: 37.2M]
  ------------------
  932|  3.18M|                {
  933|  3.18M|                    if (cast<object_storage>().ptr_ != nullptr)
  ------------------
  |  Branch (933:25): [True: 3.18M, False: 0]
  ------------------
  934|  3.18M|                    {
  935|  3.18M|                        auto& stor = cast<object_storage>();
  936|  3.18M|                        typename object_storage::allocator_type alloc{stor.ptr_->get_allocator()};
  937|  3.18M|                        std::allocator_traits<typename object_storage::allocator_type>::destroy(alloc, ext_traits::to_plain_pointer(stor.ptr_));
  938|  3.18M|                        std::allocator_traits<typename object_storage::allocator_type>::deallocate(alloc, stor.ptr_,1);
  939|  3.18M|                    }
  940|  3.18M|                    break;
  941|      0|                }
  942|  35.0M|                default:
  ------------------
  |  Branch (942:17): [True: 35.0M, False: 5.30M]
  ------------------
  943|  35.0M|                    break;
  944|  40.3M|            }
  945|  40.3M|        }
_ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE12storage_kindEv:
 1467|  77.3M|        {
 1468|       |            // It is legal to access 'common_.storage_kind_' even though 
 1469|       |            // common_ is not the active member of the union because 'storage_kind_' 
 1470|       |            // is a part of the common initial sequence of all union members
 1471|       |            // as defined in 11.4-25 of the Standard.
 1472|  77.3M|            return static_cast<json_storage_kind>(common_.storage_kind_);
 1473|  77.3M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_19long_string_storageEEERT_v:
 1009|     95|        {
 1010|     95|            return cast(identity<T>());
 1011|     95|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_19long_string_storageEEE:
 1100|     95|        {
 1101|     95|            return long_str_;
 1102|     95|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_19byte_string_storageEEERT_v:
 1009|  14.6M|        {
 1010|  14.6M|            return cast(identity<T>());
 1011|  14.6M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_19byte_string_storageEEE:
 1110|  14.6M|        {
 1111|  14.6M|            return byte_str_;
 1112|  14.6M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_13array_storageEEERT_v:
 1009|  12.4k|        {
 1010|  12.4k|            return cast(identity<T>());
 1011|  12.4k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_13array_storageEEE:
 1130|  12.4k|        {
 1131|  12.4k|            return array_;
 1132|  12.4k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2EOS5_:
 2312|  26.6M|        {
 2313|  26.6M|            uninitialized_move(std::move(other));
 2314|  26.6M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE18uninitialized_moveEOS5_:
 1307|  26.6M|        {
 1308|  26.6M|            if (is_trivial_storage(other.storage_kind()))
  ------------------
  |  Branch (1308:17): [True: 16.3M, False: 10.3M]
  ------------------
 1309|  16.3M|            {
 1310|  16.3M|                std::memcpy(static_cast<void*>(this), &other, sizeof(basic_json));
 1311|  16.3M|            }
 1312|  10.3M|            else
 1313|  10.3M|            {
 1314|  10.3M|                switch (other.storage_kind())
 1315|  10.3M|                {
 1316|     20|                    case json_storage_kind::long_str:
  ------------------
  |  Branch (1316:21): [True: 20, False: 10.3M]
  ------------------
 1317|     20|                        construct<long_string_storage>(other.cast<long_string_storage>());
 1318|     20|                        other.construct<null_storage>();
 1319|     20|                        break;
 1320|  4.12M|                    case json_storage_kind::byte_str:
  ------------------
  |  Branch (1320:21): [True: 4.12M, False: 6.18M]
  ------------------
 1321|  4.12M|                        construct<byte_string_storage>(other.cast<byte_string_storage>());
 1322|  4.12M|                        other.construct<null_storage>();
 1323|  4.12M|                        break;
 1324|  3.15k|                    case json_storage_kind::array:
  ------------------
  |  Branch (1324:21): [True: 3.15k, False: 10.3M]
  ------------------
 1325|  3.15k|                        construct<array_storage>(other.cast<array_storage>());
 1326|  3.15k|                        other.construct<null_storage>();
 1327|  3.15k|                        break;
 1328|  6.18M|                    case json_storage_kind::object:
  ------------------
  |  Branch (1328:21): [True: 6.18M, False: 4.12M]
  ------------------
 1329|  6.18M|                        construct<object_storage>(other.cast<object_storage>());
 1330|  6.18M|                        other.construct<null_storage>();
 1331|  6.18M|                        break;
 1332|      0|                    default:
  ------------------
  |  Branch (1332:21): [True: 0, False: 10.3M]
  ------------------
 1333|      0|                        JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1334|      0|                        break;
 1335|  10.3M|                }
 1336|  10.3M|            }
 1337|  26.6M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_19long_string_storageEJRS7_EEEvDpOT0_:
 1000|     34|        {
 1001|     34|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|     34|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE19long_string_storageC2ERKS6_:
  631|     48|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::long_str)), short_str_length_(0), tag_(other.tag_), ptr_(other.ptr_)
  632|     48|            {
  633|     48|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_12null_storageEJEEEvDpOT0_:
 1000|  10.3M|        {
 1001|  10.3M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|  10.3M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_12null_storageEEERT_v:
 1009|  11.3M|        {
 1010|  11.3M|            return cast(identity<T>());
 1011|  11.3M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_12null_storageEEE:
 1020|  11.3M|        {
 1021|  11.3M|            return null_;
 1022|  11.3M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE12null_storageC2ENS_12semantic_tagE:
  455|  11.3M|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::null)), short_str_length_(0), tag_(tag)
  456|  11.3M|            {
  457|  11.3M|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_19byte_string_storageEJRS7_EEEvDpOT0_:
 1000|  4.12M|        {
 1001|  4.12M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|  4.12M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE19byte_string_storageC2ERKS6_:
  680|  4.12M|                : storage_kind_(other.storage_kind_), short_str_length_(0), tag_(other.tag_), ptr_(other.ptr_)
  681|  4.12M|            {
  682|  4.12M|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_13array_storageEJRS7_EEEvDpOT0_:
 1000|  3.19k|        {
 1001|  3.19k|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|  3.19k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE13array_storageC2ERKS6_:
  732|  3.24k|                : storage_kind_(other.storage_kind_), short_str_length_(0), tag_(other.tag_), ptr_(other.ptr_)
  733|  3.24k|            {
  734|  3.24k|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_14object_storageEJRS7_EEEvDpOT0_:
 1000|  6.18M|        {
 1001|  6.18M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|  6.18M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE14object_storageC2ERKS6_:
  782|  6.18M|                : storage_kind_(other.storage_kind_), short_str_length_(0), tag_(other.tag_), ptr_(other.ptr_)
  783|  6.18M|            {
  784|  6.18M|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE11array_rangeEv:
 4743|     60|        {
 4744|     60|            switch (storage_kind())
 4745|     60|            {
 4746|     60|                case json_storage_kind::array:
  ------------------
  |  Branch (4746:17): [True: 60, False: 0]
  ------------------
 4747|     60|                    return array_range_type(cast<array_storage>().value().begin(),
 4748|     60|                        cast<array_storage>().value().end());
 4749|      0|                case json_storage_kind::json_ref:
  ------------------
  |  Branch (4749:17): [True: 0, False: 60]
  ------------------
 4750|      0|                    return cast<json_ref_storage>().value().array_range();
 4751|      0|                default:
  ------------------
  |  Branch (4751:17): [True: 0, False: 60]
  ------------------
 4752|      0|                    JSONCONS_THROW(json_runtime_error<std::domain_error>("Not an array"));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 4753|     60|            }
 4754|     60|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE13array_storage5valueEv:
  755|  1.67k|            {
  756|  1.67k|                return *ptr_;
  757|  1.67k|            }
_ZN8jsoncons5rangeINSt3__111__wrap_iterIPNS_10basic_jsonIcNS_13sorted_policyENS1_9allocatorIcEEEEEENS2_IPKS7_EEEC2ERKS9_SF_:
  353|     60|            : first_(first), last_(last)
  354|     60|        {
  355|     60|        }
_ZNK8jsoncons5rangeINSt3__111__wrap_iterIPNS_10basic_jsonIcNS_13sorted_policyENS1_9allocatorIcEEEEEENS2_IPKS7_EEE5beginEv:
  358|     60|        {
  359|     60|            return first_;
  360|     60|        }
_ZNK8jsoncons5rangeINSt3__111__wrap_iterIPNS_10basic_jsonIcNS_13sorted_policyENS1_9allocatorIcEEEEEENS2_IPKS7_EEE3endEv:
  362|     60|        {
  363|     60|            return last_;
  364|     60|        }
_ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE5emptyEv:
 3408|     16|        {
 3409|     16|            switch (storage_kind())
 3410|     16|            {
 3411|      0|                case json_storage_kind::byte_str:
  ------------------
  |  Branch (3411:17): [True: 0, False: 16]
  ------------------
 3412|      0|                    return cast<byte_string_storage>().length() == 0;
 3413|      0|                    break;
 3414|      0|                case json_storage_kind::short_str:
  ------------------
  |  Branch (3414:17): [True: 0, False: 16]
  ------------------
 3415|      0|                    return cast<short_string_storage>().length() == 0;
 3416|      0|                case json_storage_kind::long_str:
  ------------------
  |  Branch (3416:17): [True: 0, False: 16]
  ------------------
 3417|      0|                    return cast<long_string_storage>().length() == 0;
 3418|     13|                case json_storage_kind::array:
  ------------------
  |  Branch (3418:17): [True: 13, False: 3]
  ------------------
 3419|     13|                    return cast<array_storage>().value().empty();
 3420|      0|                case json_storage_kind::empty_object:
  ------------------
  |  Branch (3420:17): [True: 0, False: 16]
  ------------------
 3421|      0|                    return true;
 3422|      3|                case json_storage_kind::object:
  ------------------
  |  Branch (3422:17): [True: 3, False: 13]
  ------------------
 3423|      3|                    return cast<object_storage>().value().empty();
 3424|      0|                case json_storage_kind::const_json_ref:
  ------------------
  |  Branch (3424:17): [True: 0, False: 16]
  ------------------
 3425|      0|                    return cast<const_json_ref_storage>().value().empty();
 3426|      0|                case json_storage_kind::json_ref:
  ------------------
  |  Branch (3426:17): [True: 0, False: 16]
  ------------------
 3427|      0|                    return cast<json_ref_storage>().value().empty();
 3428|      0|                default:
  ------------------
  |  Branch (3428:17): [True: 0, False: 16]
  ------------------
 3429|      0|                    return false;
 3430|     16|            }
 3431|     16|        }
_ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_13array_storageEEERKT_v:
 1015|     13|        {
 1016|     13|            return cast(identity<T>());
 1017|     13|        }
_ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_13array_storageEEE:
 1135|     13|        {
 1136|     13|            return array_;
 1137|     13|        }
_ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE13array_storage5valueEv:
  760|     13|            {
  761|     13|                return *ptr_;
  762|     13|            }
_ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_14object_storageEEERKT_v:
 1015|      3|        {
 1016|      3|            return cast(identity<T>());
 1017|      3|        }
_ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_14object_storageEEE:
 1125|      3|        {
 1126|      3|            return object_;
 1127|      3|        }
_ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE14object_storage5valueEv:
  806|      3|            {
  807|      3|                JSONCONS_ASSERT(ptr_ != nullptr);
  ------------------
  |  |   45|      3|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 3]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  808|      3|                return *ptr_;
  809|      3|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE5clearEv:
 4139|     65|        {
 4140|     65|            switch (storage_kind())
 4141|     65|            {
 4142|     60|                case json_storage_kind::array:
  ------------------
  |  Branch (4142:17): [True: 60, False: 5]
  ------------------
 4143|     60|                    cast<array_storage>().value().clear();
 4144|     60|                    break;
 4145|      5|                case json_storage_kind::object:
  ------------------
  |  Branch (4145:17): [True: 5, False: 60]
  ------------------
 4146|      5|                    cast<object_storage>().value().clear();
 4147|      5|                    break;
 4148|      0|                case json_storage_kind::json_ref:
  ------------------
  |  Branch (4148:17): [True: 0, False: 65]
  ------------------
 4149|      0|                    cast<json_ref_storage>().value().clear();
 4150|      0|                    break;
 4151|      0|                default:
  ------------------
  |  Branch (4151:17): [True: 0, False: 65]
  ------------------
 4152|      0|                    break;
 4153|     65|            }
 4154|     65|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE14object_storage5valueEv:
  800|    211|            {
  801|    211|                JSONCONS_ASSERT(ptr_ != nullptr);
  ------------------
  |  |   45|    211|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 211]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  802|    211|                return *ptr_;
  803|    211|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE12object_rangeEv:
 4709|      5|        {
 4710|      5|            switch (storage_kind())
 4711|      5|            {
 4712|      0|                case json_storage_kind::empty_object:
  ------------------
  |  Branch (4712:17): [True: 0, False: 5]
  ------------------
 4713|      0|                    return object_range_type(object_iterator(), object_iterator());
 4714|      5|                case json_storage_kind::object:
  ------------------
  |  Branch (4714:17): [True: 5, False: 0]
  ------------------
 4715|      5|                    return object_range_type(object_iterator(cast<object_storage>().value().begin()),
 4716|      5|                                                  object_iterator(cast<object_storage>().value().end()));
 4717|      0|                case json_storage_kind::json_ref:
  ------------------
  |  Branch (4717:17): [True: 0, False: 5]
  ------------------
 4718|      0|                    return cast<json_ref_storage>().value().object_range();
 4719|      0|                default:
  ------------------
  |  Branch (4719:17): [True: 0, False: 5]
  ------------------
 4720|      0|                    JSONCONS_THROW(json_runtime_error<std::domain_error>("Not an object"));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 4721|      5|            }
 4722|      5|        }
_ZN8jsoncons5rangeINS_6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyESA_EEEEEEvEENS2_INS4_IPKSF_EEvEEEC2ERKSI_SP_:
  353|      5|            : first_(first), last_(last)
  354|      5|        {
  355|      5|        }
_ZN8jsoncons6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES9_EEEEEEvEC2ESG_:
  122|     10|            explicit random_access_iterator_wrapper(Iterator ptr) : it_(ptr), has_value_(true)  
  123|     10|            {
  124|     10|            }
_ZNK8jsoncons5rangeINS_6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyESA_EEEEEEvEENS2_INS4_IPKSF_EEvEEE5beginEv:
  358|      5|        {
  359|      5|            return first_;
  360|      5|        }
_ZNK8jsoncons5rangeINS_6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyESA_EEEEEEvEENS2_INS4_IPKSF_EEvEEE3endEv:
  362|      5|        {
  363|      5|            return last_;
  364|      5|        }
_ZNK8jsoncons6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES9_EEEEEEvEneERKSH_:
  225|     22|            {
  226|     22|                return !(*this == rhs);
  227|     22|            }
_ZNK8jsoncons6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES9_EEEEEEvEeqERKSH_:
  213|     22|            {
  214|     22|                if (!has_value_ || !rhs.has_value_)
  ------------------
  |  Branch (214:21): [True: 0, False: 22]
  |  Branch (214:36): [True: 0, False: 22]
  ------------------
  215|      0|                {
  216|      0|                    return has_value_ == rhs.has_value_ ? true : false;
  ------------------
  |  Branch (216:28): [True: 0, False: 0]
  ------------------
  217|      0|                }
  218|     22|                else
  219|     22|                {
  220|     22|                    return it_ == rhs.it_;
  221|     22|                }
  222|     22|            }
_ZNK8jsoncons6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES9_EEEEEEvEdeEv:
  144|     17|            {
  145|     17|                return *it_;
  146|     17|            }
_ZN8jsoncons6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES9_EEEEEEvEppEv:
  154|     17|            {
  155|     17|                ++it_;
  156|     17|                return *this;
  157|     17|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_14object_storageEEERT_v:
 1009|  21.9M|        {
 1010|  21.9M|            return cast(identity<T>());
 1011|  21.9M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_14object_storageEEE:
 1120|  21.9M|        {
 1121|  21.9M|            return object_;
 1122|  21.9M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2Ev:
 2280|     43|        {
 2281|     43|            construct<empty_object_storage>(semantic_tag::none);
 2282|     43|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_20empty_object_storageEJNS_12semantic_tagEEEEvDpOT0_:
 1000|     43|        {
 1001|     43|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|     43|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_20empty_object_storageEEERT_v:
 1009|     45|        {
 1010|     45|            return cast(identity<T>());
 1011|     45|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_20empty_object_storageEEE:
 1030|     45|        {
 1031|     45|            return empty_object_;
 1032|     45|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE20empty_object_storageC2ENS_12semantic_tagE:
  467|     43|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::empty_object)), short_str_length_(0), tag_(tag)
  468|     43|            {
  469|     43|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE7reserveEm:
 3467|    130|        {
 3468|    130|            if (n > 0)
  ------------------
  |  Branch (3468:17): [True: 130, False: 0]
  ------------------
 3469|    130|            {
 3470|    130|                switch (storage_kind())
 3471|    130|                {
 3472|    130|                    case json_storage_kind::array:
  ------------------
  |  Branch (3472:21): [True: 130, False: 0]
  ------------------
 3473|    130|                        cast<array_storage>().value().reserve(n);
 3474|    130|                        break;
 3475|      0|                    case json_storage_kind::empty_object:
  ------------------
  |  Branch (3475:21): [True: 0, False: 130]
  ------------------
 3476|      0|                        create_object_implicitly();
 3477|      0|                        cast<object_storage>().value().reserve(n);
 3478|      0|                        break;
 3479|      0|                    case json_storage_kind::object:
  ------------------
  |  Branch (3479:21): [True: 0, False: 130]
  ------------------
 3480|      0|                        cast<object_storage>().value().reserve(n);
 3481|      0|                        break;
 3482|      0|                    case json_storage_kind::json_ref:
  ------------------
  |  Branch (3482:21): [True: 0, False: 130]
  ------------------
 3483|      0|                        cast<json_ref_storage>().value().reserve(n);
 3484|      0|                        break;
 3485|      0|                    default:
  ------------------
  |  Branch (3485:21): [True: 0, False: 130]
  ------------------
 3486|      0|                        break;
 3487|    130|                }
 3488|    130|            }
 3489|    130|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2ENS_17json_object_arg_tENS_12semantic_tagERKS4_:
 2325|  3.18M|        {
 2326|  3.18M|            auto ptr = create_object(alloc);
 2327|  3.18M|            construct<object_storage>(ptr, tag);
 2328|  3.18M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE13create_objectIJEEEPNS_18sorted_json_objectINS2_12basic_stringIcNS2_11char_traitsIcEES4_EES5_NS2_6vectorEEERKS4_DpOT_:
  981|  3.18M|        {
  982|  3.18M|            using stor_allocator_type = typename object_storage::allocator_type;
  983|  3.18M|            stor_allocator_type stor_alloc(alloc);
  984|  3.18M|            auto ptr = std::allocator_traits<stor_allocator_type>::allocate(stor_alloc, 1);
  985|  3.18M|            JSONCONS_TRY
  ------------------
  |  |   37|  3.18M|    #define JSONCONS_TRY try
  ------------------
  986|  3.18M|            {
  987|  3.18M|                std::allocator_traits<stor_allocator_type>::construct(stor_alloc, ext_traits::to_plain_pointer(ptr), 
  988|  3.18M|                    std::forward<Args>(args)...);
  989|  3.18M|            }
  990|  3.18M|            JSONCONS_CATCH(...)
  991|  3.18M|            {
  992|      0|                std::allocator_traits<stor_allocator_type>::deallocate(stor_alloc, ptr,1);
  993|      0|                JSONCONS_RETHROW;
  ------------------
  |  |   36|      0|    #define JSONCONS_RETHROW throw
  ------------------
  994|      0|            }
  995|  3.18M|            return ptr;
  996|  3.18M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_14object_storageEJRPNS_18sorted_json_objectINS2_12basic_stringIcNS2_11char_traitsIcEES4_EES5_NS2_6vectorEEERNS_12semantic_tagEEEEvDpOT0_:
 1000|  3.18M|        {
 1001|  3.18M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|  3.18M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE14object_storageC2EPNS_18sorted_json_objectINS2_12basic_stringIcNS2_11char_traitsIcEES4_EES5_NS2_6vectorEEENS_12semantic_tagE:
  777|  3.18M|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::object)), short_str_length_(0), tag_(tag), ptr_(ptr)
  778|  3.18M|            {
  779|  3.18M|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEaSEOS5_:
 1458|  1.82k|        {
 1459|  1.82k|            if (this != &other)
  ------------------
  |  Branch (1459:17): [True: 1.82k, False: 0]
  ------------------
 1460|  1.82k|            {
 1461|  1.82k|                move_assignment(std::move(other));
 1462|  1.82k|            }
 1463|  1.82k|            return *this;
 1464|  1.82k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE15move_assignmentEOS5_:
 1420|  1.82k|        {
 1421|  1.82k|            if (is_trivial_storage(storage_kind()) && is_trivial_storage(other.storage_kind()))
  ------------------
  |  Branch (1421:17): [True: 1.82k, False: 0]
  |  Branch (1421:55): [True: 1.52k, False: 297]
  ------------------
 1422|  1.52k|            {
 1423|  1.52k|                std::memcpy(static_cast<void*>(this), &other, sizeof(basic_json));
 1424|  1.52k|            }
 1425|    297|            else
 1426|    297|            {
 1427|    297|                swap(other);
 1428|    297|            }
 1429|  1.82k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9push_backEOS5_:
 4685|  1.36k|        {
 4686|  1.36k|            switch (storage_kind())
 4687|  1.36k|            {
 4688|  1.36k|                case json_storage_kind::array:
  ------------------
  |  Branch (4688:17): [True: 1.36k, False: 0]
  ------------------
 4689|  1.36k|                    cast<array_storage>().value().push_back(std::move(val));
 4690|  1.36k|                    break;
 4691|      0|                case json_storage_kind::json_ref:
  ------------------
  |  Branch (4691:17): [True: 0, False: 1.36k]
  ------------------
 4692|      0|                    cast<json_ref_storage>().value().push_back(std::move(val));
 4693|      0|                    break;
 4694|      0|                default:
  ------------------
  |  Branch (4694:17): [True: 0, False: 1.36k]
  ------------------
 4695|      0|                    JSONCONS_THROW(json_runtime_error<std::domain_error>("Attempting to insert into a value that is not an array"));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 4696|  1.36k|            }
 4697|  1.36k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4swapERS5_:
 1939|    297|        {
 1940|    297|            if (this == &other)
  ------------------
  |  Branch (1940:17): [True: 0, False: 297]
  ------------------
 1941|      0|            {
 1942|      0|                return;
 1943|      0|            }
 1944|    297|            if (is_trivial_storage(storage_kind()) && is_trivial_storage(other.storage_kind()))
  ------------------
  |  Branch (1944:17): [True: 297, False: 0]
  |  Branch (1944:55): [True: 0, False: 297]
  ------------------
 1945|      0|            {
 1946|      0|                basic_json temp;               
 1947|      0|                std::memcpy(static_cast<void*>(&temp), static_cast<void*>(&other), sizeof(basic_json));
 1948|      0|                std::memcpy(static_cast<void*>(&other), static_cast<void*>(this), sizeof(basic_json));
 1949|      0|                std::memcpy(static_cast<void*>(this), static_cast<void*>(&temp), sizeof(basic_json));
 1950|      0|            }
 1951|    297|            else
 1952|    297|            {
 1953|    297|                switch (storage_kind())
 1954|    297|                {
 1955|    142|                    case json_storage_kind::null: swap_l<null_storage>(other); break;
  ------------------
  |  Branch (1955:21): [True: 142, False: 155]
  ------------------
 1956|      1|                    case json_storage_kind::empty_object : swap_l<empty_object_storage>(other); break;
  ------------------
  |  Branch (1956:21): [True: 1, False: 296]
  ------------------
 1957|     18|                    case json_storage_kind::boolean: swap_l<bool_storage>(other); break;
  ------------------
  |  Branch (1957:21): [True: 18, False: 279]
  ------------------
 1958|     46|                    case json_storage_kind::int64: swap_l<int64_storage>(other); break;
  ------------------
  |  Branch (1958:21): [True: 46, False: 251]
  ------------------
 1959|     88|                    case json_storage_kind::uint64: swap_l<uint64_storage>(other); break;
  ------------------
  |  Branch (1959:21): [True: 88, False: 209]
  ------------------
 1960|      0|                    case json_storage_kind::half_float: swap_l<half_storage>(other); break;
  ------------------
  |  Branch (1960:21): [True: 0, False: 297]
  ------------------
 1961|      0|                    case json_storage_kind::float64: swap_l<double_storage>(other); break;
  ------------------
  |  Branch (1961:21): [True: 0, False: 297]
  ------------------
 1962|      2|                    case json_storage_kind::short_str: swap_l<short_string_storage>(other); break;
  ------------------
  |  Branch (1962:21): [True: 2, False: 295]
  ------------------
 1963|      0|                    case json_storage_kind::long_str: swap_l<long_string_storage>(other); break;
  ------------------
  |  Branch (1963:21): [True: 0, False: 297]
  ------------------
 1964|      0|                    case json_storage_kind::byte_str: swap_l<byte_string_storage>(other); break;
  ------------------
  |  Branch (1964:21): [True: 0, False: 297]
  ------------------
 1965|      0|                    case json_storage_kind::array: swap_l<array_storage>(other); break;
  ------------------
  |  Branch (1965:21): [True: 0, False: 297]
  ------------------
 1966|      0|                    case json_storage_kind::object: swap_l<object_storage>(other); break;
  ------------------
  |  Branch (1966:21): [True: 0, False: 297]
  ------------------
 1967|      0|                    case json_storage_kind::const_json_ref: swap_l<const_json_ref_storage>(other); break;
  ------------------
  |  Branch (1967:21): [True: 0, False: 297]
  ------------------
 1968|      0|                    case json_storage_kind::json_ref: swap_l<json_ref_storage>(other); break;
  ------------------
  |  Branch (1968:21): [True: 0, False: 297]
  ------------------
 1969|      0|                    default:
  ------------------
  |  Branch (1969:21): [True: 0, False: 297]
  ------------------
 1970|      0|                        JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1971|      0|                        break;
 1972|    297|                }
 1973|    297|            }
 1974|    297|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_12null_storageEEEvRS5_:
 1175|    142|        {
 1176|    142|            switch (other.storage_kind())
 1177|    142|            {
 1178|      0|                case json_storage_kind::null         : swap_l_r<TypeL, null_storage>(other); break;
  ------------------
  |  Branch (1178:17): [True: 0, False: 142]
  ------------------
 1179|      0|                case json_storage_kind::empty_object : swap_l_r<TypeL, empty_object_storage>(other); break;
  ------------------
  |  Branch (1179:17): [True: 0, False: 142]
  ------------------
 1180|      0|                case json_storage_kind::boolean         : swap_l_r<TypeL, bool_storage>(other); break;
  ------------------
  |  Branch (1180:17): [True: 0, False: 142]
  ------------------
 1181|      0|                case json_storage_kind::int64        : swap_l_r<TypeL, int64_storage>(other); break;
  ------------------
  |  Branch (1181:17): [True: 0, False: 142]
  ------------------
 1182|      0|                case json_storage_kind::uint64       : swap_l_r<TypeL, uint64_storage>(other); break;
  ------------------
  |  Branch (1182:17): [True: 0, False: 142]
  ------------------
 1183|      0|                case json_storage_kind::half_float         : swap_l_r<TypeL, half_storage>(other); break;
  ------------------
  |  Branch (1183:17): [True: 0, False: 142]
  ------------------
 1184|      0|                case json_storage_kind::float64       : swap_l_r<TypeL, double_storage>(other); break;
  ------------------
  |  Branch (1184:17): [True: 0, False: 142]
  ------------------
 1185|      0|                case json_storage_kind::short_str : swap_l_r<TypeL, short_string_storage>(other); break;
  ------------------
  |  Branch (1185:17): [True: 0, False: 142]
  ------------------
 1186|      8|                case json_storage_kind::long_str  : swap_l_r<TypeL, long_string_storage>(other); break;
  ------------------
  |  Branch (1186:17): [True: 8, False: 134]
  ------------------
 1187|    108|                case json_storage_kind::byte_str  : swap_l_r<TypeL, byte_string_storage>(other); break;
  ------------------
  |  Branch (1187:17): [True: 108, False: 34]
  ------------------
 1188|     20|                case json_storage_kind::array        : swap_l_r<TypeL, array_storage>(other); break;
  ------------------
  |  Branch (1188:17): [True: 20, False: 122]
  ------------------
 1189|      6|                case json_storage_kind::object       : swap_l_r<TypeL, object_storage>(other); break;
  ------------------
  |  Branch (1189:17): [True: 6, False: 136]
  ------------------
 1190|      0|                case json_storage_kind::const_json_ref : swap_l_r<TypeL, const_json_ref_storage>(other); break;
  ------------------
  |  Branch (1190:17): [True: 0, False: 142]
  ------------------
 1191|      0|                case json_storage_kind::json_ref : swap_l_r<TypeL, json_ref_storage>(other); break;
  ------------------
  |  Branch (1191:17): [True: 0, False: 142]
  ------------------
 1192|      0|                default:
  ------------------
  |  Branch (1192:17): [True: 0, False: 142]
  ------------------
 1193|      0|                    JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1194|      0|                    break;
 1195|    142|            }
 1196|    142|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_12null_storageEJRS7_EEEvDpOT0_:
 1000|    142|        {
 1001|    142|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|    142|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_20empty_object_storageEJRS7_EEEvDpOT0_:
 1000|      1|        {
 1001|      1|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|      1|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_12bool_storageEEERT_v:
 1009|  2.11M|        {
 1010|  2.11M|            return cast(identity<T>());
 1011|  2.11M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_12bool_storageEEE:
 1040|  2.11M|        {
 1041|  2.11M|            return boolean_;
 1042|  2.11M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_12bool_storageEJRS7_EEEvDpOT0_:
 1000|     18|        {
 1001|     18|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|     18|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_13int64_storageEEERT_v:
 1009|  3.10M|        {
 1010|  3.10M|            return cast(identity<T>());
 1011|  3.10M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_13int64_storageEEE:
 1050|  3.10M|        {
 1051|  3.10M|            return int64_;
 1052|  3.10M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_13int64_storageEJRS7_EEEvDpOT0_:
 1000|     46|        {
 1001|     46|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|     46|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_14uint64_storageEEERT_v:
 1009|  1.21M|        {
 1010|  1.21M|            return cast(identity<T>());
 1011|  1.21M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_14uint64_storageEEE:
 1060|  1.21M|        {
 1061|  1.21M|            return uint64_;
 1062|  1.21M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_14uint64_storageEJRS7_EEEvDpOT0_:
 1000|     88|        {
 1001|     88|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|     88|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_12half_storageEEERT_v:
 1009|     65|        {
 1010|     65|            return cast(identity<T>());
 1011|     65|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_12half_storageEEE:
 1070|     65|        {
 1071|     65|            return half_float_;
 1072|     65|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_14double_storageEEERT_v:
 1009|     12|        {
 1010|     12|            return cast(identity<T>());
 1011|     12|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_14double_storageEEE:
 1080|     12|        {
 1081|     12|            return float64_;
 1082|     12|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_20short_string_storageEEERT_v:
 1009|   994k|        {
 1010|   994k|            return cast(identity<T>());
 1011|   994k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_20short_string_storageEEE:
 1090|   994k|        {
 1091|   994k|            return short_str_;
 1092|   994k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE20short_string_storageC2ERKS6_:
  590|      2|                : storage_kind_(other.storage_kind_), short_str_length_(other.short_str_length_), tag_(other.tag_)
  591|      2|            {
  592|      2|                std::memcpy(data_,other.data_,other.short_str_length_*sizeof(char_type));
  593|      2|                data_[short_str_length_] = 0;
  594|      2|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_20short_string_storageEJRS7_EEEvDpOT0_:
 1000|      2|        {
 1001|      2|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|      2|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_19long_string_storageEEEvRS5_:
 1161|      8|        {
 1162|      8|            swap_l_r(identity<TypeL>(), identity<TypeR>(), other);
 1163|      8|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_19long_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_:
 1167|      8|        {
 1168|      8|            TypeR temp{other.cast<TypeR>()};
 1169|      8|            other.construct<TypeL>(cast<TypeL>());
 1170|      8|            construct<TypeR>(temp);
 1171|      8|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_19byte_string_storageEEEvRS5_:
 1161|    108|        {
 1162|    108|            swap_l_r(identity<TypeL>(), identity<TypeR>(), other);
 1163|    108|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_19byte_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_:
 1167|    108|        {
 1168|    108|            TypeR temp{other.cast<TypeR>()};
 1169|    108|            other.construct<TypeL>(cast<TypeL>());
 1170|    108|            construct<TypeR>(temp);
 1171|    108|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_13array_storageEEEvRS5_:
 1161|     20|        {
 1162|     20|            swap_l_r(identity<TypeL>(), identity<TypeR>(), other);
 1163|     20|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_13array_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_:
 1167|     20|        {
 1168|     20|            TypeR temp{other.cast<TypeR>()};
 1169|     20|            other.construct<TypeL>(cast<TypeL>());
 1170|     20|            construct<TypeR>(temp);
 1171|     20|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_14object_storageEEEvRS5_:
 1161|      6|        {
 1162|      6|            swap_l_r(identity<TypeL>(), identity<TypeR>(), other);
 1163|      6|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_14object_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_:
 1167|      6|        {
 1168|      6|            TypeR temp{other.cast<TypeR>()};
 1169|      6|            other.construct<TypeL>(cast<TypeL>());
 1170|      6|            construct<TypeR>(temp);
 1171|      6|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_20empty_object_storageEEEvRS5_:
 1175|      1|        {
 1176|      1|            switch (other.storage_kind())
 1177|      1|            {
 1178|      0|                case json_storage_kind::null         : swap_l_r<TypeL, null_storage>(other); break;
  ------------------
  |  Branch (1178:17): [True: 0, False: 1]
  ------------------
 1179|      0|                case json_storage_kind::empty_object : swap_l_r<TypeL, empty_object_storage>(other); break;
  ------------------
  |  Branch (1179:17): [True: 0, False: 1]
  ------------------
 1180|      0|                case json_storage_kind::boolean         : swap_l_r<TypeL, bool_storage>(other); break;
  ------------------
  |  Branch (1180:17): [True: 0, False: 1]
  ------------------
 1181|      0|                case json_storage_kind::int64        : swap_l_r<TypeL, int64_storage>(other); break;
  ------------------
  |  Branch (1181:17): [True: 0, False: 1]
  ------------------
 1182|      0|                case json_storage_kind::uint64       : swap_l_r<TypeL, uint64_storage>(other); break;
  ------------------
  |  Branch (1182:17): [True: 0, False: 1]
  ------------------
 1183|      0|                case json_storage_kind::half_float         : swap_l_r<TypeL, half_storage>(other); break;
  ------------------
  |  Branch (1183:17): [True: 0, False: 1]
  ------------------
 1184|      0|                case json_storage_kind::float64       : swap_l_r<TypeL, double_storage>(other); break;
  ------------------
  |  Branch (1184:17): [True: 0, False: 1]
  ------------------
 1185|      0|                case json_storage_kind::short_str : swap_l_r<TypeL, short_string_storage>(other); break;
  ------------------
  |  Branch (1185:17): [True: 0, False: 1]
  ------------------
 1186|      0|                case json_storage_kind::long_str  : swap_l_r<TypeL, long_string_storage>(other); break;
  ------------------
  |  Branch (1186:17): [True: 0, False: 1]
  ------------------
 1187|      1|                case json_storage_kind::byte_str  : swap_l_r<TypeL, byte_string_storage>(other); break;
  ------------------
  |  Branch (1187:17): [True: 1, False: 0]
  ------------------
 1188|      0|                case json_storage_kind::array        : swap_l_r<TypeL, array_storage>(other); break;
  ------------------
  |  Branch (1188:17): [True: 0, False: 1]
  ------------------
 1189|      0|                case json_storage_kind::object       : swap_l_r<TypeL, object_storage>(other); break;
  ------------------
  |  Branch (1189:17): [True: 0, False: 1]
  ------------------
 1190|      0|                case json_storage_kind::const_json_ref : swap_l_r<TypeL, const_json_ref_storage>(other); break;
  ------------------
  |  Branch (1190:17): [True: 0, False: 1]
  ------------------
 1191|      0|                case json_storage_kind::json_ref : swap_l_r<TypeL, json_ref_storage>(other); break;
  ------------------
  |  Branch (1191:17): [True: 0, False: 1]
  ------------------
 1192|      0|                default:
  ------------------
  |  Branch (1192:17): [True: 0, False: 1]
  ------------------
 1193|      0|                    JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1194|      0|                    break;
 1195|      1|            }
 1196|      1|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20empty_object_storageENS5_19byte_string_storageEEEvRS5_:
 1161|      1|        {
 1162|      1|            swap_l_r(identity<TypeL>(), identity<TypeR>(), other);
 1163|      1|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20empty_object_storageENS5_19byte_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_:
 1167|      1|        {
 1168|      1|            TypeR temp{other.cast<TypeR>()};
 1169|      1|            other.construct<TypeL>(cast<TypeL>());
 1170|      1|            construct<TypeR>(temp);
 1171|      1|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_12bool_storageEEEvRS5_:
 1175|     18|        {
 1176|     18|            switch (other.storage_kind())
 1177|     18|            {
 1178|      0|                case json_storage_kind::null         : swap_l_r<TypeL, null_storage>(other); break;
  ------------------
  |  Branch (1178:17): [True: 0, False: 18]
  ------------------
 1179|      0|                case json_storage_kind::empty_object : swap_l_r<TypeL, empty_object_storage>(other); break;
  ------------------
  |  Branch (1179:17): [True: 0, False: 18]
  ------------------
 1180|      0|                case json_storage_kind::boolean         : swap_l_r<TypeL, bool_storage>(other); break;
  ------------------
  |  Branch (1180:17): [True: 0, False: 18]
  ------------------
 1181|      0|                case json_storage_kind::int64        : swap_l_r<TypeL, int64_storage>(other); break;
  ------------------
  |  Branch (1181:17): [True: 0, False: 18]
  ------------------
 1182|      0|                case json_storage_kind::uint64       : swap_l_r<TypeL, uint64_storage>(other); break;
  ------------------
  |  Branch (1182:17): [True: 0, False: 18]
  ------------------
 1183|      0|                case json_storage_kind::half_float         : swap_l_r<TypeL, half_storage>(other); break;
  ------------------
  |  Branch (1183:17): [True: 0, False: 18]
  ------------------
 1184|      0|                case json_storage_kind::float64       : swap_l_r<TypeL, double_storage>(other); break;
  ------------------
  |  Branch (1184:17): [True: 0, False: 18]
  ------------------
 1185|      0|                case json_storage_kind::short_str : swap_l_r<TypeL, short_string_storage>(other); break;
  ------------------
  |  Branch (1185:17): [True: 0, False: 18]
  ------------------
 1186|      4|                case json_storage_kind::long_str  : swap_l_r<TypeL, long_string_storage>(other); break;
  ------------------
  |  Branch (1186:17): [True: 4, False: 14]
  ------------------
 1187|     14|                case json_storage_kind::byte_str  : swap_l_r<TypeL, byte_string_storage>(other); break;
  ------------------
  |  Branch (1187:17): [True: 14, False: 4]
  ------------------
 1188|      0|                case json_storage_kind::array        : swap_l_r<TypeL, array_storage>(other); break;
  ------------------
  |  Branch (1188:17): [True: 0, False: 18]
  ------------------
 1189|      0|                case json_storage_kind::object       : swap_l_r<TypeL, object_storage>(other); break;
  ------------------
  |  Branch (1189:17): [True: 0, False: 18]
  ------------------
 1190|      0|                case json_storage_kind::const_json_ref : swap_l_r<TypeL, const_json_ref_storage>(other); break;
  ------------------
  |  Branch (1190:17): [True: 0, False: 18]
  ------------------
 1191|      0|                case json_storage_kind::json_ref : swap_l_r<TypeL, json_ref_storage>(other); break;
  ------------------
  |  Branch (1191:17): [True: 0, False: 18]
  ------------------
 1192|      0|                default:
  ------------------
  |  Branch (1192:17): [True: 0, False: 18]
  ------------------
 1193|      0|                    JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1194|      0|                    break;
 1195|     18|            }
 1196|     18|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12bool_storageENS5_19long_string_storageEEEvRS5_:
 1161|      4|        {
 1162|      4|            swap_l_r(identity<TypeL>(), identity<TypeR>(), other);
 1163|      4|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12bool_storageENS5_19long_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_:
 1167|      4|        {
 1168|      4|            TypeR temp{other.cast<TypeR>()};
 1169|      4|            other.construct<TypeL>(cast<TypeL>());
 1170|      4|            construct<TypeR>(temp);
 1171|      4|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12bool_storageENS5_19byte_string_storageEEEvRS5_:
 1161|     14|        {
 1162|     14|            swap_l_r(identity<TypeL>(), identity<TypeR>(), other);
 1163|     14|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12bool_storageENS5_19byte_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_:
 1167|     14|        {
 1168|     14|            TypeR temp{other.cast<TypeR>()};
 1169|     14|            other.construct<TypeL>(cast<TypeL>());
 1170|     14|            construct<TypeR>(temp);
 1171|     14|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_13int64_storageEEEvRS5_:
 1175|     46|        {
 1176|     46|            switch (other.storage_kind())
 1177|     46|            {
 1178|      0|                case json_storage_kind::null         : swap_l_r<TypeL, null_storage>(other); break;
  ------------------
  |  Branch (1178:17): [True: 0, False: 46]
  ------------------
 1179|      0|                case json_storage_kind::empty_object : swap_l_r<TypeL, empty_object_storage>(other); break;
  ------------------
  |  Branch (1179:17): [True: 0, False: 46]
  ------------------
 1180|      0|                case json_storage_kind::boolean         : swap_l_r<TypeL, bool_storage>(other); break;
  ------------------
  |  Branch (1180:17): [True: 0, False: 46]
  ------------------
 1181|      0|                case json_storage_kind::int64        : swap_l_r<TypeL, int64_storage>(other); break;
  ------------------
  |  Branch (1181:17): [True: 0, False: 46]
  ------------------
 1182|      0|                case json_storage_kind::uint64       : swap_l_r<TypeL, uint64_storage>(other); break;
  ------------------
  |  Branch (1182:17): [True: 0, False: 46]
  ------------------
 1183|      0|                case json_storage_kind::half_float         : swap_l_r<TypeL, half_storage>(other); break;
  ------------------
  |  Branch (1183:17): [True: 0, False: 46]
  ------------------
 1184|      0|                case json_storage_kind::float64       : swap_l_r<TypeL, double_storage>(other); break;
  ------------------
  |  Branch (1184:17): [True: 0, False: 46]
  ------------------
 1185|      0|                case json_storage_kind::short_str : swap_l_r<TypeL, short_string_storage>(other); break;
  ------------------
  |  Branch (1185:17): [True: 0, False: 46]
  ------------------
 1186|      0|                case json_storage_kind::long_str  : swap_l_r<TypeL, long_string_storage>(other); break;
  ------------------
  |  Branch (1186:17): [True: 0, False: 46]
  ------------------
 1187|     22|                case json_storage_kind::byte_str  : swap_l_r<TypeL, byte_string_storage>(other); break;
  ------------------
  |  Branch (1187:17): [True: 22, False: 24]
  ------------------
 1188|     24|                case json_storage_kind::array        : swap_l_r<TypeL, array_storage>(other); break;
  ------------------
  |  Branch (1188:17): [True: 24, False: 22]
  ------------------
 1189|      0|                case json_storage_kind::object       : swap_l_r<TypeL, object_storage>(other); break;
  ------------------
  |  Branch (1189:17): [True: 0, False: 46]
  ------------------
 1190|      0|                case json_storage_kind::const_json_ref : swap_l_r<TypeL, const_json_ref_storage>(other); break;
  ------------------
  |  Branch (1190:17): [True: 0, False: 46]
  ------------------
 1191|      0|                case json_storage_kind::json_ref : swap_l_r<TypeL, json_ref_storage>(other); break;
  ------------------
  |  Branch (1191:17): [True: 0, False: 46]
  ------------------
 1192|      0|                default:
  ------------------
  |  Branch (1192:17): [True: 0, False: 46]
  ------------------
 1193|      0|                    JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1194|      0|                    break;
 1195|     46|            }
 1196|     46|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_13int64_storageENS5_19byte_string_storageEEEvRS5_:
 1161|     22|        {
 1162|     22|            swap_l_r(identity<TypeL>(), identity<TypeR>(), other);
 1163|     22|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_13int64_storageENS5_19byte_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_:
 1167|     22|        {
 1168|     22|            TypeR temp{other.cast<TypeR>()};
 1169|     22|            other.construct<TypeL>(cast<TypeL>());
 1170|     22|            construct<TypeR>(temp);
 1171|     22|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_13int64_storageENS5_13array_storageEEEvRS5_:
 1161|     24|        {
 1162|     24|            swap_l_r(identity<TypeL>(), identity<TypeR>(), other);
 1163|     24|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_13int64_storageENS5_13array_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_:
 1167|     24|        {
 1168|     24|            TypeR temp{other.cast<TypeR>()};
 1169|     24|            other.construct<TypeL>(cast<TypeL>());
 1170|     24|            construct<TypeR>(temp);
 1171|     24|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_14uint64_storageEEEvRS5_:
 1175|     88|        {
 1176|     88|            switch (other.storage_kind())
 1177|     88|            {
 1178|      0|                case json_storage_kind::null         : swap_l_r<TypeL, null_storage>(other); break;
  ------------------
  |  Branch (1178:17): [True: 0, False: 88]
  ------------------
 1179|      0|                case json_storage_kind::empty_object : swap_l_r<TypeL, empty_object_storage>(other); break;
  ------------------
  |  Branch (1179:17): [True: 0, False: 88]
  ------------------
 1180|      0|                case json_storage_kind::boolean         : swap_l_r<TypeL, bool_storage>(other); break;
  ------------------
  |  Branch (1180:17): [True: 0, False: 88]
  ------------------
 1181|      0|                case json_storage_kind::int64        : swap_l_r<TypeL, int64_storage>(other); break;
  ------------------
  |  Branch (1181:17): [True: 0, False: 88]
  ------------------
 1182|      0|                case json_storage_kind::uint64       : swap_l_r<TypeL, uint64_storage>(other); break;
  ------------------
  |  Branch (1182:17): [True: 0, False: 88]
  ------------------
 1183|      0|                case json_storage_kind::half_float         : swap_l_r<TypeL, half_storage>(other); break;
  ------------------
  |  Branch (1183:17): [True: 0, False: 88]
  ------------------
 1184|      0|                case json_storage_kind::float64       : swap_l_r<TypeL, double_storage>(other); break;
  ------------------
  |  Branch (1184:17): [True: 0, False: 88]
  ------------------
 1185|      0|                case json_storage_kind::short_str : swap_l_r<TypeL, short_string_storage>(other); break;
  ------------------
  |  Branch (1185:17): [True: 0, False: 88]
  ------------------
 1186|      0|                case json_storage_kind::long_str  : swap_l_r<TypeL, long_string_storage>(other); break;
  ------------------
  |  Branch (1186:17): [True: 0, False: 88]
  ------------------
 1187|     88|                case json_storage_kind::byte_str  : swap_l_r<TypeL, byte_string_storage>(other); break;
  ------------------
  |  Branch (1187:17): [True: 88, False: 0]
  ------------------
 1188|      0|                case json_storage_kind::array        : swap_l_r<TypeL, array_storage>(other); break;
  ------------------
  |  Branch (1188:17): [True: 0, False: 88]
  ------------------
 1189|      0|                case json_storage_kind::object       : swap_l_r<TypeL, object_storage>(other); break;
  ------------------
  |  Branch (1189:17): [True: 0, False: 88]
  ------------------
 1190|      0|                case json_storage_kind::const_json_ref : swap_l_r<TypeL, const_json_ref_storage>(other); break;
  ------------------
  |  Branch (1190:17): [True: 0, False: 88]
  ------------------
 1191|      0|                case json_storage_kind::json_ref : swap_l_r<TypeL, json_ref_storage>(other); break;
  ------------------
  |  Branch (1191:17): [True: 0, False: 88]
  ------------------
 1192|      0|                default:
  ------------------
  |  Branch (1192:17): [True: 0, False: 88]
  ------------------
 1193|      0|                    JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1194|      0|                    break;
 1195|     88|            }
 1196|     88|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14uint64_storageENS5_19byte_string_storageEEEvRS5_:
 1161|     88|        {
 1162|     88|            swap_l_r(identity<TypeL>(), identity<TypeR>(), other);
 1163|     88|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14uint64_storageENS5_19byte_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_:
 1167|     88|        {
 1168|     88|            TypeR temp{other.cast<TypeR>()};
 1169|     88|            other.construct<TypeL>(cast<TypeL>());
 1170|     88|            construct<TypeR>(temp);
 1171|     88|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_20short_string_storageEEEvRS5_:
 1175|      2|        {
 1176|      2|            switch (other.storage_kind())
 1177|      2|            {
 1178|      0|                case json_storage_kind::null         : swap_l_r<TypeL, null_storage>(other); break;
  ------------------
  |  Branch (1178:17): [True: 0, False: 2]
  ------------------
 1179|      0|                case json_storage_kind::empty_object : swap_l_r<TypeL, empty_object_storage>(other); break;
  ------------------
  |  Branch (1179:17): [True: 0, False: 2]
  ------------------
 1180|      0|                case json_storage_kind::boolean         : swap_l_r<TypeL, bool_storage>(other); break;
  ------------------
  |  Branch (1180:17): [True: 0, False: 2]
  ------------------
 1181|      0|                case json_storage_kind::int64        : swap_l_r<TypeL, int64_storage>(other); break;
  ------------------
  |  Branch (1181:17): [True: 0, False: 2]
  ------------------
 1182|      0|                case json_storage_kind::uint64       : swap_l_r<TypeL, uint64_storage>(other); break;
  ------------------
  |  Branch (1182:17): [True: 0, False: 2]
  ------------------
 1183|      0|                case json_storage_kind::half_float         : swap_l_r<TypeL, half_storage>(other); break;
  ------------------
  |  Branch (1183:17): [True: 0, False: 2]
  ------------------
 1184|      0|                case json_storage_kind::float64       : swap_l_r<TypeL, double_storage>(other); break;
  ------------------
  |  Branch (1184:17): [True: 0, False: 2]
  ------------------
 1185|      0|                case json_storage_kind::short_str : swap_l_r<TypeL, short_string_storage>(other); break;
  ------------------
  |  Branch (1185:17): [True: 0, False: 2]
  ------------------
 1186|      2|                case json_storage_kind::long_str  : swap_l_r<TypeL, long_string_storage>(other); break;
  ------------------
  |  Branch (1186:17): [True: 2, False: 0]
  ------------------
 1187|      0|                case json_storage_kind::byte_str  : swap_l_r<TypeL, byte_string_storage>(other); break;
  ------------------
  |  Branch (1187:17): [True: 0, False: 2]
  ------------------
 1188|      0|                case json_storage_kind::array        : swap_l_r<TypeL, array_storage>(other); break;
  ------------------
  |  Branch (1188:17): [True: 0, False: 2]
  ------------------
 1189|      0|                case json_storage_kind::object       : swap_l_r<TypeL, object_storage>(other); break;
  ------------------
  |  Branch (1189:17): [True: 0, False: 2]
  ------------------
 1190|      0|                case json_storage_kind::const_json_ref : swap_l_r<TypeL, const_json_ref_storage>(other); break;
  ------------------
  |  Branch (1190:17): [True: 0, False: 2]
  ------------------
 1191|      0|                case json_storage_kind::json_ref : swap_l_r<TypeL, json_ref_storage>(other); break;
  ------------------
  |  Branch (1191:17): [True: 0, False: 2]
  ------------------
 1192|      0|                default:
  ------------------
  |  Branch (1192:17): [True: 0, False: 2]
  ------------------
 1193|      0|                    JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1194|      0|                    break;
 1195|      2|            }
 1196|      2|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20short_string_storageENS5_19long_string_storageEEEvRS5_:
 1161|      2|        {
 1162|      2|            swap_l_r(identity<TypeL>(), identity<TypeR>(), other);
 1163|      2|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20short_string_storageENS5_19long_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_:
 1167|      2|        {
 1168|      2|            TypeR temp{other.cast<TypeR>()};
 1169|      2|            other.construct<TypeL>(cast<TypeL>());
 1170|      2|            construct<TypeR>(temp);
 1171|      2|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2ImEET_NS_12semantic_tagENS2_9enable_ifIXaasr10ext_traits19is_unsigned_integerIS7_EE5valuelestS7_Lm8EEiE4typeE:
 2619|  1.21M|        {
 2620|  1.21M|            construct<uint64_storage>(val, tag);
 2621|  1.21M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_14uint64_storageEJRmRNS_12semantic_tagEEEEvDpOT0_:
 1000|  1.21M|        {
 1001|  1.21M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|  1.21M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE14uint64_storageC2EmNS_12semantic_tagE:
  521|  1.21M|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::uint64)), short_str_length_(0), tag_(tag),
  522|  1.21M|                  val_(val)
  523|  1.21M|            {
  524|  1.21M|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2IlEET_NS_12semantic_tagENS2_9enable_ifIXaasr10ext_traits17is_signed_integerIS7_EE5valuelestS7_Lm8EEiE4typeE:
 2650|  3.10M|        {
 2651|  3.10M|            construct<int64_storage>(val, tag);
 2652|  3.10M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_13int64_storageEJRlRNS_12semantic_tagEEEEvDpOT0_:
 1000|  3.10M|        {
 1001|  3.10M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|  3.10M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE13int64_storageC2ElNS_12semantic_tagE:
  501|  3.10M|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::int64)), short_str_length_(0), tag_(tag),
  502|  3.10M|                  val_(val)
  503|  3.10M|            {
  504|  3.10M|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2EdNS_12semantic_tagE:
 2607|     12|        {
 2608|     12|            construct<double_storage>(val, tag);
 2609|     12|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_14double_storageEJRdRNS_12semantic_tagEEEEvDpOT0_:
 1000|     12|        {
 1001|     12|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|     12|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE14double_storageC2EdNS_12semantic_tagE:
  560|     12|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::float64)), short_str_length_(0), tag_(tag),
  561|     12|                  val_(val)
  562|     12|            {
  563|     12|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2ENS_16json_array_arg_tENS_12semantic_tagE:
 2406|  1.46k|        {
 2407|  1.46k|            auto ptr = create_array(Allocator());
 2408|  1.46k|            construct<array_storage>(ptr, tag);
 2409|  1.46k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE12create_arrayIJEEEPNS_10json_arrayIS5_NS2_6vectorEEERKS4_DpOT_:
  962|  1.46k|        {
  963|  1.46k|            using stor_allocator_type = typename array_storage::allocator_type;
  964|  1.46k|            stor_allocator_type stor_alloc(alloc);
  965|  1.46k|            auto ptr = std::allocator_traits<stor_allocator_type>::allocate(stor_alloc, 1);
  966|  1.46k|            JSONCONS_TRY
  ------------------
  |  |   37|  1.46k|    #define JSONCONS_TRY try
  ------------------
  967|  1.46k|            {
  968|  1.46k|                std::allocator_traits<stor_allocator_type>::construct(stor_alloc, ext_traits::to_plain_pointer(ptr), 
  969|  1.46k|                    std::forward<Args>(args)...);
  970|  1.46k|            }
  971|  1.46k|            JSONCONS_CATCH(...)
  972|  1.46k|            {
  973|      0|                std::allocator_traits<stor_allocator_type>::deallocate(stor_alloc, ptr,1);
  974|      0|                JSONCONS_RETHROW;
  ------------------
  |  |   36|      0|    #define JSONCONS_RETHROW throw
  ------------------
  975|      0|            }
  976|  1.46k|            return ptr;
  977|  1.46k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_13array_storageEJRPNS_10json_arrayIS5_NS2_6vectorEEERNS_12semantic_tagEEEEvDpOT0_:
 1000|  1.46k|        {
 1001|  1.46k|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|  1.46k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE13array_storageC2EPNS_10json_arrayIS5_NS2_6vectorEEENS_12semantic_tagE:
  727|  1.46k|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::array)), short_str_length_(0), tag_(tag), ptr_(ptr)
  728|  1.46k|            {
  729|  1.46k|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2ENS_9null_typeENS_12semantic_tagE:
 2696|  1.02M|        {
 2697|  1.02M|            construct<null_storage>(tag);
 2698|  1.02M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_12null_storageEJRNS_12semantic_tagEEEEvDpOT0_:
 1000|  1.02M|        {
 1001|  1.02M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|  1.02M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2EbNS_12semantic_tagE:
 2706|  2.11M|        {
 2707|  2.11M|            construct<bool_storage>(val,tag);
 2708|  2.11M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_12bool_storageEJRbRNS_12semantic_tagEEEEvDpOT0_:
 1000|  2.11M|        {
 1001|  2.11M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|  2.11M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE12bool_storageC2EbNS_12semantic_tagE:
  480|  2.11M|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::boolean)), short_str_length_(0), tag_(tag),
  481|  2.11M|                  val_(val)
  482|  2.11M|            {
  483|  2.11M|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2ERKNS2_17basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagE:
 2554|   994k|            : basic_json(s.data(), s.size(), tag, allocator_type())
 2555|   994k|        {
 2556|   994k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2EPKcmNS_12semantic_tagERKS4_:
 2584|   994k|        {
 2585|   994k|            if (length <= short_string_storage::max_length)
  ------------------
  |  Branch (2585:17): [True: 994k, False: 9]
  ------------------
 2586|   994k|            {
 2587|   994k|                construct<short_string_storage>(s, static_cast<uint8_t>(length), tag);
 2588|   994k|            }
 2589|      9|            else
 2590|      9|            {
 2591|      9|                auto ptr = create_long_string(alloc, s, length);
 2592|      9|                construct<long_string_storage>(ptr, tag);
 2593|      9|            }
 2594|   994k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_20short_string_storageEJRPKchRNS_12semantic_tagEEEEvDpOT0_:
 1000|   994k|        {
 1001|   994k|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|   994k|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE20short_string_storageC2EPKchNS_12semantic_tagE:
  582|   994k|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::short_str)), short_str_length_(length), tag_(tag)
  583|   994k|            {
  584|   994k|                JSONCONS_ASSERT(length <= max_length);
  ------------------
  |  |   45|   994k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 994k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  585|   994k|                std::memcpy(data_,p,length*sizeof(char_type));
  586|   994k|                data_[length] = 0;
  587|   994k|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE18create_long_stringERKS4_PKcm:
  948|      9|        {
  949|      9|            using heap_string_factory_type = jsoncons::heap::heap_string_factory<char_type,null_type,Allocator>;
  950|      9|            return heap_string_factory_type::create(data, length, null_type(), alloc); 
  951|      9|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_19long_string_storageEJRPNS_4heap11heap_stringIcNS_9null_typeES4_EERNS_12semantic_tagEEEEvDpOT0_:
 1000|      9|        {
 1001|      9|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|      9|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE19long_string_storageC2EPNS_4heap11heap_stringIcNS_9null_typeES4_EENS_12semantic_tagE:
  626|      9|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::long_str)), short_str_length_(0), tag_(tag), ptr_(ptr)
  627|      9|            {
  628|      9|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2INS_16byte_string_viewEEENS_17byte_string_arg_tERKT_NS_12semantic_tagENS2_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS9_EE5valueEiE4typeE:
 2724|  2.12M|        {
 2725|  2.12M|            auto bytes = jsoncons::span<const uint8_t>(reinterpret_cast<const uint8_t*>(source.data()), source.size());
 2726|       |            
 2727|  2.12M|            auto ptr = create_byte_string(Allocator(), bytes.data(), bytes.size(), 0);
 2728|  2.12M|            construct<byte_string_storage>(ptr, tag);
 2729|  2.12M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE18create_byte_stringERKS4_PKhmm:
  955|  2.12M|        {
  956|  2.12M|            using heap_string_factory_type = jsoncons::heap::heap_string_factory<uint8_t,uint64_t,Allocator>;
  957|  2.12M|            return heap_string_factory_type::create(data, length, ext_tag, alloc); 
  958|  2.12M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_19byte_string_storageEJRPNS_4heap11heap_stringIhmS4_EERNS_12semantic_tagEEEEvDpOT0_:
 1000|  2.12M|        {
 1001|  2.12M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|  2.12M|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE19byte_string_storageC2EPNS_4heap11heap_stringIhmS4_EENS_12semantic_tagE:
  675|  2.12M|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::byte_str)), short_str_length_(0), tag_(tag), ptr_(ptr)
  676|  2.12M|            {
  677|  2.12M|            }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2INS_16byte_string_viewEEENS_17byte_string_arg_tERKT_NS_12semantic_tagERKS4_NS2_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS9_EE5valueEiE4typeE:
 2736|      1|        {
 2737|      1|            auto bytes = jsoncons::span<const uint8_t>(reinterpret_cast<const uint8_t*>(source.data()), source.size());
 2738|       |
 2739|      1|            auto ptr = create_byte_string(alloc, bytes.data(), bytes.size(), 0);
 2740|      1|            construct<byte_string_storage>(ptr, tag);
 2741|      1|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2INS_16byte_string_viewEEENS_17byte_string_arg_tERKT_mNS2_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS9_EE5valueEiE4typeE:
 2747|     12|        {
 2748|     12|            auto bytes = jsoncons::span<const uint8_t>(reinterpret_cast<const uint8_t*>(source.data()), source.size());
 2749|       |
 2750|     12|            auto ptr = create_byte_string(Allocator(), bytes.data(), bytes.size(), ext_tag);
 2751|     12|            construct<byte_string_storage>(ptr, semantic_tag::ext);
 2752|     12|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_19byte_string_storageEJRPNS_4heap11heap_stringIhmS4_EENS_12semantic_tagEEEEvDpOT0_:
 1000|     12|        {
 1001|     12|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|     12|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2ENS_10half_arg_tEtNS_12semantic_tagE:
 2597|     65|        {
 2598|     65|            construct<half_storage>(val, tag);
 2599|     65|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_12half_storageEJRtRNS_12semantic_tagEEEEvDpOT0_:
 1000|     65|        {
 1001|     65|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
 1002|     65|        }
_ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE12half_storageC2EtNS_12semantic_tagE:
  540|     65|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::half_float)), short_str_length_(0), tag_(tag),
  541|     65|                  val_(val)
  542|     65|            {
  543|     65|            }

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

_ZN8jsoncons12launder_castIPcNS_4heap11heap_stringIcNS_9null_typeENSt3__19allocatorIcEEEEEET_PT0_:
  239|      9|    {
  240|      9|    #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
  241|      9|        return std::launder(reinterpret_cast<T>(u));
  242|       |    #elif defined(__GNUC__) &&  (__GNUC__ * 100 + __GNUC_MINOR__) > 800
  243|       |        return __builtin_launder(reinterpret_cast<T>(u));
  244|       |    #else
  245|       |        return reinterpret_cast<T>(u);
  246|       |    #endif
  247|      9|    }
_ZN8jsoncons12launder_castIPcNS_4heap11heap_stringIhmNSt3__19allocatorIcEEEEEET_PT0_:
  239|  2.12M|    {
  240|  2.12M|    #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
  241|  2.12M|        return std::launder(reinterpret_cast<T>(u));
  242|       |    #elif defined(__GNUC__) &&  (__GNUC__ * 100 + __GNUC_MINOR__) > 800
  243|       |        return __builtin_launder(reinterpret_cast<T>(u));
  244|       |    #else
  245|       |        return reinterpret_cast<T>(u);
  246|       |    #endif
  247|  2.12M|    }
_ZN8jsoncons12launder_castIPNS_4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE9storage_tEcEET_PT0_:
  239|      9|    {
  240|      9|    #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
  241|      9|        return std::launder(reinterpret_cast<T>(u));
  242|       |    #elif defined(__GNUC__) &&  (__GNUC__ * 100 + __GNUC_MINOR__) > 800
  243|       |        return __builtin_launder(reinterpret_cast<T>(u));
  244|       |    #else
  245|       |        return reinterpret_cast<T>(u);
  246|       |    #endif
  247|      9|    }
_ZN8jsoncons12launder_castIPNS_4heap19heap_string_factoryIhmNSt3__19allocatorIcEEE9storage_tEcEET_PT0_:
  239|  2.12M|    {
  240|  2.12M|    #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
  241|  2.12M|        return std::launder(reinterpret_cast<T>(u));
  242|       |    #elif defined(__GNUC__) &&  (__GNUC__ * 100 + __GNUC_MINOR__) > 800
  243|       |        return __builtin_launder(reinterpret_cast<T>(u));
  244|       |    #else
  245|       |        return reinterpret_cast<T>(u);
  246|       |    #endif
  247|  2.12M|    }

_ZN8jsoncons6detail8expectedImNSt3__14errcEEC2IJS3_EEENS0_10unexpect_tEDpOT_:
   66|      1|        : has_value_(false)
   67|      1|    {
   68|      1|        ::new (&error_) E(std::forward<Args>(args)...);
   69|      1|    }
_ZNK8jsoncons6detail8expectedImNSt3__14errcEEcvbEv:
  146|      1|    {
  147|      1|        return has_value_;
  148|      1|    }
_ZN8jsoncons6detail8expectedImNSt3__14errcEED2Ev:
  100|      1|    {
  101|      1|        destroy();
  102|      1|    }
_ZN8jsoncons6detail8expectedImNSt3__14errcEE7destroyEv:
  280|      1|    {
  281|      1|        if (has_value_) 
  ------------------
  |  Branch (281:13): [True: 0, False: 1]
  ------------------
  282|      0|        {
  283|      0|            value_.~T();
  284|      0|            has_value_ = false;
  285|      0|        }
  286|      1|        else
  287|      1|        {
  288|      1|            error_.~E();
  289|      1|        }
  290|      1|    }
_ZN8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEEC2IJRNS4_10error_codeEmmEEENS0_10unexpect_tEDpOT_:
   66|     41|        : has_value_(false)
   67|     41|    {
   68|     41|        ::new (&error_) E(std::forward<Args>(args)...);
   69|     41|    }
_ZN8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEEC2EOS7_:
   52|      2|        : has_value_(true)
   53|      2|    {
   54|      2|        construct(std::move(value));
   55|      2|    }
_ZN8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEE9constructEOS7_:
  274|      2|    {
  275|      2|        ::new (&value_) T(std::move(value));
  276|      2|        has_value_ = true;
  277|      2|    }
_ZNK8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEEcvbEv:
  146|     43|    {
  147|     43|        return has_value_;
  148|     43|    }
_ZNR8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEE5errorEv:
  192|    123|    {
  193|    123|        assert(!has_value_);
  ------------------
  |  Branch (193:9): [True: 123, False: 0]
  ------------------
  194|    123|        return this->error_;
  195|    123|    }
_ZNR8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEEdeEv:
  231|      2|    {
  232|      2|        return this->value_;
  233|      2|    }
_ZN8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEED2Ev:
  100|     43|    {
  101|     43|        destroy();
  102|     43|    }
_ZN8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEE7destroyEv:
  280|     43|    {
  281|     43|        if (has_value_) 
  ------------------
  |  Branch (281:13): [True: 2, False: 41]
  ------------------
  282|      2|        {
  283|      2|            value_.~T();
  284|      2|            has_value_ = false;
  285|      2|        }
  286|     41|        else
  287|     41|        {
  288|     41|            error_.~E();
  289|     41|        }
  290|     43|    }

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

_ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2EPS2_m:
   61|  2.12M|            : data_(data), size_(size)
   62|  2.12M|        {
   63|  2.12M|        }
_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4dataEv:
  111|  2.12M|        {
  112|  2.12M|            return data_;
  113|  2.12M|        }
_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4sizeEv:
  116|  2.12M|        {
  117|  2.12M|            return size_;
  118|  2.12M|        }
_ZNK8jsoncons6detail4spanIKmLm18446744073709551615EE4sizeEv:
  116|     17|        {
  117|     17|            return size_;
  118|     17|        }
_ZNK8jsoncons6detail4spanIhLm18446744073709551615EE4dataEv:
  111|  2.10k|        {
  112|  2.10k|            return data_;
  113|  2.10k|        }
_ZNK8jsoncons6detail4spanIhLm18446744073709551615EE4sizeEv:
  116|  2.10k|        {
  117|  2.10k|            return size_;
  118|  2.10k|        }
_ZN8jsoncons6detail4spanIhLm18446744073709551615EEC2INSt3__16vectorIhNS4_9allocatorIhEEEEEERT_PNS4_9enable_ifIXaaaaaantsr7is_spanIS9_EE5valuentsr10ext_traits12is_std_arrayIS9_EE5valuesr10ext_traits21is_compatible_elementIS9_hEE5valuesr10ext_traits17has_data_and_sizeIS9_EE5valueEvE4typeE:
   68|  2.10k|            : data_(c.data()), size_(c.size())
   69|  2.10k|        {
   70|  2.10k|        }
_ZN8jsoncons6detail4spanIKmLm18446744073709551615EEC2INSt3__16vectorImNS5_9allocatorImEEEEEERT_PNS5_9enable_ifIXaaaaaantsr7is_spanISA_EE5valuentsr10ext_traits12is_std_arrayISA_EE5valuesr10ext_traits21is_compatible_elementISA_S2_EE5valuesr10ext_traits17has_data_and_sizeISA_EE5valueEvE4typeE:
   68|      1|            : data_(c.data()), size_(c.size())
   69|      1|        {
   70|      1|        }
_ZNK8jsoncons6detail4spanIKmLm18446744073709551615EEixEm:
  126|     51|         {
  127|     51|             return data_[index];
  128|     51|         }
_ZNK8jsoncons6detail4spanIKhLm18446744073709551615EEixEm:
  126|      2|         {
  127|      2|             return data_[index];
  128|      2|         }
_ZN8jsoncons6detail4spanItLm18446744073709551615EEC2EPtm:
   61|      4|            : data_(data), size_(size)
   62|      4|        {
   63|      4|        }
_ZNK8jsoncons6detail4spanItLm18446744073709551615EE4sizeEv:
  116|  2.05k|        {
  117|  2.05k|            return size_;
  118|  2.05k|        }
_ZNK8jsoncons6detail4spanItLm18446744073709551615EEixEm:
  126|  3.06k|         {
  127|  3.06k|             return data_[index];
  128|  3.06k|         }
_ZN8jsoncons6detail4spanIjLm18446744073709551615EEC2EPjm:
   61|     88|            : data_(data), size_(size)
   62|     88|        {
   63|     88|        }
_ZNK8jsoncons6detail4spanIjLm18446744073709551615EE4sizeEv:
  116|    352|        {
  117|    352|            return size_;
  118|    352|        }
_ZNK8jsoncons6detail4spanIjLm18446744073709551615EEixEm:
  126|      3|         {
  127|      3|             return data_[index];
  128|      3|         }
_ZN8jsoncons6detail4spanImLm18446744073709551615EEC2EPmm:
   61|    178|            : data_(data), size_(size)
   62|    178|        {
   63|    178|        }
_ZNK8jsoncons6detail4spanImLm18446744073709551615EE4sizeEv:
  116|    736|        {
  117|    736|            return size_;
  118|    736|        }
_ZNK8jsoncons6detail4spanImLm18446744073709551615EEixEm:
  126|     36|         {
  127|     36|             return data_[index];
  128|     36|         }
_ZN8jsoncons6detail4spanIaLm18446744073709551615EEC2EPam:
   61|  1.23k|            : data_(data), size_(size)
   62|  1.23k|        {
   63|  1.23k|        }
_ZNK8jsoncons6detail4spanIaLm18446744073709551615EE4sizeEv:
  116|  3.70k|        {
  117|  3.70k|            return size_;
  118|  3.70k|        }
_ZN8jsoncons6detail4spanIsLm18446744073709551615EEC2EPsm:
   61|     63|            : data_(data), size_(size)
   62|     63|        {
   63|     63|        }
_ZNK8jsoncons6detail4spanIsLm18446744073709551615EE4sizeEv:
  116|    252|        {
  117|    252|            return size_;
  118|    252|        }
_ZN8jsoncons6detail4spanIiLm18446744073709551615EEC2EPim:
   61|     16|            : data_(data), size_(size)
   62|     16|        {
   63|     16|        }
_ZNK8jsoncons6detail4spanIiLm18446744073709551615EE4sizeEv:
  116|  36.9k|        {
  117|  36.9k|            return size_;
  118|  36.9k|        }
_ZNK8jsoncons6detail4spanIiLm18446744073709551615EEixEm:
  126|  55.2k|         {
  127|  55.2k|             return data_[index];
  128|  55.2k|         }
_ZN8jsoncons6detail4spanIlLm18446744073709551615EEC2EPlm:
   61|      4|            : data_(data), size_(size)
   62|      4|        {
   63|      4|        }
_ZNK8jsoncons6detail4spanIlLm18446744073709551615EE4sizeEv:
  116|    520|        {
  117|    520|            return size_;
  118|    520|        }
_ZNK8jsoncons6detail4spanIlLm18446744073709551615EEixEm:
  126|    756|         {
  127|    756|             return data_[index];
  128|    756|         }
_ZN8jsoncons6detail4spanIfLm18446744073709551615EEC2EPfm:
   61|    384|            : data_(data), size_(size)
   62|    384|        {
   63|    384|        }
_ZNK8jsoncons6detail4spanIfLm18446744073709551615EE4sizeEv:
  116|  1.69k|        {
  117|  1.69k|            return size_;
  118|  1.69k|        }
_ZNK8jsoncons6detail4spanIfLm18446744073709551615EEixEm:
  126|    240|         {
  127|    240|             return data_[index];
  128|    240|         }
_ZN8jsoncons6detail4spanIdLm18446744073709551615EEC2EPdm:
   61|    122|            : data_(data), size_(size)
   62|    122|        {
   63|    122|        }
_ZNK8jsoncons6detail4spanIdLm18446744073709551615EE4sizeEv:
  116|    488|        {
  117|    488|            return size_;
  118|    488|        }
_ZNK8jsoncons6detail4spanIKmLm18446744073709551615EE5emptyEv:
  121|      1|        { 
  122|      1|            return size_ == 0; 
  123|      1|        }

_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEEC2ERNS_18basic_json_visitorIcEERKS3_:
  858|     43|            : destination_(std::addressof(visitor)), 
  859|     43|              key_(alloc), key_buffer_(alloc), level_stack_(alloc)
  860|     43|        {
  861|     43|            level_stack_.emplace_back(target_t::destination,container_t::root); // root
  862|     43|        }
_ZN8jsoncons24basic_item_event_visitorIcEC2Ev:
   51|     43|        basic_item_event_visitor() = default;
_ZN8jsoncons24basic_item_event_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  293|   343k|        {
  294|   343k|            visit_begin_array(length, tag, context, ec);
  295|   343k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|   343k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  296|   343k|        }
_ZN8jsoncons24basic_item_event_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  362|  4.36M|        {
  363|  4.36M|            visit_uint64(value, tag, context, ec);
  364|  4.36M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  4.36M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  365|  4.36M|        }
_ZN8jsoncons24basic_item_event_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  299|   343k|        {
  300|   343k|            visit_end_array(context, ec);
  301|   343k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|   343k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  302|   343k|        }
_ZN8jsoncons24basic_item_event_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  371|  3.63M|        {
  372|  3.63M|            visit_int64(value, tag, context, ec);
  373|  3.63M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.63M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  374|  3.63M|        }
_ZN8jsoncons24basic_item_event_visitorIcE10half_valueEtNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  380|  5.07k|        {
  381|  5.07k|            visit_half(value, tag, context, ec);
  382|  5.07k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  5.07k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  383|  5.07k|        }
_ZN8jsoncons24basic_item_event_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  389|  1.46k|        {
  390|  1.46k|            visit_double(value, tag, context, ec);
  391|  1.46k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.46k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  392|  1.46k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5levelC2ENS4_8target_tENS4_11container_tE:
  797|  3.66M|                : state_(state), type_(type), even_odd_(type == container_t::object ? 0 : 1)
  ------------------
  |  Branch (797:57): [True: 3.31M, False: 346k]
  ------------------
  798|  3.66M|            {
  799|  3.66M|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1011|   346k|        {
 1012|   346k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1012:17): [True: 7.10k, False: 338k]
  ------------------
 1013|  7.10k|            {
 1014|  7.10k|                if (level_stack_.back().target() == target_t::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1014:21): [True: 6.95k, False: 149]
  |  Branch (1014:73): [True: 6.88k, False: 74]
  ------------------
 1015|  6.88k|                {
 1016|  6.88k|                    key_buffer_.push_back(',');
 1017|  6.88k|                }
 1018|  7.10k|                level_stack_.emplace_back(target_t::buffer, container_t::array);
 1019|  7.10k|                key_buffer_.push_back('[');
 1020|  7.10k|            }
 1021|   338k|            else
 1022|   338k|            {
 1023|   338k|                switch (level_stack_.back().target())
 1024|   338k|                {
 1025|   337k|                    case target_t::buffer:
  ------------------
  |  Branch (1025:21): [True: 337k, False: 1.44k]
  ------------------
 1026|   337k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1026:29): [True: 330k, False: 7.29k]
  |  Branch (1026:65): [True: 328k, False: 2.14k]
  ------------------
 1027|   328k|                        {
 1028|   328k|                            key_buffer_.push_back(',');
 1029|   328k|                        }
 1030|   337k|                        level_stack_.emplace_back(target_t::buffer, container_t::array);
 1031|   337k|                        key_buffer_.push_back('[');
 1032|   337k|                        break;
 1033|  1.44k|                    default:
  ------------------
  |  Branch (1033:21): [True: 1.44k, False: 337k]
  ------------------
 1034|  1.44k|                        level_stack_.emplace_back(target_t::destination, container_t::array);
 1035|  1.44k|                        destination_->begin_array(length, tag, context, ec);
 1036|  1.44k|                        break;
 1037|   338k|                }
 1038|   338k|            }
 1039|   346k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|   346k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
 1040|   346k|        }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level6is_keyEv:
  814|  53.2M|            {
  815|  53.2M|                return even_odd_ == 0;
  816|  53.2M|            }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level6targetEv:
  824|  35.9M|            {
  825|  35.9M|                return state_;
  826|  35.9M|            }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level5countEv:
  829|  3.57M|            {
  830|  3.57M|                return count_;
  831|  3.57M|            }
_ZNK8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level9is_objectEv:
  819|  22.8M|            {
  820|  22.8M|                return type_ == container_t::object;
  821|  22.8M|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE15visit_end_arrayERKNS_11ser_contextERNS1_10error_codeE:
 1043|   345k|        {
 1044|   345k|            switch (level_stack_.back().target())
 1045|   345k|            {
 1046|   344k|                case target_t::buffer:
  ------------------
  |  Branch (1046:17): [True: 344k, False: 1.42k]
  ------------------
 1047|   344k|                    key_buffer_.push_back(']');
 1048|   344k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   45|   344k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 344k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1049|   344k|                    level_stack_.pop_back();
 1050|   344k|                    if (level_stack_.back().target() == target_t::destination)
  ------------------
  |  Branch (1050:25): [True: 146, False: 344k]
  ------------------
 1051|    146|                    {
 1052|    146|                        destination_->key(key_buffer_, context, ec);
 1053|    146|                        key_buffer_.clear();
 1054|    146|                    }
 1055|   344k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (1055:30): [True: 6.96k, False: 337k]
  ------------------
 1056|  6.96k|                    {
 1057|  6.96k|                        key_buffer_.push_back(':');
 1058|  6.96k|                    }
 1059|   344k|                    level_stack_.back().advance();
 1060|   344k|                    break;
 1061|  1.42k|                default:
  ------------------
  |  Branch (1061:17): [True: 1.42k, False: 344k]
  ------------------
 1062|  1.42k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   45|  1.42k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 1.42k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1063|  1.42k|                    level_stack_.pop_back();
 1064|  1.42k|                    level_stack_.back().advance();
 1065|  1.42k|                    destination_->end_array(context, ec);
 1066|  1.42k|                    break;
 1067|   345k|            }
 1068|   345k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|   345k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
 1069|   345k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE5level7advanceEv:
  802|  19.2M|            {
  803|  19.2M|                if (!is_key())
  ------------------
  |  Branch (803:21): [True: 17.3M, False: 1.95M]
  ------------------
  804|  17.3M|                {
  805|  17.3M|                    ++count_;
  806|  17.3M|                }
  807|  19.2M|                if (is_object())
  ------------------
  |  Branch (807:21): [True: 3.91M, False: 15.3M]
  ------------------
  808|  3.91M|                {
  809|  3.91M|                    even_odd_ = !even_odd_;
  810|  3.91M|                }
  811|  19.2M|            }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1236|  4.36M|        {
 1237|  4.36M|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1237:17): [True: 1.23M, False: 3.13M]
  |  Branch (1237:49): [True: 1.91M, False: 1.21M]
  ------------------
 1238|  3.14M|            {
 1239|  3.14M|                key_.clear();
 1240|  3.14M|                jsoncons::from_integer(value,key_);
 1241|  3.14M|            }
 1242|       |
 1243|  4.36M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1243:17): [True: 1.23M, False: 3.13M]
  ------------------
 1244|  1.23M|            {
 1245|  1.23M|                switch (level_stack_.back().target())
 1246|  1.23M|                {
 1247|   169k|                    case target_t::buffer:
  ------------------
  |  Branch (1247:21): [True: 169k, False: 1.06M]
  ------------------
 1248|   169k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1248:29): [True: 168k, False: 240]
  ------------------
 1249|   168k|                        {
 1250|   168k|                            key_buffer_.push_back(',');
 1251|   168k|                        }
 1252|   169k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1253|   169k|                        key_buffer_.push_back(':');
 1254|   169k|                        break;
 1255|  1.06M|                    default:
  ------------------
  |  Branch (1255:21): [True: 1.06M, False: 169k]
  ------------------
 1256|  1.06M|                        destination_->key(key_, context, ec);
 1257|  1.06M|                        break;
 1258|  1.23M|                }
 1259|  1.23M|            }
 1260|  3.13M|            else
 1261|  3.13M|            {
 1262|  3.13M|                switch (level_stack_.back().target())
 1263|  3.13M|                {
 1264|  1.91M|                    case target_t::buffer:
  ------------------
  |  Branch (1264:21): [True: 1.91M, False: 1.21M]
  ------------------
 1265|  1.91M|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1265:29): [True: 1.74M, False: 169k]
  |  Branch (1265:65): [True: 1.74M, False: 251]
  ------------------
 1266|  1.74M|                        {
 1267|  1.74M|                            key_buffer_.push_back(',');
 1268|  1.74M|                        }
 1269|  1.91M|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1270|  1.91M|                        break;
 1271|  1.21M|                    default:
  ------------------
  |  Branch (1271:21): [True: 1.21M, False: 1.91M]
  ------------------
 1272|  1.21M|                        destination_->uint64_value(value, tag, context, ec);
 1273|  1.21M|                        break;
 1274|  3.13M|                }
 1275|  3.13M|            }
 1276|       |
 1277|  4.36M|            level_stack_.back().advance();
 1278|  4.36M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  4.36M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
 1279|  4.36M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1282|  3.65M|        {
 1283|  3.65M|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1283:17): [True: 234k, False: 3.41M]
  |  Branch (1283:49): [True: 318k, False: 3.10M]
  ------------------
 1284|   552k|            {
 1285|   552k|                key_.clear();
 1286|   552k|                jsoncons::from_integer(value,key_);
 1287|   552k|            }
 1288|       |
 1289|  3.65M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1289:17): [True: 234k, False: 3.41M]
  ------------------
 1290|   234k|            {
 1291|   234k|                switch (level_stack_.back().target())
 1292|   234k|                {
 1293|   231k|                    case target_t::buffer:
  ------------------
  |  Branch (1293:21): [True: 231k, False: 3.58k]
  ------------------
 1294|   231k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1294:29): [True: 231k, False: 74]
  ------------------
 1295|   231k|                        {
 1296|   231k|                            key_buffer_.push_back(',');
 1297|   231k|                        }
 1298|   231k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1299|   231k|                        key_buffer_.push_back(':');
 1300|   231k|                        break;
 1301|  3.58k|                    default:
  ------------------
  |  Branch (1301:21): [True: 3.58k, False: 231k]
  ------------------
 1302|  3.58k|                        destination_->key(key_, context, ec);
 1303|  3.58k|                        break;
 1304|   234k|                }
 1305|   234k|            }
 1306|  3.41M|            else
 1307|  3.41M|            {
 1308|  3.41M|                switch (level_stack_.back().target())
 1309|  3.41M|                {
 1310|   318k|                    case target_t::buffer:
  ------------------
  |  Branch (1310:21): [True: 318k, False: 3.10M]
  ------------------
 1311|   318k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1311:29): [True: 86.6k, False: 231k]
  |  Branch (1311:65): [True: 73.2k, False: 13.3k]
  ------------------
 1312|  73.2k|                        {
 1313|  73.2k|                            key_buffer_.push_back(',');
 1314|  73.2k|                        }
 1315|   318k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1316|   318k|                        break;
 1317|  3.10M|                    default:
  ------------------
  |  Branch (1317:21): [True: 3.10M, False: 318k]
  ------------------
 1318|  3.10M|                        destination_->int64_value(value, tag, context, ec);
 1319|  3.10M|                        break;
 1320|  3.41M|                }
 1321|  3.41M|            }
 1322|       |
 1323|  3.65M|            level_stack_.back().advance();
 1324|  3.65M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.65M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
 1325|  3.65M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1377|  2.56k|        {
 1378|  2.56k|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1378:17): [True: 346, False: 2.22k]
  |  Branch (1378:49): [True: 2.21k, False: 12]
  ------------------
 1379|  2.55k|            {
 1380|  2.55k|                key_.clear();
 1381|  2.55k|                string_sink<string_type> sink(key_);
 1382|  2.55k|                jsoncons::write_double f{float_chars_format::general,0};
 1383|  2.55k|                f(value, sink);
 1384|  2.55k|            }
 1385|       |
 1386|  2.56k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1386:17): [True: 346, False: 2.22k]
  ------------------
 1387|    346|            {
 1388|    346|                switch (level_stack_.back().target())
 1389|    346|                {
 1390|    341|                    case target_t::buffer:
  ------------------
  |  Branch (1390:21): [True: 341, False: 5]
  ------------------
 1391|    341|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1391:29): [True: 113, False: 228]
  ------------------
 1392|    113|                        {
 1393|    113|                            key_buffer_.push_back(',');
 1394|    113|                        }
 1395|    341|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1396|    341|                        key_buffer_.push_back(':');
 1397|    341|                        break;
 1398|      5|                    default:
  ------------------
  |  Branch (1398:21): [True: 5, False: 341]
  ------------------
 1399|      5|                        destination_->key(key_, context, ec);
 1400|      5|                        break;
 1401|    346|                }
 1402|    346|            }
 1403|  2.22k|            else
 1404|  2.22k|            {
 1405|  2.22k|                switch (level_stack_.back().target())
 1406|  2.22k|                {
 1407|  2.21k|                    case target_t::buffer:
  ------------------
  |  Branch (1407:21): [True: 2.21k, False: 12]
  ------------------
 1408|  2.21k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1408:29): [True: 2.07k, False: 133]
  |  Branch (1408:65): [True: 2.05k, False: 20]
  ------------------
 1409|  2.05k|                        {
 1410|  2.05k|                            key_buffer_.push_back(',');
 1411|  2.05k|                        }
 1412|  2.21k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1413|  2.21k|                        break;
 1414|     12|                    default:
  ------------------
  |  Branch (1414:21): [True: 12, False: 2.21k]
  ------------------
 1415|     12|                        destination_->double_value(value, tag, context, ec);
 1416|     12|                        break;
 1417|  2.22k|                }
 1418|  2.22k|            }
 1419|       |
 1420|  2.56k|            level_stack_.back().advance();
 1421|  2.56k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.56k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
 1422|  2.56k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE11visit_flushEv:
  884|      2|        {
  885|      2|            destination_->flush();
  886|      2|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  889|   122k|        {
  890|   122k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (890:17): [True: 61.2k, False: 61.5k]
  ------------------
  891|  61.2k|            {
  892|  61.2k|                if (level_stack_.back().target() == target_t::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (892:21): [True: 61.2k, False: 2]
  |  Branch (892:73): [True: 61.2k, False: 18]
  ------------------
  893|  61.2k|                {
  894|  61.2k|                    key_buffer_.push_back(',');
  895|  61.2k|                }
  896|  61.2k|                level_stack_.emplace_back(target_t::buffer, container_t::object);
  897|  61.2k|                key_buffer_.push_back('{');
  898|  61.2k|            }
  899|  61.5k|            else
  900|  61.5k|            {
  901|  61.5k|                switch (level_stack_.back().target())
  902|  61.5k|                {
  903|  61.4k|                    case target_t::buffer:
  ------------------
  |  Branch (903:21): [True: 61.4k, False: 28]
  ------------------
  904|  61.4k|                        level_stack_.emplace_back(target_t::buffer, container_t::object);
  905|  61.4k|                        key_buffer_.push_back('{');
  906|  61.4k|                        break;
  907|     28|                    default:
  ------------------
  |  Branch (907:21): [True: 28, False: 61.4k]
  ------------------
  908|     28|                        level_stack_.emplace_back(target_t::destination, container_t::object);
  909|     28|                        destination_->begin_object(tag, context, ec);
  910|     28|                        break;
  911|  61.5k|                }
  912|  61.5k|            }
  913|   122k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|   122k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  914|   122k|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  917|  3.19M|        {
  918|  3.19M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (918:17): [True: 1.25k, False: 3.19M]
  ------------------
  919|  1.25k|            {
  920|  1.25k|                if (level_stack_.back().target() == target_t::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (920:21): [True: 662, False: 588]
  |  Branch (920:73): [True: 207, False: 455]
  ------------------
  921|    207|                {
  922|    207|                    key_buffer_.push_back(',');
  923|    207|                }
  924|  1.25k|                level_stack_.emplace_back(target_t::buffer, container_t::object);
  925|  1.25k|                key_buffer_.push_back('{');
  926|  1.25k|            }
  927|  3.19M|            else
  928|  3.19M|            {
  929|  3.19M|                switch (level_stack_.back().target())
  930|  3.19M|                {
  931|  7.91k|                    case target_t::buffer:
  ------------------
  |  Branch (931:21): [True: 7.91k, False: 3.18M]
  ------------------
  932|  7.91k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (932:29): [True: 7.63k, False: 280]
  |  Branch (932:65): [True: 7.61k, False: 19]
  ------------------
  933|  7.61k|                        {
  934|  7.61k|                            key_buffer_.push_back(',');
  935|  7.61k|                        }
  936|  7.91k|                        level_stack_.emplace_back(target_t::buffer, container_t::object);
  937|  7.91k|                        key_buffer_.push_back('{');
  938|  7.91k|                        break;
  939|  3.18M|                    default:
  ------------------
  |  Branch (939:21): [True: 3.18M, False: 7.91k]
  ------------------
  940|  3.18M|                        level_stack_.emplace_back(target_t::destination, container_t::object);
  941|  3.18M|                        destination_->begin_object(length, tag, context, ec);
  942|  3.18M|                        break;
  943|  3.19M|                }
  944|  3.19M|            }
  945|  3.19M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.19M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  946|  3.19M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE16visit_end_objectERKNS_11ser_contextERNS1_10error_codeE:
  949|  3.31M|        {
  950|  3.31M|            switch (level_stack_.back().target())
  951|  3.31M|            {
  952|   131k|                case target_t::buffer:
  ------------------
  |  Branch (952:17): [True: 131k, False: 3.18M]
  ------------------
  953|   131k|                    key_buffer_.push_back('}');
  954|   131k|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   45|   131k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 131k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  955|   131k|                    level_stack_.pop_back();
  956|       |                    
  957|   131k|                    if (level_stack_.back().target() == target_t::destination)
  ------------------
  |  Branch (957:25): [True: 584, False: 131k]
  ------------------
  958|    584|                    {
  959|    584|                        destination_->key(key_buffer_,context, ec);
  960|    584|                        key_buffer_.clear();
  961|    584|                    }
  962|   131k|                    else if (level_stack_.back().is_key())
  ------------------
  |  Branch (962:30): [True: 61.8k, False: 69.2k]
  ------------------
  963|  61.8k|                    {
  964|  61.8k|                        key_buffer_.push_back(':');
  965|  61.8k|                    }
  966|   131k|                    level_stack_.back().advance();
  967|   131k|                    break;
  968|  3.18M|                default:
  ------------------
  |  Branch (968:17): [True: 3.18M, False: 131k]
  ------------------
  969|  3.18M|                    JSONCONS_ASSERT(level_stack_.size() > 1);
  ------------------
  |  |   45|  3.18M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 3.18M]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  970|  3.18M|                    level_stack_.pop_back();
  971|  3.18M|                    level_stack_.back().advance();
  972|  3.18M|                    destination_->end_object(context, ec);
  973|  3.18M|                    break;
  974|  3.31M|            }
  975|  3.31M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.31M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  976|  3.31M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
  979|    117|        {
  980|    117|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (980:17): [True: 18, False: 99]
  ------------------
  981|     18|            {
  982|     18|                if (level_stack_.back().target() == target_t::buffer && level_stack_.back().count() > 0)
  ------------------
  |  Branch (982:21): [True: 15, False: 3]
  |  Branch (982:73): [True: 8, False: 7]
  ------------------
  983|      8|                {
  984|      8|                    key_buffer_.push_back(',');
  985|      8|                }
  986|     18|                level_stack_.emplace_back(target_t::buffer, container_t::array);
  987|     18|                key_buffer_.push_back('[');
  988|     18|            }
  989|     99|            else
  990|     99|            {
  991|     99|                switch (level_stack_.back().target())
  992|     99|                {
  993|     72|                    case target_t::buffer:
  ------------------
  |  Branch (993:21): [True: 72, False: 27]
  ------------------
  994|     72|                        if (level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (994:29): [True: 11, False: 61]
  |  Branch (994:64): [True: 11, False: 0]
  ------------------
  995|     11|                        {
  996|     11|                            key_buffer_.push_back(',');
  997|     11|                        }
  998|     72|                        level_stack_.emplace_back(target_t::buffer, container_t::array);
  999|     72|                        key_buffer_.push_back('[');
 1000|     72|                        break;
 1001|     27|                    default:
  ------------------
  |  Branch (1001:21): [True: 27, False: 72]
  ------------------
 1002|     27|                        level_stack_.emplace_back(target_t::destination, container_t::array);
 1003|     27|                        destination_->begin_array(tag, context, ec);
 1004|     27|                        break;
 1005|     99|                }
 1006|     99|            }
 1007|    117|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|    117|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
 1008|    117|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1478|  1.12M|        {
 1479|  1.12M|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1479:17): [True: 91.6k, False: 1.03M]
  |  Branch (1479:49): [True: 7.30k, False: 1.02M]
  ------------------
 1480|  98.9k|            {
 1481|  98.9k|                key_.clear(); 
 1482|  98.9k|                key_.insert(key_.begin(), null_constant.begin(), null_constant.end());
 1483|  98.9k|            }
 1484|       |
 1485|  1.12M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1485:17): [True: 91.6k, False: 1.03M]
  ------------------
 1486|  91.6k|            {
 1487|  91.6k|                switch (level_stack_.back().target())
 1488|  91.6k|                {
 1489|  7.11k|                    case target_t::buffer:
  ------------------
  |  Branch (1489:21): [True: 7.11k, False: 84.4k]
  ------------------
 1490|  7.11k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1490:29): [True: 7.09k, False: 20]
  ------------------
 1491|  7.09k|                        {
 1492|  7.09k|                            key_buffer_.push_back(',');
 1493|  7.09k|                        }
 1494|  7.11k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1495|  7.11k|                        key_buffer_.push_back(':');
 1496|  7.11k|                        break;
 1497|  84.4k|                    default:
  ------------------
  |  Branch (1497:21): [True: 84.4k, False: 7.11k]
  ------------------
 1498|  84.4k|                        destination_->key(key_, context, ec);
 1499|  84.4k|                        break;
 1500|  91.6k|                }
 1501|  91.6k|            }
 1502|  1.03M|            else
 1503|  1.03M|            {
 1504|  1.03M|                switch (level_stack_.back().target())
 1505|  1.03M|                {
 1506|  7.30k|                    case target_t::buffer:
  ------------------
  |  Branch (1506:21): [True: 7.30k, False: 1.02M]
  ------------------
 1507|  7.30k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1507:29): [True: 389, False: 6.91k]
  |  Branch (1507:65): [True: 385, False: 4]
  ------------------
 1508|    385|                        {
 1509|    385|                            key_buffer_.push_back(',');
 1510|    385|                        }
 1511|  7.30k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1512|  7.30k|                        break;
 1513|  1.02M|                    default:
  ------------------
  |  Branch (1513:21): [True: 1.02M, False: 7.30k]
  ------------------
 1514|  1.02M|                        destination_->null_value(tag, context, ec);
 1515|  1.02M|                        break;
 1516|  1.03M|                }
 1517|  1.03M|            }
 1518|       |
 1519|  1.12M|            level_stack_.back().advance();
 1520|  1.12M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.12M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
 1521|  1.12M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1425|  2.31M|        {
 1426|  2.31M|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1426:17): [True: 101k, False: 2.21M]
  |  Branch (1426:49): [True: 106k, False: 2.11M]
  ------------------
 1427|   207k|            {
 1428|   207k|                key_.clear(); 
 1429|   207k|                if (value)
  ------------------
  |  Branch (1429:21): [True: 198k, False: 8.65k]
  ------------------
 1430|   198k|                {
 1431|   198k|                    key_.insert(key_.begin(), true_constant.begin(), true_constant.end());
 1432|   198k|                }
 1433|  8.65k|                else
 1434|  8.65k|                {
 1435|  8.65k|                    key_.insert(key_.begin(), false_constant.begin(), false_constant.end());
 1436|  8.65k|                }
 1437|   207k|            }
 1438|       |
 1439|  2.31M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1439:17): [True: 101k, False: 2.21M]
  ------------------
 1440|   101k|            {
 1441|   101k|                switch (level_stack_.back().target())
 1442|   101k|                {
 1443|  99.8k|                    case target_t::buffer:
  ------------------
  |  Branch (1443:21): [True: 99.8k, False: 1.32k]
  ------------------
 1444|  99.8k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1444:29): [True: 99.8k, False: 6]
  ------------------
 1445|  99.8k|                        {
 1446|  99.8k|                            key_buffer_.push_back(',');
 1447|  99.8k|                        }
 1448|  99.8k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1449|  99.8k|                        key_buffer_.push_back(':');
 1450|  99.8k|                        break;
 1451|  1.32k|                    default:
  ------------------
  |  Branch (1451:21): [True: 1.32k, False: 99.8k]
  ------------------
 1452|  1.32k|                        destination_->key(key_, context, ec);
 1453|  1.32k|                        break;
 1454|   101k|                }
 1455|   101k|            }
 1456|  2.21M|            else
 1457|  2.21M|            {
 1458|  2.21M|                switch (level_stack_.back().target())
 1459|  2.21M|                {
 1460|   106k|                    case target_t::buffer:
  ------------------
  |  Branch (1460:21): [True: 106k, False: 2.11M]
  ------------------
 1461|   106k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1461:29): [True: 6.47k, False: 99.8k]
  |  Branch (1461:65): [True: 6.46k, False: 12]
  ------------------
 1462|  6.46k|                        {
 1463|  6.46k|                            key_buffer_.push_back(',');
 1464|  6.46k|                        }
 1465|   106k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1466|   106k|                        break;
 1467|  2.11M|                    default:
  ------------------
  |  Branch (1467:21): [True: 2.11M, False: 106k]
  ------------------
 1468|  2.11M|                        destination_->bool_value(value, tag, context, ec);
 1469|  2.11M|                        break;
 1470|  2.21M|                }
 1471|  2.21M|            }
 1472|       |
 1473|  2.31M|            level_stack_.back().advance();
 1474|  2.31M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.31M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
 1475|  2.31M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE12visit_stringERKNS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1075|  1.44M|        {
 1076|  1.44M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1076:17): [True: 218k, False: 1.22M]
  ------------------
 1077|   218k|            {
 1078|   218k|                switch (level_stack_.back().target())
 1079|   218k|                {
 1080|   217k|                    case target_t::buffer:
  ------------------
  |  Branch (1080:21): [True: 217k, False: 182]
  ------------------
 1081|   217k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1081:29): [True: 217k, False: 96]
  ------------------
 1082|   217k|                        {
 1083|   217k|                            key_buffer_.push_back(',');
 1084|   217k|                        }
 1085|   217k|                        key_buffer_.push_back('\"');
 1086|   217k|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1087|   217k|                        key_buffer_.push_back('\"');
 1088|   217k|                        key_buffer_.push_back(':');
 1089|   217k|                        break;
 1090|    182|                    default:
  ------------------
  |  Branch (1090:21): [True: 182, False: 217k]
  ------------------
 1091|    182|                        destination_->key(value, context, ec);
 1092|    182|                        break;
 1093|   218k|                }
 1094|   218k|            }
 1095|  1.22M|            else
 1096|  1.22M|            {
 1097|  1.22M|                switch (level_stack_.back().target())
 1098|  1.22M|                {
 1099|   228k|                    case target_t::buffer:
  ------------------
  |  Branch (1099:21): [True: 228k, False: 994k]
  ------------------
 1100|   228k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1100:29): [True: 10.8k, False: 217k]
  |  Branch (1100:65): [True: 10.7k, False: 41]
  ------------------
 1101|  10.7k|                        {
 1102|  10.7k|                            key_buffer_.push_back(',');
 1103|  10.7k|                        }
 1104|   228k|                        key_buffer_.push_back('\"');
 1105|   228k|                        key_buffer_.insert(key_buffer_.end(), value.begin(), value.end());
 1106|   228k|                        key_buffer_.push_back('\"');
 1107|   228k|                        break;
 1108|   994k|                    default:
  ------------------
  |  Branch (1108:21): [True: 994k, False: 228k]
  ------------------
 1109|   994k|                        destination_->string_value(value, tag, context, ec);
 1110|   994k|                        break;
 1111|  1.22M|                }
 1112|  1.22M|            }
 1113|       |
 1114|  1.44M|            level_stack_.back().advance();
 1115|  1.44M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.44M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
 1116|  1.44M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1122|  2.72M|        {
 1123|  2.72M|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1123:17): [True: 12.0k, False: 2.70M]
  |  Branch (1123:49): [True: 589k, False: 2.12M]
  ------------------
 1124|   601k|            {
 1125|   601k|                key_.clear();
 1126|   601k|                switch (tag)
 1127|   601k|                {
 1128|      0|                    case semantic_tag::base64:
  ------------------
  |  Branch (1128:21): [True: 0, False: 601k]
  ------------------
 1129|      0|                        bytes_to_base64(value.begin(), value.end(), key_);
 1130|      0|                        break;
 1131|      0|                    case semantic_tag::base16:
  ------------------
  |  Branch (1131:21): [True: 0, False: 601k]
  ------------------
 1132|      0|                        bytes_to_base16(value.begin(), value.end(),key_);
 1133|      0|                        break;
 1134|   601k|                    default:
  ------------------
  |  Branch (1134:21): [True: 601k, False: 0]
  ------------------
 1135|   601k|                        bytes_to_base64url(value.begin(), value.end(),key_);
 1136|   601k|                        break;
 1137|   601k|                }
 1138|   601k|            }
 1139|       |
 1140|  2.72M|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1140:17): [True: 12.0k, False: 2.70M]
  ------------------
 1141|  12.0k|            {
 1142|  12.0k|                switch (level_stack_.back().target())
 1143|  12.0k|                {
 1144|  10.8k|                    case target_t::buffer:
  ------------------
  |  Branch (1144:21): [True: 10.8k, False: 1.18k]
  ------------------
 1145|  10.8k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1145:29): [True: 10.7k, False: 157]
  ------------------
 1146|  10.7k|                        {
 1147|  10.7k|                            key_buffer_.push_back(',');
 1148|  10.7k|                        }
 1149|  10.8k|                        key_buffer_.push_back('\"');
 1150|  10.8k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1151|  10.8k|                        key_buffer_.push_back('\"');
 1152|  10.8k|                        key_buffer_.push_back(':');
 1153|  10.8k|                        break;
 1154|  1.18k|                    default:
  ------------------
  |  Branch (1154:21): [True: 1.18k, False: 10.8k]
  ------------------
 1155|  1.18k|                        destination_->key(key_, context, ec);
 1156|  1.18k|                        break;
 1157|  12.0k|                }
 1158|  12.0k|            }
 1159|  2.70M|            else
 1160|  2.70M|            {
 1161|  2.70M|                switch (level_stack_.back().target())
 1162|  2.70M|                {
 1163|   589k|                    case target_t::buffer:
  ------------------
  |  Branch (1163:21): [True: 589k, False: 2.12M]
  ------------------
 1164|   589k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1164:29): [True: 578k, False: 10.9k]
  |  Branch (1164:65): [True: 578k, False: 14]
  ------------------
 1165|   578k|                        {
 1166|   578k|                            key_buffer_.push_back(',');
 1167|   578k|                        }
 1168|   589k|                        key_buffer_.push_back('\"');
 1169|   589k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1170|   589k|                        key_buffer_.push_back('\"');
 1171|   589k|                        break;
 1172|  2.12M|                    default:
  ------------------
  |  Branch (1172:21): [True: 2.12M, False: 589k]
  ------------------
 1173|  2.12M|                        destination_->byte_string_value(value, tag, context, ec);
 1174|  2.12M|                        break;
 1175|  2.70M|                }
 1176|  2.70M|            }
 1177|       |
 1178|  2.72M|            level_stack_.back().advance();
 1179|  2.72M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.72M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
 1180|  2.72M|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS1_10error_codeE:
 1186|    144|        {
 1187|    144|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1187:17): [True: 63, False: 81]
  |  Branch (1187:49): [True: 69, False: 12]
  ------------------
 1188|    132|            {
 1189|    132|                key_.clear();
 1190|    132|                bytes_to_base64url(value.begin(), value.end(),key_);
 1191|    132|            }
 1192|       |
 1193|    144|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1193:17): [True: 63, False: 81]
  ------------------
 1194|     63|            {
 1195|     63|                switch (level_stack_.back().target())
 1196|     63|                {
 1197|     63|                    case target_t::buffer:
  ------------------
  |  Branch (1197:21): [True: 63, False: 0]
  ------------------
 1198|     63|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1198:29): [True: 63, False: 0]
  ------------------
 1199|     63|                        {
 1200|     63|                            key_buffer_.push_back(',');
 1201|     63|                        }
 1202|     63|                        key_buffer_.push_back('\"');
 1203|     63|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1204|     63|                        key_buffer_.push_back('\"');
 1205|     63|                        key_buffer_.push_back(':');
 1206|     63|                        break;
 1207|      0|                    default:
  ------------------
  |  Branch (1207:21): [True: 0, False: 63]
  ------------------
 1208|      0|                        destination_->key(key_, context, ec);
 1209|      0|                        break;
 1210|     63|                }
 1211|     63|            }
 1212|     81|            else
 1213|     81|            {
 1214|     81|                switch (level_stack_.back().target())
 1215|     81|                {
 1216|     69|                    case target_t::buffer:
  ------------------
  |  Branch (1216:21): [True: 69, False: 12]
  ------------------
 1217|     69|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1217:29): [True: 64, False: 5]
  |  Branch (1217:65): [True: 63, False: 1]
  ------------------
 1218|     63|                        {
 1219|     63|                            key_buffer_.push_back(',');
 1220|     63|                        }
 1221|     69|                        key_buffer_.push_back('\"');
 1222|     69|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1223|     69|                        key_buffer_.push_back('\"');
 1224|     69|                        break;
 1225|     12|                    default:
  ------------------
  |  Branch (1225:21): [True: 12, False: 69]
  ------------------
 1226|     12|                        destination_->byte_string_value(value, ext_tag, context, ec);
 1227|     12|                        break;
 1228|     81|                }
 1229|     81|            }
 1230|       |
 1231|    144|            level_stack_.back().advance();
 1232|    144|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|    144|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
 1233|    144|        }
_ZN8jsoncons40basic_item_event_visitor_to_json_visitorIcNSt3__19allocatorIcEEE10visit_halfEtNS_12semantic_tagERKNS_11ser_contextERNS1_10error_codeE:
 1328|  5.07k|        {
 1329|  5.07k|            if (level_stack_.back().is_key() || level_stack_.back().target() == target_t::buffer)
  ------------------
  |  Branch (1329:17): [True: 1.44k, False: 3.63k]
  |  Branch (1329:49): [True: 3.57k, False: 65]
  ------------------
 1330|  5.01k|            {
 1331|  5.01k|                key_.clear();
 1332|  5.01k|                jsoncons::string_sink<string_type> sink(key_);
 1333|  5.01k|                jsoncons::write_double f{float_chars_format::general,0};
 1334|  5.01k|                double x = binary::decode_half(value);
 1335|  5.01k|                f(x, sink);
 1336|  5.01k|            }
 1337|       |
 1338|  5.07k|            if (level_stack_.back().is_key())
  ------------------
  |  Branch (1338:17): [True: 1.44k, False: 3.63k]
  ------------------
 1339|  1.44k|            {
 1340|  1.44k|                switch (level_stack_.back().target())
 1341|  1.44k|                {
 1342|  1.39k|                    case target_t::buffer:
  ------------------
  |  Branch (1342:21): [True: 1.39k, False: 47]
  ------------------
 1343|  1.39k|                        if (level_stack_.back().count() > 0)
  ------------------
  |  Branch (1343:29): [True: 1.39k, False: 5]
  ------------------
 1344|  1.39k|                        {
 1345|  1.39k|                            key_buffer_.push_back(',');
 1346|  1.39k|                        }
 1347|  1.39k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1348|  1.39k|                        key_buffer_.push_back(':');
 1349|  1.39k|                        break;
 1350|     47|                    default:
  ------------------
  |  Branch (1350:21): [True: 47, False: 1.39k]
  ------------------
 1351|     47|                        destination_->key(key_, context, ec);
 1352|     47|                        break;
 1353|  1.44k|                }
 1354|  1.44k|            }
 1355|  3.63k|            else
 1356|  3.63k|            {
 1357|  3.63k|                switch (level_stack_.back().target())
 1358|  3.63k|                {
 1359|  3.57k|                    case target_t::buffer:
  ------------------
  |  Branch (1359:21): [True: 3.57k, False: 65]
  ------------------
 1360|  3.57k|                        if (!level_stack_.back().is_object() && level_stack_.back().count() > 0)
  ------------------
  |  Branch (1360:29): [True: 2.30k, False: 1.26k]
  |  Branch (1360:65): [True: 2.30k, False: 4]
  ------------------
 1361|  2.30k|                        {
 1362|  2.30k|                            key_buffer_.push_back(',');
 1363|  2.30k|                        }
 1364|  3.57k|                        key_buffer_.insert(key_buffer_.end(), key_.begin(), key_.end());
 1365|  3.57k|                        break;
 1366|     65|                    default:
  ------------------
  |  Branch (1366:21): [True: 65, False: 3.57k]
  ------------------
 1367|     65|                        destination_->half_value(value, tag, context, ec);
 1368|     65|                        break;
 1369|  3.63k|                }
 1370|  3.63k|            }
 1371|       |
 1372|  5.07k|            level_stack_.back().advance();
 1373|  5.07k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  5.07k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
 1374|  5.07k|        }
_ZN8jsoncons24basic_item_event_visitorIcE17byte_string_valueINSt3__16vectorIhNS3_9allocatorIhEEEEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeENS3_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS8_EE5valueEiE4typeE:
  342|  2.72M|        {
  343|  2.72M|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  344|  2.72M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.72M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  345|  2.72M|        }
_ZN8jsoncons24basic_item_event_visitorIcE17byte_string_valueINSt3__16vectorIhNS3_9allocatorIhEEEEEEbRKT_mRKNS_11ser_contextERNS3_10error_codeENS3_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS8_EE5valueEiE4typeE:
  353|    144|        {
  354|    144|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), ext_tag, context, ec);
  355|    144|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|    144|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  356|    144|        }
_ZN8jsoncons24basic_item_event_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  322|  2.31M|        {
  323|  2.31M|            visit_bool(value, tag, context, ec);
  324|  2.31M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.31M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  325|  2.31M|        }
_ZN8jsoncons24basic_item_event_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  313|  1.12M|        {
  314|  1.12M|            visit_null(tag, context, ec);
  315|  1.12M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.12M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  316|  1.12M|        }
_ZN8jsoncons24basic_item_event_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  331|  1.44M|        {
  332|  1.44M|            visit_string(value, tag, context, ec);
  333|  1.44M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.44M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  334|  1.44M|        }
_ZN8jsoncons24basic_item_event_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  287|    117|        {
  288|    117|            visit_begin_array(tag, context, ec);
  289|    117|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|    117|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  290|    117|        }
_ZN8jsoncons24basic_item_event_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  266|   122k|        {
  267|   122k|            visit_begin_object(tag, context, ec);
  268|   122k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|   122k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  269|   122k|        }
_ZN8jsoncons24basic_item_event_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  275|  3.19M|        {
  276|  3.19M|            visit_begin_object(length, tag, context, ec);
  277|  3.19M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.19M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  278|  3.19M|        }
_ZN8jsoncons24basic_item_event_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  281|  3.31M|        {
  282|  3.31M|            visit_end_object(context, ec);
  283|  3.31M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.31M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  284|  3.31M|        }
_ZN8jsoncons24basic_item_event_visitorIcE5flushEv:
   56|      2|        {
   57|      2|            visit_flush();
   58|      2|        }

_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEED2Ev:
  107|  1.65k|        {
  108|  1.65k|            flatten_and_destroy();
  109|  1.65k|        }
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE19flatten_and_destroyEv:
  246|  1.65k|        {
  247|  3.01k|            while (!elements_.empty())
  ------------------
  |  Branch (247:20): [True: 1.35k, False: 1.65k]
  ------------------
  248|  1.35k|            {
  249|  1.35k|                value_type current = std::move(elements_.back());
  250|  1.35k|                elements_.pop_back();
  251|  1.35k|                switch (current.storage_kind())
  252|  1.35k|                {
  253|     60|                    case json_storage_kind::array:
  ------------------
  |  Branch (253:21): [True: 60, False: 1.29k]
  ------------------
  254|     60|                    {
  255|     60|                        for (auto&& item : current.array_range())
  ------------------
  |  Branch (255:42): [True: 21, False: 60]
  ------------------
  256|     21|                        {
  257|     21|                            if ((item.storage_kind() == json_storage_kind::array || item.storage_kind() == json_storage_kind::object)
  ------------------
  |  Branch (257:34): [True: 5, False: 16]
  |  Branch (257:85): [True: 0, False: 16]
  ------------------
  258|      5|                                && !item.empty()) // non-empty object or array
  ------------------
  |  Branch (258:36): [True: 5, False: 0]
  ------------------
  259|      5|                            {
  260|      5|                                elements_.push_back(std::move(item));
  261|      5|                            }
  262|     21|                        }
  263|     60|                        current.clear();                           
  264|     60|                        break;
  265|      0|                    }
  266|      5|                    case json_storage_kind::object:
  ------------------
  |  Branch (266:21): [True: 5, False: 1.34k]
  ------------------
  267|      5|                    {
  268|      5|                        for (auto&& kv : current.object_range())
  ------------------
  |  Branch (268:40): [True: 17, False: 5]
  ------------------
  269|     17|                        {
  270|     17|                            if ((kv.value().storage_kind() == json_storage_kind::array || kv.value().storage_kind() == json_storage_kind::object)
  ------------------
  |  Branch (270:34): [True: 0, False: 17]
  |  Branch (270:91): [True: 0, False: 17]
  ------------------
  271|      0|                                && !kv.value().empty()) // non-empty object or array
  ------------------
  |  Branch (271:36): [True: 0, False: 0]
  ------------------
  272|      0|                            {
  273|      0|                                elements_.push_back(std::move(kv.value()));
  274|      0|                            }
  275|     17|                        }
  276|      5|                        current.clear();                           
  277|      5|                        break;
  278|      0|                    }
  279|  1.28k|                    default:
  ------------------
  |  Branch (279:21): [True: 1.28k, False: 65]
  ------------------
  280|  1.28k|                        break;
  281|  1.35k|                }
  282|  1.35k|            }
  283|  1.65k|        }
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE5beginEv:
  220|     60|        iterator begin() {return elements_.begin();}
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE3endEv:
  222|     60|        iterator end() {return elements_.end();}
_ZNK8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE5emptyEv:
  127|     13|        {
  128|     13|            return elements_.empty();
  129|     13|        }
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE5clearEv:
  140|     60|        void clear() {elements_.clear();}
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEEC2ERKS5_:
   51|    191|            : allocator_holder<allocator_type>(alloc), 
   52|    191|              elements_(value_allocator_type(alloc))
   53|    191|        {
   54|    191|        }
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE12emplace_backIJS6_EEERS6_DpOT_:
  215|      2|        {
  216|      2|            elements_.emplace_back(std::forward<Args>(args)...);
  217|      2|            return elements_.back();
  218|      2|        }
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE7reserveEm:
  151|    130|        void reserve(std::size_t n) {elements_.reserve(n);}
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE9push_backIS6_S5_EENS3_9enable_ifIXsr3std16allocator_traitsIT0_E15is_always_equalE5valueEvE4typeEOT_:
  176|  1.36k|        {
  177|  1.36k|            elements_.emplace_back(std::forward<T>(value));
  178|  1.36k|        }
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEEC2Ev:
   47|  1.46k|        {
   48|  1.46k|        }

_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_EC2ERKS5_S9_:
   74|     43|        : allocator_(alloc),
   75|     43|          result_(),
   76|     43|          name_(alloc),
   77|     43|          item_stack_(alloc),
   78|     43|          structure_stack_(temp_alloc)
   79|     43|    {
   80|     43|        item_stack_.reserve(1000);
   81|     43|        structure_stack_.reserve(100);
   82|     43|        structure_stack_.emplace_back(structure_type::root_t, 0);
   83|     43|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E14structure_infoC2ENS7_14structure_typeEm:
   51|  3.18M|            : type_(type), container_index_(offset)
   52|  3.18M|        {
   53|  3.18M|        }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E15visit_end_arrayERKNS_11ser_contextERNS3_10error_codeE:
  179|  1.42k|    {
  180|  1.42k|        JSONCONS_ASSERT(structure_stack_.size() > 1);
  ------------------
  |  |   45|  1.42k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 1.42k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  181|  1.42k|        JSONCONS_ASSERT(structure_stack_.back().type_ == structure_type::array_t);
  ------------------
  |  |   45|  1.42k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 1.42k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  182|  1.42k|        const size_t container_index = structure_stack_.back().container_index_;
  183|  1.42k|        JSONCONS_ASSERT(item_stack_.size() > container_index);
  ------------------
  |  |   45|  1.42k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 1.42k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  184|       |
  185|  1.42k|        auto& container = item_stack_[container_index].value;
  186|       |
  187|  1.42k|        const size_t size = item_stack_.size() - (container_index + 1);
  188|       |        //std::cout << "size on item stack: " << size << "\n";
  189|       |
  190|  1.42k|        if (size > 0)
  ------------------
  |  Branch (190:13): [True: 130, False: 1.29k]
  ------------------
  191|    130|        {
  192|    130|            container.reserve(size);
  193|    130|            auto first = item_stack_.begin() + (container_index+1);
  194|    130|            auto last = first + size;
  195|  1.49k|            for (auto it = first; it != last; ++it)
  ------------------
  |  Branch (195:35): [True: 1.36k, False: 130]
  ------------------
  196|  1.36k|            {
  197|  1.36k|                container.push_back(std::move((*it).value));
  198|  1.36k|            }
  199|    130|            item_stack_.erase(first, item_stack_.end());
  200|    130|        }
  201|       |
  202|  1.42k|        structure_stack_.pop_back();
  203|  1.42k|        if (structure_stack_.back().type_ == structure_type::root_t)
  ------------------
  |  Branch (203:13): [True: 0, False: 1.42k]
  ------------------
  204|      0|        {
  205|      0|            result_.swap(item_stack_.front().value);
  206|      0|            item_stack_.pop_back();
  207|      0|            is_valid_ = true;
  208|      0|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  209|      0|        }
  210|  1.42k|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.42k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  211|  1.42k|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  296|  1.21M|    {
  297|  1.21M|        switch (structure_stack_.back().type_)
  ------------------
  |  Branch (297:17): [True: 1.21M, False: 0]
  ------------------
  298|  1.21M|        {
  299|  1.06M|            case structure_type::object_t:
  ------------------
  |  Branch (299:13): [True: 1.06M, False: 156k]
  ------------------
  300|  1.21M|            case structure_type::array_t:
  ------------------
  |  Branch (300:13): [True: 156k, False: 1.06M]
  ------------------
  301|  1.21M|                item_stack_.emplace_back(std::move(name_), index_++, value, tag);
  302|  1.21M|                break;
  303|      1|            case structure_type::root_t:
  ------------------
  |  Branch (303:13): [True: 1, False: 1.21M]
  ------------------
  304|      1|                result_ = Json(value,tag);
  305|      1|                is_valid_ = true;
  306|      1|                JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      1|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  307|  1.21M|        }
  308|  1.21M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.21M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  309|  1.21M|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  277|  3.10M|    {
  278|  3.10M|        switch (structure_stack_.back().type_)
  ------------------
  |  Branch (278:17): [True: 3.10M, False: 0]
  ------------------
  279|  3.10M|        {
  280|  3.56k|            case structure_type::object_t:
  ------------------
  |  Branch (280:13): [True: 3.56k, False: 3.09M]
  ------------------
  281|  3.10M|            case structure_type::array_t:
  ------------------
  |  Branch (281:13): [True: 3.09M, False: 3.56k]
  ------------------
  282|  3.10M|                item_stack_.emplace_back(std::move(name_), index_++, value, tag);
  283|  3.10M|                break;
  284|      0|            case structure_type::root_t:
  ------------------
  |  Branch (284:13): [True: 0, False: 3.10M]
  ------------------
  285|      0|                result_ = Json(value,tag);
  286|      0|                is_valid_ = true;
  287|      0|                JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  288|  3.10M|        }
  289|  3.10M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.10M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  290|  3.10M|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  334|     12|    {
  335|     12|        switch (structure_stack_.back().type_)
  ------------------
  |  Branch (335:17): [True: 12, False: 0]
  ------------------
  336|     12|        {
  337|      0|            case structure_type::object_t:
  ------------------
  |  Branch (337:13): [True: 0, False: 12]
  ------------------
  338|     12|            case structure_type::array_t:
  ------------------
  |  Branch (338:13): [True: 12, False: 0]
  ------------------
  339|     12|                item_stack_.emplace_back(std::move(name_), index_++, value, tag);
  340|     12|                break;
  341|      0|            case structure_type::root_t:
  ------------------
  |  Branch (341:13): [True: 0, False: 12]
  ------------------
  342|      0|                result_ = Json(value, tag);
  343|      0|                is_valid_ = true;
  344|      0|                JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  345|     12|        }
  346|     12|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     12|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  347|     12|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E11visit_flushEv:
  122|      2|    {
  123|      2|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  126|  3.18M|    {
  127|  3.18M|        if (structure_stack_.back().type_ == structure_type::root_t)
  ------------------
  |  Branch (127:13): [True: 16, False: 3.18M]
  ------------------
  128|     16|        {
  129|     16|            index_ = 0;
  130|     16|            item_stack_.clear();
  131|     16|            is_valid_ = false;
  132|     16|        }
  133|  3.18M|        item_stack_.emplace_back(std::move(name_), index_++, json_object_arg, tag);
  134|  3.18M|        structure_stack_.emplace_back(structure_type::object_t, item_stack_.size()-1);
  135|  3.18M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.18M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  136|  3.18M|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E16visit_end_objectERKNS_11ser_contextERNS3_10error_codeE:
  139|  3.18M|    {
  140|  3.18M|        JSONCONS_ASSERT(structure_stack_.size() > 0);
  ------------------
  |  |   45|  3.18M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 3.18M]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  141|  3.18M|        JSONCONS_ASSERT(structure_stack_.back().type_ == structure_type::object_t);
  ------------------
  |  |   45|  3.18M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 3.18M]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  142|  3.18M|        const size_t structure_index = structure_stack_.back().container_index_;
  143|  3.18M|        JSONCONS_ASSERT(item_stack_.size() > structure_index);
  ------------------
  |  |   45|  3.18M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 3.18M]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  144|  3.18M|        const size_t count = item_stack_.size() - (structure_index + 1);
  145|  3.18M|        auto first = item_stack_.begin() + (structure_index+1);
  146|       |
  147|  3.18M|        if (count > 0)
  ------------------
  |  Branch (147:13): [True: 196, False: 3.18M]
  ------------------
  148|    196|        {
  149|    196|            item_stack_[structure_index].value.template cast<typename Json::object_storage>().value().uninitialized_init(
  150|    196|                &item_stack_[structure_index+1], count);
  151|    196|        }
  152|       |
  153|  3.18M|        item_stack_.erase(first, item_stack_.end());
  154|  3.18M|        structure_stack_.pop_back();
  155|  3.18M|        if (structure_stack_.back().type_ == structure_type::root_t)
  ------------------
  |  Branch (155:13): [True: 0, False: 3.18M]
  ------------------
  156|      0|        {
  157|      0|            result_.swap(item_stack_.front().value);
  158|      0|            item_stack_.pop_back();
  159|      0|            is_valid_ = true;
  160|      0|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  161|      0|        }
  162|  3.18M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.18M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  163|  3.18M|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  166|  1.46k|    {
  167|  1.46k|        if (structure_stack_.back().type_ == structure_type::root_t)
  ------------------
  |  Branch (167:13): [True: 18, False: 1.44k]
  ------------------
  168|     18|        {
  169|     18|            index_ = 0;
  170|     18|            item_stack_.clear();
  171|     18|            is_valid_ = false;
  172|     18|        }
  173|  1.46k|        item_stack_.emplace_back(std::move(name_), index_++, json_array_arg, tag);
  174|  1.46k|        structure_stack_.emplace_back(structure_type::array_t, item_stack_.size()-1);
  175|  1.46k|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.46k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  176|  1.46k|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E9visit_keyERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKNS_11ser_contextERNS3_10error_codeE:
  214|  1.15M|    {
  215|  1.15M|        name_ = key_type(name.data(),name.length(),allocator_);
  216|  1.15M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.15M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  217|  1.15M|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  366|  1.02M|    {
  367|  1.02M|        switch (structure_stack_.back().type_)
  ------------------
  |  Branch (367:17): [True: 1.02M, False: 0]
  ------------------
  368|  1.02M|        {
  369|  84.2k|            case structure_type::object_t:
  ------------------
  |  Branch (369:13): [True: 84.2k, False: 942k]
  ------------------
  370|  1.02M|            case structure_type::array_t:
  ------------------
  |  Branch (370:13): [True: 942k, False: 84.2k]
  ------------------
  371|  1.02M|                item_stack_.emplace_back(std::move(name_), index_++, null_type(), tag);
  372|  1.02M|                break;
  373|      0|            case structure_type::root_t:
  ------------------
  |  Branch (373:13): [True: 0, False: 1.02M]
  ------------------
  374|      0|                result_ = Json(null_type(), tag);
  375|      0|                is_valid_ = true;
  376|      0|                JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  377|  1.02M|        }
  378|  1.02M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.02M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  379|  1.02M|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  350|  2.11M|    {
  351|  2.11M|        switch (structure_stack_.back().type_)
  ------------------
  |  Branch (351:17): [True: 2.11M, False: 0]
  ------------------
  352|  2.11M|        {
  353|  1.13k|            case structure_type::object_t:
  ------------------
  |  Branch (353:13): [True: 1.13k, False: 2.11M]
  ------------------
  354|  2.11M|            case structure_type::array_t:
  ------------------
  |  Branch (354:13): [True: 2.11M, False: 1.13k]
  ------------------
  355|  2.11M|                item_stack_.emplace_back(std::move(name_), index_++, value, tag);
  356|  2.11M|                break;
  357|      0|            case structure_type::root_t:
  ------------------
  |  Branch (357:13): [True: 0, False: 2.11M]
  ------------------
  358|      0|                result_ = Json(value, tag);
  359|      0|                is_valid_ = true;
  360|      0|                JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  361|  2.11M|        }
  362|  2.11M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.11M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  363|  2.11M|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E12visit_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  220|   994k|    {
  221|   994k|        switch (structure_stack_.back().type_)
  ------------------
  |  Branch (221:17): [True: 994k, False: 0]
  ------------------
  222|   994k|        {
  223|    185|            case structure_type::object_t:
  ------------------
  |  Branch (223:13): [True: 185, False: 994k]
  ------------------
  224|   994k|            case structure_type::array_t:
  ------------------
  |  Branch (224:13): [True: 994k, False: 185]
  ------------------
  225|   994k|                item_stack_.emplace_back(std::move(name_), index_++, sv, tag);
  226|   994k|                break;
  227|      0|            case structure_type::root_t:
  ------------------
  |  Branch (227:13): [True: 0, False: 994k]
  ------------------
  228|      0|                result_ = Json(sv, tag, allocator_);
  229|      0|                is_valid_ = true;
  230|      0|                JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  231|   994k|        }
  232|   994k|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|   994k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  233|   994k|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  239|  2.12M|    {
  240|  2.12M|        switch (structure_stack_.back().type_)
  ------------------
  |  Branch (240:17): [True: 2.12M, False: 0]
  ------------------
  241|  2.12M|        {
  242|  1.33k|            case structure_type::object_t:
  ------------------
  |  Branch (242:13): [True: 1.33k, False: 2.11M]
  ------------------
  243|  2.12M|            case structure_type::array_t:
  ------------------
  |  Branch (243:13): [True: 2.11M, False: 1.33k]
  ------------------
  244|  2.12M|                item_stack_.emplace_back(std::move(name_), index_++, byte_string_arg, b, tag);
  245|  2.12M|                break;
  246|      1|            case structure_type::root_t:
  ------------------
  |  Branch (246:13): [True: 1, False: 2.12M]
  ------------------
  247|      1|                result_ = Json(byte_string_arg, b, tag, allocator_);
  248|      1|                is_valid_ = true;
  249|      1|                JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      1|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  250|  2.12M|        }
  251|  2.12M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.12M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  252|  2.12M|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS3_10error_codeE:
  258|     12|    {
  259|     12|        switch (structure_stack_.back().type_)
  ------------------
  |  Branch (259:17): [True: 12, False: 0]
  ------------------
  260|     12|        {
  261|      2|            case structure_type::object_t:
  ------------------
  |  Branch (261:13): [True: 2, False: 10]
  ------------------
  262|     12|            case structure_type::array_t:
  ------------------
  |  Branch (262:13): [True: 10, False: 2]
  ------------------
  263|     12|                item_stack_.emplace_back(std::move(name_), index_++, byte_string_arg, b, ext_tag);
  264|     12|                break;
  265|      0|            case structure_type::root_t:
  ------------------
  |  Branch (265:13): [True: 0, False: 12]
  ------------------
  266|      0|                result_ = Json(byte_string_arg, b, ext_tag, allocator_);
  267|      0|                is_valid_ = true;
  268|      0|                JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  269|     12|        }
  270|     12|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     12|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  271|     12|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E10visit_halfEtNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  315|     65|    {
  316|     65|        switch (structure_stack_.back().type_)
  ------------------
  |  Branch (316:17): [True: 65, False: 0]
  ------------------
  317|     65|        {
  318|     46|            case structure_type::object_t:
  ------------------
  |  Branch (318:13): [True: 46, False: 19]
  ------------------
  319|     65|            case structure_type::array_t:
  ------------------
  |  Branch (319:13): [True: 19, False: 46]
  ------------------
  320|     65|                item_stack_.emplace_back(std::move(name_), index_++, half_arg, value, tag);
  321|     65|                break;
  322|      0|            case structure_type::root_t:
  ------------------
  |  Branch (322:13): [True: 0, False: 65]
  ------------------
  323|      0|                result_ = Json(half_arg, value, tag);
  324|      0|                is_valid_ = true;
  325|      0|                JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  326|     65|        }
  327|     65|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     65|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  328|     65|    }
_ZNK8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E8is_validEv:
  108|      2|    {
  109|      2|        return is_valid_;
  110|      2|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E10get_resultEv:
  113|      2|    {
  114|      2|        JSONCONS_ASSERT(is_valid_);
  ------------------
  |  |   45|      2|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 2]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  115|      2|        is_valid_ = false;
  116|      2|        return std::move(result_);
  117|      2|    }

_ZN8jsoncons14json_exceptionD2Ev:
   27|     41|        virtual ~json_exception() = default;
_ZN8jsoncons9ser_errorC1ENSt3__110error_codeEmm:
  194|     41|            : ec_(ec), line_(line), column_(column)
  195|     41|        {
  196|     41|            err_ = to_what_arg(ec, "", line, column); 
  197|     41|        }
_ZN8jsoncons9ser_error11to_what_argENSt3__110error_codeEPKcmm:
  233|     41|        {
  234|     41|            std::string what_arg(s);
  235|     41|            if (!what_arg.empty())
  ------------------
  |  Branch (235:17): [True: 0, False: 41]
  ------------------
  236|      0|            {
  237|      0|                what_arg.append(": ");
  238|      0|            }
  239|     41|            what_arg.append(ec.message());
  240|     41|            if (line != 0 && column != 0)
  ------------------
  |  Branch (240:17): [True: 0, False: 41]
  |  Branch (240:30): [True: 0, False: 0]
  ------------------
  241|      0|            {
  242|      0|                what_arg.append(" at line ");
  243|      0|                what_arg.append(std::to_string(line));
  244|      0|                what_arg.append(" and column ");
  245|      0|                what_arg.append(std::to_string(column));
  246|      0|            }
  247|     41|            else if (column != 0)
  ------------------
  |  Branch (247:22): [True: 41, False: 0]
  ------------------
  248|     41|            {
  249|     41|                what_arg.append(" at position ");
  250|     41|                what_arg.append(std::to_string(column));
  251|     41|            }
  252|     41|            return what_arg; 
  253|     41|        }

_ZN8jsoncons25make_json_visitor_adaptorINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEEENS_20json_visitor_adaptorIT_T0_vEERSD_:
 1064|     43|{
 1065|     43|    return json_visitor_adaptor<From, To>(to);
 1066|     43|}
_ZN8jsoncons20json_visitor_adaptorINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEvEC2ERSA_:
  983|     43|        : supertype(visitor)
  984|     43|    {
  985|     43|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEEC2ERSA_:
  721|     43|        : destination1_(std::addressof(visitor))
  722|     43|    {
  723|     43|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE:
  777|  1.44k|    {
  778|  1.44k|        destination1_->begin_array(length, tag, context, ec);
  779|  1.44k|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.44k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  780|  1.44k|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE15visit_end_arrayERKNS_11ser_contextERNS6_10error_codeE:
  783|  1.42k|    {
  784|  1.42k|        destination1_->end_array(context, ec);
  785|  1.42k|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.42k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  786|  1.42k|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE:
  825|  1.21M|    {
  826|  1.21M|        destination1_->uint64_value(value, tag, context, ec);
  827|  1.21M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.21M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  828|  1.21M|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE:
  819|  3.10M|    {
  820|  3.10M|        destination1_->int64_value(value, tag, context, ec);
  821|  3.10M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.10M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  822|  3.10M|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE:
  813|     12|    {
  814|     12|        destination1_->double_value(value, tag, context, ec);
  815|     12|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     12|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  816|     12|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE11visit_flushEv:
  738|      2|    {
  739|      2|        destination1_->flush();
  740|      2|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE:
  745|     28|    {
  746|     28|        destination1_->begin_object(tag, context, ec);
  747|     28|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     28|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  748|     28|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE:
  754|  3.18M|    {
  755|  3.18M|        destination1_->begin_object(length, tag, context, ec);
  756|  3.18M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.18M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  757|  3.18M|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE16visit_end_objectERKNS_11ser_contextERNS6_10error_codeE:
  760|  3.18M|    {
  761|  3.18M|        destination1_->end_object(context, ec);
  762|  3.18M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.18M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  763|  3.18M|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE:
  768|     27|    {
  769|     27|        destination1_->begin_array(tag, context, ec);
  770|     27|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     27|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  771|     27|    }
_ZN8jsoncons20json_visitor_adaptorINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEvE9visit_keyERKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEERKNS_11ser_contextERNS6_10error_codeE:
  995|  1.15M|    {
  996|  1.15M|        return destination().key(string_view_type(reinterpret_cast<const to_char_type*>(key.data()),key.size()), context, ec);
  997|  1.15M|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE11destinationEv:
  732|  2.14M|    {
  733|  2.14M|        return *destination1_;
  734|  2.14M|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE:
  837|  1.02M|    {
  838|  1.02M|        destination1_->null_value(tag, context, ec);
  839|  1.02M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.02M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  840|  1.02M|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE:
  831|  2.11M|    {
  832|  2.11M|        destination1_->bool_value(value, tag, context, ec);
  833|  2.11M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.11M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  834|  2.11M|    }
_ZN8jsoncons20json_visitor_adaptorINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEvE12visit_stringERKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE:
 1003|   994k|    {
 1004|   994k|        return destination().string_value(string_view_type(reinterpret_cast<const to_char_type*>(value.data()),value.size()), tag, context, ec);
 1005|   994k|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE17visit_byte_stringERKNS_16byte_string_viewENS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE:
  792|  2.12M|    {
  793|  2.12M|        destination1_->byte_string_value(b, tag, context, ec);
  794|  2.12M|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.12M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  795|  2.12M|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS6_10error_codeE:
  801|     12|    {
  802|     12|        destination1_->byte_string_value(b, ext_tag, context, ec);
  803|     12|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     12|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  804|     12|    }
_ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE10visit_halfEtNS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE:
  807|     65|    {
  808|     65|        destination1_->half_value(value, tag, context, ec);
  809|     65|        JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     65|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  810|     65|    }

_ZNK8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE5emptyEv:
  432|      3|        {
  433|      3|            return members_.empty();
  434|      3|        }
_ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE5clearEv:
  465|      5|        void clear() {members_.clear();}
_ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE5beginEv:
  442|      5|        {
  443|      5|            return members_.begin();
  444|      5|        }
_ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE3endEv:
  447|      5|        {
  448|      5|            return members_.end();
  449|      5|        }
_ZN8jsoncons9key_valueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EEE5valueEv:
  120|    568|        {
  121|    568|            return value_;
  122|    568|        }
_ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEED2Ev:
  427|  3.18M|        {
  428|  3.18M|            flatten_and_destroy();
  429|  3.18M|        }
_ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE19flatten_and_destroyEv:
  986|  3.18M|        {
  987|  3.18M|            if (!members_.empty())
  ------------------
  |  Branch (987:17): [True: 191, False: 3.18M]
  ------------------
  988|    191|            {
  989|    191|                json_array<Json> temp(get_allocator());
  990|       |
  991|    191|                for (auto& kv : members_)
  ------------------
  |  Branch (991:31): [True: 521, False: 191]
  ------------------
  992|    521|                {
  993|    521|                    switch (kv.value().storage_kind())
  994|    521|                    {
  995|      8|                        case json_storage_kind::array:
  ------------------
  |  Branch (995:25): [True: 8, False: 513]
  ------------------
  996|     11|                        case json_storage_kind::object:
  ------------------
  |  Branch (996:25): [True: 3, False: 518]
  ------------------
  997|     11|                            if (!kv.value().empty())
  ------------------
  |  Branch (997:33): [True: 2, False: 9]
  ------------------
  998|      2|                            {
  999|      2|                                temp.emplace_back(std::move(kv.value()));
 1000|      2|                            }
 1001|     11|                            break;
 1002|    510|                        default:
  ------------------
  |  Branch (1002:25): [True: 510, False: 11]
  ------------------
 1003|    510|                            break;
 1004|    521|                    }
 1005|    521|                }
 1006|    191|            }
 1007|  3.18M|        }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2EOS7_:
   49|  26.6M|        index_key_value(index_key_value&&) = default;
_ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEEC2Ev:
  334|  3.18M|        {
  335|  3.18M|        }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEaSEOS7_:
   60|  1.82k|        index_key_value& operator=(index_key_value&&) = default;
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRmRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|  1.21M|            : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|  1.21M|        {
   45|  1.21M|        }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRlRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|  3.10M|            : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|  3.10M|        {
   45|  3.10M|        }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRdRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|     12|            : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|     12|        {
   45|     12|        }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRKNS_17json_object_arg_tERNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|  3.18M|            : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|  3.18M|        {
   45|  3.18M|        }
_ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE18uninitialized_initEPNS_15index_key_valueISA_EEm:
  539|    196|        {
  540|    196|            if (count > 0)
  ------------------
  |  Branch (540:17): [True: 196, False: 0]
  ------------------
  541|    196|            {
  542|    196|                members_.reserve(count);
  543|       |
  544|    196|                std::sort(items, items+count, compare);
  545|    196|                members_.emplace_back(key_type(items[0].name.data(), items[0].name.size(), get_allocator()), std::move(items[0].value));
  546|       |                
  547|  2.13k|                for (std::size_t i = 1; i < count; ++i)
  ------------------
  |  Branch (547:41): [True: 1.93k, False: 196]
  ------------------
  548|  1.93k|                {
  549|  1.93k|                    auto& item = items[i];
  550|  1.93k|                    if (item.name != items[i-1].name)
  ------------------
  |  Branch (550:25): [True: 342, False: 1.59k]
  ------------------
  551|    342|                    {
  552|    342|                        members_.emplace_back(key_type(item.name.data(), item.name.size(), get_allocator()), std::move(item.value));
  553|    342|                    }
  554|  1.93k|                }
  555|    196|            }
  556|    196|        }
_ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE7compareERKNS_15index_key_valueISA_EESG_:
  530|  3.06k|        {
  531|  3.06k|            int comp = item1.name.compare(item2.name); 
  532|  3.06k|            if (comp < 0) return true;
  ------------------
  |  Branch (532:17): [True: 1.26k, False: 1.80k]
  ------------------
  533|  1.80k|            if (comp == 0) return item1.index < item2.index;
  ------------------
  |  Branch (533:17): [True: 1.63k, False: 171]
  ------------------
  534|       |
  535|    171|            return false;
  536|  1.80k|        }
_ZN8jsoncons9key_valueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EEEC2IJSA_EEEOS7_DpOT_:
   86|    538|            : key_(std::move(name)), value_(std::forward<Args>(args)...)
   87|    538|        {
   88|    538|        }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRKNS_16json_array_arg_tERNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|  1.46k|            : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|  1.46k|        {
   45|  1.46k|        }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJNS_9null_typeERNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|  1.02M|            : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|  1.02M|        {
   45|  1.02M|        }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRbRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|  2.11M|            : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|  2.11M|        {
   45|  2.11M|        }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERNS_12semantic_tagEEEEONS3_12basic_stringIcSB_S5_EElDpOT_:
   43|   994k|            : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|   994k|        {
   45|   994k|        }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRKNS_17byte_string_arg_tERKNS_16byte_string_viewERNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|  2.12M|            : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|  2.12M|        {
   45|  2.12M|        }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRKNS_17byte_string_arg_tERKNS_16byte_string_viewERmEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|     12|            : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|     12|        {
   45|     12|        }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRKNS_10half_arg_tERtRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|     65|            : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|     65|        {
   45|     65|        }

_ZN8jsoncons18is_trivial_storageENS_17json_storage_kindE:
  222|  26.6M|    {
  223|  26.6M|        static const uint8_t mask{ uint8_t(json_storage_kind::long_str) & uint8_t(json_storage_kind::byte_str) 
  224|  26.6M|            & uint8_t(json_storage_kind::array) & uint8_t(json_storage_kind::object) };
  225|  26.6M|        return (uint8_t(storage_kind) & mask) != mask;
  226|  26.6M|    }

_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|    129|        basic_json_visitor() = default;
_ZN8jsoncons19typed_array_visitorD2Ev:
   33|    172|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE17visit_begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  560|  1.44k|        {
  561|  1.44k|            visit_begin_array(tag, context, ec);
  562|  1.44k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.44k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  563|  1.44k|        }
_ZN8jsoncons18basic_json_visitorIcE18visit_begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  544|  3.18M|        {
  545|  3.18M|            visit_begin_object(tag, context, ec);
  546|  3.18M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  3.18M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  547|  3.18M|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  345|  2.88k|        {
  346|  2.88k|            visit_begin_array(length, tag, context, ec);
  347|  2.88k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.88k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  348|  2.88k|        }
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|  2.43M|        {
  415|  2.43M|            visit_uint64(value, tag, context, ec);
  416|  2.43M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.43M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  417|  2.43M|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  351|  2.84k|        {
  352|  2.84k|            visit_end_array(context, ec);
  353|  2.84k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.84k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  354|  2.84k|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|  6.20M|        {
  424|  6.20M|            visit_int64(value, tag, context, ec);
  425|  6.20M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  6.20M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  426|  6.20M|        }
_ZN8jsoncons18basic_json_visitorIcE10half_valueEtNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  432|    130|        {
  433|    130|            visit_half(value, tag, context, ec);
  434|    130|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|    130|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  435|    130|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|     24|        {
  442|     24|            visit_double(value, tag, context, ec);
  443|     24|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     24|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  444|     24|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|      4|        {
  109|      4|            visit_flush();
  110|      4|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  318|     56|        {
  319|     56|            visit_begin_object(tag, context, ec);
  320|     56|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     56|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  321|     56|        }
_ZN8jsoncons18basic_json_visitorIcE12begin_objectEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  327|  6.37M|        {
  328|  6.37M|            visit_begin_object(length, tag, context, ec);
  329|  6.37M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  6.37M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  330|  6.37M|        }
_ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE:
  333|  6.37M|        {
  334|  6.37M|            visit_end_object(context, ec);
  335|  6.37M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  6.37M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  336|  6.37M|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  339|     54|        {
  340|     54|            visit_begin_array(tag, context, ec);
  341|     54|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     54|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  342|     54|        }
_ZN8jsoncons18basic_json_visitorIcE3keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE:
  357|  2.30M|        {
  358|  2.30M|            visit_key(name, context, ec);
  359|  2.30M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.30M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  360|  2.30M|        }
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  365|  2.05M|        {
  366|  2.05M|            visit_null(tag, context, ec);
  367|  2.05M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.05M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  368|  2.05M|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  374|  4.22M|        {
  375|  4.22M|            visit_bool(value, tag, context, ec);
  376|  4.22M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  4.22M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  377|  4.22M|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  383|  1.98M|        {
  384|  1.98M|            visit_string(value, tag, context, ec);
  385|  1.98M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.98M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  386|  1.98M|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_NS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeENSB_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  394|  4.24M|        {
  395|  4.24M|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), tag, context, ec);
  396|  4.24M|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  4.24M|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  397|  4.24M|        }
_ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE:
  405|     24|        {
  406|     24|            visit_byte_string(byte_string_view(reinterpret_cast<const uint8_t*>(b.data()),b.size()), ext_tag, context, ec);
  407|     24|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     24|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
  408|     24|        }
_ZN8jsoncons26basic_default_json_visitorIcEC2Ev:
  811|     43|        basic_default_json_visitor() = default;
_ZN8jsoncons19typed_array_visitor11begin_arrayEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
   36|  2.10k|        {
   37|  2.10k|            visit_begin_array(length, tag, context, ec);
   38|  2.10k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.10k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
   39|  2.10k|        }
_ZN8jsoncons19typed_array_visitor9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
   42|  2.10k|        {
   43|  2.10k|            visit_end_array(context, ec);
   44|  2.10k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  2.10k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
   45|  2.10k|        }
_ZN8jsoncons19typed_array_visitor12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
   51|     15|        {
   52|     15|            visit_uint64(value, tag, context, ec);
   53|     15|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|     15|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
   54|     15|        }
_ZN8jsoncons19typed_array_visitor11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
   60|  18.6k|        {
   61|  18.6k|            visit_int64(value, tag, context, ec);
   62|  18.6k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  18.6k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
   63|  18.6k|        }
_ZN8jsoncons19typed_array_visitor12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
   69|  1.10k|        {
   70|  1.10k|            visit_double(value, tag, context, ec);
   71|  1.10k|            JSONCONS_VISITOR_RET_VAL
  ------------------
  |  |  276|  1.10k|#define JSONCONS_VISITOR_RET_VAL return true; 
  ------------------
   72|  1.10k|        }

_ZN8jsoncons11ser_contextD2Ev:
   21|     43|    virtual ~ser_context() = default;
_ZN8jsoncons10read_errorC2ENSt3__110error_codeEmm:
   63|     41|        : ec_{ec}, line_{line}, column_{column}
   64|     41|    {
   65|     41|    }
_ZNK8jsoncons10read_error4codeEv:
   81|     41|    {
   82|     41|        return ec_;
   83|     41|    }
_ZNK8jsoncons10read_error4lineEv:
   89|     41|    {
   90|     41|        return line_;
   91|     41|    }
_ZNK8jsoncons10read_error6columnEv:
   93|     41|    {
   94|     41|        return column_;
   95|     41|    }

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

_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  171|     43|            : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  172|     43|              buffer_size_(default_max_buffer_size)
  173|     43|        {
  174|     43|            buffer_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, buffer_size_);
  175|     43|            data_ = buffer_;
  176|     43|        }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   54|     43|          : std::basic_istream<CharT>(&nb_)
   55|     43|        {
   56|     43|        }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   40|     43|            null_buffer() = default;
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev:
  188|     43|        {
  189|     43|            if (buffer_)
  ------------------
  |  Branch (189:17): [True: 43, False: 0]
  ------------------
  190|     43|            {
  191|     43|                std::allocator_traits<char_allocator_type>::deallocate(alloc_, buffer_, buffer_size_);
  192|     43|            }
  193|     43|        }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE8positionEv:
  281|     41|        {
  282|     41|            return position_;
  283|     41|        }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm:
  343|  20.7M|        {
  344|  20.7M|            std::size_t len = 0;
  345|  20.7M|            if (length_ > 0)
  ------------------
  |  Branch (345:17): [True: 20.7M, False: 548]
  ------------------
  346|  20.7M|            {
  347|  20.7M|                len = (std::min)(length_, length);
  348|  20.7M|                std::memcpy(p, data_, len*sizeof(value_type));
  349|  20.7M|                data_ += len;
  350|  20.7M|                length_ -= len;
  351|  20.7M|                position_ += len;
  352|  20.7M|            }
  353|  20.7M|            if (length - len == 0)
  ------------------
  |  Branch (353:17): [True: 20.7M, False: 700]
  ------------------
  354|  20.7M|            {
  355|  20.7M|                return len;
  356|  20.7M|            }
  357|    700|            else if (length - len < buffer_size_)
  ------------------
  |  Branch (357:22): [True: 603, False: 97]
  ------------------
  358|    603|            {
  359|    603|                fill_buffer();
  360|    603|                if (length_ > 0)
  ------------------
  |  Branch (360:21): [True: 594, False: 9]
  ------------------
  361|    594|                {
  362|    594|                    std::size_t len2 = (std::min)(length_, length-len);
  363|    594|                    std::memcpy(p+len, data_, len2*sizeof(value_type));
  364|    594|                    data_ += len2;
  365|    594|                    length_ -= len2;
  366|    594|                    position_ += len2;
  367|    594|                    len += len2;
  368|    594|                }
  369|    603|                return len;
  370|    603|            }
  371|     97|            else
  372|     97|            {
  373|     97|                if (stream_ptr_->eof())
  ------------------
  |  Branch (373:21): [True: 0, False: 97]
  ------------------
  374|      0|                {
  375|      0|                    length_ = 0;
  376|      0|                    return 0;
  377|      0|                }
  378|     97|                JSONCONS_TRY
  ------------------
  |  |   37|     97|    #define JSONCONS_TRY try
  ------------------
  379|     97|                {
  380|     97|                    std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(p+len), length-len);
  381|     97|                    std::size_t len2 = static_cast<std::size_t>(count);
  382|     97|                    if (len2 < length-len)
  ------------------
  |  Branch (382:25): [True: 2, False: 95]
  ------------------
  383|      2|                    {
  384|      2|                        stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  385|      2|                    }
  386|     97|                    len += len2;
  387|     97|                    position_ += len2;
  388|     97|                    return len;
  389|     97|                }
  390|     97|                JSONCONS_CATCH(const std::exception&)     
  391|     97|                {
  392|      0|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  393|      0|                    return 0;
  394|      0|                }
  395|     97|            }
  396|  20.7M|        }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEv:
  399|  2.10k|        {
  400|  2.10k|            if (stream_ptr_->eof())
  ------------------
  |  Branch (400:17): [True: 11, False: 2.09k]
  ------------------
  401|     11|            {
  402|     11|                length_ = 0;
  403|     11|                return;
  404|     11|            }
  405|       |
  406|  2.09k|            data_ = buffer_;
  407|  2.09k|            JSONCONS_TRY
  ------------------
  |  |   37|  2.09k|    #define JSONCONS_TRY try
  ------------------
  408|  2.09k|            {
  409|  2.09k|                std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(buffer_), buffer_size_);
  410|  2.09k|                length_ = static_cast<std::size_t>(count);
  411|       |
  412|  2.09k|                if (length_ < buffer_size_)
  ------------------
  |  Branch (412:21): [True: 33, False: 2.05k]
  ------------------
  413|     33|                {
  414|     33|                    stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  415|     33|                }
  416|  2.09k|            }
  417|  2.09k|            JSONCONS_CATCH(const std::exception&)     
  418|  2.09k|            {
  419|      0|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  420|      0|                length_ = 0;
  421|      0|            }
  422|  2.09k|        }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_6vectorIhS4_EEEENS2_9enable_ifIXaaaasr3std14is_convertibleIhNT_10value_typeEEE5valuesr10ext_traits11has_reserveISB_EE5valuesr10ext_traits14has_data_exactIPhSB_EE5valueEmE4typeERS5_RSB_m:
  859|  2.77M|        {
  860|  2.77M|            std::size_t unread = length;
  861|       |
  862|  2.77M|            std::size_t n = (std::min)(max_buffer_length, unread);
  863|  2.77M|            while (n > 0 && !source.eof())
  ------------------
  |  Branch (863:20): [True: 3.43k, False: 2.77M]
  |  Branch (863:29): [True: 3.43k, False: 5]
  ------------------
  864|  3.43k|            {
  865|  3.43k|                std::size_t offset = v.size();
  866|  3.43k|                v.resize(v.size()+n);
  867|  3.43k|                std::size_t actual = source.read(v.data()+offset, n);
  868|  3.43k|                unread -= actual;
  869|  3.43k|                n = (std::min)(max_buffer_length, unread);
  870|  3.43k|            }
  871|       |
  872|  2.77M|            return length - unread;
  873|  2.77M|        }
_ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv:
  271|  6.77k|        {
  272|  6.77k|            return length_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:20): [True: 237, False: 6.54k]
  |  Branch (272:36): [True: 12, False: 225]
  ------------------
  273|  6.77k|        }
_ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_12basic_stringIcNS2_11char_traitsIcEENS3_IcEEEEEENS2_9enable_ifIXaaaasr3std14is_convertibleIhNT_10value_typeEEE5valuesr10ext_traits11has_reserveISE_EE5valuentsr10ext_traits14has_data_exactIPhSE_EE5valueEmE4typeERS5_RSE_m:
  882|  1.07M|        {
  883|  1.07M|            std::size_t unread = length;
  884|       |
  885|  1.07M|            std::size_t n = (std::min)(max_buffer_length, unread);
  886|  1.07M|            while (n > 0 && !source.eof())
  ------------------
  |  Branch (886:20): [True: 3.33k, False: 1.07M]
  |  Branch (886:29): [True: 3.33k, False: 7]
  ------------------
  887|  3.33k|            {
  888|  3.33k|                v.reserve(v.size()+n);
  889|  3.33k|                std::size_t actual = 0;
  890|  7.37M|                while (actual < n)
  ------------------
  |  Branch (890:24): [True: 7.36M, False: 3.32k]
  ------------------
  891|  7.36M|                {
  892|  7.36M|                    typename Source::value_type c{};
  893|  7.36M|                    if (source.read(&c,1) != 1)
  ------------------
  |  Branch (893:25): [True: 7, False: 7.36M]
  ------------------
  894|      7|                    {
  895|      7|                        break;
  896|      7|                    }
  897|  7.36M|                    v.push_back(c);
  898|  7.36M|                    ++actual;
  899|  7.36M|                }
  900|  3.33k|                unread -= actual;
  901|  3.33k|                n = (std::min)(max_buffer_length, unread);
  902|  3.33k|            }
  903|       |
  904|  1.07M|            return length - unread;
  905|  1.07M|        }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4peekEv:
  311|  67.7M|        {
  312|  67.7M|            if (length_ == 0)
  ------------------
  |  Branch (312:17): [True: 1.49k, False: 67.7M]
  ------------------
  313|  1.49k|            {
  314|  1.49k|                fill_buffer();
  315|  1.49k|            }
  316|  67.7M|            if (length_ > 0)
  ------------------
  |  Branch (316:17): [True: 67.7M, False: 16]
  ------------------
  317|  67.7M|            {
  318|  67.7M|                value_type c = *data_;
  319|  67.7M|                return char_result<value_type>{c, false};
  320|  67.7M|            }
  321|     16|            else
  322|     16|            {
  323|     16|                return char_result<value_type>{0, true};
  324|     16|            }
  325|  67.7M|        }
_ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE6ignoreEm:
  286|  10.5M|        {
  287|  10.5M|            std::size_t len = 0;
  288|  10.5M|            if (length_ > 0)
  ------------------
  |  Branch (288:17): [True: 10.5M, False: 0]
  ------------------
  289|  10.5M|            {
  290|  10.5M|                len = (std::min)(length_, length);
  291|  10.5M|                position_ += len;
  292|  10.5M|                data_ += len;
  293|  10.5M|                length_ -= len;
  294|  10.5M|            }
  295|  10.5M|            while (len < length)
  ------------------
  |  Branch (295:20): [True: 0, False: 10.5M]
  ------------------
  296|      0|            {
  297|      0|                fill_buffer();
  298|      0|                if (length_ == 0)
  ------------------
  |  Branch (298:21): [True: 0, False: 0]
  ------------------
  299|      0|                {
  300|      0|                    break;
  301|      0|                }
  302|      0|                std::size_t len2 = (std::min)(length_, length-len);
  303|      0|                position_ += len2;
  304|      0|                data_ += len2;
  305|      0|                length_ -= len2;
  306|      0|                len += len2;
  307|      0|            }
  308|  10.5M|        }

_ZN8jsoncons16typed_array_castIKhEENS_6detail4spanIT_Lm18446744073709551615EEENS3_IhLm18446744073709551615EEE:
  140|     12|{
  141|     12|    return jsoncons::span<const uint8_t>{reinterpret_cast<const uint8_t*>(bytes.data()), bytes.size()};
  142|     12|}
_ZN8jsoncons20typed_array_iteratorD2Ev:
  247|  2.10k|    virtual ~typed_array_iterator() = default;
_ZN8jsoncons20typed_array_iterator11write_valueIhEENSt3__19enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueEvE4typeES4_NS_12semantic_tagERNS_19typed_array_visitorERKNS_11ser_contextERNS2_10error_codeE:
  266|      2|    {
  267|      2|        visitor.uint64_value(val, tag, context, ec);
  268|      2|    }
_ZN8jsoncons31sequential_typed_array_iteratorIKhNS_8identityEEC2ENS_6detail4spanIS1_Lm18446744073709551615EEENS_12semantic_tagES2_:
  291|     12|        : data_(data), tag_(tag), func_(func)
  292|     12|    {
  293|     12|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIKhNS_8identityEE4doneEv:
  295|     28|    {
  296|     28|        return done_;
  297|     28|    }
_ZN8jsoncons31sequential_typed_array_iteratorIKhNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  301|     26|    {
  302|     26|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|     26|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 12, False: 14]
  |  |  ------------------
  ------------------
  303|     12|        {
  304|     12|            visitor.begin_array(data_.size(), tag_, context, ec);
  305|     12|            first_ = false;
  306|     12|        }
  307|     14|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|     14|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 2, False: 12]
  |  |  ------------------
  ------------------
  308|      2|        {
  309|      2|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  310|      2|            ++index_;
  311|      2|        }
  312|     12|        else if (!done_)
  ------------------
  |  Branch (312:18): [True: 12, False: 0]
  ------------------
  313|     12|        {
  314|     12|            visitor.end_array(context, ec);
  315|     12|            done_ = true;
  316|     12|        }
  317|     26|    }
_ZN8jsoncons16typed_array_castItEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   86|      4|{
   87|      4|    return jsoncons::span<uint16_t>{reinterpret_cast<uint16_t*>(bytes.data()), bytes.size()/sizeof(uint16_t)};
   88|      4|}
_ZN8jsoncons16typed_array_castIjEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   92|     88|{
   93|     88|    return jsoncons::span<uint32_t>{reinterpret_cast<uint32_t*>(bytes.data()), bytes.size()/sizeof(uint32_t)};
   94|     88|}
_ZN8jsoncons20typed_array_iterator11write_valueIjEENSt3__19enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueEvE4typeES4_NS_12semantic_tagERNS_19typed_array_visitorERKNS_11ser_contextERNS2_10error_codeE:
  266|      1|    {
  267|      1|        visitor.uint64_value(val, tag, context, ec);
  268|      1|    }
_ZN8jsoncons31sequential_typed_array_iteratorIjNS_8identityEEC2ENS_6detail4spanIjLm18446744073709551615EEENS_12semantic_tagES1_:
  291|     88|        : data_(data), tag_(tag), func_(func)
  292|     88|    {
  293|     88|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIjNS_8identityEE4doneEv:
  295|    178|    {
  296|    178|        return done_;
  297|    178|    }
_ZN8jsoncons31sequential_typed_array_iteratorIjNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  301|    177|    {
  302|    177|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|    177|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 88, False: 89]
  |  |  ------------------
  ------------------
  303|     88|        {
  304|     88|            visitor.begin_array(data_.size(), tag_, context, ec);
  305|     88|            first_ = false;
  306|     88|        }
  307|     89|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|     89|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 1, False: 88]
  |  |  ------------------
  ------------------
  308|      1|        {
  309|      1|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  310|      1|            ++index_;
  311|      1|        }
  312|     88|        else if (!done_)
  ------------------
  |  Branch (312:18): [True: 88, False: 0]
  ------------------
  313|     88|        {
  314|     88|            visitor.end_array(context, ec);
  315|     88|            done_ = true;
  316|     88|        }
  317|    177|    }
_ZN8jsoncons16typed_array_castImEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
   98|    178|{
   99|    178|    return jsoncons::span<uint64_t>{reinterpret_cast<uint64_t*>(bytes.data()), bytes.size()/sizeof(uint64_t)};
  100|    178|}
_ZN8jsoncons20typed_array_iterator11write_valueImEENSt3__19enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueEvE4typeES4_NS_12semantic_tagERNS_19typed_array_visitorERKNS_11ser_contextERNS2_10error_codeE:
  266|     12|    {
  267|     12|        visitor.uint64_value(val, tag, context, ec);
  268|     12|    }
_ZN8jsoncons31sequential_typed_array_iteratorImNS_8identityEEC2ENS_6detail4spanImLm18446744073709551615EEENS_12semantic_tagES1_:
  291|    178|        : data_(data), tag_(tag), func_(func)
  292|    178|    {
  293|    178|    }
_ZNK8jsoncons31sequential_typed_array_iteratorImNS_8identityEE4doneEv:
  295|    380|    {
  296|    380|        return done_;
  297|    380|    }
_ZN8jsoncons31sequential_typed_array_iteratorImNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  301|    368|    {
  302|    368|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|    368|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 178, False: 190]
  |  |  ------------------
  ------------------
  303|    178|        {
  304|    178|            visitor.begin_array(data_.size(), tag_, context, ec);
  305|    178|            first_ = false;
  306|    178|        }
  307|    190|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|    190|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 12, False: 178]
  |  |  ------------------
  ------------------
  308|     12|        {
  309|     12|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  310|     12|            ++index_;
  311|     12|        }
  312|    178|        else if (!done_)
  ------------------
  |  Branch (312:18): [True: 178, False: 0]
  ------------------
  313|    178|        {
  314|    178|            visitor.end_array(context, ec);
  315|    178|            done_ = true;
  316|    178|        }
  317|    368|    }
_ZN8jsoncons16typed_array_castIaEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  104|  1.23k|{
  105|  1.23k|    return jsoncons::span<int8_t>{reinterpret_cast<int8_t*>(bytes.data()), bytes.size()};
  106|  1.23k|}
_ZN8jsoncons31sequential_typed_array_iteratorIaNS_8identityEEC2ENS_6detail4spanIaLm18446744073709551615EEENS_12semantic_tagES1_:
  291|  1.23k|        : data_(data), tag_(tag), func_(func)
  292|  1.23k|    {
  293|  1.23k|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIaNS_8identityEE4doneEv:
  295|  2.46k|    {
  296|  2.46k|        return done_;
  297|  2.46k|    }
_ZN8jsoncons31sequential_typed_array_iteratorIaNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  301|  2.46k|    {
  302|  2.46k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|  2.46k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.23k, False: 1.23k]
  |  |  ------------------
  ------------------
  303|  1.23k|        {
  304|  1.23k|            visitor.begin_array(data_.size(), tag_, context, ec);
  305|  1.23k|            first_ = false;
  306|  1.23k|        }
  307|  1.23k|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|  1.23k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 0, False: 1.23k]
  |  |  ------------------
  ------------------
  308|      0|        {
  309|      0|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  310|      0|            ++index_;
  311|      0|        }
  312|  1.23k|        else if (!done_)
  ------------------
  |  Branch (312:18): [True: 1.23k, False: 0]
  ------------------
  313|  1.23k|        {
  314|  1.23k|            visitor.end_array(context, ec);
  315|  1.23k|            done_ = true;
  316|  1.23k|        }
  317|  2.46k|    }
_ZN8jsoncons16typed_array_castIsEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  110|     63|{
  111|     63|    return jsoncons::span<int16_t>{reinterpret_cast<int16_t*>(bytes.data()), bytes.size()/sizeof(int16_t)};
  112|     63|}
_ZN8jsoncons31sequential_typed_array_iteratorIsNS_8identityEEC2ENS_6detail4spanIsLm18446744073709551615EEENS_12semantic_tagES1_:
  291|     63|        : data_(data), tag_(tag), func_(func)
  292|     63|    {
  293|     63|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIsNS_8identityEE4doneEv:
  295|    126|    {
  296|    126|        return done_;
  297|    126|    }
_ZN8jsoncons31sequential_typed_array_iteratorIsNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  301|    126|    {
  302|    126|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|    126|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 63, False: 63]
  |  |  ------------------
  ------------------
  303|     63|        {
  304|     63|            visitor.begin_array(data_.size(), tag_, context, ec);
  305|     63|            first_ = false;
  306|     63|        }
  307|     63|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|     63|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 0, False: 63]
  |  |  ------------------
  ------------------
  308|      0|        {
  309|      0|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  310|      0|            ++index_;
  311|      0|        }
  312|     63|        else if (!done_)
  ------------------
  |  Branch (312:18): [True: 63, False: 0]
  ------------------
  313|     63|        {
  314|     63|            visitor.end_array(context, ec);
  315|     63|            done_ = true;
  316|     63|        }
  317|    126|    }
_ZN8jsoncons16typed_array_castIiEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  116|     16|{
  117|     16|    return jsoncons::span<int32_t>{reinterpret_cast<int32_t*>(bytes.data()), bytes.size()/sizeof(int32_t)};
  118|     16|}
_ZN8jsoncons20typed_array_iterator11write_valueIiEENSt3__19enable_ifIXsr10ext_traits17is_signed_integerIT_EE5valueEvE4typeES4_NS_12semantic_tagERNS_19typed_array_visitorERKNS_11ser_contextERNS2_10error_codeE:
  258|  18.4k|    {
  259|  18.4k|        visitor.int64_value(val, tag, context, ec);
  260|  18.4k|    }
_ZN8jsoncons31sequential_typed_array_iteratorIiNS_8identityEEC2ENS_6detail4spanIiLm18446744073709551615EEENS_12semantic_tagES1_:
  291|     16|        : data_(data), tag_(tag), func_(func)
  292|     16|    {
  293|     16|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIiNS_8identityEE4doneEv:
  295|  36.8k|    {
  296|  36.8k|        return done_;
  297|  36.8k|    }
_ZN8jsoncons31sequential_typed_array_iteratorIiNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  301|  18.4k|    {
  302|  18.4k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|  18.4k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 16, False: 18.4k]
  |  |  ------------------
  ------------------
  303|     16|        {
  304|     16|            visitor.begin_array(data_.size(), tag_, context, ec);
  305|     16|            first_ = false;
  306|     16|        }
  307|  18.4k|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|  18.4k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 18.4k, False: 16]
  |  |  ------------------
  ------------------
  308|  18.4k|        {
  309|  18.4k|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  310|  18.4k|            ++index_;
  311|  18.4k|        }
  312|     16|        else if (!done_)
  ------------------
  |  Branch (312:18): [True: 16, False: 0]
  ------------------
  313|     16|        {
  314|     16|            visitor.end_array(context, ec);
  315|     16|            done_ = true;
  316|     16|        }
  317|  18.4k|    }
_ZN8jsoncons16typed_array_castIlEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  122|      4|{
  123|      4|    return jsoncons::span<int64_t>{reinterpret_cast<int64_t*>(bytes.data()), bytes.size()/sizeof(int64_t)};
  124|      4|}
_ZN8jsoncons20typed_array_iterator11write_valueIlEENSt3__19enable_ifIXsr10ext_traits17is_signed_integerIT_EE5valueEvE4typeES4_NS_12semantic_tagERNS_19typed_array_visitorERKNS_11ser_contextERNS2_10error_codeE:
  258|    252|    {
  259|    252|        visitor.int64_value(val, tag, context, ec);
  260|    252|    }
_ZN8jsoncons31sequential_typed_array_iteratorIlNS_8identityEEC2ENS_6detail4spanIlLm18446744073709551615EEENS_12semantic_tagES1_:
  291|      4|        : data_(data), tag_(tag), func_(func)
  292|      4|    {
  293|      4|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIlNS_8identityEE4doneEv:
  295|    512|    {
  296|    512|        return done_;
  297|    512|    }
_ZN8jsoncons31sequential_typed_array_iteratorIlNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  301|    260|    {
  302|    260|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|    260|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 256]
  |  |  ------------------
  ------------------
  303|      4|        {
  304|      4|            visitor.begin_array(data_.size(), tag_, context, ec);
  305|      4|            first_ = false;
  306|      4|        }
  307|    256|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|    256|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 252, False: 4]
  |  |  ------------------
  ------------------
  308|    252|        {
  309|    252|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  310|    252|            ++index_;
  311|    252|        }
  312|      4|        else if (!done_)
  ------------------
  |  Branch (312:18): [True: 4, False: 0]
  ------------------
  313|      4|        {
  314|      4|            visitor.end_array(context, ec);
  315|      4|            done_ = true;
  316|      4|        }
  317|    260|    }
_ZN8jsoncons31sequential_typed_array_iteratorItNS_11decode_halfEEC2ENS_6detail4spanItLm18446744073709551615EEENS_12semantic_tagES1_:
  291|      4|        : data_(data), tag_(tag), func_(func)
  292|      4|    {
  293|      4|    }
_ZNK8jsoncons31sequential_typed_array_iteratorItNS_11decode_halfEE4doneEv:
  295|  2.04k|    {
  296|  2.04k|        return done_;
  297|  2.04k|    }
_ZN8jsoncons31sequential_typed_array_iteratorItNS_11decode_halfEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  301|  1.02k|    {
  302|  1.02k|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|  1.02k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 1.02k]
  |  |  ------------------
  ------------------
  303|      4|        {
  304|      4|            visitor.begin_array(data_.size(), tag_, context, ec);
  305|      4|            first_ = false;
  306|      4|        }
  307|  1.02k|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|  1.02k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 1.02k, False: 4]
  |  |  ------------------
  ------------------
  308|  1.02k|        {
  309|  1.02k|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  310|  1.02k|            ++index_;
  311|  1.02k|        }
  312|      4|        else if (!done_)
  ------------------
  |  Branch (312:18): [True: 4, False: 0]
  ------------------
  313|      4|        {
  314|      4|            visitor.end_array(context, ec);
  315|      4|            done_ = true;
  316|      4|        }
  317|  1.02k|    }
_ZN8jsoncons20typed_array_iterator11write_valueIdEENSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEvE4typeES4_NS_12semantic_tagERNS_19typed_array_visitorERKNS_11ser_contextERNS2_10error_codeE:
  274|  1.02k|    {
  275|  1.02k|        visitor.double_value(val, tag, context, ec);
  276|  1.02k|    }
_ZN8jsoncons16typed_array_castIfEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  128|    384|{
  129|    384|    return jsoncons::span<float>{reinterpret_cast<float*>(bytes.data()), bytes.size()/sizeof(float)};
  130|    384|}
_ZN8jsoncons20typed_array_iterator11write_valueIfEENSt3__19enable_ifIXsr17is_floating_pointIT_EE5valueEvE4typeES4_NS_12semantic_tagERNS_19typed_array_visitorERKNS_11ser_contextERNS2_10error_codeE:
  274|     80|    {
  275|     80|        visitor.double_value(val, tag, context, ec);
  276|     80|    }
_ZN8jsoncons31sequential_typed_array_iteratorIfNS_8identityEEC2ENS_6detail4spanIfLm18446744073709551615EEENS_12semantic_tagES1_:
  291|    384|        : data_(data), tag_(tag), func_(func)
  292|    384|    {
  293|    384|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIfNS_8identityEE4doneEv:
  295|    928|    {
  296|    928|        return done_;
  297|    928|    }
_ZN8jsoncons31sequential_typed_array_iteratorIfNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  301|    848|    {
  302|    848|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|    848|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 384, False: 464]
  |  |  ------------------
  ------------------
  303|    384|        {
  304|    384|            visitor.begin_array(data_.size(), tag_, context, ec);
  305|    384|            first_ = false;
  306|    384|        }
  307|    464|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|    464|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 80, False: 384]
  |  |  ------------------
  ------------------
  308|     80|        {
  309|     80|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  310|     80|            ++index_;
  311|     80|        }
  312|    384|        else if (!done_)
  ------------------
  |  Branch (312:18): [True: 384, False: 0]
  ------------------
  313|    384|        {
  314|    384|            visitor.end_array(context, ec);
  315|    384|            done_ = true;
  316|    384|        }
  317|    848|    }
_ZN8jsoncons16typed_array_castIdEENS_6detail4spanIT_Lm18446744073709551615EEENS2_IhLm18446744073709551615EEE:
  134|    122|{
  135|    122|    return jsoncons::span<double>{reinterpret_cast<double*>(bytes.data()), bytes.size()/sizeof(double)};
  136|    122|}
_ZN8jsoncons31sequential_typed_array_iteratorIdNS_8identityEEC2ENS_6detail4spanIdLm18446744073709551615EEENS_12semantic_tagES1_:
  291|    122|        : data_(data), tag_(tag), func_(func)
  292|    122|    {
  293|    122|    }
_ZNK8jsoncons31sequential_typed_array_iteratorIdNS_8identityEE4doneEv:
  295|    244|    {
  296|    244|        return done_;
  297|    244|    }
_ZN8jsoncons31sequential_typed_array_iteratorIdNS_8identityEE4nextERNS_19typed_array_visitorERKNS_11ser_contextERNSt3__110error_codeE:
  301|    244|    {
  302|    244|        if (JSONCONS_UNLIKELY(first_))
  ------------------
  |  |   78|    244|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 122, False: 122]
  |  |  ------------------
  ------------------
  303|    122|        {
  304|    122|            visitor.begin_array(data_.size(), tag_, context, ec);
  305|    122|            first_ = false;
  306|    122|        }
  307|    122|        else if (JSONCONS_LIKELY(index_ < data_.size()))
  ------------------
  |  |   77|    122|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 0, False: 122]
  |  |  ------------------
  ------------------
  308|      0|        {
  309|      0|            this->write_value(func_(data_[index_]), semantic_tag::none, visitor, context, ec);
  310|      0|            ++index_;
  311|      0|        }
  312|    122|        else if (!done_)
  ------------------
  |  Branch (312:18): [True: 122, False: 0]
  ------------------
  313|    122|        {
  314|    122|            visitor.end_array(context, ec);
  315|    122|            done_ = true;
  316|    122|        }
  317|    244|    }
_ZN8jsoncons22calculate_mdarray_sizeENS_6detail4spanIKmLm18446744073709551615EEE:
  322|      1|{
  323|      1|    using result_type = jsoncons::expected<std::size_t,std::errc>;
  324|       |
  325|      1|    if (extents.empty())
  ------------------
  |  Branch (325:9): [True: 0, False: 1]
  ------------------
  326|      0|    {
  327|      0|        return result_type(0);
  328|      0|    }
  329|      1|    std::size_t n = extents[0];
  330|     17|    for (std::size_t i = 1; i < extents.size(); ++i)
  ------------------
  |  Branch (330:29): [True: 17, False: 0]
  ------------------
  331|     17|    {
  332|     17|        if (extents[i] == 0 || JSONCONS_UNLIKELY(n > (std::numeric_limits<std::size_t>::max)()/extents[i]))
  ------------------
  |  |   78|     17|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 16]
  |  |  ------------------
  ------------------
  |  Branch (332:13): [True: 0, False: 17]
  ------------------
  333|      1|        {
  334|      1|            return result_type(jsoncons::unexpect, std::errc::value_too_large);
  335|      1|        }
  336|     16|        n *= extents[i];
  337|     16|    }
  338|      0|    return n;
  339|      1|}

_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE13from_bytes_beEiPKhm:
  801|    147|    {
  802|    147|        static const double radix_log2 = std::log2(next_power_of_two(256));
  803|       |        // Estimate how big the result will be, so we can pre-allocate it.
  804|    147|        double bits = radix_log2 * n;
  805|    147|        double big_digits = std::ceil(bits / 64.0);
  806|       |        //std::cout << "ESTIMATED: " << big_digits << "\n";
  807|       |
  808|    147|        basic_bigint<Allocator> v = 0;
  809|    147|        v.reserve(static_cast<size_type>(big_digits));
  810|       |
  811|    147|        if (n > 0)
  ------------------
  |  Branch (811:13): [True: 143, False: 4]
  ------------------
  812|    143|        {
  813|  1.36k|            for (size_type i = 0; i < n; i++)
  ------------------
  |  Branch (813:35): [True: 1.21k, False: 143]
  ------------------
  814|  1.21k|            {
  815|  1.21k|                v = (v * 256) + (word_type)(str[i]);
  816|  1.21k|            }
  817|    143|        }
  818|       |        //std::cout << "ACTUAL: " << v.size() << "\n";
  819|       |
  820|    147|        if (signum < 0)
  ------------------
  |  Branch (820:13): [True: 0, False: 147]
  ------------------
  821|      0|        {
  822|      0|            v.set_negative(true);
  823|      0|        }
  824|       |
  825|    147|        return v;
  826|    147|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE17next_power_of_twoEm:
 1858|      1|    static word_type next_power_of_two(word_type n) {
 1859|      1|        n = n - 1;
 1860|      1|        n |= n >> 1u;
 1861|      1|        n |= n >> 2u;
 1862|      1|        n |= n >> 4u;
 1863|      1|        n |= n >> 8u;
 1864|      1|        n |= n >> 16u;
 1865|      1|        n |= n >> 32u;
 1866|      1|        return n + 1;
 1867|      1|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE7reserveEm:
  834|    147|    {
  835|    147|        storage_.reserve(n);
  836|    147|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7reserveEm:
  446|  4.69k|    {
  447|  4.69k|       if (capacity() < n)
  ------------------
  |  Branch (447:12): [True: 470, False: 4.22k]
  ------------------
  448|    470|       {
  449|    470|           if (!is_allocated())
  ------------------
  |  Branch (449:16): [True: 470, False: 0]
  ------------------
  450|    470|           {
  451|    470|               size_type size = inlined_.size_;
  452|    470|               size_type is_neg = inlined_.is_negative_;
  453|    470|               word_type values[inlined_capacity] = {inlined_.values_[0], inlined_.values_[1]};
  454|       |
  455|    470|               ::new (&allocated_) allocated_storage();
  456|    470|               allocated_.reserve(n, get_allocator());
  457|    470|               allocated_.size_ = size;
  458|    470|               allocated_.is_negative_ = is_neg;
  459|    470|               if (n >= 1)
  ------------------
  |  Branch (459:20): [True: 470, False: 0]
  ------------------
  460|    470|               {
  461|    470|                   allocated_.data_[0] = values[0];
  462|    470|               }
  463|    470|               if (n >= 2)
  ------------------
  |  Branch (463:20): [True: 470, False: 0]
  ------------------
  464|    470|               {
  465|    470|                   allocated_.data_[1] = values[1];
  466|    470|               }
  467|    470|           }
  468|      0|           else
  469|      0|           {
  470|      0|               allocated_.reserve(n, get_allocator());
  471|      0|           }
  472|    470|       }
  473|  4.69k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE8capacityEv:
  499|  4.69k|    {
  500|  4.69k|        return is_allocated() ? allocated_.capacity_ : inlined_capacity;
  ------------------
  |  Branch (500:16): [True: 441, False: 4.25k]
  ------------------
  501|  4.69k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12is_allocatedEv:
  494|  19.7k|    {
  495|  19.7k|        return common_.is_allocated_;
  496|  19.7k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2Ev:
  202|    470|            : is_allocated_(true),
  203|    470|            is_negative_(false)
  204|    470|        {
  205|    470|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7reserveEmRKS4_:
  254|    470|        {
  255|    470|            size_type capacity_new = round_up(n);
  256|       |
  257|    470|            real_allocator_type alloc(a);
  258|    470|            word_type* data_new = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_new);
  259|    470|            if (size_ > 0)
  ------------------
  |  Branch (259:17): [True: 0, False: 470]
  ------------------
  260|      0|            {
  261|      0|                std::memcpy(data_new, data_, size_type(size_ * sizeof(word_type)));
  262|      0|            }
  263|    470|            if (data_ != nullptr)
  ------------------
  |  Branch (263:17): [True: 0, False: 470]
  ------------------
  264|      0|            {
  265|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  266|      0|            }
  267|    470|            capacity_ = capacity_new;
  268|    470|            data_ = data_new;
  269|    470|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage8round_upEm:
  273|    470|        {
  274|    470|            std::size_t remainder = i % mem_unit;
  275|       |
  276|    470|            std::size_t x = (std::numeric_limits<size_type>::max)() - (mem_unit - remainder);
  277|    470|            if (i > x)
  ------------------
  |  Branch (277:17): [True: 0, False: 470]
  ------------------
  278|      0|            {
  279|      0|                return (std::numeric_limits<size_type>::max)();
  280|      0|            }
  281|       |
  282|    470|            return i + (mem_unit - remainder);
  283|    470|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE13get_allocatorEv:
  476|  7.55k|    {
  477|  7.55k|        return static_cast<const word_allocator_type&>(*this);
  478|  7.55k|    }
_ZN8jsonconsplENS_12basic_bigintINSt3__19allocatorImEEEEl:
 1459|  1.21k|    {
 1460|  1.21k|        return x += y;
 1461|  1.21k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IlEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  687|  1.21k|        : storage_(n, alloc)
  688|  1.21k|    {
  689|  1.21k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IlEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  354|  1.21k|        : word_allocator_type(alloc)
  355|  1.21k|    {
  356|  1.21k|        ::new (&inlined_) inlined_storage(n);
  357|  1.21k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IlEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  125|  1.21k|            : is_allocated_(false),
  126|  1.21k|            is_negative_(n < 0),
  127|  1.21k|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (127:19): [True: 226, False: 993]
  ------------------
  128|  1.21k|        {
  129|  1.21k|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (129:26): [True: 0, False: 1.21k]
  ------------------
  130|  1.21k|            values_[1] = 0;
  131|  1.21k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEpLERKS4_:
  859|  1.34k|    {
  860|  1.34k|        auto y_view = y.get_storage_view();
  861|       |        
  862|  1.34k|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (862:14): [True: 0, False: 1.34k]
  ------------------
  863|      0|            return *this -= -y;
  864|  1.34k|        word_type d;
  865|  1.34k|        word_type carry = 0;
  866|       |
  867|  1.34k|        auto this_view = get_storage_view();
  868|  1.34k|        resize( (std::max)(y_view.size(), this_view.size()) + 1 );
  869|  1.34k|        this_view = get_storage_view();
  870|       |
  871|  2.48k|        for (size_type i = 0; i < this_view.size(); i++ )
  ------------------
  |  Branch (871:31): [True: 2.48k, False: 1]
  ------------------
  872|  2.48k|        {
  873|  2.48k|            if ( i >= y_view.size() && carry == 0 )
  ------------------
  |  Branch (873:18): [True: 1.34k, False: 1.14k]
  |  Branch (873:40): [True: 1.34k, False: 1]
  ------------------
  874|  1.34k|                break;
  875|  1.14k|            d = this_view[i] + carry;
  876|  1.14k|            carry = d < carry;
  877|  1.14k|            if ( i < y_view.size())
  ------------------
  |  Branch (877:18): [True: 1.14k, False: 1]
  ------------------
  878|  1.14k|            {
  879|  1.14k|                this_view[i] = d + y_view[i];
  880|  1.14k|                if (this_view[i] < d)
  ------------------
  |  Branch (880:21): [True: 1, False: 1.14k]
  ------------------
  881|      1|                    carry = 1;
  882|  1.14k|            }
  883|      1|            else
  884|      1|            {
  885|      1|                this_view[i] = d;
  886|      1|            }
  887|  1.14k|        }
  888|  1.34k|        reduce();
  889|  1.34k|        return *this;
  890|  1.34k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  717|  2.14k|    {
  718|  2.14k|        return storage_.get_storage_view();
  719|  2.14k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  521|  3.93k|    {
  522|  3.93k|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (522:16): [True: 421, False: 3.50k]
  ------------------
  523|    421|            storage_view<const word_type>{allocated_.data_, allocated_.size_} :
  524|  3.93k|            storage_view<const word_type>{inlined_.values_, inlined_.size_};
  525|  3.93k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEC2EPS7_m:
   64|  3.93k|            : data_(data), size_(size)
   65|  3.93k|        {
   66|  3.93k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11is_negativeEv:
  722|  4.83k|    {
  723|  4.83k|        return storage_.is_negative();
  724|  4.83k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE11is_negativeEv:
  504|  4.83k|    {
  505|  4.83k|        return common_.is_negative_;
  506|  4.83k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEEngEv:
  846|    122|    {
  847|    122|        basic_bigint<Allocator> v(*this);
  848|    122|        v.set_negative(!v.is_negative());
  849|    122|        return v;
  850|    122|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmIERKS4_:
  893|    122|    {
  894|    122|        auto y_view = y.get_storage_view();
  895|       |
  896|    122|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (896:14): [True: 122, False: 0]
  ------------------
  897|    122|            return *this += -y;
  898|      0|        if ( (!is_negative() && y > *this) || (is_negative() && y < *this) )
  ------------------
  |  Branch (898:15): [True: 0, False: 0]
  |  Branch (898:33): [True: 0, False: 0]
  |  Branch (898:48): [True: 0, False: 0]
  |  Branch (898:65): [True: 0, False: 0]
  ------------------
  899|      0|            return *this = -(y - *this);
  900|      0|        word_type borrow = 0;
  901|      0|        word_type d;
  902|      0|        auto this_view = get_storage_view();
  903|      0|        for (size_type i = 0; i < this_view.size(); i++ )
  ------------------
  |  Branch (903:31): [True: 0, False: 0]
  ------------------
  904|      0|        {
  905|      0|            if ( i >= y_view.size() && borrow == 0 )
  ------------------
  |  Branch (905:18): [True: 0, False: 0]
  |  Branch (905:40): [True: 0, False: 0]
  ------------------
  906|      0|                break;
  907|      0|            d = this_view[i] - borrow;
  908|      0|            borrow = d > this_view[i];
  909|      0|            if ( i < y_view.size())
  ------------------
  |  Branch (909:18): [True: 0, False: 0]
  ------------------
  910|      0|            {
  911|      0|                this_view[i] = d - y_view[i];
  912|      0|                if ( this_view[i] > d )
  ------------------
  |  Branch (912:22): [True: 0, False: 0]
  ------------------
  913|      0|                    borrow = 1;
  914|      0|            }
  915|      0|            else 
  916|      0|            {
  917|      0|                this_view[i] = d;
  918|      0|            }
  919|      0|        }
  920|      0|        reduce();
  921|      0|        return *this;
  922|      0|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE7compareERKS4_:
 1579|    274|    {
 1580|    274|        auto this_view = get_storage_view();
 1581|    274|        auto y_view = y.get_storage_view();
 1582|       |
 1583|    274|        if ( this_view.size() == 0 && y_view.size() == 0 )
  ------------------
  |  Branch (1583:14): [True: 0, False: 274]
  |  Branch (1583:39): [True: 0, False: 0]
  ------------------
 1584|      0|            return 0;
 1585|    274|        if ( is_negative() != y.is_negative())
  ------------------
  |  Branch (1585:14): [True: 0, False: 274]
  ------------------
 1586|      0|            return y.is_negative() - is_negative();
 1587|    274|        int code = 0;
 1588|    274|        if ( this_view.size() < y_view.size())
  ------------------
  |  Branch (1588:14): [True: 0, False: 274]
  ------------------
 1589|      0|            code = -1;
 1590|    274|        else if ( this_view.size() > y_view.size())
  ------------------
  |  Branch (1590:19): [True: 99, False: 175]
  ------------------
 1591|     99|            code = +1;
 1592|    175|        else
 1593|    175|        {
 1594|    175|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1594:50): [True: 175, False: 0]
  ------------------
 1595|    175|            {
 1596|    175|                if (this_view[i] > y_view[i])
  ------------------
  |  Branch (1596:21): [True: 30, False: 145]
  ------------------
 1597|     30|                {
 1598|     30|                    code = 1;
 1599|     30|                    break;
 1600|     30|                }
 1601|    145|                else if (this_view[i] < y_view[i])
  ------------------
  |  Branch (1601:26): [True: 145, False: 0]
  ------------------
 1602|    145|                {
 1603|    145|                    code = -1;
 1604|    145|                    break;
 1605|    145|                }
 1606|    175|            }
 1607|    175|        }
 1608|    274|        return is_negative() ? -code : code;
  ------------------
  |  Branch (1608:16): [True: 0, False: 274]
  ------------------
 1609|    274|    }
_ZN8jsonconsltERKNS_12basic_bigintINSt3__19allocatorImEEEES6_:
 1414|    274|    {
 1415|    274|       return x.compare(y) < 0 ? true : false;
  ------------------
  |  Branch (1415:15): [True: 145, False: 129]
  ------------------
 1416|    274|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE16get_storage_viewEv:
  712|  7.23k|    {
  713|  7.23k|        return storage_.get_storage_view();
  714|  7.23k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE16get_storage_viewEv:
  514|  11.9k|    {
  515|  11.9k|        return common_.is_allocated_ ? 
  ------------------
  |  Branch (515:16): [True: 2.31k, False: 9.67k]
  ------------------
  516|  2.31k|            storage_view<word_type>{allocated_.data_, allocated_.size_} :
  517|  11.9k|            storage_view<word_type>{inlined_.values_, inlined_.size_};
  518|  11.9k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEC2EPmm:
   64|  11.9k|            : data_(data), size_(size)
   65|  11.9k|        {
   66|  11.9k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6resizeEm:
  829|  2.75k|    {
  830|  2.75k|        storage_.resize(new_length);
  831|  2.75k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6resizeEm:
  528|  4.54k|    {
  529|  4.54k|        size_type old_length = common_.size_;
  530|  4.54k|        reserve(new_length);
  531|  4.54k|        common_.size_ = new_length;
  532|       |
  533|  4.54k|        if (old_length < new_length)
  ------------------
  |  Branch (533:13): [True: 3.04k, False: 1.50k]
  ------------------
  534|  3.04k|        {
  535|  3.04k|            if (is_allocated())
  ------------------
  |  Branch (535:17): [True: 862, False: 2.18k]
  ------------------
  536|    862|            {
  537|    862|                std::memset(allocated_.data_+old_length, 0, size_type((new_length-old_length)*sizeof(word_type)));
  538|    862|            }
  539|  2.18k|            else
  540|  2.18k|            {
  541|  2.18k|                JSONCONS_ASSERT(new_length <= inlined_capacity);
  ------------------
  |  |   45|  2.18k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 2.18k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  542|  4.95k|                for (size_type i = old_length; i < inlined_capacity; ++i)
  ------------------
  |  Branch (542:48): [True: 2.76k, False: 2.18k]
  ------------------
  543|  2.76k|                {
  544|  2.76k|                    inlined_.values_[i] = 0;
  545|  2.76k|                }
  546|  2.18k|            }
  547|  3.04k|        }
  548|  4.54k|    }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4sizeEv:
   84|  11.7k|        {
   85|  11.7k|            return size_;
   86|  11.7k|        }
_ZNK8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4sizeEv:
   84|  11.2k|        {
   85|  11.2k|            return size_;
   86|  11.2k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImEixEm:
   69|  11.5k|        {
   70|  11.5k|            return data_[i];
   71|  11.5k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmEixEm:
   69|  1.78k|        {
   70|  1.78k|            return data_[i];
   71|  1.78k|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE6reduceEv:
 1854|  2.95k|    {
 1855|  2.95k|        storage_.reduce();
 1856|  2.95k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE6reduceEv:
  423|  2.95k|    {
  424|  2.95k|        if (common_.size_ > 0)
  ------------------
  |  Branch (424:13): [True: 2.95k, False: 0]
  ------------------
  425|  2.95k|        {
  426|  2.95k|            auto this_view = get_storage_view();
  427|  2.95k|            word_type* p = this_view.end() - 1;
  428|  2.95k|            word_type* first = this_view.begin();
  429|  5.61k|            while ( p >= first )
  ------------------
  |  Branch (429:21): [True: 5.46k, False: 151]
  ------------------
  430|  5.46k|            {
  431|  5.46k|                if ( *p )
  ------------------
  |  Branch (431:22): [True: 2.80k, False: 2.65k]
  ------------------
  432|  2.80k|                {
  433|  2.80k|                    break;
  434|  2.80k|                }
  435|  2.65k|                --common_.size_;
  436|  2.65k|                --p;
  437|  2.65k|            }
  438|  2.95k|        }
  439|  2.95k|        if (common_.size_ == 0)
  ------------------
  |  Branch (439:13): [True: 151, False: 2.80k]
  ------------------
  440|    151|        {
  441|    151|            common_.is_negative_ = false;
  442|    151|        }
  443|  2.95k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE3endEv:
   93|  2.95k|        {
   94|  2.95k|            return data_ + size_;
   95|  2.95k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE5beginEv:
   88|  2.95k|        {
   89|  2.95k|            return data_;
   90|  2.95k|        }
_ZN8jsonconsmlENS_12basic_bigintINSt3__19allocatorImEEEEl:
 1484|  1.21k|    {
 1485|  1.21k|        return x *= y;
 1486|  1.21k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLIlEENS1_9enable_ifIXsr10ext_traits17is_signed_integerIT_EE5valueERS4_E4typeES7_:
  927|  1.21k|    {
  928|  1.21k|        *this *= word_type(y < 0 ? -y : y);
  ------------------
  |  Branch (928:28): [True: 0, False: 1.21k]
  ------------------
  929|  1.21k|        if ( y < 0 )
  ------------------
  |  Branch (929:14): [True: 0, False: 1.21k]
  ------------------
  930|      0|            set_negative(!is_negative());
  931|  1.21k|        return *this;
  932|  1.21k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEmLImEENS1_9enable_ifIXsr10ext_traits19is_unsigned_integerIT_EE5valueERS4_E4typeES7_:
  937|  1.21k|    {
  938|  1.21k|        auto this_view = get_storage_view();
  939|  1.21k|        size_type len0 = this_view.size();
  940|  1.21k|        word_type dig = this_view[0];
  941|  1.21k|        word_type carry = 0;
  942|       |
  943|  1.21k|        resize(this_view.size() + 1);
  944|  1.21k|        this_view = get_storage_view();
  945|       |
  946|  1.21k|        size_type i = 0;
  947|  2.63k|        for (; i < len0; i++ )
  ------------------
  |  Branch (947:16): [True: 1.41k, False: 1.21k]
  ------------------
  948|  1.41k|        {
  949|  1.41k|            word_type hi;
  950|  1.41k|            word_type lo;
  951|  1.41k|            DDproduct( dig, y, hi, lo );
  952|  1.41k|            this_view[i] = lo + carry;
  953|  1.41k|            dig = this_view[i+1];
  954|  1.41k|            carry = hi + (this_view[i] < lo);
  955|  1.41k|        }
  956|  1.21k|        this_view[i] = carry;
  957|  1.21k|        reduce();
  958|  1.21k|        return *this;
  959|  1.21k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9DDproductEmmRmS5_:
 1718|  1.56k|    {
 1719|  1.56k|        word_type hiA = A >> word_type_half_bits, loA = A & r_mask,
 1720|  1.56k|                   hiB = B >> word_type_half_bits, loB = B & r_mask;
 1721|       |
 1722|  1.56k|        lo = loA * loB;
 1723|  1.56k|        hi = hiA * hiB;
 1724|  1.56k|        word_type mid1 = loA * hiB;
 1725|  1.56k|        word_type mid2 = hiA * loB;
 1726|  1.56k|        word_type old = lo;
 1727|  1.56k|        lo += mid1 << word_type_half_bits;
 1728|  1.56k|            hi += (lo < old) + (mid1 >> word_type_half_bits);
 1729|  1.56k|        old = lo;
 1730|  1.56k|        lo += mid2 << word_type_half_bits;
 1731|  1.56k|            hi += (lo < old) + (mid2 >> word_type_half_bits);
 1732|  1.56k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_:
  665|  4.04k|        : storage_(other.storage_)
  666|  4.04k|    {
  667|  4.04k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_:
  300|  4.04k|        : word_allocator_type(other.get_allocator())
  301|  4.04k|    {
  302|  4.04k|        if (!other.is_allocated())
  ------------------
  |  Branch (302:13): [True: 3.28k, False: 764]
  ------------------
  303|  3.28k|        {
  304|  3.28k|            ::new (&inlined_) inlined_storage(other.inlined_);
  305|  3.28k|        }
  306|    764|        else
  307|    764|        {
  308|    764|            ::new (&allocated_) allocated_storage(other.allocated_, get_allocator());
  309|    764|        }
  310|  4.04k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ERKS6_:
  178|  4.03k|            : is_allocated_(false),
  179|  4.03k|            is_negative_(stor.is_negative_),
  180|  4.03k|            size_(stor.size_)
  181|  4.03k|        {
  182|  4.03k|            values_[0] = stor.values_[0];
  183|  4.03k|            values_[1] = stor.values_[1];
  184|  4.03k|        }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storageC2ERKS6_RKS4_:
  208|    764|            : is_allocated_(true),
  209|    764|              is_negative_(stor.is_negative_),
  210|    764|              size_(stor.size_),
  211|    764|              capacity_(stor.capacity_)
  212|    764|        {
  213|    764|            real_allocator_type alloc(a);
  214|       |
  215|    764|            data_ = std::allocator_traits<real_allocator_type>::allocate(alloc, capacity_);
  216|    764|            JSONCONS_TRY
  ------------------
  |  |   37|    764|    #define JSONCONS_TRY try
  ------------------
  217|    764|            {
  218|    764|                std::allocator_traits<real_allocator_type>::construct(alloc, ext_traits::to_plain_pointer(data_));
  219|    764|            }
  220|    764|            JSONCONS_CATCH(...)
  221|    764|            {
  222|      0|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  223|      0|                data_ = nullptr;
  224|      0|                JSONCONS_RETHROW;
  ------------------
  |  |   36|      0|    #define JSONCONS_RETHROW throw
  ------------------
  225|      0|            }
  226|    764|            JSONCONS_ASSERT(stor.data_ != nullptr);
  ------------------
  |  |   45|    764|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 764]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  227|    764|            std::memcpy(data_, stor.data_, size_type(stor.size_ * sizeof(word_type)));
  228|    764|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEE12set_negativeEb:
  727|  1.21k|    {
  728|  1.21k|        storage_.set_negative(value);
  729|  1.21k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12set_negativeEb:
  509|  1.21k|    {
  510|  1.21k|        common_.is_negative_ = value;
  511|  1.21k|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE12write_stringIcNS1_11char_traitsIcEENS2_IcEEEEvRNS1_12basic_stringIT_T0_T1_EE:
 1297|    146|    {
 1298|    146|        basic_bigint<Allocator> v(*this);
 1299|    146|        auto v_view = v.get_storage_view();
 1300|       |
 1301|    146|        size_type len = (v_view.size() * word_type_bits / 3) + 2;
 1302|    146|        data.reserve(len);
 1303|       |
 1304|    146|        if ( v_view.size() == 0 )
  ------------------
  |  Branch (1304:14): [True: 2, False: 144]
  ------------------
 1305|      2|        {
 1306|      2|            data.push_back('0');
 1307|      2|        }
 1308|    144|        else
 1309|    144|        {
 1310|    144|            word_type r;
 1311|    144|            basic_bigint<Allocator> R(get_allocator());
 1312|    144|            basic_bigint<Allocator> LP10(max_unsigned_power_10, get_allocator()); 
 1313|       |
 1314|    144|            do
 1315|    273|            {
 1316|    273|                v.divide( LP10, v, R, true );
 1317|    273|                v_view = v.get_storage_view();
 1318|       |
 1319|    273|                auto R_view = R.get_storage_view();
 1320|    273|                r = (R_view.size() ? R_view[0] : 0);
  ------------------
  |  Branch (1320:22): [True: 273, False: 0]
  ------------------
 1321|  3.08k|                for ( size_type j=0; j < imax_unsigned_power_10; j++ )
  ------------------
  |  Branch (1321:38): [True: 2.95k, False: 129]
  ------------------
 1322|  2.95k|                {
 1323|  2.95k|                    data.push_back(char(r % 10u + '0'));
 1324|  2.95k|                    r /= 10u;
 1325|  2.95k|                    if ( r + v_view.size() == 0 )
  ------------------
  |  Branch (1325:26): [True: 144, False: 2.81k]
  ------------------
 1326|    144|                        break;
 1327|  2.95k|                }
 1328|    273|            } 
 1329|    273|            while ( v_view.size() > 0);
  ------------------
  |  Branch (1329:21): [True: 129, False: 144]
  ------------------
 1330|       |
 1331|    144|            if (is_negative())
  ------------------
  |  Branch (1331:17): [True: 122, False: 22]
  ------------------
 1332|    122|            {
 1333|    122|                data.push_back('-');
 1334|    122|            }
 1335|    144|            std::reverse(data.begin(),data.end());
 1336|    144|        }
 1337|    146|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE13get_allocatorEv:
  707|  1.03k|    {
  708|  1.03k|        return storage_.get_allocator();
  709|  1.03k|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS3_:
  638|    144|        : storage_(alloc)
  639|    144|    {
  640|    144|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS4_:
  294|    145|        : word_allocator_type(alloc)
  295|    145|    {
  296|    145|        ::new (&inlined_) inlined_storage();
  297|    145|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2Ev:
  113|    145|            : is_allocated_(false),
  114|    145|            is_negative_(false),
  115|    145|            size_(0),
  116|    145|            values_{0, 0}
  117|    145|        {
  118|    145|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ImEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  687|    350|        : storage_(n, alloc)
  688|    350|    {
  689|    350|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ImEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  354|    350|        : word_allocator_type(alloc)
  355|    350|    {
  356|    350|        ::new (&inlined_) inlined_storage(n);
  357|    350|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2ImEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Entsr3std9is_signedIS8_EE5valueEvE4typeE:
  138|    350|            : is_allocated_(false),
  139|    350|            is_negative_(false),
  140|    350|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (140:19): [True: 145, False: 205]
  ------------------
  141|    350|        {
  142|    350|            values_[0] = n;
  143|    350|            values_[1] = 0;
  144|    350|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE6divideERKS4_RS4_S7_b:
 1612|    274|    {
 1613|    274|        basic_bigint<Allocator> denom(denom_, get_allocator());
 1614|    274|        auto denom_view = denom.get_storage_view();
 1615|       |
 1616|    274|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1616:13): [True: 0, False: 274]
  ------------------
 1617|      0|        {
 1618|      0|            JSONCONS_THROW(std::runtime_error( "Zero divide." ));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 1619|      0|        }
 1620|    274|        bool quot_neg = is_negative() ^ denom.is_negative();
 1621|    274|        bool rem_neg = is_negative();
 1622|    274|        basic_bigint<Allocator> num(*this, get_allocator());
 1623|    274|        num.set_negative(false);
 1624|    274|        denom.set_negative(false);
 1625|    274|        if ( num < denom )
  ------------------
  |  Branch (1625:14): [True: 145, False: 129]
  ------------------
 1626|    145|        {
 1627|    145|            quot = word_type(0);
 1628|    145|            quot.set_negative(quot_neg);
 1629|    145|            rem = num;
 1630|    145|            rem.set_negative(rem_neg);
 1631|    145|            return;
 1632|    145|        }
 1633|       |
 1634|    129|        auto num_view = num.get_storage_view();
 1635|    129|        auto quot_view = quot.get_storage_view();
 1636|    129|        auto this_view = get_storage_view();
 1637|       |
 1638|    129|        if ( denom_view.size() == 1 && num_view.size() == 1 )
  ------------------
  |  Branch (1638:14): [True: 129, False: 0]
  |  Branch (1638:40): [True: 30, False: 99]
  ------------------
 1639|     30|        {
 1640|     30|            quot = word_type( num_view[0]/denom_view[0] );
 1641|     30|            rem = word_type( num_view[0]%denom_view[0] );
 1642|     30|            quot.set_negative(quot_neg);
 1643|     30|            rem.set_negative(rem_neg);
 1644|     30|            return;
 1645|     30|        }
 1646|     99|        if (denom_view.size() == 1 && (denom_view[0] & l_mask) == 0 )
  ------------------
  |  Branch (1646:13): [True: 99, False: 0]
  |  Branch (1646:39): [True: 0, False: 99]
  ------------------
 1647|      0|        {
 1648|       |            // Denominator fits into a half word
 1649|      0|            word_type divisor = denom_view[0], dHi = 0, q1, r, q2, dividend;
 1650|      0|            quot.resize(this_view.size());
 1651|      0|            quot_view = quot.get_storage_view();
 1652|      0|            for (size_type i=this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1652:48): [True: 0, False: 0]
  ------------------
 1653|      0|            {
 1654|      0|                dividend = (dHi << word_type_half_bits) | (this_view[i] >> word_type_half_bits);
 1655|      0|                q1 = dividend/divisor;
 1656|      0|                r = dividend % divisor;
 1657|      0|                dividend = (r << word_type_half_bits) | (this_view[i] & r_mask);
 1658|      0|                q2 = dividend/divisor;
 1659|      0|                dHi = dividend % divisor;
 1660|      0|                quot_view[i] = (q1 << word_type_half_bits) | q2;
 1661|      0|            }
 1662|      0|            quot.reduce();
 1663|      0|            rem = dHi;
 1664|      0|            quot.set_negative(quot_neg);
 1665|      0|            rem.set_negative(rem_neg);
 1666|      0|            return;
 1667|      0|        }
 1668|     99|        basic_bigint<Allocator> num0(num, get_allocator());
 1669|     99|        basic_bigint<Allocator> denom0(denom, get_allocator());
 1670|     99|        int x = 0;
 1671|     99|        bool second_done = normalize(denom, num, x);
 1672|     99|        denom_view = denom.get_storage_view();
 1673|     99|        num_view = num.get_storage_view();
 1674|       |
 1675|     99|        size_type l = denom_view.size() - 1;
 1676|     99|        size_type n = num_view.size() - 1;
 1677|     99|        quot.resize(n - l);
 1678|     99|        quot_view = quot.get_storage_view();
 1679|    198|        for (size_type i = quot_view.size(); i-- > 0; )
  ------------------
  |  Branch (1679:46): [True: 99, False: 99]
  ------------------
 1680|     99|        {
 1681|     99|            quot_view[i] = 0;
 1682|     99|        }
 1683|     99|        rem = num;
 1684|     99|        auto rem_view = rem.get_storage_view();
 1685|     99|        if ( rem_view[n] >= denom_view[l] )
  ------------------
  |  Branch (1685:14): [True: 49, False: 50]
  ------------------
 1686|     49|        {
 1687|     49|            rem.resize(rem_view.size() + 1);
 1688|     49|            rem_view = rem.get_storage_view();
 1689|     49|            n++;
 1690|     49|            quot.resize(quot_view.size() + 1);
 1691|     49|            quot_view = quot.get_storage_view();
 1692|     49|        }
 1693|     99|        word_type d = denom_view[l];
 1694|       |
 1695|    247|        for ( size_type k = n; k > l; k-- )
  ------------------
  |  Branch (1695:32): [True: 148, False: 99]
  ------------------
 1696|    148|        {
 1697|    148|            word_type q = DDquotient(rem_view[k], rem_view[k-1], d);
 1698|    148|            subtractmul( rem_view.data() + (k - l - 1), denom_view.data(), l + 1, q );
 1699|    148|            quot_view[k - l - 1] = q;
 1700|    148|        }
 1701|     99|        quot.reduce();
 1702|     99|        quot.set_negative(quot_neg);
 1703|     99|        if (remDesired)
  ------------------
  |  Branch (1703:13): [True: 99, False: 0]
  ------------------
 1704|     99|        {
 1705|     99|            unnormalize(rem, x, second_done);
 1706|     99|            rem.set_negative(rem_neg);
 1707|     99|        }
 1708|     99|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2ERKS4_RKS3_:
  670|    746|        : storage_(other.storage_, alloc)
  671|    746|    {
  672|    746|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2ERKS5_RKS4_:
  313|    746|        : word_allocator_type(alloc)
  314|    746|    {
  315|    746|        if (!other.is_allocated())
  ------------------
  |  Branch (315:13): [True: 746, False: 0]
  ------------------
  316|    746|        {
  317|    746|            ::new (&inlined_) inlined_storage(other.inlined_);
  318|    746|        }
  319|      0|        else
  320|      0|        {
  321|      0|            ::new (&allocated_) allocated_storage(other.allocated_, alloc);
  322|      0|        }
  323|    746|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE9normalizeERS4_S5_Ri:
 1809|     99|    {
 1810|     99|        auto denom_view = denom.get_storage_view();
 1811|     99|        if (denom_view.size() == 0)
  ------------------
  |  Branch (1811:13): [True: 0, False: 99]
  ------------------
 1812|      0|        {
 1813|      0|            return false;
 1814|      0|        }
 1815|     99|        size_type r = denom_view.size() - 1;
 1816|     99|        word_type y = denom_view[r];
 1817|       |
 1818|     99|        x = 0;
 1819|     99|        while ( (y & l_bit) == 0 )
  ------------------
  |  Branch (1819:17): [True: 0, False: 99]
  ------------------
 1820|      0|        {
 1821|      0|            y <<= 1;
 1822|      0|            x++;
 1823|      0|        }
 1824|     99|        denom <<= x;
 1825|     99|        num <<= x;
 1826|       |
 1827|     99|        denom_view = denom.get_storage_view();
 1828|     99|        if ( r > 0 && denom_view[r] < denom_view[r-1] )
  ------------------
  |  Branch (1828:14): [True: 0, False: 99]
  |  Branch (1828:23): [True: 0, False: 0]
  ------------------
 1829|      0|        {
 1830|      0|            denom *= max_word;
 1831|      0|            num *= max_word;
 1832|      0|            return true;
 1833|      0|        }
 1834|     99|        return false;
 1835|     99|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEElSEm:
 1055|    198|    {
 1056|    198|        auto this_view = get_storage_view();
 1057|    198|        size_type q = k / word_type_bits;
 1058|    198|        if ( q ) // Increase storage_.size() by q:
  ------------------
  |  Branch (1058:14): [True: 0, False: 198]
  ------------------
 1059|      0|        {
 1060|      0|            resize(this_view.size() + q);
 1061|      0|            this_view = get_storage_view();
 1062|      0|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1062:50): [True: 0, False: 0]
  ------------------
 1063|      0|                this_view[i] = ( i < q ? 0 : this_view[i - q]);
  ------------------
  |  Branch (1063:34): [True: 0, False: 0]
  ------------------
 1064|      0|            k %= word_type_bits;
 1065|      0|        }
 1066|    198|        if ( k )  // 0 < k < word_type_bits:
  ------------------
  |  Branch (1066:14): [True: 0, False: 198]
  ------------------
 1067|      0|        {
 1068|      0|            size_type k1 = word_type_bits - k;
 1069|      0|            word_type mask = (word_type(1) << k) - word_type(1);
 1070|      0|            resize( this_view.size() + 1 );
 1071|      0|            this_view = get_storage_view();
 1072|      0|            for (size_type i = this_view.size(); i-- > 0; )
  ------------------
  |  Branch (1072:50): [True: 0, False: 0]
  ------------------
 1073|      0|            {
 1074|      0|                this_view[i] <<= k;
 1075|      0|                if ( i > 0 )
  ------------------
  |  Branch (1075:22): [True: 0, False: 0]
  ------------------
 1076|      0|                    this_view[i] |= (this_view[i-1] >> k1) & mask;
 1077|      0|            }
 1078|      0|        }
 1079|    198|        reduce();
 1080|    198|        return *this;
 1081|    198|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE10DDquotientEmmm:
 1736|    148|    {
 1737|    148|        word_type left, middle, right, qHi, qLo, x, dLo1,
 1738|    148|                   dHi = d >> word_type_half_bits, dLo = d & r_mask;
 1739|    148|        qHi = A/(dHi + 1);
 1740|       |        // This initial guess of qHi may be too small.
 1741|    148|        middle = qHi * dLo;
 1742|    148|        left = qHi * dHi;
 1743|    148|        x = B - (middle << word_type_half_bits);
 1744|    148|        A -= (middle >> word_type_half_bits) + left + (x > B);
 1745|    148|        B = x;
 1746|    148|        dLo1 = dLo << word_type_half_bits;
 1747|       |        // Increase qHi if necessary:
 1748|    196|        while ( A > dHi || (A == dHi && B >= dLo1) )
  ------------------
  |  Branch (1748:17): [True: 48, False: 148]
  |  Branch (1748:29): [True: 0, False: 148]
  |  Branch (1748:41): [True: 0, False: 0]
  ------------------
 1749|     48|        {
 1750|     48|            x = B - dLo1;
 1751|     48|            A -= dHi + (x > B);
 1752|     48|            B = x;
 1753|     48|            qHi++;
 1754|     48|        }
 1755|    148|        qLo = ((A << word_type_half_bits) | (B >> word_type_half_bits))/(dHi + 1);
 1756|       |        // This initial guess of qLo may be too small.
 1757|    148|        right = qLo * dLo;
 1758|    148|        middle = qLo * dHi;
 1759|    148|        x = B - right;
 1760|    148|        A -= (x > B);
 1761|    148|        B = x;
 1762|    148|        x = B - (middle << word_type_half_bits);
 1763|    148|            A -= (middle >> word_type_half_bits) + (x > B);
 1764|    148|        B = x;
 1765|       |        // Increase qLo if necessary:
 1766|    149|        while ( A || B >= d )
  ------------------
  |  Branch (1766:17): [True: 0, False: 149]
  |  Branch (1766:22): [True: 1, False: 148]
  ------------------
 1767|      1|        {
 1768|      1|            x = B - d;
 1769|      1|            A -= (x > B);
 1770|      1|            B = x;
 1771|      1|            qLo++;
 1772|      1|        }
 1773|    148|        return (qHi << word_type_half_bits) + qLo;
 1774|    148|    }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11subtractmulEPmS5_mRm:
 1778|    148|    {
 1779|    148|        word_type hi, lo, d, carry = 0;
 1780|    148|        size_type i;
 1781|    296|        for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1781:22): [True: 148, False: 148]
  ------------------
 1782|    148|        {
 1783|    148|            DDproduct( b[i], q, hi, lo );
 1784|    148|            d = a[i];
 1785|    148|            a[i] -= lo;
 1786|    148|            if ( a[i] > d )
  ------------------
  |  Branch (1786:18): [True: 1, False: 147]
  ------------------
 1787|      1|                carry++;
 1788|    148|            d = a[i + 1];
 1789|    148|            a[i + 1] -= hi + carry;
 1790|    148|            carry = a[i + 1] > d;
 1791|    148|        }
 1792|    148|        if ( carry ) // q was too large
  ------------------
  |  Branch (1792:14): [True: 0, False: 148]
  ------------------
 1793|      0|        {
 1794|      0|            q--;
 1795|      0|            carry = 0;
 1796|      0|            for ( i = 0; i < n; i++ )
  ------------------
  |  Branch (1796:26): [True: 0, False: 0]
  ------------------
 1797|      0|            {
 1798|      0|                d = a[i] + carry;
 1799|      0|                carry = d < carry;
 1800|      0|                a[i] = d + b[i];
 1801|      0|                if ( a[i] < d )
  ------------------
  |  Branch (1801:22): [True: 0, False: 0]
  ------------------
 1802|      0|                    carry = 1;
 1803|      0|            }
 1804|      0|            a[n] = 0;
 1805|      0|        }
 1806|    148|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewImE4dataEv:
   79|  1.93k|        {
   80|  1.93k|            return data_;
   81|  1.93k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE11unnormalizeERS4_ib:
 1838|     99|    {
 1839|     99|        if (secondDone)
  ------------------
  |  Branch (1839:13): [True: 0, False: 99]
  ------------------
 1840|      0|        {
 1841|      0|            rem /= max_word;
 1842|      0|        }
 1843|     99|        if ( x > 0 )
  ------------------
  |  Branch (1843:14): [True: 0, False: 99]
  ------------------
 1844|      0|        {
 1845|      0|            rem >>= x;
 1846|      0|        }
 1847|     99|        else
 1848|     99|        {
 1849|     99|            rem.reduce();
 1850|     99|        }
 1851|     99|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2Ev:
  635|      1|    basic_bigint() = default;
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEED2Ev:
  702|  6.77k|    {
  703|  6.77k|        storage_.destroy();
  704|  6.77k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE7destroyEv:
  481|  6.77k|    {
  482|  6.77k|        if (is_allocated())
  ------------------
  |  Branch (482:13): [True: 1.23k, False: 5.54k]
  ------------------
  483|  1.23k|        {
  484|  1.23k|            allocated_.destroy(get_allocator());
  485|  1.23k|            allocated_.~allocated_storage();
  486|  1.23k|        }
  487|  5.54k|        else
  488|  5.54k|        {
  489|  5.54k|            inlined_.~inlined_storage();
  490|  5.54k|        }
  491|  6.77k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE17allocated_storage7destroyERKS4_:
  245|  1.23k|        {
  246|  1.23k|            if (data_ != nullptr)
  ------------------
  |  Branch (246:17): [True: 1.23k, False: 0]
  ------------------
  247|  1.23k|            {
  248|  1.23k|                real_allocator_type alloc(a);
  249|  1.23k|                std::allocator_traits<real_allocator_type>::deallocate(alloc, data_, capacity_);
  250|  1.23k|            }
  251|  1.23k|        }
_ZN8jsonconsmiENS_12basic_bigintINSt3__19allocatorImEEEERKS4_:
 1464|    122|    {
 1465|    122|        return x -= y;
 1466|    122|    }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEC2IiEET_RKS3_PNS1_9enable_ifIXsr3std11is_integralIS6_EE5valueEvE4typeE:
  687|    269|        : storage_(n, alloc)
  688|    269|    {
  689|    269|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEC2IiEET_RKS4_PNS2_9enable_ifIXsr3std11is_integralIS7_EE5valueEvE4typeE:
  354|    269|        : word_allocator_type(alloc)
  355|    269|    {
  356|    269|        ::new (&inlined_) inlined_storage(n);
  357|    269|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE15inlined_storageC2IiEET_PNS2_9enable_ifIXaaaasr3std11is_integralIS8_EE5valuelestS8_Lm8Esr3std9is_signedIS8_EE5valueEvE4typeE:
  125|    269|            : is_allocated_(false),
  126|    269|            is_negative_(n < 0),
  127|    269|            size_(n == 0 ? 0 : 1)
  ------------------
  |  Branch (127:19): [True: 147, False: 122]
  ------------------
  128|    269|        {
  129|    269|            values_[0] = n < 0 ? (word_type(0) - static_cast<word_type>(n)) : static_cast<word_type>(n);
  ------------------
  |  Branch (129:26): [True: 122, False: 147]
  ------------------
  130|    269|            values_[1] = 0;
  131|    269|        }
_ZN8jsoncons12basic_bigintINSt3__19allocatorImEEEaSERKS4_:
  853|  1.79k|    {
  854|  1.79k|        storage_ = y.storage_;
  855|  1.79k|        return *this;
  856|  1.79k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEEaSERKS5_:
  360|  1.79k|    {
  361|  1.79k|        if (this != &other)
  ------------------
  |  Branch (361:13): [True: 1.79k, False: 0]
  ------------------
  362|  1.79k|        {
  363|  1.79k|            auto other_view = other.get_storage_view();
  364|  1.79k|            resize(other_view.size());
  365|  1.79k|            auto this_view = get_storage_view();
  366|  1.79k|            if (other_view.size() > 0)
  ------------------
  |  Branch (366:17): [True: 1.64k, False: 149]
  ------------------
  367|  1.64k|            {
  368|  1.64k|                common_.is_negative_ = other.common_.is_negative_;
  369|  1.64k|                std::memcpy(this_view.data(), other_view.data(), size_type(other_view.size()*sizeof(word_type)));
  370|  1.64k|            }
  371|  1.79k|        }
  372|  1.79k|        return *this;
  373|  1.79k|    }
_ZN8jsoncons6detail14bigint_storageINSt3__19allocatorImEEE12storage_viewIKmE4dataEv:
   79|  1.64k|        {
   80|  1.64k|            return data_;
   81|  1.64k|        }
_ZNK8jsoncons12basic_bigintINSt3__19allocatorImEEE16write_string_hexIcNS1_11char_traitsIcEENS2_IcEEEEvRNS1_12basic_stringIT_T0_T1_EE:
 1348|      1|    {
 1349|       |
 1350|       |
 1351|      1|        basic_bigint<Allocator> v(*this);
 1352|      1|        auto v_view = v.get_storage_view();
 1353|       |
 1354|      1|        size_type len = (v_view.size() * basic_bigint<Allocator>::word_type_bits / 3) + 2;
 1355|      1|        data.reserve(len);
 1356|       |
 1357|      1|        if ( v_view.size() == 0 )
  ------------------
  |  Branch (1357:14): [True: 0, False: 1]
  ------------------
 1358|      0|        {
 1359|      0|            data.push_back('0');
 1360|      0|        }
 1361|      1|        else
 1362|      1|        {
 1363|      1|            word_type r;
 1364|      1|            basic_bigint<Allocator> R;
 1365|      1|            basic_bigint<Allocator> LP10 = max_unsigned_power_16; // LP10 = max_unsigned_power_16 = ::pow(16, imax_unsigned_power_16)
 1366|      1|            do
 1367|      1|            {
 1368|      1|                v.divide( LP10, v, R, true );
 1369|      1|                v_view = v.get_storage_view();
 1370|      1|                auto R_view = R.get_storage_view();
 1371|      1|                r = (R_view.size() ? R_view[0] : 0);
  ------------------
  |  Branch (1371:22): [True: 1, False: 0]
  ------------------
 1372|      2|                for ( size_type j=0; j < imax_unsigned_power_16; j++ )
  ------------------
  |  Branch (1372:38): [True: 2, False: 0]
  ------------------
 1373|      2|                {
 1374|      2|                    uint8_t c = r % 16u;
 1375|      2|                    data.push_back((c < 10u) ? ('0' + c) : ('A' - 10u + c));
  ------------------
  |  Branch (1375:36): [True: 1, False: 1]
  ------------------
 1376|      2|                    r /= 16u;
 1377|      2|                    if ( r + v_view.size() == 0 )
  ------------------
  |  Branch (1377:26): [True: 1, False: 1]
  ------------------
 1378|      1|                        break;
 1379|      2|                }
 1380|      1|            } 
 1381|      1|            while (v_view.size() > 0);
  ------------------
  |  Branch (1381:20): [True: 0, False: 1]
  ------------------
 1382|       |
 1383|      1|            if (is_negative())
  ------------------
  |  Branch (1383:17): [True: 0, False: 1]
  ------------------
 1384|      0|            {
 1385|      0|                data.push_back('-');
 1386|      0|            }
 1387|      1|            std::reverse(data.begin(),data.end());
 1388|      1|        }
 1389|      1|    }

_ZN8jsoncons6binary13big_to_nativeItNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|  7.78k|    {
  183|  7.78k|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 7.78k]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|  7.78k|        T val;
  188|  7.78k|        std::memcpy(&val,first,sizeof(T));
  189|  7.78k|        return byte_swap(val);
  190|  7.78k|    }
_ZN8jsoncons6binary9byte_swapItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm2EES4_E4typeES4_:
   28|  8.80k|    {
   29|  8.80k|    #if defined(JSONCONS_BYTE_SWAP_16)
   30|  8.80k|        return JSONCONS_BYTE_SWAP_16(val);
  ------------------
  |  |  466|  8.80k|#      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|  8.80k|    }
_ZN8jsoncons6binary13big_to_nativeIjNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|    162|    {
  183|    162|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 162]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|    162|        T val;
  188|    162|        std::memcpy(&val,first,sizeof(T));
  189|    162|        return byte_swap(val);
  190|    162|    }
_ZN8jsoncons6binary9byte_swapIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|    872|    {
   40|    872|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|    872|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  462|    872|#  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|    872|    }
_ZN8jsoncons6binary13big_to_nativeImNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|    229|    {
  183|    229|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 229]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|    229|        T val;
  188|    229|        std::memcpy(&val,first,sizeof(T));
  189|    229|        return byte_swap(val);
  190|    229|    }
_ZN8jsoncons6binary9byte_swapImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|  1.08k|    {
   52|  1.08k|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|  1.08k|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|  1.08k|#  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|  1.08k|    }
_ZN8jsoncons6binary9byte_swapIiEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   39|  18.4k|    {
   40|  18.4k|    #if defined(JSONCONS_BYTE_SWAP_32)
   41|  18.4k|        return JSONCONS_BYTE_SWAP_32(val);
  ------------------
  |  |  462|  18.4k|#  define JSONCONS_BYTE_SWAP_32 __builtin_bswap32
  ------------------
   42|       |    #else
   43|       |        uint32_t tmp = ((static_cast<uint32_t>(val) << 8) & 0xff00ff00) | ((static_cast<uint32_t>(val) >> 8) & 0xff00ff);
   44|       |        return (tmp << 16) | (tmp >> 16);
   45|       |    #endif
   46|  18.4k|    }
_ZN8jsoncons6binary9byte_swapIlEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   51|    252|    {
   52|    252|    #if defined(JSONCONS_BYTE_SWAP_64)
   53|    252|        return JSONCONS_BYTE_SWAP_64(val);
  ------------------
  |  |  461|    252|#  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|    252|    }
_ZN8jsoncons6binary9byte_swapIfEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm4EES4_E4typeES4_:
   64|    709|    {
   65|    709|        uint32_t x;
   66|    709|        std::memcpy(&x,&val,sizeof(uint32_t));
   67|    709|        uint32_t y = byte_swap(x);
   68|    709|        T val2;
   69|    709|        std::memcpy(&val2,&y,sizeof(uint32_t));
   70|    709|        return val2;
   71|    709|    }
_ZN8jsoncons6binary9byte_swapIdEENSt3__19enable_ifIXaasr3std17is_floating_pointIT_EE5valueeqstS4_Lm8EES4_E4typeES4_:
   76|    839|    {
   77|    839|        uint64_t x;
   78|    839|        std::memcpy(&x,&val,sizeof(uint64_t));
   79|    839|        uint64_t y = byte_swap(x);
   80|    839|        T val2;
   81|    839|        std::memcpy(&val2,&y,sizeof(uint64_t));
   82|    839|        return val2;
   83|    839|    }
_ZN8jsoncons6binary13big_to_nativeIfNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|    629|    {
  183|    629|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 629]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|    629|        T val;
  188|    629|        std::memcpy(&val,first,sizeof(T));
  189|    629|        return byte_swap(val);
  190|    629|    }
_ZN8jsoncons6binary13big_to_nativeIdNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm:
  182|    839|    {
  183|    839|        if (sizeof(T) > count)
  ------------------
  |  Branch (183:13): [True: 0, False: 839]
  ------------------
  184|      0|        {
  185|      0|            return T{};
  186|      0|        }
  187|    839|        T val;
  188|    839|        std::memcpy(&val,first,sizeof(T));
  189|    839|        return byte_swap(val);
  190|    839|    }

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

_ZNK8jsoncons8identityclIRKhEEOT_S5_:
   19|      2|    {
   20|      2|        return std::forward<T>(val);
   21|      2|    }
_ZNK8jsoncons8identityclIRjEEOT_S4_:
   19|      1|    {
   20|      1|        return std::forward<T>(val);
   21|      1|    }
_ZNK8jsoncons8identityclIRmEEOT_S4_:
   19|     12|    {
   20|     12|        return std::forward<T>(val);
   21|     12|    }
_ZNK8jsoncons8identityclIRiEEOT_S4_:
   19|  18.4k|    {
   20|  18.4k|        return std::forward<T>(val);
   21|  18.4k|    }
_ZNK8jsoncons8identityclIRlEEOT_S4_:
   19|    252|    {
   20|    252|        return std::forward<T>(val);
   21|    252|    }
_ZNK8jsoncons11decode_halfclEt:
   36|  1.02k|    {
   37|  1.02k|        return binary::decode_half(val);
   38|  1.02k|    }
_ZNK8jsoncons8identityclIRfEEOT_S4_:
   19|     80|    {
   20|     80|        return std::forward<T>(val);
   21|     80|    }

_ZN8jsoncons4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE7destroyEPNS0_11heap_stringIcS2_S5_EE:
  169|      9|    {
  170|      9|        if (ptr != nullptr)
  ------------------
  |  Branch (170:13): [True: 9, False: 0]
  ------------------
  171|      9|        {
  172|      9|            heap_string_type* rawp = ext_traits::to_plain_pointer(ptr);
  173|       |
  174|      9|            char* q = launder_cast<char*>(rawp);
  175|       |
  176|      9|            char* p = q - ptr->offset_;
  177|       |
  178|      9|            std::size_t mem_size = ptr->align_pad_ + aligned_size(ptr->length_*sizeof(char_type));
  179|      9|            byte_allocator_type byte_alloc(ptr->get_allocator());
  180|      9|            byte_alloc.deallocate(p,mem_size);
  181|      9|        }
  182|      9|    }
_ZN8jsoncons4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE12aligned_sizeEm:
  119|     18|    {
  120|     18|        return sizeof(storage_type) + n;
  121|     18|    }
_ZN8jsoncons4heap16heap_string_baseINS_9null_typeENSt3__19allocatorIcEEE13get_allocatorEv:
   35|      9|    {
   36|      9|        return alloc_;
   37|      9|    }
_ZN8jsoncons4heap19heap_string_factoryIhmNSt3__19allocatorIcEEE7destroyEPNS0_11heap_stringIhmS4_EE:
  169|  2.12M|    {
  170|  2.12M|        if (ptr != nullptr)
  ------------------
  |  Branch (170:13): [True: 2.12M, False: 0]
  ------------------
  171|  2.12M|        {
  172|  2.12M|            heap_string_type* rawp = ext_traits::to_plain_pointer(ptr);
  173|       |
  174|  2.12M|            char* q = launder_cast<char*>(rawp);
  175|       |
  176|  2.12M|            char* p = q - ptr->offset_;
  177|       |
  178|  2.12M|            std::size_t mem_size = ptr->align_pad_ + aligned_size(ptr->length_*sizeof(char_type));
  179|  2.12M|            byte_allocator_type byte_alloc(ptr->get_allocator());
  180|  2.12M|            byte_alloc.deallocate(p,mem_size);
  181|  2.12M|        }
  182|  2.12M|    }
_ZN8jsoncons4heap19heap_string_factoryIhmNSt3__19allocatorIcEEE12aligned_sizeEm:
  119|  4.24M|    {
  120|  4.24M|        return sizeof(storage_type) + n;
  121|  4.24M|    }
_ZN8jsoncons4heap16heap_string_baseImNSt3__19allocatorIcEEE13get_allocatorEv:
   35|  2.12M|    {
   36|  2.12M|        return alloc_;
   37|  2.12M|    }
_ZN8jsoncons4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE6createEPKcmS2_RKS5_:
  126|      9|    {
  127|      9|        std::size_t len = aligned_size(length*sizeof(char_type));
  128|       |
  129|      9|        std::size_t align = alignof(storage_type);
  130|      9|        char* q = nullptr;
  131|      9|        char* storage = nullptr;
  132|      9|        byte_allocator_type byte_alloc(alloc);
  133|      9|        uint8_t align_pad = 0;
  134|       |
  135|      9|        if (align <= 8) {
  ------------------
  |  Branch (135:13): [True: 9, False: 0]
  ------------------
  136|      9|            byte_pointer ptr = byte_alloc.allocate(len);
  137|      9|            q = ext_traits::to_plain_pointer(ptr);
  138|       |
  139|      9|            if (reinterpret_cast<uintptr_t>(q) % align == 0) {
  ------------------
  |  Branch (139:17): [True: 9, False: 0]
  ------------------
  140|      9|                storage = q;
  141|      9|            } else {
  142|      0|                byte_alloc.deallocate(ptr, len);
  143|      0|            }
  144|      9|        }
  145|       |
  146|      9|        if (storage == nullptr) {
  ------------------
  |  Branch (146:13): [True: 0, False: 9]
  ------------------
  147|      0|            align_pad = uint8_t(align-1);
  148|      0|            byte_pointer ptr = byte_alloc.allocate(align_pad+len);
  149|      0|            q = ext_traits::to_plain_pointer(ptr);
  150|      0|            storage = align_up(q, align);
  151|      0|            JSONCONS_ASSERT(storage >= q);
  ------------------
  |  |   45|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  152|      0|        }
  153|       |
  154|      9|        heap_string_type* ps = new(storage)heap_string_type(extra, byte_alloc);
  155|       |
  156|      9|        auto psa = launder_cast<storage_t*>(storage);
  157|       |
  158|      9|        CharT* p = new(&psa->c)char_type[length + 1];
  159|      9|        std::memcpy(p, s, length*sizeof(char_type));
  160|      9|        p[length] = 0;
  161|      9|        ps->p_ = std::pointer_traits<typename heap_string_type::pointer>::pointer_to(*p);
  162|      9|        ps->length_ = length;
  163|      9|        ps->offset_ = (uint8_t)(storage - q);
  164|      9|        ps->align_pad_ = align_pad;
  165|      9|        return std::pointer_traits<pointer>::pointer_to(*ps);
  166|      9|    }
_ZN8jsoncons4heap11heap_stringIcNS_9null_typeENSt3__19allocatorIcEEEC2ES2_RKS5_:
   69|      9|        : heap_string_base<Extra,Allocator>(extra, alloc)
   70|      9|    {
   71|      9|    }
_ZN8jsoncons4heap16heap_string_baseINS_9null_typeENSt3__19allocatorIcEEEC2ERKS2_RKS5_:
   45|      9|        : extra_(extra), alloc_(alloc)
   46|      9|    {
   47|      9|    }
_ZN8jsoncons4heap19heap_string_factoryIhmNSt3__19allocatorIcEEE6createEPKhmmRKS4_:
  126|  2.12M|    {
  127|  2.12M|        std::size_t len = aligned_size(length*sizeof(char_type));
  128|       |
  129|  2.12M|        std::size_t align = alignof(storage_type);
  130|  2.12M|        char* q = nullptr;
  131|  2.12M|        char* storage = nullptr;
  132|  2.12M|        byte_allocator_type byte_alloc(alloc);
  133|  2.12M|        uint8_t align_pad = 0;
  134|       |
  135|  2.12M|        if (align <= 8) {
  ------------------
  |  Branch (135:13): [True: 2.12M, False: 0]
  ------------------
  136|  2.12M|            byte_pointer ptr = byte_alloc.allocate(len);
  137|  2.12M|            q = ext_traits::to_plain_pointer(ptr);
  138|       |
  139|  2.12M|            if (reinterpret_cast<uintptr_t>(q) % align == 0) {
  ------------------
  |  Branch (139:17): [True: 2.12M, False: 0]
  ------------------
  140|  2.12M|                storage = q;
  141|  2.12M|            } else {
  142|      0|                byte_alloc.deallocate(ptr, len);
  143|      0|            }
  144|  2.12M|        }
  145|       |
  146|  2.12M|        if (storage == nullptr) {
  ------------------
  |  Branch (146:13): [True: 0, False: 2.12M]
  ------------------
  147|      0|            align_pad = uint8_t(align-1);
  148|      0|            byte_pointer ptr = byte_alloc.allocate(align_pad+len);
  149|      0|            q = ext_traits::to_plain_pointer(ptr);
  150|      0|            storage = align_up(q, align);
  151|      0|            JSONCONS_ASSERT(storage >= q);
  ------------------
  |  |   45|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  152|      0|        }
  153|       |
  154|  2.12M|        heap_string_type* ps = new(storage)heap_string_type(extra, byte_alloc);
  155|       |
  156|  2.12M|        auto psa = launder_cast<storage_t*>(storage);
  157|       |
  158|  2.12M|        CharT* p = new(&psa->c)char_type[length + 1];
  159|  2.12M|        std::memcpy(p, s, length*sizeof(char_type));
  160|  2.12M|        p[length] = 0;
  161|  2.12M|        ps->p_ = std::pointer_traits<typename heap_string_type::pointer>::pointer_to(*p);
  162|  2.12M|        ps->length_ = length;
  163|  2.12M|        ps->offset_ = (uint8_t)(storage - q);
  164|  2.12M|        ps->align_pad_ = align_pad;
  165|  2.12M|        return std::pointer_traits<pointer>::pointer_to(*ps);
  166|  2.12M|    }
_ZN8jsoncons4heap11heap_stringIhmNSt3__19allocatorIcEEEC2EmRKS4_:
   69|  2.12M|        : heap_string_base<Extra,Allocator>(extra, alloc)
   70|  2.12M|    {
   71|  2.12M|    }
_ZN8jsoncons4heap16heap_string_baseImNSt3__19allocatorIcEEEC2ERKmRKS4_:
   45|  2.12M|        : extra_(extra), alloc_(alloc)
   46|  2.12M|    {
   47|  2.12M|    }

_ZN8jsoncons10ext_traits16to_plain_pointerINS_4heap11heap_stringIcNS_9null_typeENSt3__19allocatorIcEEEEEEPT_SA_:
  241|      9|    {       
  242|      9|        return (ptr);
  243|      9|    }  
_ZN8jsoncons10ext_traits16to_plain_pointerINS_4heap11heap_stringIhmNSt3__19allocatorIcEEEEEEPT_S9_:
  241|  2.12M|    {       
  242|  2.12M|        return (ptr);
  243|  2.12M|    }  
_ZN8jsoncons10ext_traits16to_plain_pointerINS_10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS5_6vectorEEEEEPT_SC_:
  241|  2.93k|    {       
  242|  2.93k|        return (ptr);
  243|  2.93k|    }  
_ZN8jsoncons10ext_traits16to_plain_pointerINS_18sorted_json_objectINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES8_EENS3_6vectorEEEEEPT_SG_:
  241|  6.37M|    {       
  242|  6.37M|        return (ptr);
  243|  6.37M|    }  
_ZN8jsoncons10ext_traits16to_plain_pointerIcEEPT_S3_:
  241|  2.12M|    {       
  242|  2.12M|        return (ptr);
  243|  2.12M|    }  
_ZN8jsoncons10ext_traits16to_plain_pointerImEEPT_S3_:
  241|    764|    {       
  242|    764|        return (ptr);
  243|    764|    }  

_ZN8jsoncons16decstr_to_doubleEPKcmRd:
  866|    144|{
  867|    144|    const char* cur = s+length;
  868|    144|    char *end = nullptr;
  869|    144|    val = strtod(s, &end);
  870|    144|    const char* str_end = end;
  871|    144|    if (JSONCONS_UNLIKELY(end < cur))
  ------------------
  |  |   78|    144|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 144]
  |  |  ------------------
  ------------------
  872|      0|    {
  873|      0|        if (*end == '.')
  ------------------
  |  Branch (873:13): [True: 0, False: 0]
  ------------------
  874|      0|        {
  875|      0|            std::string buf{s, length};
  876|      0|            char* dot_ptr = &buf[0] + (cur - end - 1);
  877|      0|            *dot_ptr = ',';
  878|      0|            end = nullptr;
  879|      0|            val = strtod(buf.c_str(), &end);
  880|      0|            str_end = s + (end - &buf[0]);
  881|      0|        }
  882|      0|        if (JSONCONS_UNLIKELY(str_end != cur))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  883|      0|        {
  884|      0|            return to_number_result<char>{str_end,std::errc::invalid_argument};
  885|      0|        }
  886|      0|    }
  887|    144|    if (JSONCONS_UNLIKELY(val <= -HUGE_VAL || val >= HUGE_VAL))
  ------------------
  |  |   78|    288|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 144]
  |  |  |  Branch (78:50): [True: 0, False: 144]
  |  |  |  Branch (78:50): [True: 0, False: 144]
  |  |  ------------------
  ------------------
  888|      0|    {
  889|      0|        return to_number_result<char>{str_end, std::errc::result_out_of_range};
  890|      0|    }
  891|    144|    return to_number_result<char>{str_end};
  892|    144|}
_ZN8jsoncons16to_number_resultIcEC2EPKc:
  137|    144|        : ptr(ptr_), ec(std::errc{})
  138|    144|    {
  139|    144|    }

_ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_14convert_resultIS4_EEE4typeEPKS4_m:
 1136|  1.07M|    {
 1137|  1.07M|        conv_errc  result = conv_errc();
 1138|  1.07M|        const CharT* last = data + length;
 1139|  1.07M|        while (data != last) 
  ------------------
  |  Branch (1139:16): [True: 6.40k, False: 1.07M]
  ------------------
 1140|  6.40k|        {
 1141|  6.40k|            std::size_t len = static_cast<std::size_t>(trailing_bytes_for_utf8[static_cast<uint8_t>(*data)]) + 1;
 1142|  6.40k|            if (len > (std::size_t)(last - data))
  ------------------
  |  Branch (1142:17): [True: 0, False: 6.40k]
  ------------------
 1143|      0|            {
 1144|      0|                return convert_result<CharT>{data, conv_errc::source_exhausted};
 1145|      0|            }
 1146|  6.40k|            if ((result=is_legal_utf8(data, len)) != conv_errc())
  ------------------
  |  Branch (1146:17): [True: 2, False: 6.39k]
  ------------------
 1147|      2|            {
 1148|      2|                return convert_result<CharT>{data,result} ;
 1149|      2|            }
 1150|  6.39k|            data += len;
 1151|  6.39k|        }
 1152|  1.07M|        return convert_result<CharT>{data,result} ;
 1153|  1.07M|    }
_ZN8jsoncons14unicode_traits13is_legal_utf8IcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_9conv_errcEE4typeEPKS4_m:
  305|  6.40k|    {
  306|  6.40k|        uint8_t a;
  307|  6.40k|        const CharT* srcptr = first+length;
  308|  6.40k|        switch (length) {
  309|      0|        default:
  ------------------
  |  Branch (309:9): [True: 0, False: 6.40k]
  ------------------
  310|      0|            return conv_errc::over_long_utf8_sequence;
  311|      0|        case 4:
  ------------------
  |  Branch (311:9): [True: 0, False: 6.40k]
  ------------------
  312|      0|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (312:17): [True: 0, False: 0]
  ------------------
  313|      0|                return conv_errc::expected_continuation_byte;
  314|      0|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|      0|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  315|     15|        case 3:
  ------------------
  |  Branch (315:9): [True: 15, False: 6.38k]
  ------------------
  316|     15|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (316:17): [True: 0, False: 15]
  ------------------
  317|      0|                return conv_errc::expected_continuation_byte;
  318|     15|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|     15|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  319|    182|        case 2:
  ------------------
  |  Branch (319:9): [True: 167, False: 6.23k]
  ------------------
  320|    182|            if (((a = (*--srcptr))& 0xC0) != 0x80)
  ------------------
  |  Branch (320:17): [True: 0, False: 182]
  ------------------
  321|      0|                return conv_errc::expected_continuation_byte;
  322|       |
  323|    182|            switch (static_cast<uint8_t>(*first)) 
  324|    182|            {
  325|       |                // no fall-through in this inner switch
  326|      0|                case 0xE0: if (a < 0xA0) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (326:17): [True: 0, False: 182]
  |  Branch (326:32): [True: 0, False: 0]
  ------------------
  327|     15|                case 0xED: if (a > 0x9F) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (327:17): [True: 15, False: 167]
  |  Branch (327:32): [True: 0, False: 15]
  ------------------
  328|     15|                case 0xF0: if (a < 0x90) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (328:17): [True: 0, False: 182]
  |  Branch (328:32): [True: 0, False: 0]
  ------------------
  329|      0|                case 0xF4: if (a > 0x8F) return conv_errc::source_illegal; break;
  ------------------
  |  Branch (329:17): [True: 0, False: 182]
  |  Branch (329:32): [True: 0, False: 0]
  ------------------
  330|    167|                default:   if (a < 0x80) return conv_errc::source_illegal;
  ------------------
  |  Branch (330:17): [True: 167, False: 15]
  |  Branch (330:32): [True: 0, False: 167]
  ------------------
  331|    182|            }
  332|       |
  333|    182|            JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|    182|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  334|  6.40k|        case 1:
  ------------------
  |  Branch (334:9): [True: 6.21k, False: 182]
  ------------------
  335|  6.40k|            if (static_cast<uint8_t>(*first) >= 0x80 && static_cast<uint8_t>(*first) < 0xC2)
  ------------------
  |  Branch (335:17): [True: 184, False: 6.21k]
  |  Branch (335:57): [True: 2, False: 182]
  ------------------
  336|      2|                return conv_errc::source_illegal;
  337|  6.39k|            break;
  338|  6.40k|        }
  339|  6.39k|        if (static_cast<uint8_t>(*first) > 0xF4) 
  ------------------
  |  Branch (339:13): [True: 0, False: 6.39k]
  ------------------
  340|      0|            return conv_errc::source_illegal;
  341|       |
  342|  6.39k|        return conv_errc();
  343|  6.39k|    }

_ZN8jsoncons12from_integerImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  3.14M|{
   43|  3.14M|    using char_type = typename Result::value_type;
   44|       |
   45|  3.14M|    char_type buf[255];
   46|  3.14M|    char_type *p = buf;
   47|  3.14M|    const char_type* last = buf+255;
   48|       |
   49|  3.14M|    bool is_negative = value < 0;
   50|       |
   51|  3.14M|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 3.14M]
  ------------------
   52|      0|    {
   53|      0|        do
   54|      0|        {
   55|      0|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|      0|        }
   57|      0|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 0, False: 0]
  |  Branch (57:33): [True: 0, False: 0]
  ------------------
   58|      0|    }
   59|  3.14M|    else
   60|  3.14M|    {
   61|       |
   62|  3.14M|        do
   63|  3.29M|        {
   64|  3.29M|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  3.29M|        }
   66|  3.29M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 147k, False: 3.14M]
  |  Branch (66:33): [True: 147k, False: 0]
  ------------------
   67|  3.14M|    }
   68|  3.14M|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   45|  3.14M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 3.14M]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|  3.14M|    std::size_t count = (p - buf);
   71|  3.14M|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 3.14M]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|  6.44M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 3.29M, False: 3.14M]
  ------------------
   77|  3.29M|    {
   78|  3.29M|        result.push_back(*p);
   79|  3.29M|    }
   80|       |
   81|  3.14M|    return count;
   82|  3.14M|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|   920k|{
   43|   920k|    using char_type = typename Result::value_type;
   44|       |
   45|   920k|    char_type buf[255];
   46|   920k|    char_type *p = buf;
   47|   920k|    const char_type* last = buf+255;
   48|       |
   49|   920k|    bool is_negative = value < 0;
   50|       |
   51|   920k|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 907k, False: 13.4k]
  ------------------
   52|   907k|    {
   53|   907k|        do
   54|  1.42M|        {
   55|  1.42M|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|  1.42M|        }
   57|  1.42M|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 519k, False: 907k]
  |  Branch (57:33): [True: 519k, False: 0]
  ------------------
   58|   907k|    }
   59|  13.4k|    else
   60|  13.4k|    {
   61|       |
   62|  13.4k|        do
   63|  85.9k|        {
   64|  85.9k|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  85.9k|        }
   66|  85.9k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 72.4k, False: 13.4k]
  |  Branch (66:33): [True: 72.4k, False: 0]
  ------------------
   67|  13.4k|    }
   68|   920k|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   45|   920k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 920k]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|   920k|    std::size_t count = (p - buf);
   71|   920k|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 907k, False: 13.4k]
  ------------------
   72|   907k|    {
   73|   907k|        result.push_back('-');
   74|   907k|        ++count;
   75|   907k|    }
   76|  2.43M|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 1.51M, False: 920k]
  ------------------
   77|  1.51M|    {
   78|  1.51M|        result.push_back(*p);
   79|  1.51M|    }
   80|       |
   81|   920k|    return count;
   82|   920k|}
_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|  7.56k|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|  7.56k|    {
  489|  7.56k|#if !defined(JSONCONS_NO_LOCALECONV)
  490|  7.56k|        struct lconv *lc = localeconv();
  491|  7.56k|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 7.56k, False: 0]
  |  Branch (491:30): [True: 7.56k, False: 0]
  ------------------
  492|  7.56k|        {
  493|  7.56k|            decimal_point_ = lc->decimal_point[0];
  494|  7.56k|        }
  495|  7.56k|#endif
  496|  7.56k|    }
_ZN8jsoncons12write_doubleclINS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEmdRT_:
  503|  7.56k|    {
  504|  7.56k|        std::size_t count = 0;
  505|       |
  506|  7.56k|        char number_buffer[200];
  507|  7.56k|        int length = 0;
  508|       |
  509|  7.56k|        switch (float_format_)
  510|  7.56k|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 7.56k]
  ------------------
  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: 7.56k]
  ------------------
  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|  7.56k|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 7.56k, False: 0]
  ------------------
  552|  7.56k|            {
  553|  7.56k|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 7.56k]
  ------------------
  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|  7.56k|                else
  563|  7.56k|                {
  564|  7.56k|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 7.56k]
  ------------------
  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|  7.56k|                }             
  569|  7.56k|                break;
  570|  7.56k|            }
  571|  7.56k|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 7.56k]
  ------------------
  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|  7.56k|        }
  575|  7.56k|        return count;
  576|  7.56k|    }
_ZN8jsoncons11dump_bufferINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKcmcRT_:
  243|    144|{
  244|    144|    const char *sbeg = buffer;
  245|    144|    const char *send = sbeg + length;
  246|       |
  247|    144|    if (sbeg != send)
  ------------------
  |  Branch (247:9): [True: 144, False: 0]
  ------------------
  248|    144|    {
  249|    144|        bool needs_dot = true;
  250|    914|        for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (250:36): [True: 770, False: 144]
  ------------------
  251|    770|        {
  252|    770|            switch (*q)
  253|    770|            {
  254|    144|            case '-':
  ------------------
  |  Branch (254:13): [True: 144, False: 626]
  ------------------
  255|    172|            case '0':
  ------------------
  |  Branch (255:13): [True: 28, False: 742]
  ------------------
  256|    192|            case '1':
  ------------------
  |  Branch (256:13): [True: 20, False: 750]
  ------------------
  257|    212|            case '2':
  ------------------
  |  Branch (257:13): [True: 20, False: 750]
  ------------------
  258|    262|            case '3':
  ------------------
  |  Branch (258:13): [True: 50, False: 720]
  ------------------
  259|    282|            case '4':
  ------------------
  |  Branch (259:13): [True: 20, False: 750]
  ------------------
  260|    314|            case '5':
  ------------------
  |  Branch (260:13): [True: 32, False: 738]
  ------------------
  261|    320|            case '6':
  ------------------
  |  Branch (261:13): [True: 6, False: 764]
  ------------------
  262|    334|            case '7':
  ------------------
  |  Branch (262:13): [True: 14, False: 756]
  ------------------
  263|    352|            case '8':
  ------------------
  |  Branch (263:13): [True: 18, False: 752]
  ------------------
  264|    360|            case '9':
  ------------------
  |  Branch (264:13): [True: 8, False: 762]
  ------------------
  265|    362|            case '+':
  ------------------
  |  Branch (265:13): [True: 2, False: 768]
  ------------------
  266|    362|                result.push_back(*q);
  267|    362|                break;
  268|      6|            case 'e':
  ------------------
  |  Branch (268:13): [True: 6, False: 764]
  ------------------
  269|      6|            case 'E':
  ------------------
  |  Branch (269:13): [True: 0, False: 770]
  ------------------
  270|      6|                result.push_back('e');
  271|      6|                needs_dot = false;
  272|      6|                break;
  273|    402|            default:
  ------------------
  |  Branch (273:13): [True: 402, False: 368]
  ------------------
  274|    402|                if (*q == decimal_point)
  ------------------
  |  Branch (274:21): [True: 6, False: 396]
  ------------------
  275|      6|                {
  276|      6|                    needs_dot = false;
  277|      6|                    result.push_back('.');
  278|      6|                }
  279|    402|                break;
  280|    770|            }
  281|    770|        }
  282|    144|        if (needs_dot)
  ------------------
  |  Branch (282:13): [True: 138, False: 6]
  ------------------
  283|    138|        {
  284|    138|            result.push_back('.');
  285|    138|            result.push_back('0');
  286|    138|        }
  287|    144|    }
  288|    144|}
_ZN8jsoncons15prettify_stringINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEvPKcmiiiRT_:
  171|  7.19k|{
  172|  7.19k|    int nb_digits = (int)length;
  173|  7.19k|    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|  7.19k|    int kk = nb_digits + k;
  179|       |
  180|  7.19k|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 5.80k, False: 1.39k]
  |  Branch (180:28): [True: 4.56k, False: 1.23k]
  ------------------
  181|  4.56k|    {
  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|  27.3k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 22.7k, False: 4.56k]
  ------------------
  186|  22.7k|        {
  187|  22.7k|            result.push_back(buffer[i]);
  188|  22.7k|        }
  189|  4.96k|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 403, False: 4.56k]
  ------------------
  190|    403|        {
  191|    403|            result.push_back('0');
  192|    403|        }
  193|  4.56k|        result.push_back('.');
  194|  4.56k|        result.push_back('0');
  195|  4.56k|    } 
  196|  2.63k|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 1.32k, False: 1.31k]
  |  Branch (196:24): [True: 84, False: 1.23k]
  ------------------
  197|     84|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|    270|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 186, False: 84]
  ------------------
  200|    186|        {
  201|    186|            result.push_back(buffer[i]);
  202|    186|        }
  203|     84|        result.push_back('.');
  204|    440|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 356, False: 84]
  ------------------
  205|    356|        {
  206|    356|            result.push_back(buffer[i]);
  207|    356|        }
  208|     84|    } 
  209|  2.54k|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 1.87k, False: 670]
  |  Branch (209:30): [True: 641, False: 1.23k]
  ------------------
  210|    641|    {
  211|    641|        offset = 2 - kk;
  212|       |
  213|    641|        result.push_back('0');
  214|    641|        result.push_back('.');
  215|  1.31k|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 669, False: 641]
  ------------------
  216|    669|            result.push_back('0');
  217|  9.10k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 8.46k, False: 641]
  ------------------
  218|  8.46k|        {
  219|  8.46k|            result.push_back(buffer[i]);
  220|  8.46k|        }
  221|    641|    } 
  222|  1.90k|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 0, False: 1.90k]
  ------------------
  223|      0|    {
  224|      0|        result.push_back(buffer[0]);
  225|      0|        result.push_back('e');
  226|      0|        fill_exponent(kk - 1, result);
  227|      0|    } 
  228|  1.90k|    else
  229|  1.90k|    {
  230|  1.90k|        result.push_back(buffer[0]);
  231|  1.90k|        result.push_back('.');
  232|  31.0k|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 29.1k, False: 1.90k]
  ------------------
  233|  29.1k|        {
  234|  29.1k|            result.push_back(buffer[i]);
  235|  29.1k|        }
  236|  1.90k|        result.push_back('e');
  237|  1.90k|        fill_exponent(kk - 1, result);
  238|  1.90k|    }
  239|  7.19k|}
_ZN8jsoncons13fill_exponentINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEviRT_:
  136|  1.90k|{
  137|  1.90k|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 670, False: 1.23k]
  ------------------
  138|    670|    {
  139|    670|        result.push_back('-');
  140|    670|        K = -K;
  141|    670|    }
  142|  1.23k|    else
  143|  1.23k|    {
  144|  1.23k|        result.push_back('+'); // compatibility with sprintf
  145|  1.23k|    }
  146|       |
  147|  1.90k|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 481, False: 1.42k]
  ------------------
  148|    481|    {
  149|    481|        result.push_back('0'); // compatibility with sprintf
  150|    481|        result.push_back((char)('0' + K));
  151|    481|    }
  152|  1.42k|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 501, False: 924]
  ------------------
  153|    501|    {
  154|    501|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|    501|        result.push_back((char)('0' + K));
  156|    501|    }
  157|    924|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 924, False: 0]
  ------------------
  158|    924|    {
  159|    924|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|    924|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|    924|        result.push_back((char)('0' + K));
  162|    924|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|  1.90k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_:
  475|  7.56k|{
  476|  7.56k|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|  7.56k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb1EEE:
  366|  7.56k|{
  367|  7.56k|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 228, False: 7.34k]
  ------------------
  368|    228|    {
  369|    228|        result.push_back('0');
  370|    228|        result.push_back('.');
  371|    228|        result.push_back('0');
  372|    228|        return true;
  373|    228|    }
  374|       |
  375|  7.34k|    int length = 0;
  376|  7.34k|    int k;
  377|       |
  378|  7.34k|    char buffer[100];
  379|       |
  380|  7.34k|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 6.07k, False: 1.26k]
  ------------------
  381|  7.34k|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 7.19k, False: 144]
  ------------------
  382|  7.19k|    {
  383|  7.19k|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 5.93k, False: 1.25k]
  ------------------
  384|  5.93k|        {
  385|  5.93k|            result.push_back('-');
  386|  5.93k|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|  7.19k|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|  7.19k|        return true;
  391|  7.19k|    }
  392|    144|    else
  393|    144|    {
  394|    144|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|    144|    }
  396|  7.34k|}
_ZN8jsoncons12dtoa_generalINS_11string_sinkINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbdcRT_NS2_17integral_constantIbLb0EEE:
  329|    144|{
  330|    144|    if (val == 0)
  ------------------
  |  Branch (330:9): [True: 0, False: 144]
  ------------------
  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|    144|    char buffer[100];
  339|    144|    int precision = std::numeric_limits<double>::digits10;
  340|    144|    int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  341|    144|    if (length < 0)
  ------------------
  |  Branch (341:9): [True: 0, False: 144]
  ------------------
  342|      0|    {
  343|      0|        return false;
  344|      0|    }
  345|    144|    double x{0};
  346|    144|    auto res = decstr_to_double(buffer, length, x);
  347|    144|    if (res.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (347:9): [True: 0, False: 144]
  ------------------
  348|      0|    {
  349|      0|        return false;
  350|      0|    }
  351|    144|    if (x != val)
  ------------------
  |  Branch (351:9): [True: 144, False: 0]
  ------------------
  352|    144|    {
  353|    144|        const int precision2 = std::numeric_limits<double>::max_digits10;
  354|    144|        length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  355|    144|        if (length < 0)
  ------------------
  |  Branch (355:13): [True: 0, False: 144]
  ------------------
  356|      0|        {
  357|      0|            return false;
  358|      0|        }
  359|    144|    }
  360|    144|    dump_buffer(buffer, length, decimal_point, result);
  361|    144|    return true;
  362|    144|}
_ZN8jsoncons15prettify_stringINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKcmiiiRT_:
  171|   368k|{
  172|   368k|    int nb_digits = (int)length;
  173|   368k|    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|   368k|    int kk = nb_digits + k;
  179|       |
  180|   368k|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 601, False: 368k]
  |  Branch (180:28): [True: 601, False: 0]
  ------------------
  181|    601|    {
  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.21k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 617, False: 601]
  ------------------
  186|    617|        {
  187|    617|            result.push_back(buffer[i]);
  188|    617|        }
  189|  4.33k|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 3.73k, False: 601]
  ------------------
  190|  3.73k|        {
  191|  3.73k|            result.push_back('0');
  192|  3.73k|        }
  193|    601|        result.push_back('.');
  194|    601|        result.push_back('0');
  195|    601|    } 
  196|   368k|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 367k, False: 248]
  |  Branch (196:24): [True: 367k, False: 0]
  ------------------
  197|   367k|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|   735k|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 367k, False: 367k]
  ------------------
  200|   367k|        {
  201|   367k|            result.push_back(buffer[i]);
  202|   367k|        }
  203|   367k|        result.push_back('.');
  204|   735k|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 367k, False: 367k]
  ------------------
  205|   367k|        {
  206|   367k|            result.push_back(buffer[i]);
  207|   367k|        }
  208|   367k|    } 
  209|    248|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 232, False: 16]
  |  Branch (209:30): [True: 232, False: 0]
  ------------------
  210|    232|    {
  211|    232|        offset = 2 - kk;
  212|       |
  213|    232|        result.push_back('0');
  214|    232|        result.push_back('.');
  215|    280|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 48, False: 232]
  ------------------
  216|     48|            result.push_back('0');
  217|    488|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 256, False: 232]
  ------------------
  218|    256|        {
  219|    256|            result.push_back(buffer[i]);
  220|    256|        }
  221|    232|    } 
  222|     16|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 8, False: 8]
  ------------------
  223|      8|    {
  224|      8|        result.push_back(buffer[0]);
  225|      8|        result.push_back('e');
  226|      8|        fill_exponent(kk - 1, result);
  227|      8|    } 
  228|      8|    else
  229|      8|    {
  230|      8|        result.push_back(buffer[0]);
  231|      8|        result.push_back('.');
  232|     16|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 8, False: 8]
  ------------------
  233|      8|        {
  234|      8|            result.push_back(buffer[i]);
  235|      8|        }
  236|      8|        result.push_back('e');
  237|      8|        fill_exponent(kk - 1, result);
  238|      8|    }
  239|   368k|}
_ZN8jsoncons13fill_exponentINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEviRT_:
  136|     16|{
  137|     16|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 16, False: 0]
  ------------------
  138|     16|    {
  139|     16|        result.push_back('-');
  140|     16|        K = -K;
  141|     16|    }
  142|      0|    else
  143|      0|    {
  144|      0|        result.push_back('+'); // compatibility with sprintf
  145|      0|    }
  146|       |
  147|     16|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 8, False: 8]
  ------------------
  148|      8|    {
  149|      8|        result.push_back('0'); // compatibility with sprintf
  150|      8|        result.push_back((char)('0' + K));
  151|      8|    }
  152|      8|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 0, False: 8]
  ------------------
  153|      0|    {
  154|      0|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|      0|        result.push_back((char)('0' + K));
  156|      0|    }
  157|      8|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 0, False: 8]
  ------------------
  158|      0|    {
  159|      0|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|      0|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|      0|        result.push_back((char)('0' + K));
  162|      0|    }
  163|      8|    else
  164|      8|    {
  165|      8|        jsoncons::from_integer(K, result);
  166|      8|    }
  167|     16|}
_ZN8jsoncons12from_integerIiNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|      8|{
   43|      8|    using char_type = typename Result::value_type;
   44|       |
   45|      8|    char_type buf[255];
   46|      8|    char_type *p = buf;
   47|      8|    const char_type* last = buf+255;
   48|       |
   49|      8|    bool is_negative = value < 0;
   50|       |
   51|      8|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 8]
  ------------------
   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|      8|    else
   60|      8|    {
   61|       |
   62|      8|        do
   63|     72|        {
   64|     72|            *p++ = static_cast<char_type>(48 + value % 10);
   65|     72|        }
   66|     72|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 64, False: 8]
  |  Branch (66:33): [True: 64, False: 0]
  ------------------
   67|      8|    }
   68|      8|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   45|      8|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 8]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|      8|    std::size_t count = (p - buf);
   71|      8|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 8]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|     80|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 72, False: 8]
  ------------------
   77|     72|    {
   78|     72|        result.push_back(*p);
   79|     72|    }
   80|       |
   81|      8|    return count;
   82|      8|}
_ZN8jsoncons14integer_to_hexImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_:
   89|    197|{
   90|    197|    using char_type = typename Result::value_type;
   91|       |
   92|    197|    char_type buf[255];
   93|    197|    char_type *p = buf;
   94|    197|    const char_type* last = buf+255;
   95|       |
   96|    197|    bool is_negative = value < 0;
   97|       |
   98|    197|    if (value < 0)
  ------------------
  |  Branch (98:9): [True: 0, False: 197]
  ------------------
   99|      0|    {
  100|      0|        do
  101|      0|        {
  102|      0|            *p++ = to_hex_character(0-(value % 16));
  103|      0|        }
  104|      0|        while ((value /= 16) && (p < last));
  ------------------
  |  Branch (104:16): [True: 0, False: 0]
  |  Branch (104:33): [True: 0, False: 0]
  ------------------
  105|      0|    }
  106|    197|    else
  107|    197|    {
  108|       |
  109|    197|        do
  110|    255|        {
  111|    255|            *p++ = to_hex_character(value % 16);
  112|    255|        }
  113|    255|        while ((value /= 16) && (p < last));
  ------------------
  |  Branch (113:16): [True: 58, False: 197]
  |  Branch (113:33): [True: 58, False: 0]
  ------------------
  114|    197|    }
  115|    197|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   45|    197|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 197]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  116|       |
  117|    197|    std::size_t count = (p - buf);
  118|    197|    if (is_negative)
  ------------------
  |  Branch (118:9): [True: 0, False: 197]
  ------------------
  119|      0|    {
  120|      0|        result.push_back('-');
  121|      0|        ++count;
  122|      0|    }
  123|    452|    while (--p >= buf)
  ------------------
  |  Branch (123:12): [True: 255, False: 197]
  ------------------
  124|    255|    {
  125|    255|        result.push_back(*p);
  126|    255|    }
  127|       |
  128|    197|    return count;
  129|    197|}
_ZN8jsoncons16to_hex_characterEh:
   33|    255|{
   34|    255|    return (char)((c < 10) ? ('0' + c) : ('A' - 10 + c));
  ------------------
  |  Branch (34:19): [True: 252, False: 3]
  ------------------
   35|    255|}

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

_ZN8jsoncons4cbor15make_error_codeENS0_9cbor_errcE:
   93|     41|{
   94|     41|    return std::error_code(static_cast<int>(e),cbor_error_category());
   95|     41|}
_ZN8jsoncons4cbor19cbor_error_categoryEv:
   86|     41|{
   87|     41|  static cbor_error_category_impl instance;
   88|     41|  return instance;
   89|     41|}
_ZNK8jsoncons4cbor24cbor_error_category_impl7messageEi:
   47|     41|    {
   48|     41|        switch (static_cast<cbor_errc>(ev))
   49|     41|        {
   50|     28|            case cbor_errc::unexpected_eof:
  ------------------
  |  Branch (50:13): [True: 28, False: 13]
  ------------------
   51|     28|                return "Unexpected end of file";
   52|      0|            case cbor_errc::source_error:
  ------------------
  |  Branch (52:13): [True: 0, False: 41]
  ------------------
   53|      0|                return "Source error";
   54|      2|            case cbor_errc::invalid_decimal_fraction:
  ------------------
  |  Branch (54:13): [True: 2, False: 39]
  ------------------
   55|      2|                return "Invalid decimal fraction";
   56|      0|            case cbor_errc::invalid_bigfloat:
  ------------------
  |  Branch (56:13): [True: 0, False: 41]
  ------------------
   57|      0|                return "Invalid bigfloat";
   58|      2|            case cbor_errc::invalid_utf8_text_string:
  ------------------
  |  Branch (58:13): [True: 2, False: 39]
  ------------------
   59|      2|                return "Illegal UTF-8 encoding in text string";
   60|      0|            case cbor_errc::too_many_items:
  ------------------
  |  Branch (60:13): [True: 0, False: 41]
  ------------------
   61|      0|                return "Too many items were added to a CBOR map or array of known length";
   62|      0|            case cbor_errc::too_few_items:
  ------------------
  |  Branch (62:13): [True: 0, False: 41]
  ------------------
   63|      0|                return "Too few items were added to a CBOR map or array of known length";
   64|      0|            case cbor_errc::number_too_large:
  ------------------
  |  Branch (64:13): [True: 0, False: 41]
  ------------------
   65|      0|                return "Number exceeds implementation limits";
   66|      0|            case cbor_errc::stringref_too_large:
  ------------------
  |  Branch (66:13): [True: 0, False: 41]
  ------------------
   67|      0|                return "stringref exceeds stringref map size";
   68|      0|            case cbor_errc::max_nesting_depth_exceeded:
  ------------------
  |  Branch (68:13): [True: 0, False: 41]
  ------------------
   69|      0|                return "Data item nesting exceeds limit in options";
   70|      4|            case cbor_errc::unknown_type:
  ------------------
  |  Branch (70:13): [True: 4, False: 37]
  ------------------
   71|      4|                return "An unknown type was found in the stream";
   72|      4|            case cbor_errc::illegal_chunked_string:
  ------------------
  |  Branch (72:13): [True: 4, False: 37]
  ------------------
   73|      4|                return "An illegal type was found while parsing an indefinite length string";
   74|      0|            case cbor_errc::bad_mdarray:
  ------------------
  |  Branch (74:13): [True: 0, False: 41]
  ------------------
   75|      0|                return "Invalid multi-dimensional array.";
   76|      1|            case cbor_errc::bad_extents:
  ------------------
  |  Branch (76:13): [True: 1, False: 40]
  ------------------
   77|      1|                return "Product of extents does not match number of elements.";
   78|      0|            default:
  ------------------
  |  Branch (78:13): [True: 0, False: 41]
  ------------------
   79|      0|                return "Unknown CBOR parser error";
   80|     41|        }
   81|     41|    }

_ZNK8jsoncons4cbor19cbor_options_common17max_nesting_depthEv:
   33|     43|    {
   34|     43|        return max_nesting_depth_;
   35|     43|    }
_ZN8jsoncons4cbor19cbor_decode_optionsC1Ev:
   42|     43|    cbor_decode_options() = default;
_ZN8jsoncons4cbor19cbor_options_commonC2Ev:
   25|     43|    cbor_options_common() = default;
_ZN8jsoncons4cbor19cbor_options_commonD2Ev:
   27|     43|    virtual ~cbor_options_common() = default;

_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_13basic_istreamIcNS3_11char_traitsIcEEEEEEOT_RKNS0_19cbor_decode_optionsERKS7_:
  324|     43|       : alloc_(alloc),
  325|     43|         source_(std::forward<Sourceable>(source)),
  326|     43|         max_nesting_depth_(options.max_nesting_depth()),
  327|     43|         text_buffer_(alloc),
  328|     43|         bytes_buffer_(alloc),
  329|     43|         state_stack_(alloc),
  330|     43|         array_buffer_(alloc),
  331|     43|         stringref_map_stack_(alloc)
  332|     43|    {
  333|     43|        state_stack_.emplace_back(parse_mode::root,0);
  334|     43|    }
_ZN8jsoncons4cbor24mdarray_row_major_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2Ev:
   58|     43|        : done_(true), parser_(nullptr)
   59|     43|    {
   60|     43|    }
_ZN8jsoncons4cbor11parse_stateC2ENS0_10parse_modeEmb:
  177|  3.66M|        : mode(mode), length(length), pop_stringref_map_stack(pop_stringref_map_stack)
  178|  3.66M|    {
  179|  3.66M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringD2Ev:
  248|    807|        ~mapped_string() = default;
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4lineEv:
  420|     41|    {
  421|     41|        return 0;
  422|     41|    }
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE6columnEv:
  425|     41|    {
  426|     41|        return source_.position();
  427|     41|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEED2Ev:
  341|     43|    ~basic_cbor_parser() = default;
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5resetEv:
  349|     43|    {
  350|     43|        more_ = true;
  351|     43|        done_ = false;
  352|     43|        text_buffer_.clear();
  353|     43|        bytes_buffer_.clear();
  354|     43|        raw_tag_ = 0;
  355|     43|        state_stack_.clear();
  356|     43|        state_stack_.emplace_back(parse_mode::root,0);
  357|     43|        array_buffer_.clear();
  358|     43|        stringref_map_stack_.clear();
  359|     43|        nesting_depth_ = 0;
  360|     43|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
  451|     43|    {
  452|  22.9M|        while (!done_ && more_)
  ------------------
  |  Branch (452:16): [True: 22.9M, False: 2]
  |  Branch (452:26): [True: 22.9M, False: 0]
  ------------------
  453|  22.9M|        {
  454|  22.9M|            switch (state_stack_.back().mode)
  ------------------
  |  Branch (454:21): [True: 22.9M, False: 0]
  ------------------
  455|  22.9M|            {
  456|      0|                case parse_mode::multi_dim:
  ------------------
  |  Branch (456:17): [True: 0, False: 22.9M]
  ------------------
  457|      0|                {
  458|      0|                    state_stack_.pop_back();
  459|      0|                    break;
  460|      0|                }
  461|  2.13M|                case parse_mode::array:
  ------------------
  |  Branch (461:17): [True: 2.13M, False: 20.8M]
  ------------------
  462|  2.13M|                {
  463|  2.13M|                    if (is_multi_dim() && order_ == mdarray_order::row_major)
  ------------------
  |  Branch (463:25): [True: 0, False: 2.13M]
  |  Branch (463:43): [True: 0, False: 0]
  ------------------
  464|      0|                    {
  465|      0|                        if (!row_major_reader_.done())
  ------------------
  |  Branch (465:29): [True: 0, False: 0]
  ------------------
  466|      0|                        {
  467|      0|                            row_major_reader_.next(visitor, *this, ec);
  468|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  469|      0|                            {
  470|      0|                                return;
  471|      0|                            }
  472|      0|                        }
  473|      0|                        else
  474|      0|                        {
  475|      0|                            if (row_major_reader_.count() != state_stack_.back().length)
  ------------------
  |  Branch (475:33): [True: 0, False: 0]
  ------------------
  476|      0|                            {
  477|       |                                //std::cout << state_stack_.back().index << "!=" << state_stack_.back().length << "\n";
  478|      0|                                ec = cbor_errc::bad_mdarray;
  479|      0|                                return;
  480|      0|                            }
  481|      0|                            end_row_major_storage(ec);
  482|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  483|      0|                            {
  484|      0|                                return;
  485|      0|                            }
  486|      0|                        }
  487|      0|                    }
  488|  2.13M|                    else
  489|  2.13M|                    {
  490|  2.13M|                        if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (490:29): [True: 1.78M, False: 343k]
  ------------------
  491|  1.78M|                        {
  492|  1.78M|                            ++state_stack_.back().index;
  493|  1.78M|                            read_item(visitor, ec);
  494|  1.78M|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.78M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 1.78M]
  |  |  ------------------
  ------------------
  495|      3|                            {
  496|      3|                                return;
  497|      3|                            }
  498|  1.78M|                        }
  499|   343k|                        else
  500|   343k|                        {
  501|   343k|                            end_array(visitor, ec);
  502|   343k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   343k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 343k]
  |  |  ------------------
  ------------------
  503|      0|                            {
  504|      0|                                return;
  505|      0|                            }
  506|   343k|                        }
  507|  2.13M|                    }
  508|  2.13M|                    break;
  509|  2.13M|                }
  510|  13.5M|                case parse_mode::indefinite_array:
  ------------------
  |  Branch (510:17): [True: 13.5M, False: 9.39M]
  ------------------
  511|  13.5M|                {
  512|  13.5M|                    if (is_multi_dim() && order_ == mdarray_order::row_major)
  ------------------
  |  Branch (512:25): [True: 0, False: 13.5M]
  |  Branch (512:43): [True: 0, False: 0]
  ------------------
  513|      0|                    {
  514|      0|                        if (!row_major_reader_.done())
  ------------------
  |  Branch (514:29): [True: 0, False: 0]
  ------------------
  515|      0|                        {
  516|      0|                            row_major_reader_.next(visitor, *this, ec);
  517|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  518|      0|                            {
  519|      0|                                return;
  520|      0|                            }
  521|      0|                        }
  522|      0|                        else
  523|      0|                        {
  524|      0|                            auto c = source_.peek();
  525|      0|                            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  526|      0|                            {
  527|      0|                                ec = cbor_errc::unexpected_eof;
  528|      0|                                more_ = false;
  529|      0|                                return;
  530|      0|                            }
  531|      0|                            if (c.value == 0xff)
  ------------------
  |  Branch (531:33): [True: 0, False: 0]
  ------------------
  532|      0|                            {
  533|      0|                                source_.ignore(1);
  534|      0|                            }
  535|      0|                            else
  536|      0|                            {
  537|      0|                                ec = cbor_errc::bad_mdarray;
  538|      0|                                return;
  539|      0|                            }
  540|      0|                            end_row_major_storage(ec);
  541|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  542|      0|                            {
  543|      0|                                return;
  544|      0|                            }
  545|      0|                        }
  546|      0|                    }
  547|  13.5M|                    else
  548|  13.5M|                    {
  549|  13.5M|                        auto c = source_.peek();
  550|  13.5M|                        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  13.5M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 10, False: 13.5M]
  |  |  ------------------
  ------------------
  551|     10|                        {
  552|     10|                            ec = cbor_errc::unexpected_eof;
  553|     10|                            more_ = false;
  554|     10|                            return;
  555|     10|                        }
  556|  13.5M|                        if (c.value == 0xff)
  ------------------
  |  Branch (556:29): [True: 12, False: 13.5M]
  ------------------
  557|     12|                        {
  558|     12|                            source_.ignore(1);
  559|     12|                            end_array(visitor, ec);
  560|     12|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     12|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 12]
  |  |  ------------------
  ------------------
  561|      0|                            {
  562|      0|                                return;
  563|      0|                            }
  564|     12|                        }
  565|  13.5M|                        else
  566|  13.5M|                        {
  567|  13.5M|                            read_item(visitor, ec);
  568|  13.5M|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  13.5M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 13.5M]
  |  |  ------------------
  ------------------
  569|      7|                            {
  570|      7|                                return;
  571|      7|                            }
  572|  13.5M|                        }
  573|  13.5M|                    }
  574|  13.5M|                    break;
  575|  13.5M|                }
  576|  13.5M|                case parse_mode::typed_array:
  ------------------
  |  Branch (576:17): [True: 21.8k, False: 22.9M]
  ------------------
  577|  21.8k|                {
  578|  21.8k|                    read_typed_array_item(visitor, ec);
  579|  21.8k|                    break;
  580|  13.5M|                }
  581|  3.36M|                case parse_mode::map_key:
  ------------------
  |  Branch (581:17): [True: 3.36M, False: 19.5M]
  ------------------
  582|  3.36M|                {
  583|  3.36M|                    if (state_stack_.back().index < state_stack_.back().length)
  ------------------
  |  Branch (583:25): [True: 171k, False: 3.19M]
  ------------------
  584|   171k|                    {
  585|   171k|                        ++state_stack_.back().index;
  586|   171k|                        state_stack_.back().mode = parse_mode::map_value;
  587|   171k|                        read_item(visitor, ec);
  588|   171k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   171k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 171k]
  |  |  ------------------
  ------------------
  589|      3|                        {
  590|      3|                            return;
  591|      3|                        }
  592|   171k|                    }
  593|  3.19M|                    else
  594|  3.19M|                    {
  595|  3.19M|                        end_object(visitor, ec);
  596|  3.19M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.19M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.19M]
  |  |  ------------------
  ------------------
  597|      0|                        {
  598|      0|                            return;
  599|      0|                        }
  600|  3.19M|                    }
  601|  3.36M|                    break;
  602|  3.36M|                }
  603|  3.36M|                case parse_mode::map_value:
  ------------------
  |  Branch (603:17): [True: 171k, False: 22.7M]
  ------------------
  604|   171k|                {
  605|   171k|                    state_stack_.back().mode = parse_mode::map_key;
  606|   171k|                    read_item(visitor, ec);
  607|   171k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   171k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 6, False: 171k]
  |  |  ------------------
  ------------------
  608|      6|                    {
  609|      6|                        return;
  610|      6|                    }
  611|   171k|                    break;
  612|   171k|                }
  613|  1.91M|                case parse_mode::indefinite_map_key:
  ------------------
  |  Branch (613:17): [True: 1.91M, False: 21.0M]
  ------------------
  614|  1.91M|                {
  615|  1.91M|                    auto c = source_.peek();
  616|  1.91M|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.91M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 1.91M]
  |  |  ------------------
  ------------------
  617|      2|                    {
  618|      2|                        ec = cbor_errc::unexpected_eof;
  619|      2|                        more_ = false;
  620|      2|                        return;
  621|      2|                    }
  622|  1.91M|                    if (c.value == 0xff)
  ------------------
  |  Branch (622:25): [True: 122k, False: 1.78M]
  ------------------
  623|   122k|                    {
  624|   122k|                        source_.ignore(1);
  625|   122k|                        end_object(visitor, ec);
  626|   122k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   122k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 122k]
  |  |  ------------------
  ------------------
  627|      0|                        {
  628|      0|                            return;
  629|      0|                        }
  630|   122k|                    }
  631|  1.78M|                    else
  632|  1.78M|                    {
  633|  1.78M|                        state_stack_.back().mode = parse_mode::indefinite_map_value;
  634|  1.78M|                        read_item(visitor, ec);
  635|  1.78M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.78M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 1.78M]
  |  |  ------------------
  ------------------
  636|      1|                        {
  637|      1|                            return;
  638|      1|                        }
  639|  1.78M|                    }
  640|  1.91M|                    break;
  641|  1.91M|                }
  642|  1.91M|                case parse_mode::indefinite_map_value:
  ------------------
  |  Branch (642:17): [True: 1.78M, False: 21.1M]
  ------------------
  643|  1.78M|                {
  644|  1.78M|                    state_stack_.back().mode = parse_mode::indefinite_map_key;
  645|  1.78M|                    read_item(visitor, ec);
  646|  1.78M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.78M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 2, False: 1.78M]
  |  |  ------------------
  ------------------
  647|      2|                    {
  648|      2|                        return;
  649|      2|                    }
  650|  1.78M|                    break;
  651|  1.78M|                }
  652|  1.78M|                case parse_mode::root:
  ------------------
  |  Branch (652:17): [True: 43, False: 22.9M]
  ------------------
  653|     43|                {
  654|     43|                    state_stack_.back().mode = parse_mode::accept;
  655|     43|                    read_item(visitor, ec);
  656|     43|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     43|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 36]
  |  |  ------------------
  ------------------
  657|      7|                    {
  658|      7|                        return;
  659|      7|                    }
  660|     36|                    break;
  661|     43|                }
  662|     36|                case parse_mode::accept:
  ------------------
  |  Branch (662:17): [True: 2, False: 22.9M]
  ------------------
  663|      2|                {
  664|      2|                    JSONCONS_ASSERT(state_stack_.size() == 1);
  ------------------
  |  |   45|      2|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 2]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  665|      2|                    state_stack_.clear();
  666|      2|                    more_ = false;
  667|      2|                    done_ = true;
  668|      2|                    visitor.flush();
  669|      2|                    break;
  670|      2|                }
  671|  22.9M|            }
  672|  22.9M|        }
  673|     43|    }
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12is_multi_dimEv:
  373|  15.7M|    {
  374|  15.7M|        return state_stack_.size() >=2 && state_stack_[state_stack_.size()-2].mode == parse_mode::multi_dim;
  ------------------
  |  Branch (374:16): [True: 15.7M, False: 0]
  |  Branch (374:43): [True: 0, False: 15.7M]
  ------------------
  375|  15.7M|    }
_ZNK8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5levelEv:
  395|  3.66M|    {
  396|  3.66M|        return static_cast<int>(state_stack_.size());
  397|  3.66M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_itemERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
  694|  19.2M|    {
  695|  19.2M|        read_tags(ec);
  696|  19.2M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  19.2M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 19.2M]
  |  |  ------------------
  ------------------
  697|      3|        {
  698|      3|            return;
  699|      3|        }
  700|  19.2M|        auto c = source_.peek();
  701|  19.2M|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  19.2M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 19.2M]
  |  |  ------------------
  ------------------
  702|      0|        {
  703|      0|            ec = cbor_errc::unexpected_eof;
  704|      0|            more_ = false;
  705|      0|            return;
  706|      0|        }
  707|  19.2M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
  708|  19.2M|        uint8_t info = get_additional_information_value(c.value);
  709|       |
  710|  19.2M|        switch (major_type)
  711|  19.2M|        {
  712|  4.36M|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (712:13): [True: 4.36M, False: 14.9M]
  ------------------
  713|  4.36M|            {
  714|  4.36M|                uint64_t val = read_uint64(ec);
  715|  4.36M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.36M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4.36M]
  |  |  ------------------
  ------------------
  716|      0|                {
  717|      0|                    return;
  718|      0|                }
  719|  4.36M|                if (!stringref_map_stack_.empty() && other_tags_[stringref_tag])
  ------------------
  |  Branch (719:21): [True: 267k, False: 4.09M]
  |  Branch (719:21): [True: 69, False: 4.36M]
  |  Branch (719:54): [True: 69, False: 267k]
  ------------------
  720|     69|                {
  721|     69|                    other_tags_[stringref_tag] = false;
  722|     69|                    if (val >= stringref_map_stack_.back().size())
  ------------------
  |  Branch (722:25): [True: 0, False: 69]
  ------------------
  723|      0|                    {
  724|      0|                        ec = cbor_errc::stringref_too_large;
  725|      0|                        more_ = false;
  726|      0|                        return;
  727|      0|                    }
  728|     69|                    auto index = static_cast<typename stringref_map::size_type>(val);
  729|     69|                    if (index != val)
  ------------------
  |  Branch (729:25): [True: 0, False: 69]
  ------------------
  730|      0|                    {
  731|      0|                        ec = cbor_errc::number_too_large;
  732|      0|                        more_ = false;
  733|      0|                        return;
  734|      0|                    }
  735|     69|                    auto& str = stringref_map_stack_.back().at(index);
  736|     69|                    switch (str.type)
  737|     69|                    {
  738|      0|                        case jsoncons::cbor::detail::cbor_major_type::text_string:
  ------------------
  |  Branch (738:25): [True: 0, False: 69]
  ------------------
  739|      0|                        {
  740|      0|                            handle_string(visitor, jsoncons::basic_string_view<char>(str.str.data(),str.str.length()),ec);
  741|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  742|      0|                            {
  743|      0|                                return;
  744|      0|                            }
  745|      0|                            break;
  746|      0|                        }
  747|     69|                        case jsoncons::cbor::detail::cbor_major_type::byte_string:
  ------------------
  |  Branch (747:25): [True: 69, False: 0]
  ------------------
  748|     69|                        {
  749|     69|                            read_byte_string_from_buffer read(byte_string_view(str.bytes));
  750|     69|                            read_byte_string(read, visitor, ec);
  751|     69|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     69|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 69]
  |  |  ------------------
  ------------------
  752|      0|                            {
  753|      0|                                return;
  754|      0|                            }
  755|     69|                            break;
  756|     69|                        }
  757|     69|                        default:
  ------------------
  |  Branch (757:25): [True: 0, False: 69]
  ------------------
  758|      0|                            JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
  759|      0|                            break;
  760|     69|                    }
  761|     69|                }
  762|  4.36M|                else
  763|  4.36M|                {
  764|  4.36M|                    semantic_tag tag = semantic_tag::none;
  765|  4.36M|                    if (other_tags_[item_tag])
  ------------------
  |  Branch (765:25): [True: 2.43k, False: 4.36M]
  ------------------
  766|  2.43k|                    {
  767|  2.43k|                        if (raw_tag_ == 1)
  ------------------
  |  Branch (767:29): [True: 7, False: 2.43k]
  ------------------
  768|      7|                        {
  769|      7|                            tag = semantic_tag::epoch_second;
  770|      7|                        }
  771|  2.43k|                        other_tags_[item_tag] = false;
  772|  2.43k|                    }
  773|  4.36M|                    visitor.uint64_value(val, tag, *this, ec);
  774|  4.36M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  4.36M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4.36M]
  |  |  ------------------
  ------------------
  775|      0|                    {
  776|      0|                        return;
  777|      0|                    }
  778|  4.36M|                    more_ = !cursor_mode_;
  779|  4.36M|                }
  780|  4.36M|                break;
  781|  4.36M|            }
  782|  4.36M|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (782:13): [True: 3.63M, False: 15.6M]
  ------------------
  783|  3.63M|            {
  784|  3.63M|                int64_t val = read_int64(ec);
  785|  3.63M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.63M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.63M]
  |  |  ------------------
  ------------------
  786|      0|                {
  787|      0|                    return;
  788|      0|                }
  789|  3.63M|                semantic_tag tag = semantic_tag::none;
  790|  3.63M|                if (other_tags_[item_tag])
  ------------------
  |  Branch (790:21): [True: 441, False: 3.63M]
  ------------------
  791|    441|                {
  792|    441|                    if (raw_tag_ == 1)
  ------------------
  |  Branch (792:25): [True: 0, False: 441]
  ------------------
  793|      0|                    {
  794|      0|                        tag = semantic_tag::epoch_second;
  795|      0|                    }
  796|    441|                    other_tags_[item_tag] = false;
  797|    441|                }
  798|  3.63M|                visitor.int64_value(val, tag, *this, ec);
  799|  3.63M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.63M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.63M]
  |  |  ------------------
  ------------------
  800|      0|                {
  801|      0|                    return;
  802|      0|                }
  803|  3.63M|                more_ = !cursor_mode_;
  804|  3.63M|                break;
  805|  3.63M|            }
  806|  2.72M|            case jsoncons::cbor::detail::cbor_major_type::byte_string:
  ------------------
  |  Branch (806:13): [True: 2.72M, False: 16.5M]
  ------------------
  807|  2.72M|            {
  808|  2.72M|                read_byte_string_from_source read(this);
  809|  2.72M|                read_byte_string(read, visitor, ec);
  810|  2.72M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.72M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 2.72M]
  |  |  ------------------
  ------------------
  811|      7|                {
  812|      7|                    return;
  813|      7|                }
  814|  2.72M|                break;
  815|  2.72M|            }
  816|  2.72M|            case jsoncons::cbor::detail::cbor_major_type::text_string:
  ------------------
  |  Branch (816:13): [True: 1.07M, False: 18.2M]
  ------------------
  817|  1.07M|            {
  818|  1.07M|                text_buffer_.clear();
  819|       |
  820|  1.07M|                read_text_string(text_buffer_, ec);
  821|  1.07M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.07M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 9, False: 1.07M]
  |  |  ------------------
  ------------------
  822|      9|                {
  823|      9|                    return;
  824|      9|                }
  825|  1.07M|                auto result = unicode_traits::validate(text_buffer_.data(),text_buffer_.size());
  826|  1.07M|                if (result.ec != unicode_traits::conv_errc())
  ------------------
  |  Branch (826:21): [True: 2, False: 1.07M]
  ------------------
  827|      2|                {
  828|      2|                    ec = cbor_errc::invalid_utf8_text_string;
  829|      2|                    more_ = false;
  830|      2|                    return;
  831|      2|                }
  832|  1.07M|                handle_string(visitor, jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()),ec);
  833|  1.07M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.07M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.07M]
  |  |  ------------------
  ------------------
  834|      0|                {
  835|      0|                    return;
  836|      0|                }
  837|  1.07M|                break;
  838|  1.07M|            }
  839|  1.07M|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (839:13): [True: 0, False: 19.2M]
  ------------------
  840|      0|            {
  841|      0|                JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
  842|      0|                break;
  843|  1.07M|            }
  844|  3.45M|            case jsoncons::cbor::detail::cbor_major_type::simple:
  ------------------
  |  Branch (844:13): [True: 3.45M, False: 15.8M]
  ------------------
  845|  3.45M|            {
  846|  3.45M|                switch (info)
  847|  3.45M|                {
  848|  2.11M|                    case 0x14:
  ------------------
  |  Branch (848:21): [True: 2.11M, False: 1.33M]
  ------------------
  849|  2.11M|                        visitor.bool_value(false, semantic_tag::none, *this, ec);
  850|  2.11M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.11M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.11M]
  |  |  ------------------
  ------------------
  851|      0|                        {
  852|      0|                            return;
  853|      0|                        }
  854|  2.11M|                        more_ = !cursor_mode_;
  855|  2.11M|                        source_.ignore(1);
  856|  2.11M|                        break;
  857|   201k|                    case 0x15:
  ------------------
  |  Branch (857:21): [True: 201k, False: 3.24M]
  ------------------
  858|   201k|                        visitor.bool_value(true, semantic_tag::none, *this, ec);
  859|   201k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   201k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 201k]
  |  |  ------------------
  ------------------
  860|      0|                        {
  861|      0|                            return;
  862|      0|                        }
  863|   201k|                        more_ = !cursor_mode_;
  864|   201k|                        source_.ignore(1);
  865|   201k|                        break;
  866|  1.11M|                    case 0x16:
  ------------------
  |  Branch (866:21): [True: 1.11M, False: 2.33M]
  ------------------
  867|  1.11M|                        visitor.null_value(semantic_tag::none, *this, ec);
  868|  1.11M|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.11M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.11M]
  |  |  ------------------
  ------------------
  869|      0|                        {
  870|      0|                            return;
  871|      0|                        }
  872|  1.11M|                        more_ = !cursor_mode_;
  873|  1.11M|                        source_.ignore(1);
  874|  1.11M|                        break;
  875|  9.62k|                    case 0x17:
  ------------------
  |  Branch (875:21): [True: 9.62k, False: 3.44M]
  ------------------
  876|  9.62k|                        visitor.null_value(semantic_tag::undefined, *this, ec);
  877|  9.62k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  9.62k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 9.62k]
  |  |  ------------------
  ------------------
  878|      0|                        {
  879|      0|                            return;
  880|      0|                        }
  881|  9.62k|                        more_ = !cursor_mode_;
  882|  9.62k|                        source_.ignore(1);
  883|  9.62k|                        break;
  884|  5.07k|                    case 0x19: // Half-Precision Float (two-byte IEEE 754)
  ------------------
  |  Branch (884:21): [True: 5.07k, False: 3.44M]
  ------------------
  885|  5.07k|                    {
  886|  5.07k|                        uint64_t val = read_uint64(ec);
  887|  5.07k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  5.07k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5.07k]
  |  |  ------------------
  ------------------
  888|      0|                        {
  889|      0|                            return;
  890|      0|                        }
  891|  5.07k|                        visitor.half_value(static_cast<uint16_t>(val), semantic_tag::none, *this, ec);
  892|  5.07k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  5.07k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 5.07k]
  |  |  ------------------
  ------------------
  893|      0|                        {
  894|      0|                            return;
  895|      0|                        }
  896|  5.07k|                        more_ = !cursor_mode_;
  897|  5.07k|                        break;
  898|  5.07k|                    }
  899|    629|                    case 0x1a: // Single-Precision Float (four-byte IEEE 754)
  ------------------
  |  Branch (899:21): [True: 629, False: 3.45M]
  ------------------
  900|  1.46k|                    case 0x1b: // Double-Precision Float (eight-byte IEEE 754)
  ------------------
  |  Branch (900:21): [True: 839, False: 3.45M]
  ------------------
  901|  1.46k|                    {
  902|  1.46k|                        double val = read_double(ec);
  903|  1.46k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.46k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.46k]
  |  |  ------------------
  ------------------
  904|      0|                        {
  905|      0|                            return;
  906|      0|                        }
  907|  1.46k|                        semantic_tag tag = semantic_tag::none;
  908|  1.46k|                        if (other_tags_[item_tag])
  ------------------
  |  Branch (908:29): [True: 16, False: 1.45k]
  ------------------
  909|     16|                        {
  910|     16|                            if (raw_tag_ == 1)
  ------------------
  |  Branch (910:33): [True: 0, False: 16]
  ------------------
  911|      0|                            {
  912|      0|                                tag = semantic_tag::epoch_second;
  913|      0|                            }
  914|     16|                            other_tags_[item_tag] = false;
  915|     16|                        }
  916|  1.46k|                        visitor.double_value(val, tag, *this, ec);
  917|  1.46k|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.46k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.46k]
  |  |  ------------------
  ------------------
  918|      0|                        {
  919|      0|                            return;
  920|      0|                        }
  921|  1.46k|                        more_ = !cursor_mode_;
  922|  1.46k|                        break;
  923|  1.46k|                    }
  924|      4|                    default:
  ------------------
  |  Branch (924:21): [True: 4, False: 3.45M]
  ------------------
  925|      4|                    {
  926|      4|                        ec = cbor_errc::unknown_type;
  927|      4|                        more_ = false;
  928|      4|                        return;
  929|  1.46k|                    }
  930|  3.45M|                }
  931|  3.45M|                break;
  932|  3.45M|            }
  933|  3.45M|            case jsoncons::cbor::detail::cbor_major_type::array:
  ------------------
  |  Branch (933:13): [True: 712k, False: 18.5M]
  ------------------
  934|   712k|            {
  935|   712k|                if (other_tags_[item_tag])
  ------------------
  |  Branch (935:21): [True: 377k, False: 335k]
  ------------------
  936|   377k|                {
  937|   377k|                    switch (raw_tag_)
  938|   377k|                    {
  939|   368k|                        case 0x04:
  ------------------
  |  Branch (939:25): [True: 368k, False: 8.52k]
  ------------------
  940|   368k|                            text_buffer_.clear();
  941|   368k|                            read_decimal_fraction(text_buffer_, ec);
  942|   368k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   368k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 368k]
  |  |  ------------------
  ------------------
  943|      3|                            {
  944|      3|                                return;
  945|      3|                            }
  946|   368k|                            visitor.string_value(text_buffer_, semantic_tag::bigdec, *this, ec);
  947|   368k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   368k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 368k]
  |  |  ------------------
  ------------------
  948|      0|                            {
  949|      0|                                return;
  950|      0|                            }
  951|   368k|                            more_ = !cursor_mode_;
  952|   368k|                            break;
  953|    100|                        case 0x05:
  ------------------
  |  Branch (953:25): [True: 100, False: 377k]
  ------------------
  954|    100|                            text_buffer_.clear();
  955|    100|                            read_bigfloat(text_buffer_, ec);
  956|    100|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    100|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 100]
  |  |  ------------------
  ------------------
  957|      0|                            {
  958|      0|                                return;
  959|      0|                            }
  960|    100|                            visitor.string_value(text_buffer_, semantic_tag::bigfloat, *this, ec);
  961|    100|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    100|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 100]
  |  |  ------------------
  ------------------
  962|      0|                            {
  963|      0|                                return;
  964|      0|                            }
  965|    100|                            more_ = !cursor_mode_;
  966|    100|                            break;
  967|      1|                        case 40: // row major storage
  ------------------
  |  Branch (967:25): [True: 1, False: 377k]
  ------------------
  968|      1|                            order_ = mdarray_order::row_major;
  969|      1|                            read_mdarray_header(visitor, ec);
  970|      1|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  971|      1|                            {
  972|      1|                                return;
  973|      1|                            }
  974|      0|                            break;
  975|      0|                        case 1040: // column major storage
  ------------------
  |  Branch (975:25): [True: 0, False: 377k]
  ------------------
  976|      0|                            order_ = mdarray_order::column_major;
  977|      0|                            read_mdarray_header(visitor, ec);
  978|      0|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  979|      0|                            {
  980|      0|                                return;
  981|      0|                            }
  982|      0|                            break;
  983|  8.42k|                        default:
  ------------------
  |  Branch (983:25): [True: 8.42k, False: 368k]
  ------------------
  984|  8.42k|                            begin_array(visitor, info, ec);
  985|  8.42k|                            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  8.42k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 8.42k]
  |  |  ------------------
  ------------------
  986|      0|                            {
  987|      0|                                return;
  988|      0|                            }
  989|  8.42k|                            break;
  990|   377k|                    }
  991|   377k|                    other_tags_[item_tag] = false;
  992|   377k|                }
  993|   335k|                else
  994|   335k|                {
  995|   335k|                    begin_array(visitor, info, ec);
  996|   335k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   335k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 335k]
  |  |  ------------------
  ------------------
  997|      0|                    {
  998|      0|                        return;
  999|      0|                    }
 1000|   335k|                }
 1001|   712k|                break;
 1002|   712k|            }
 1003|  3.31M|            case jsoncons::cbor::detail::cbor_major_type::map:
  ------------------
  |  Branch (1003:13): [True: 3.31M, False: 15.9M]
  ------------------
 1004|  3.31M|            {
 1005|  3.31M|                begin_object(visitor, info, ec);
 1006|  3.31M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.31M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.31M]
  |  |  ------------------
  ------------------
 1007|      0|                {
 1008|      0|                    return;
 1009|      0|                }
 1010|  3.31M|                break;
 1011|  3.31M|            }
 1012|  3.31M|            default:
  ------------------
  |  Branch (1012:13): [True: 0, False: 19.2M]
  ------------------
 1013|      0|                break;
 1014|  19.2M|        }
 1015|  19.2M|        other_tags_[item_tag] = false;
 1016|  19.2M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_tagsERNS3_10error_codeE:
 1927|  19.2M|    {
 1928|  19.2M|        auto c = source_.peek();
 1929|  19.2M|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  19.2M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 3, False: 19.2M]
  |  |  ------------------
  ------------------
 1930|      3|        {
 1931|      3|            ec = cbor_errc::unexpected_eof;
 1932|      3|            more_ = false;
 1933|      3|            return;
 1934|      3|        }
 1935|  19.2M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1936|       |
 1937|  20.5M|        while (major_type == jsoncons::cbor::detail::cbor_major_type::semantic_tag)
  ------------------
  |  Branch (1937:16): [True: 1.25M, False: 19.2M]
  ------------------
 1938|  1.25M|        {
 1939|  1.25M|            uint64_t val = read_uint64(ec);
 1940|  1.25M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.25M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.25M]
  |  |  ------------------
  ------------------
 1941|      0|            {
 1942|      0|                return;
 1943|      0|            }
 1944|  1.25M|            switch(val)
 1945|  1.25M|            {
 1946|    640|                case 25: // stringref
  ------------------
  |  Branch (1946:17): [True: 640, False: 1.25M]
  ------------------
 1947|    640|                    other_tags_[stringref_tag] = true;
 1948|    640|                    break;
 1949|     62|                case 256: // stringref-namespace
  ------------------
  |  Branch (1949:17): [True: 62, False: 1.25M]
  ------------------
 1950|     62|                    other_tags_[stringref_namespace_tag] = true;
 1951|     62|                    break;
 1952|  1.25M|                default:
  ------------------
  |  Branch (1952:17): [True: 1.25M, False: 702]
  ------------------
 1953|  1.25M|                    other_tags_[item_tag] = true;
 1954|  1.25M|                    raw_tag_ = val;
 1955|  1.25M|                    break;
 1956|  1.25M|            }
 1957|  1.25M|            c = source_.peek();
 1958|  1.25M|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.25M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.25M]
  |  |  ------------------
  ------------------
 1959|      0|            {
 1960|      0|                ec = cbor_errc::unexpected_eof;
 1961|      0|                more_ = false;
 1962|      0|                return;
 1963|      0|            }
 1964|  1.25M|            major_type = get_major_type(c.value);
 1965|  1.25M|        }
 1966|  19.2M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE14get_major_typeEh:
 1913|  51.8M|    {
 1914|  51.8M|        static constexpr uint8_t major_type_shift = 0x05;
 1915|  51.8M|        uint8_t value = type >> major_type_shift;
 1916|  51.8M|        return static_cast<jsoncons::cbor::detail::cbor_major_type>(value);
 1917|  51.8M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE32get_additional_information_valueEh:
 1920|  43.9M|    {
 1921|  43.9M|        static constexpr uint8_t additional_information_mask = (1U << 5) - 1;
 1922|  43.9M|        uint8_t value = type & additional_information_mask;
 1923|  43.9M|        return value;
 1924|  43.9M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11read_uint64ERNS3_10error_codeE:
 1387|  13.3M|    {
 1388|  13.3M|        uint64_t val = 0;
 1389|       |
 1390|  13.3M|        uint8_t initial_b;
 1391|  13.3M|        if (source_.read(&initial_b, 1) == 0)
  ------------------
  |  Branch (1391:13): [True: 0, False: 13.3M]
  ------------------
 1392|      0|        {
 1393|      0|            ec = cbor_errc::unexpected_eof;
 1394|      0|            more_ = false;
 1395|      0|            return 0;
 1396|      0|        }
 1397|  13.3M|        uint8_t info = get_additional_information_value(initial_b);
 1398|  13.3M|        switch (info)
 1399|  13.3M|        {
 1400|  8.21M|            case JSONCONS_EXT_CBOR_0x00_0x17: // Integer 0x00..0x17 (0..23)
  ------------------
  |  |   18|  8.21M|    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: 15.3k, False: 13.3M]
  |  |  |  Branch (18:20): [True: 390k, False: 12.9M]
  |  |  |  Branch (18:30): [True: 940, False: 13.3M]
  |  |  |  Branch (18:40): [True: 374k, False: 13.0M]
  |  |  |  Branch (18:50): [True: 875k, False: 12.5M]
  |  |  |  Branch (18:60): [True: 569, False: 13.3M]
  |  |  |  Branch (18:70): [True: 349, False: 13.3M]
  |  |  |  Branch (18:80): [True: 4.68k, False: 13.3M]
  |  |  |  Branch (18:90): [True: 130k, False: 13.2M]
  |  |  |  Branch (18:100): [True: 458, False: 13.3M]
  |  |  |  Branch (18:110): [True: 413, False: 13.3M]
  |  |  |  Branch (18:120): [True: 9.04k, False: 13.3M]
  |  |  |  Branch (18:130): [True: 1.00k, False: 13.3M]
  |  |  |  Branch (18:140): [True: 41, False: 13.3M]
  |  |  |  Branch (18:150): [True: 940, False: 13.3M]
  |  |  |  Branch (18:160): [True: 666, False: 13.3M]
  |  |  |  Branch (18:170): [True: 10.1k, False: 13.3M]
  |  |  |  Branch (18:180): [True: 3.20k, False: 13.3M]
  |  |  |  Branch (18:190): [True: 8.55k, False: 13.3M]
  |  |  |  Branch (18:200): [True: 265, False: 13.3M]
  |  |  |  Branch (18:210): [True: 123k, False: 13.2M]
  |  |  |  Branch (18:220): [True: 1.01k, False: 13.3M]
  |  |  ------------------
  ------------------
  |  Branch (1400:13): [True: 6.26M, False: 7.10M]
  ------------------
 1401|  8.21M|            {
 1402|  8.21M|                val = info;
 1403|  8.21M|                break;
 1404|   171M|            }
 1405|       |
 1406|  4.93k|            case 0x18: // Unsigned integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1406:13): [True: 4.93k, False: 13.3M]
  ------------------
 1407|  4.93k|            {
 1408|  4.93k|                uint8_t b;
 1409|  4.93k|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1409:21): [True: 0, False: 4.93k]
  ------------------
 1410|      0|                {
 1411|      0|                    ec = cbor_errc::unexpected_eof;
 1412|      0|                    more_ = false;
 1413|      0|                    return val;
 1414|      0|                }
 1415|  4.93k|                val = b;
 1416|  4.93k|                break;
 1417|  4.93k|            }
 1418|       |
 1419|  5.36k|            case 0x19: // Unsigned integer (two-byte uint16_t follows)
  ------------------
  |  Branch (1419:13): [True: 5.36k, False: 13.3M]
  ------------------
 1420|  5.36k|            {
 1421|  5.36k|                uint8_t buf[sizeof(uint16_t)];
 1422|  5.36k|                source_.read(buf, sizeof(uint16_t));
 1423|  5.36k|                val = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1424|  5.36k|                break;
 1425|  4.93k|            }
 1426|       |
 1427|     90|            case 0x1a: // Unsigned integer (four-byte uint32_t follows)
  ------------------
  |  Branch (1427:13): [True: 90, False: 13.3M]
  ------------------
 1428|     90|            {
 1429|     90|                uint8_t buf[sizeof(uint32_t)];
 1430|     90|                source_.read(buf, sizeof(uint32_t));
 1431|     90|                val = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1432|     90|                break;
 1433|  4.93k|            }
 1434|       |
 1435|    147|            case 0x1b: // Unsigned integer (eight-byte uint64_t follows)
  ------------------
  |  Branch (1435:13): [True: 147, False: 13.3M]
  ------------------
 1436|    147|            {
 1437|    147|                uint8_t buf[sizeof(uint64_t)];
 1438|    147|                source_.read(buf, sizeof(uint64_t));
 1439|    147|                val = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1440|    147|                break;
 1441|  4.93k|            }
 1442|  5.14M|            default:
  ------------------
  |  Branch (1442:13): [True: 5.14M, False: 8.23M]
  ------------------
 1443|  5.14M|                break;
 1444|  13.3M|        }
 1445|  13.3M|        return val;
 1446|  13.3M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13handle_stringERNS_24basic_item_event_visitorIcEERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERNS3_10error_codeE:
 1969|  1.07M|    {
 1970|  1.07M|        semantic_tag tag = semantic_tag::none;
 1971|  1.07M|        if (other_tags_[item_tag])
  ------------------
  |  Branch (1971:13): [True: 468, False: 1.07M]
  ------------------
 1972|    468|        {
 1973|    468|            switch (raw_tag_)
 1974|    468|            {
 1975|    410|                case 0:
  ------------------
  |  Branch (1975:17): [True: 410, False: 58]
  ------------------
 1976|    410|                    tag = semantic_tag::datetime;
 1977|    410|                    break;
 1978|      0|                case 32:
  ------------------
  |  Branch (1978:17): [True: 0, False: 468]
  ------------------
 1979|      0|                    tag = semantic_tag::uri;
 1980|      0|                    break;
 1981|      0|                case 33:
  ------------------
  |  Branch (1981:17): [True: 0, False: 468]
  ------------------
 1982|      0|                    tag = semantic_tag::base64url;
 1983|      0|                    break;
 1984|     36|                case 34:
  ------------------
  |  Branch (1984:17): [True: 36, False: 432]
  ------------------
 1985|     36|                    tag = semantic_tag::base64;
 1986|     36|                    break;
 1987|     22|                default:
  ------------------
  |  Branch (1987:17): [True: 22, False: 446]
  ------------------
 1988|     22|                    break;
 1989|    468|            }
 1990|    468|            other_tags_[item_tag] = false;
 1991|    468|        }
 1992|  1.07M|        visitor.string_value(v, tag, *this, ec);
 1993|  1.07M|        more_ = !cursor_mode_;
 1994|  1.07M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_bufferC2ERKNS_16byte_string_viewE:
  289|     69|            : bytes(b)
  290|     69|        {
  291|     69|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringINS8_28read_byte_string_from_bufferEEEvT_RNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
 2011|     69|    {
 2012|     69|        if (other_tags_[item_tag])
  ------------------
  |  Branch (2012:13): [True: 58, False: 11]
  ------------------
 2013|     58|        {
 2014|     58|            switch (raw_tag_)
 2015|     58|            {
 2016|     20|                case 0x2:
  ------------------
  |  Branch (2016:17): [True: 20, False: 38]
  ------------------
 2017|     20|                {
 2018|     20|                    bytes_buffer_.clear();
 2019|     20|                    read(bytes_buffer_,ec);
 2020|     20|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     20|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 20]
  |  |  ------------------
  ------------------
 2021|      0|                    {
 2022|      0|                        more_ = false;
 2023|      0|                        return;
 2024|      0|                    }
 2025|     20|                    bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 2026|     20|                    text_buffer_.clear();
 2027|     20|                    n.write_string(text_buffer_);
 2028|     20|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2029|     20|                    more_ = !cursor_mode_;
 2030|     20|                    break;
 2031|     20|                }
 2032|     29|                case 0x3:
  ------------------
  |  Branch (2032:17): [True: 29, False: 29]
  ------------------
 2033|     29|                {
 2034|     29|                    bytes_buffer_.clear();
 2035|     29|                    read(bytes_buffer_,ec);
 2036|     29|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     29|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 29]
  |  |  ------------------
  ------------------
 2037|      0|                    {
 2038|      0|                        more_ = false;
 2039|      0|                        return;
 2040|      0|                    }
 2041|     29|                    bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 2042|     29|                    n = -1 - n;
 2043|     29|                    text_buffer_.clear();
 2044|     29|                    n.write_string(text_buffer_);
 2045|     29|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2046|     29|                    more_ = !cursor_mode_;
 2047|     29|                    break;
 2048|     29|                }
 2049|      0|                case 0x15:
  ------------------
  |  Branch (2049:17): [True: 0, False: 58]
  ------------------
 2050|      0|                {
 2051|      0|                    read(bytes_buffer_,ec);
 2052|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2053|      0|                    {
 2054|      0|                        more_ = false;
 2055|      0|                        return;
 2056|      0|                    }
 2057|      0|                    visitor.byte_string_value(bytes_buffer_, semantic_tag::base64url, *this, ec);
 2058|      0|                    more_ = !cursor_mode_;
 2059|      0|                    break;
 2060|      0|                }
 2061|      0|                case 0x16:
  ------------------
  |  Branch (2061:17): [True: 0, False: 58]
  ------------------
 2062|      0|                {
 2063|      0|                    read(bytes_buffer_,ec);
 2064|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2065|      0|                    {
 2066|      0|                        more_ = false;
 2067|      0|                        return;
 2068|      0|                    }
 2069|      0|                    visitor.byte_string_value(bytes_buffer_, semantic_tag::base64, *this, ec);
 2070|      0|                    more_ = !cursor_mode_;
 2071|      0|                    break;
 2072|      0|                }
 2073|      0|                case 0x17:
  ------------------
  |  Branch (2073:17): [True: 0, False: 58]
  ------------------
 2074|      0|                {
 2075|      0|                    read(bytes_buffer_,ec);
 2076|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2077|      0|                    {
 2078|      0|                        more_ = false;
 2079|      0|                        return;
 2080|      0|                    }
 2081|      0|                    visitor.byte_string_value(bytes_buffer_, semantic_tag::base16, *this, ec);
 2082|      0|                    more_ = !cursor_mode_;
 2083|      0|                    break;
 2084|      0|                }
 2085|      0|                case 0x40:
  ------------------
  |  Branch (2085:17): [True: 0, False: 58]
  ------------------
 2086|      0|                {
 2087|      0|                    array_tag_ = typed_array_tags::uint8;
 2088|      0|                    array_buffer_.clear();
 2089|      0|                    read(array_buffer_,ec);
 2090|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2091|      0|                    {
 2092|      0|                        more_ = false;
 2093|      0|                        return;
 2094|      0|                    }
 2095|      0|                    auto ta = typed_array_cast<const uint8_t>(array_buffer_);
 2096|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2096:25): [True: 0, False: 0]
  ------------------
 2097|      0|                    {
 2098|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2098:29): [True: 0, False: 0]
  ------------------
 2099|      0|                        {
 2100|      0|                            ec = cbor_errc::bad_extents;
 2101|      0|                            more_ = false;
 2102|      0|                            return;
 2103|      0|                        }
 2104|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<const uint8_t>>(ta, extents_, order_);
 2105|      0|                    }
 2106|      0|                    else
 2107|      0|                    {
 2108|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<const uint8_t>>(ta);
 2109|      0|                    }
 2110|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2111|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2112|      0|                    more_ = !cursor_mode_;
 2113|      0|                    break;
 2114|      0|                }
 2115|      0|                case 0x44:
  ------------------
  |  Branch (2115:17): [True: 0, False: 58]
  ------------------
 2116|      0|                {
 2117|      0|                    array_tag_ = typed_array_tags::uint8;
 2118|      0|                    typed_array_tag_ = semantic_tag::clamped;
 2119|      0|                    array_buffer_.clear();
 2120|      0|                    read(array_buffer_,ec);
 2121|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2122|      0|                    {
 2123|      0|                        more_ = false;
 2124|      0|                        return;
 2125|      0|                    }
 2126|      0|                    auto ta = typed_array_cast<const uint8_t>(array_buffer_);
 2127|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2127:25): [True: 0, False: 0]
  ------------------
 2128|      0|                    {
 2129|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2129:29): [True: 0, False: 0]
  ------------------
 2130|      0|                        {
 2131|      0|                            ec = cbor_errc::bad_extents;
 2132|      0|                            more_ = false;
 2133|      0|                            return;
 2134|      0|                        }
 2135|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<const uint8_t>>(ta, extents_, order_);
 2136|      0|                    }
 2137|      0|                    else
 2138|      0|                    {
 2139|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<const uint8_t>>(ta, semantic_tag::clamped);
 2140|      0|                    }
 2141|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2142|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2143|      0|                    more_ = !cursor_mode_;
 2144|      0|                    break;
 2145|      0|                }
 2146|      0|                case 0x41:
  ------------------
  |  Branch (2146:17): [True: 0, False: 58]
  ------------------
 2147|      0|                case 0x45:
  ------------------
  |  Branch (2147:17): [True: 0, False: 58]
  ------------------
 2148|      0|                {
 2149|      0|                    array_tag_ = typed_array_tags::uint16;
 2150|      0|                    array_buffer_.clear();
 2151|      0|                    read(array_buffer_,ec);
 2152|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2153|      0|                    {
 2154|      0|                        more_ = false;
 2155|      0|                        return;
 2156|      0|                    }
 2157|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2158|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2159|      0|                    auto ta = typed_array_cast<uint16_t>(array_buffer_);
 2160|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2160:25): [True: 0, False: 0]
  ------------------
 2161|      0|                    {
 2162|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2162:49): [True: 0, False: 0]
  ------------------
 2163|      0|                        {
 2164|      0|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2165|      0|                        }
 2166|      0|                    }
 2167|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2167:25): [True: 0, False: 0]
  ------------------
 2168|      0|                    {
 2169|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2169:29): [True: 0, False: 0]
  ------------------
 2170|      0|                        {
 2171|      0|                            ec = cbor_errc::bad_extents;
 2172|      0|                            more_ = false;
 2173|      0|                            return;
 2174|      0|                        }
 2175|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint16_t>>(ta, extents_, order_);
 2176|      0|                    }
 2177|      0|                    else
 2178|      0|                    {
 2179|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint16_t>>(ta);
 2180|      0|                    }
 2181|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2182|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2183|      0|                    more_ = !cursor_mode_;
 2184|      0|                    break;
 2185|      0|                }
 2186|      1|                case 0x42:
  ------------------
  |  Branch (2186:17): [True: 1, False: 57]
  ------------------
 2187|      1|                case 0x46:
  ------------------
  |  Branch (2187:17): [True: 0, False: 58]
  ------------------
 2188|      1|                {
 2189|      1|                    array_tag_ = typed_array_tags::uint32;
 2190|      1|                    array_buffer_.clear();
 2191|      1|                    read(array_buffer_,ec);
 2192|      1|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2193|      0|                    {
 2194|      0|                        more_ = false;
 2195|      0|                        return;
 2196|      0|                    }
 2197|      1|                    const uint8_t tag = (uint8_t)raw_tag_;
 2198|      1|                    jsoncons::endian e = get_typed_array_endianness(tag);
 2199|      1|                    auto ta = typed_array_cast<uint32_t>(array_buffer_);
 2200|      1|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2200:25): [True: 1, False: 0]
  ------------------
 2201|      1|                    {
 2202|      2|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2202:49): [True: 1, False: 1]
  ------------------
 2203|      1|                        {
 2204|      1|                            ta[i] = binary::byte_swap<uint32_t>(ta[i]);
 2205|      1|                        }
 2206|      1|                    }
 2207|      1|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2207:25): [True: 0, False: 1]
  ------------------
 2208|      0|                    {
 2209|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2209:29): [True: 0, False: 0]
  ------------------
 2210|      0|                        {
 2211|      0|                            ec = cbor_errc::bad_extents;
 2212|      0|                            more_ = false;
 2213|      0|                            return;
 2214|      0|                        }
 2215|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint32_t>>(ta, extents_, order_);
 2216|      0|                    }
 2217|      1|                    else
 2218|      1|                    {
 2219|      1|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint32_t>>(ta);
 2220|      1|                    }
 2221|      1|                    typed_array_iter_->next(visitor, *this, ec);
 2222|      1|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2223|      1|                    more_ = !cursor_mode_;
 2224|      1|                    break;
 2225|      1|                }
 2226|      0|                case 0x43:
  ------------------
  |  Branch (2226:17): [True: 0, False: 58]
  ------------------
 2227|      0|                case 0x47:
  ------------------
  |  Branch (2227:17): [True: 0, False: 58]
  ------------------
 2228|      0|                {
 2229|      0|                    array_tag_ = typed_array_tags::uint64;
 2230|      0|                    array_buffer_.clear();
 2231|      0|                    read(array_buffer_,ec);
 2232|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2233|      0|                    {
 2234|      0|                        more_ = false;
 2235|      0|                        return;
 2236|      0|                    }
 2237|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2238|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2239|      0|                    auto ta = typed_array_cast<uint64_t>(array_buffer_);
 2240|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2240:25): [True: 0, False: 0]
  ------------------
 2241|      0|                    {
 2242|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2242:49): [True: 0, False: 0]
  ------------------
 2243|      0|                        {
 2244|      0|                            ta[i] = binary::byte_swap<uint64_t>(ta[i]);
 2245|      0|                        }
 2246|      0|                    }
 2247|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2247:25): [True: 0, False: 0]
  ------------------
 2248|      0|                    {
 2249|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2249:29): [True: 0, False: 0]
  ------------------
 2250|      0|                        {
 2251|      0|                            ec = cbor_errc::bad_extents;
 2252|      0|                            more_ = false;
 2253|      0|                            return;
 2254|      0|                        }
 2255|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint64_t>>(ta, extents_, order_);
 2256|      0|                    }
 2257|      0|                    else
 2258|      0|                    {
 2259|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint64_t>>(ta);
 2260|      0|                    }
 2261|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2262|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2263|      0|                    more_ = !cursor_mode_;
 2264|      0|                    break;
 2265|      0|                }
 2266|      0|                case 0x48:
  ------------------
  |  Branch (2266:17): [True: 0, False: 58]
  ------------------
 2267|      0|                {
 2268|      0|                    array_tag_ = typed_array_tags::int8;
 2269|      0|                    array_buffer_.clear();
 2270|      0|                    read(array_buffer_,ec);
 2271|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2272|      0|                    {
 2273|      0|                        more_ = false;
 2274|      0|                        return;
 2275|      0|                    }
 2276|      0|                    auto ta = typed_array_cast<int8_t>(array_buffer_);
 2277|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2277:25): [True: 0, False: 0]
  ------------------
 2278|      0|                    {
 2279|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2279:29): [True: 0, False: 0]
  ------------------
 2280|      0|                        {
 2281|      0|                            ec = cbor_errc::bad_extents;
 2282|      0|                            more_ = false;
 2283|      0|                            return;
 2284|      0|                        }
 2285|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int8_t>>(ta, extents_, order_);
 2286|      0|                    }
 2287|      0|                    else
 2288|      0|                    {
 2289|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int8_t>>(ta);
 2290|      0|                    }
 2291|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2292|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2293|      0|                    more_ = !cursor_mode_;
 2294|      0|                    break;
 2295|      0|                }
 2296|      0|                case 0x49:
  ------------------
  |  Branch (2296:17): [True: 0, False: 58]
  ------------------
 2297|      0|                case 0x4d:
  ------------------
  |  Branch (2297:17): [True: 0, False: 58]
  ------------------
 2298|      0|                {
 2299|      0|                    array_tag_ = typed_array_tags::int16;
 2300|      0|                    array_buffer_.clear();
 2301|      0|                    read(array_buffer_,ec);
 2302|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2303|      0|                    {
 2304|      0|                        more_ = false;
 2305|      0|                        return;
 2306|      0|                    }
 2307|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2308|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2309|      0|                    auto ta = typed_array_cast<int16_t>(array_buffer_);
 2310|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2310:25): [True: 0, False: 0]
  ------------------
 2311|      0|                    {
 2312|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2312:49): [True: 0, False: 0]
  ------------------
 2313|      0|                        {
 2314|      0|                            ta[i] = binary::byte_swap<int16_t>(ta[i]);
 2315|      0|                        }
 2316|      0|                    }
 2317|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2317:25): [True: 0, False: 0]
  ------------------
 2318|      0|                    {
 2319|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2319:29): [True: 0, False: 0]
  ------------------
 2320|      0|                        {
 2321|      0|                            ec = cbor_errc::bad_extents;
 2322|      0|                            more_ = false;
 2323|      0|                            return;
 2324|      0|                        }
 2325|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int16_t>>(ta, extents_, order_);
 2326|      0|                    }
 2327|      0|                    else
 2328|      0|                    {
 2329|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int16_t>>(ta);
 2330|      0|                    }
 2331|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2332|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2333|      0|                    more_ = !cursor_mode_;
 2334|      0|                    break;
 2335|      0|                }
 2336|      0|                case 0x4a:
  ------------------
  |  Branch (2336:17): [True: 0, False: 58]
  ------------------
 2337|      0|                case 0x4e:
  ------------------
  |  Branch (2337:17): [True: 0, False: 58]
  ------------------
 2338|      0|                {
 2339|      0|                    array_tag_ = typed_array_tags::int32;
 2340|      0|                    array_buffer_.clear();
 2341|      0|                    read(array_buffer_,ec);
 2342|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2343|      0|                    {
 2344|      0|                        more_ = false;
 2345|      0|                        return;
 2346|      0|                    }
 2347|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2348|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2349|      0|                    auto ta = typed_array_cast<int32_t>(array_buffer_);
 2350|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2350:25): [True: 0, False: 0]
  ------------------
 2351|      0|                    {
 2352|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2352:49): [True: 0, False: 0]
  ------------------
 2353|      0|                        {
 2354|      0|                            ta[i] = binary::byte_swap<int32_t>(ta[i]);
 2355|      0|                        }
 2356|      0|                    }
 2357|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2357:25): [True: 0, False: 0]
  ------------------
 2358|      0|                    {
 2359|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2359:29): [True: 0, False: 0]
  ------------------
 2360|      0|                        {
 2361|      0|                            ec = cbor_errc::bad_extents;
 2362|      0|                            more_ = false;
 2363|      0|                            return;
 2364|      0|                        }
 2365|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int32_t>>(ta, extents_, order_);
 2366|      0|                    }
 2367|      0|                    else
 2368|      0|                    {
 2369|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int32_t>>(ta);
 2370|      0|                    }
 2371|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2372|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2373|      0|                    more_ = !cursor_mode_;
 2374|      0|                    break;
 2375|      0|                }
 2376|      0|                case 0x4b:
  ------------------
  |  Branch (2376:17): [True: 0, False: 58]
  ------------------
 2377|      0|                case 0x4f:
  ------------------
  |  Branch (2377:17): [True: 0, False: 58]
  ------------------
 2378|      0|                {
 2379|      0|                    array_tag_ = typed_array_tags::int64;
 2380|      0|                    array_buffer_.clear();
 2381|      0|                    read(array_buffer_,ec);
 2382|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2383|      0|                    {
 2384|      0|                        more_ = false;
 2385|      0|                        return;
 2386|      0|                    }
 2387|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2388|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2389|      0|                    auto ta = typed_array_cast<int64_t>(array_buffer_);
 2390|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2390:25): [True: 0, False: 0]
  ------------------
 2391|      0|                    {
 2392|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2392:49): [True: 0, False: 0]
  ------------------
 2393|      0|                        {
 2394|      0|                            ta[i] = binary::byte_swap<int64_t>(ta[i]);
 2395|      0|                        }
 2396|      0|                    }
 2397|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2397:25): [True: 0, False: 0]
  ------------------
 2398|      0|                    {
 2399|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2399:29): [True: 0, False: 0]
  ------------------
 2400|      0|                        {
 2401|      0|                            ec = cbor_errc::bad_extents;
 2402|      0|                            more_ = false;
 2403|      0|                            return;
 2404|      0|                        }
 2405|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int64_t>>(ta, extents_, order_);
 2406|      0|                    }
 2407|      0|                    else
 2408|      0|                    {
 2409|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int64_t>>(ta);
 2410|      0|                    }
 2411|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2412|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2413|      0|                    more_ = !cursor_mode_;
 2414|      0|                    break;
 2415|      0|                }
 2416|      4|                case 0x50:
  ------------------
  |  Branch (2416:17): [True: 4, False: 54]
  ------------------
 2417|      4|                case 0x54:
  ------------------
  |  Branch (2417:17): [True: 0, False: 58]
  ------------------
 2418|      4|                {
 2419|      4|                    array_tag_ = typed_array_tags::half_float;
 2420|      4|                    array_buffer_.clear();
 2421|      4|                    read(array_buffer_,ec);
 2422|      4|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 2423|      0|                    {
 2424|      0|                        more_ = false;
 2425|      0|                        return;
 2426|      0|                    }
 2427|      4|                    const uint8_t tag = (uint8_t)raw_tag_;
 2428|      4|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2429|      4|                    auto ta = typed_array_cast<uint16_t>(array_buffer_);
 2430|      4|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2430:25): [True: 4, False: 0]
  ------------------
 2431|      4|                    {
 2432|  1.02k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2432:49): [True: 1.02k, False: 4]
  ------------------
 2433|  1.02k|                        {
 2434|  1.02k|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2435|  1.02k|                        }
 2436|      4|                    }
 2437|      4|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2437:25): [True: 0, False: 4]
  ------------------
 2438|      0|                    {
 2439|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2439:29): [True: 0, False: 0]
  ------------------
 2440|      0|                        {
 2441|      0|                            ec = cbor_errc::bad_extents;
 2442|      0|                            more_ = false;
 2443|      0|                            return;
 2444|      0|                        }
 2445|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint16_t>>(ta, extents_, order_);
 2446|      0|                    }
 2447|      4|                    else
 2448|      4|                    {
 2449|      4|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint16_t,decode_half>>(ta);
 2450|      4|                    }
 2451|      4|                    typed_array_iter_->next(visitor, *this, ec);
 2452|      4|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2453|      4|                    more_ = !cursor_mode_;
 2454|      4|                    break;
 2455|      4|                }
 2456|      0|                case 0x51:
  ------------------
  |  Branch (2456:17): [True: 0, False: 58]
  ------------------
 2457|      0|                case 0x55:
  ------------------
  |  Branch (2457:17): [True: 0, False: 58]
  ------------------
 2458|      0|                {
 2459|      0|                    array_tag_ = typed_array_tags::float32;
 2460|      0|                    array_buffer_.clear();
 2461|      0|                    read(array_buffer_,ec);
 2462|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2463|      0|                    {
 2464|      0|                        more_ = false;
 2465|      0|                        return;
 2466|      0|                    }
 2467|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2468|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2469|      0|                    auto ta = typed_array_cast<float>(array_buffer_);
 2470|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2470:25): [True: 0, False: 0]
  ------------------
 2471|      0|                    {
 2472|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2472:49): [True: 0, False: 0]
  ------------------
 2473|      0|                        {
 2474|      0|                            ta[i] = binary::byte_swap<float>(ta[i]);
 2475|      0|                        }
 2476|      0|                    }
 2477|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2477:25): [True: 0, False: 0]
  ------------------
 2478|      0|                    {
 2479|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2479:29): [True: 0, False: 0]
  ------------------
 2480|      0|                        {
 2481|      0|                            ec = cbor_errc::bad_extents;
 2482|      0|                            more_ = false;
 2483|      0|                            return;
 2484|      0|                        }
 2485|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<float>>(ta, extents_, order_);
 2486|      0|                    }
 2487|      0|                    else
 2488|      0|                    {
 2489|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<float>>(ta);
 2490|      0|                    }
 2491|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2492|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2493|      0|                    more_ = !cursor_mode_;
 2494|      0|                    break;
 2495|      0|                }
 2496|      0|                case 0x52:
  ------------------
  |  Branch (2496:17): [True: 0, False: 58]
  ------------------
 2497|      0|                case 0x56:
  ------------------
  |  Branch (2497:17): [True: 0, False: 58]
  ------------------
 2498|      0|                {
 2499|      0|                    array_tag_ = typed_array_tags::float64 ;
 2500|      0|                    array_buffer_.clear();
 2501|      0|                    read(array_buffer_,ec);
 2502|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2503|      0|                    {
 2504|      0|                        more_ = false;
 2505|      0|                        return;
 2506|      0|                    }
 2507|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2508|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2509|      0|                    auto ta = typed_array_cast<double>(array_buffer_);
 2510|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2510:25): [True: 0, False: 0]
  ------------------
 2511|      0|                    {
 2512|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2512:49): [True: 0, False: 0]
  ------------------
 2513|      0|                        {
 2514|      0|                            ta[i] = binary::byte_swap<double>(ta[i]);
 2515|      0|                        }
 2516|      0|                    }
 2517|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2517:25): [True: 0, False: 0]
  ------------------
 2518|      0|                    {
 2519|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2519:29): [True: 0, False: 0]
  ------------------
 2520|      0|                        {
 2521|      0|                            ec = cbor_errc::bad_extents;
 2522|      0|                            more_ = false;
 2523|      0|                            return;
 2524|      0|                        }
 2525|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<double>>(ta, extents_, order_);
 2526|      0|                    }
 2527|      0|                    else
 2528|      0|                    {
 2529|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<double>>(ta);
 2530|      0|                    }
 2531|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2532|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2533|      0|                    more_ = !cursor_mode_;
 2534|      0|                    break;
 2535|      0|                }
 2536|      4|                default:
  ------------------
  |  Branch (2536:17): [True: 4, False: 54]
  ------------------
 2537|      4|                {
 2538|      4|                    read(bytes_buffer_,ec);
 2539|      4|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 2540|      0|                    {
 2541|      0|                        more_ = false;
 2542|      0|                        return;
 2543|      0|                    }
 2544|      4|                    visitor.byte_string_value(bytes_buffer_, raw_tag_, *this, ec);
 2545|      4|                    more_ = !cursor_mode_;
 2546|      4|                    break;
 2547|      4|                }
 2548|     58|            }
 2549|     58|            other_tags_[item_tag] = false;
 2550|     58|        }
 2551|     11|        else
 2552|     11|        {
 2553|     11|            read(bytes_buffer_,ec);
 2554|     11|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     11|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 11]
  |  |  ------------------
  ------------------
 2555|      0|            {
 2556|      0|                return;
 2557|      0|            }
 2558|     11|            visitor.byte_string_value(bytes_buffer_, semantic_tag::none, *this, ec);
 2559|     11|            more_ = !cursor_mode_;
 2560|     11|        }
 2561|     69|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_bufferclINS3_6vectorIhS5_EEEEvRT_RNS3_10error_codeE:
  294|     69|        {
  295|     69|            c.clear();
  296|     69|            c.reserve(bytes.size());
  297|     69|            for (auto b : bytes)
  ------------------
  |  Branch (297:25): [True: 4.21k, False: 69]
  ------------------
  298|  4.21k|            {
  299|  4.21k|                c.push_back(b);
  300|  4.21k|            }
  301|     69|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE26get_typed_array_endiannessEh:
 1997|    859|    {
 1998|    859|        return ((tag & detail::cbor_array_tags_e_mask) >> detail::cbor_array_tags_e_shift) == 0 ? jsoncons::endian::big : jsoncons::endian::little; 
  ------------------
  |  Branch (1998:16): [True: 855, False: 4]
  ------------------
 1999|    859|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10read_int64ERNS3_10error_codeE:
 1449|  4.37M|    {
 1450|  4.37M|        int64_t val = 0;
 1451|       |
 1452|  4.37M|        auto ch = source_.peek();
 1453|  4.37M|        if (ch.eof)
  ------------------
  |  Branch (1453:13): [True: 0, False: 4.37M]
  ------------------
 1454|      0|        {
 1455|      0|            ec = cbor_errc::unexpected_eof;
 1456|      0|            more_ = false;
 1457|      0|            return val;
 1458|      0|        }
 1459|       |
 1460|  4.37M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(ch.value);
 1461|  4.37M|        uint8_t info = get_additional_information_value(ch.value);
 1462|  4.37M|        switch (major_type)
 1463|  4.37M|        {
 1464|  4.37M|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1464:13): [True: 4.37M, False: 0]
  ------------------
 1465|  4.37M|                source_.ignore(1);
 1466|  4.37M|                switch (info)
  ------------------
  |  Branch (1466:25): [True: 4.36M, False: 5.20k]
  ------------------
 1467|  4.37M|                {
 1468|  4.36M|                    case JSONCONS_EXT_CBOR_0x00_0x17: // 0x00..0x17 (0..23)
  ------------------
  |  |   18|  4.36M|    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: 226, False: 4.37M]
  |  |  |  Branch (18:20): [True: 169, False: 4.37M]
  |  |  |  Branch (18:30): [True: 934, False: 4.37M]
  |  |  |  Branch (18:40): [True: 458, False: 4.37M]
  |  |  |  Branch (18:50): [True: 136, False: 4.37M]
  |  |  |  Branch (18:60): [True: 122, False: 4.37M]
  |  |  |  Branch (18:70): [True: 1.45k, False: 4.37M]
  |  |  |  Branch (18:80): [True: 3.50M, False: 866k]
  |  |  |  Branch (18:90): [True: 71, False: 4.37M]
  |  |  |  Branch (18:100): [True: 1.04k, False: 4.37M]
  |  |  |  Branch (18:110): [True: 1.16k, False: 4.37M]
  |  |  |  Branch (18:120): [True: 33.3k, False: 4.33M]
  |  |  |  Branch (18:130): [True: 389k, False: 3.98M]
  |  |  |  Branch (18:140): [True: 639, False: 4.37M]
  |  |  |  Branch (18:150): [True: 9.97k, False: 4.36M]
  |  |  |  Branch (18:160): [True: 1.17k, False: 4.37M]
  |  |  |  Branch (18:170): [True: 5.28k, False: 4.36M]
  |  |  |  Branch (18:180): [True: 6.94k, False: 4.36M]
  |  |  |  Branch (18:190): [True: 236, False: 4.37M]
  |  |  |  Branch (18:200): [True: 268, False: 4.37M]
  |  |  |  Branch (18:210): [True: 1.89k, False: 4.36M]
  |  |  |  Branch (18:220): [True: 2.99k, False: 4.36M]
  |  |  ------------------
  ------------------
  |  Branch (1468:21): [True: 397k, False: 3.97M]
  ------------------
 1469|  4.36M|                    {
 1470|  4.36M|                        val = static_cast<int8_t>(- 1 - info);
 1471|  4.36M|                        break;
 1472|  65.8M|                    }
 1473|  2.29k|                    case 0x18: // Negative integer (one-byte uint8_t follows)
  ------------------
  |  Branch (1473:21): [True: 2.29k, False: 4.36M]
  ------------------
 1474|  2.29k|                        {
 1475|  2.29k|                            uint8_t b;
 1476|  2.29k|                            if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1476:33): [True: 0, False: 2.29k]
  ------------------
 1477|      0|                            {
 1478|      0|                                ec = cbor_errc::unexpected_eof;
 1479|      0|                                more_ = false;
 1480|      0|                                return val;
 1481|      0|                            }
 1482|  2.29k|                            val = static_cast<int64_t>(-1) - static_cast<int64_t>(b);
 1483|  2.29k|                            break;
 1484|  2.29k|                        }
 1485|       |
 1486|  2.42k|                    case 0x19: // Negative integer -1-n (two-byte uint16_t follows)
  ------------------
  |  Branch (1486:21): [True: 2.42k, False: 4.36M]
  ------------------
 1487|  2.42k|                        {
 1488|  2.42k|                            uint8_t buf[sizeof(uint16_t)];
 1489|  2.42k|                            if (source_.read(buf, sizeof(uint16_t)) != sizeof(uint16_t))
  ------------------
  |  Branch (1489:33): [True: 0, False: 2.42k]
  ------------------
 1490|      0|                            {
 1491|      0|                                ec = cbor_errc::unexpected_eof;
 1492|      0|                                more_ = false;
 1493|      0|                                return val;
 1494|      0|                            }
 1495|  2.42k|                            auto x = binary::big_to_native<uint16_t>(buf, sizeof(buf));
 1496|  2.42k|                            val = static_cast<int64_t>(-1)- x;
 1497|  2.42k|                            break;
 1498|  2.42k|                        }
 1499|       |
 1500|     72|                    case 0x1a: // Negative integer -1-n (four-byte uint32_t follows)
  ------------------
  |  Branch (1500:21): [True: 72, False: 4.37M]
  ------------------
 1501|     72|                        {
 1502|     72|                            uint8_t buf[sizeof(uint32_t)];
 1503|     72|                            if (source_.read(buf, sizeof(uint32_t)) != sizeof(uint32_t))
  ------------------
  |  Branch (1503:33): [True: 0, False: 72]
  ------------------
 1504|      0|                            {
 1505|      0|                                ec = cbor_errc::unexpected_eof;
 1506|      0|                                more_ = false;
 1507|      0|                                return val;
 1508|      0|                            }
 1509|     72|                            auto x = binary::big_to_native<uint32_t>(buf, sizeof(buf));
 1510|     72|                            val = static_cast<int64_t>(-1)- x;
 1511|     72|                            break;
 1512|     72|                        }
 1513|       |
 1514|     82|                    case 0x1b: // Negative integer -1-n (eight-byte uint64_t follows)
  ------------------
  |  Branch (1514:21): [True: 82, False: 4.37M]
  ------------------
 1515|     82|                        {
 1516|     82|                            uint8_t buf[sizeof(uint64_t)];
 1517|     82|                            if (source_.read(buf, sizeof(uint64_t)) != sizeof(uint64_t))
  ------------------
  |  Branch (1517:33): [True: 0, False: 82]
  ------------------
 1518|      0|                            {
 1519|      0|                                ec = cbor_errc::unexpected_eof;
 1520|      0|                                more_ = false;
 1521|      0|                                return val;
 1522|      0|                            }
 1523|     82|                            auto x = binary::big_to_native<uint64_t>(buf, sizeof(buf));
 1524|     82|                            val = static_cast<int64_t>(-1)- static_cast<int64_t>(x);
 1525|     82|                            break;
 1526|     82|                        }
 1527|  4.37M|                }
 1528|  4.37M|                break;
 1529|       |
 1530|  4.37M|                case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1530:17): [True: 0, False: 4.37M]
  ------------------
 1531|      0|                {
 1532|      0|                    uint64_t x = read_uint64(ec);
 1533|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1534|      0|                    {
 1535|      0|                        return 0;
 1536|      0|                    }
 1537|      0|                    if (x <= static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))
  ------------------
  |  Branch (1537:25): [True: 0, False: 0]
  ------------------
 1538|      0|                    {
 1539|      0|                        val = x;
 1540|      0|                    }
 1541|      0|                    else
 1542|      0|                    {
 1543|       |                        // error;
 1544|      0|                    }
 1545|       |                    
 1546|      0|                    break;
 1547|      0|                }
 1548|      0|                break;
 1549|      0|            default:
  ------------------
  |  Branch (1549:13): [True: 0, False: 4.37M]
  ------------------
 1550|      0|                break;
 1551|  4.37M|        }
 1552|       |
 1553|  4.37M|        return val;
 1554|  4.37M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_sourceC2EPS8_:
  309|  2.72M|            : source(source)
  310|  2.72M|        {
  311|  2.72M|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringINS8_28read_byte_string_from_sourceEEEvT_RNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
 2011|  2.72M|    {
 2012|  2.72M|        if (other_tags_[item_tag])
  ------------------
  |  Branch (2012:13): [True: 2.33k, False: 2.72M]
  ------------------
 2013|  2.33k|        {
 2014|  2.33k|            switch (raw_tag_)
 2015|  2.33k|            {
 2016|      4|                case 0x2:
  ------------------
  |  Branch (2016:17): [True: 4, False: 2.33k]
  ------------------
 2017|      4|                {
 2018|      4|                    bytes_buffer_.clear();
 2019|      4|                    read(bytes_buffer_,ec);
 2020|      4|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 2021|      0|                    {
 2022|      0|                        more_ = false;
 2023|      0|                        return;
 2024|      0|                    }
 2025|      4|                    bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 2026|      4|                    text_buffer_.clear();
 2027|      4|                    n.write_string(text_buffer_);
 2028|      4|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2029|      4|                    more_ = !cursor_mode_;
 2030|      4|                    break;
 2031|      4|                }
 2032|     93|                case 0x3:
  ------------------
  |  Branch (2032:17): [True: 93, False: 2.24k]
  ------------------
 2033|     93|                {
 2034|     93|                    bytes_buffer_.clear();
 2035|     93|                    read(bytes_buffer_,ec);
 2036|     93|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     93|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 93]
  |  |  ------------------
  ------------------
 2037|      0|                    {
 2038|      0|                        more_ = false;
 2039|      0|                        return;
 2040|      0|                    }
 2041|     93|                    bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 2042|     93|                    n = -1 - n;
 2043|     93|                    text_buffer_.clear();
 2044|     93|                    n.write_string(text_buffer_);
 2045|     93|                    visitor.string_value(text_buffer_, semantic_tag::bigint, *this, ec);
 2046|     93|                    more_ = !cursor_mode_;
 2047|     93|                    break;
 2048|     93|                }
 2049|      0|                case 0x15:
  ------------------
  |  Branch (2049:17): [True: 0, False: 2.33k]
  ------------------
 2050|      0|                {
 2051|      0|                    read(bytes_buffer_,ec);
 2052|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2053|      0|                    {
 2054|      0|                        more_ = false;
 2055|      0|                        return;
 2056|      0|                    }
 2057|      0|                    visitor.byte_string_value(bytes_buffer_, semantic_tag::base64url, *this, ec);
 2058|      0|                    more_ = !cursor_mode_;
 2059|      0|                    break;
 2060|      0|                }
 2061|      0|                case 0x16:
  ------------------
  |  Branch (2061:17): [True: 0, False: 2.33k]
  ------------------
 2062|      0|                {
 2063|      0|                    read(bytes_buffer_,ec);
 2064|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2065|      0|                    {
 2066|      0|                        more_ = false;
 2067|      0|                        return;
 2068|      0|                    }
 2069|      0|                    visitor.byte_string_value(bytes_buffer_, semantic_tag::base64, *this, ec);
 2070|      0|                    more_ = !cursor_mode_;
 2071|      0|                    break;
 2072|      0|                }
 2073|      0|                case 0x17:
  ------------------
  |  Branch (2073:17): [True: 0, False: 2.33k]
  ------------------
 2074|      0|                {
 2075|      0|                    read(bytes_buffer_,ec);
 2076|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2077|      0|                    {
 2078|      0|                        more_ = false;
 2079|      0|                        return;
 2080|      0|                    }
 2081|      0|                    visitor.byte_string_value(bytes_buffer_, semantic_tag::base16, *this, ec);
 2082|      0|                    more_ = !cursor_mode_;
 2083|      0|                    break;
 2084|      0|                }
 2085|     12|                case 0x40:
  ------------------
  |  Branch (2085:17): [True: 12, False: 2.32k]
  ------------------
 2086|     12|                {
 2087|     12|                    array_tag_ = typed_array_tags::uint8;
 2088|     12|                    array_buffer_.clear();
 2089|     12|                    read(array_buffer_,ec);
 2090|     12|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     12|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 12]
  |  |  ------------------
  ------------------
 2091|      0|                    {
 2092|      0|                        more_ = false;
 2093|      0|                        return;
 2094|      0|                    }
 2095|     12|                    auto ta = typed_array_cast<const uint8_t>(array_buffer_);
 2096|     12|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2096:25): [True: 0, False: 12]
  ------------------
 2097|      0|                    {
 2098|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2098:29): [True: 0, False: 0]
  ------------------
 2099|      0|                        {
 2100|      0|                            ec = cbor_errc::bad_extents;
 2101|      0|                            more_ = false;
 2102|      0|                            return;
 2103|      0|                        }
 2104|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<const uint8_t>>(ta, extents_, order_);
 2105|      0|                    }
 2106|     12|                    else
 2107|     12|                    {
 2108|     12|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<const uint8_t>>(ta);
 2109|     12|                    }
 2110|     12|                    typed_array_iter_->next(visitor, *this, ec);
 2111|     12|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2112|     12|                    more_ = !cursor_mode_;
 2113|     12|                    break;
 2114|     12|                }
 2115|      0|                case 0x44:
  ------------------
  |  Branch (2115:17): [True: 0, False: 2.33k]
  ------------------
 2116|      0|                {
 2117|      0|                    array_tag_ = typed_array_tags::uint8;
 2118|      0|                    typed_array_tag_ = semantic_tag::clamped;
 2119|      0|                    array_buffer_.clear();
 2120|      0|                    read(array_buffer_,ec);
 2121|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2122|      0|                    {
 2123|      0|                        more_ = false;
 2124|      0|                        return;
 2125|      0|                    }
 2126|      0|                    auto ta = typed_array_cast<const uint8_t>(array_buffer_);
 2127|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2127:25): [True: 0, False: 0]
  ------------------
 2128|      0|                    {
 2129|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2129:29): [True: 0, False: 0]
  ------------------
 2130|      0|                        {
 2131|      0|                            ec = cbor_errc::bad_extents;
 2132|      0|                            more_ = false;
 2133|      0|                            return;
 2134|      0|                        }
 2135|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<const uint8_t>>(ta, extents_, order_);
 2136|      0|                    }
 2137|      0|                    else
 2138|      0|                    {
 2139|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<const uint8_t>>(ta, semantic_tag::clamped);
 2140|      0|                    }
 2141|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2142|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2143|      0|                    more_ = !cursor_mode_;
 2144|      0|                    break;
 2145|      0|                }
 2146|      0|                case 0x41:
  ------------------
  |  Branch (2146:17): [True: 0, False: 2.33k]
  ------------------
 2147|      0|                case 0x45:
  ------------------
  |  Branch (2147:17): [True: 0, False: 2.33k]
  ------------------
 2148|      0|                {
 2149|      0|                    array_tag_ = typed_array_tags::uint16;
 2150|      0|                    array_buffer_.clear();
 2151|      0|                    read(array_buffer_,ec);
 2152|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2153|      0|                    {
 2154|      0|                        more_ = false;
 2155|      0|                        return;
 2156|      0|                    }
 2157|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2158|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2159|      0|                    auto ta = typed_array_cast<uint16_t>(array_buffer_);
 2160|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2160:25): [True: 0, False: 0]
  ------------------
 2161|      0|                    {
 2162|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2162:49): [True: 0, False: 0]
  ------------------
 2163|      0|                        {
 2164|      0|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2165|      0|                        }
 2166|      0|                    }
 2167|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2167:25): [True: 0, False: 0]
  ------------------
 2168|      0|                    {
 2169|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2169:29): [True: 0, False: 0]
  ------------------
 2170|      0|                        {
 2171|      0|                            ec = cbor_errc::bad_extents;
 2172|      0|                            more_ = false;
 2173|      0|                            return;
 2174|      0|                        }
 2175|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint16_t>>(ta, extents_, order_);
 2176|      0|                    }
 2177|      0|                    else
 2178|      0|                    {
 2179|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint16_t>>(ta);
 2180|      0|                    }
 2181|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2182|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2183|      0|                    more_ = !cursor_mode_;
 2184|      0|                    break;
 2185|      0|                }
 2186|     85|                case 0x42:
  ------------------
  |  Branch (2186:17): [True: 85, False: 2.25k]
  ------------------
 2187|     87|                case 0x46:
  ------------------
  |  Branch (2187:17): [True: 2, False: 2.33k]
  ------------------
 2188|     87|                {
 2189|     87|                    array_tag_ = typed_array_tags::uint32;
 2190|     87|                    array_buffer_.clear();
 2191|     87|                    read(array_buffer_,ec);
 2192|     87|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     87|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 87]
  |  |  ------------------
  ------------------
 2193|      0|                    {
 2194|      0|                        more_ = false;
 2195|      0|                        return;
 2196|      0|                    }
 2197|     87|                    const uint8_t tag = (uint8_t)raw_tag_;
 2198|     87|                    jsoncons::endian e = get_typed_array_endianness(tag);
 2199|     87|                    auto ta = typed_array_cast<uint32_t>(array_buffer_);
 2200|     87|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2200:25): [True: 85, False: 2]
  ------------------
 2201|     85|                    {
 2202|     85|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2202:49): [True: 0, False: 85]
  ------------------
 2203|      0|                        {
 2204|      0|                            ta[i] = binary::byte_swap<uint32_t>(ta[i]);
 2205|      0|                        }
 2206|     85|                    }
 2207|     87|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2207:25): [True: 0, False: 87]
  ------------------
 2208|      0|                    {
 2209|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2209:29): [True: 0, False: 0]
  ------------------
 2210|      0|                        {
 2211|      0|                            ec = cbor_errc::bad_extents;
 2212|      0|                            more_ = false;
 2213|      0|                            return;
 2214|      0|                        }
 2215|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint32_t>>(ta, extents_, order_);
 2216|      0|                    }
 2217|     87|                    else
 2218|     87|                    {
 2219|     87|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint32_t>>(ta);
 2220|     87|                    }
 2221|     87|                    typed_array_iter_->next(visitor, *this, ec);
 2222|     87|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2223|     87|                    more_ = !cursor_mode_;
 2224|     87|                    break;
 2225|     87|                }
 2226|    178|                case 0x43:
  ------------------
  |  Branch (2226:17): [True: 178, False: 2.15k]
  ------------------
 2227|    178|                case 0x47:
  ------------------
  |  Branch (2227:17): [True: 0, False: 2.33k]
  ------------------
 2228|    178|                {
 2229|    178|                    array_tag_ = typed_array_tags::uint64;
 2230|    178|                    array_buffer_.clear();
 2231|    178|                    read(array_buffer_,ec);
 2232|    178|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    178|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 178]
  |  |  ------------------
  ------------------
 2233|      0|                    {
 2234|      0|                        more_ = false;
 2235|      0|                        return;
 2236|      0|                    }
 2237|    178|                    const uint8_t tag = (uint8_t)raw_tag_;
 2238|    178|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2239|    178|                    auto ta = typed_array_cast<uint64_t>(array_buffer_);
 2240|    178|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2240:25): [True: 178, False: 0]
  ------------------
 2241|    178|                    {
 2242|    190|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2242:49): [True: 12, False: 178]
  ------------------
 2243|     12|                        {
 2244|     12|                            ta[i] = binary::byte_swap<uint64_t>(ta[i]);
 2245|     12|                        }
 2246|    178|                    }
 2247|    178|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2247:25): [True: 0, False: 178]
  ------------------
 2248|      0|                    {
 2249|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2249:29): [True: 0, False: 0]
  ------------------
 2250|      0|                        {
 2251|      0|                            ec = cbor_errc::bad_extents;
 2252|      0|                            more_ = false;
 2253|      0|                            return;
 2254|      0|                        }
 2255|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint64_t>>(ta, extents_, order_);
 2256|      0|                    }
 2257|    178|                    else
 2258|    178|                    {
 2259|    178|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint64_t>>(ta);
 2260|    178|                    }
 2261|    178|                    typed_array_iter_->next(visitor, *this, ec);
 2262|    178|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2263|    178|                    more_ = !cursor_mode_;
 2264|    178|                    break;
 2265|    178|                }
 2266|  1.23k|                case 0x48:
  ------------------
  |  Branch (2266:17): [True: 1.23k, False: 1.10k]
  ------------------
 2267|  1.23k|                {
 2268|  1.23k|                    array_tag_ = typed_array_tags::int8;
 2269|  1.23k|                    array_buffer_.clear();
 2270|  1.23k|                    read(array_buffer_,ec);
 2271|  1.23k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.23k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.23k]
  |  |  ------------------
  ------------------
 2272|      0|                    {
 2273|      0|                        more_ = false;
 2274|      0|                        return;
 2275|      0|                    }
 2276|  1.23k|                    auto ta = typed_array_cast<int8_t>(array_buffer_);
 2277|  1.23k|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2277:25): [True: 0, False: 1.23k]
  ------------------
 2278|      0|                    {
 2279|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2279:29): [True: 0, False: 0]
  ------------------
 2280|      0|                        {
 2281|      0|                            ec = cbor_errc::bad_extents;
 2282|      0|                            more_ = false;
 2283|      0|                            return;
 2284|      0|                        }
 2285|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int8_t>>(ta, extents_, order_);
 2286|      0|                    }
 2287|  1.23k|                    else
 2288|  1.23k|                    {
 2289|  1.23k|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int8_t>>(ta);
 2290|  1.23k|                    }
 2291|  1.23k|                    typed_array_iter_->next(visitor, *this, ec);
 2292|  1.23k|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2293|  1.23k|                    more_ = !cursor_mode_;
 2294|  1.23k|                    break;
 2295|  1.23k|                }
 2296|     63|                case 0x49:
  ------------------
  |  Branch (2296:17): [True: 63, False: 2.27k]
  ------------------
 2297|     63|                case 0x4d:
  ------------------
  |  Branch (2297:17): [True: 0, False: 2.33k]
  ------------------
 2298|     63|                {
 2299|     63|                    array_tag_ = typed_array_tags::int16;
 2300|     63|                    array_buffer_.clear();
 2301|     63|                    read(array_buffer_,ec);
 2302|     63|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     63|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 63]
  |  |  ------------------
  ------------------
 2303|      0|                    {
 2304|      0|                        more_ = false;
 2305|      0|                        return;
 2306|      0|                    }
 2307|     63|                    const uint8_t tag = (uint8_t)raw_tag_;
 2308|     63|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2309|     63|                    auto ta = typed_array_cast<int16_t>(array_buffer_);
 2310|     63|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2310:25): [True: 63, False: 0]
  ------------------
 2311|     63|                    {
 2312|     63|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2312:49): [True: 0, False: 63]
  ------------------
 2313|      0|                        {
 2314|      0|                            ta[i] = binary::byte_swap<int16_t>(ta[i]);
 2315|      0|                        }
 2316|     63|                    }
 2317|     63|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2317:25): [True: 0, False: 63]
  ------------------
 2318|      0|                    {
 2319|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2319:29): [True: 0, False: 0]
  ------------------
 2320|      0|                        {
 2321|      0|                            ec = cbor_errc::bad_extents;
 2322|      0|                            more_ = false;
 2323|      0|                            return;
 2324|      0|                        }
 2325|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int16_t>>(ta, extents_, order_);
 2326|      0|                    }
 2327|     63|                    else
 2328|     63|                    {
 2329|     63|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int16_t>>(ta);
 2330|     63|                    }
 2331|     63|                    typed_array_iter_->next(visitor, *this, ec);
 2332|     63|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2333|     63|                    more_ = !cursor_mode_;
 2334|     63|                    break;
 2335|     63|                }
 2336|     14|                case 0x4a:
  ------------------
  |  Branch (2336:17): [True: 14, False: 2.32k]
  ------------------
 2337|     16|                case 0x4e:
  ------------------
  |  Branch (2337:17): [True: 2, False: 2.33k]
  ------------------
 2338|     16|                {
 2339|     16|                    array_tag_ = typed_array_tags::int32;
 2340|     16|                    array_buffer_.clear();
 2341|     16|                    read(array_buffer_,ec);
 2342|     16|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     16|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 16]
  |  |  ------------------
  ------------------
 2343|      0|                    {
 2344|      0|                        more_ = false;
 2345|      0|                        return;
 2346|      0|                    }
 2347|     16|                    const uint8_t tag = (uint8_t)raw_tag_;
 2348|     16|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2349|     16|                    auto ta = typed_array_cast<int32_t>(array_buffer_);
 2350|     16|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2350:25): [True: 14, False: 2]
  ------------------
 2351|     14|                    {
 2352|  18.4k|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2352:49): [True: 18.4k, False: 14]
  ------------------
 2353|  18.4k|                        {
 2354|  18.4k|                            ta[i] = binary::byte_swap<int32_t>(ta[i]);
 2355|  18.4k|                        }
 2356|     14|                    }
 2357|     16|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2357:25): [True: 0, False: 16]
  ------------------
 2358|      0|                    {
 2359|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2359:29): [True: 0, False: 0]
  ------------------
 2360|      0|                        {
 2361|      0|                            ec = cbor_errc::bad_extents;
 2362|      0|                            more_ = false;
 2363|      0|                            return;
 2364|      0|                        }
 2365|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int32_t>>(ta, extents_, order_);
 2366|      0|                    }
 2367|     16|                    else
 2368|     16|                    {
 2369|     16|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int32_t>>(ta);
 2370|     16|                    }
 2371|     16|                    typed_array_iter_->next(visitor, *this, ec);
 2372|     16|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2373|     16|                    more_ = !cursor_mode_;
 2374|     16|                    break;
 2375|     16|                }
 2376|      4|                case 0x4b:
  ------------------
  |  Branch (2376:17): [True: 4, False: 2.33k]
  ------------------
 2377|      4|                case 0x4f:
  ------------------
  |  Branch (2377:17): [True: 0, False: 2.33k]
  ------------------
 2378|      4|                {
 2379|      4|                    array_tag_ = typed_array_tags::int64;
 2380|      4|                    array_buffer_.clear();
 2381|      4|                    read(array_buffer_,ec);
 2382|      4|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 2383|      0|                    {
 2384|      0|                        more_ = false;
 2385|      0|                        return;
 2386|      0|                    }
 2387|      4|                    const uint8_t tag = (uint8_t)raw_tag_;
 2388|      4|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2389|      4|                    auto ta = typed_array_cast<int64_t>(array_buffer_);
 2390|      4|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2390:25): [True: 4, False: 0]
  ------------------
 2391|      4|                    {
 2392|    256|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2392:49): [True: 252, False: 4]
  ------------------
 2393|    252|                        {
 2394|    252|                            ta[i] = binary::byte_swap<int64_t>(ta[i]);
 2395|    252|                        }
 2396|      4|                    }
 2397|      4|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2397:25): [True: 0, False: 4]
  ------------------
 2398|      0|                    {
 2399|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2399:29): [True: 0, False: 0]
  ------------------
 2400|      0|                        {
 2401|      0|                            ec = cbor_errc::bad_extents;
 2402|      0|                            more_ = false;
 2403|      0|                            return;
 2404|      0|                        }
 2405|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<int64_t>>(ta, extents_, order_);
 2406|      0|                    }
 2407|      4|                    else
 2408|      4|                    {
 2409|      4|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<int64_t>>(ta);
 2410|      4|                    }
 2411|      4|                    typed_array_iter_->next(visitor, *this, ec);
 2412|      4|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2413|      4|                    more_ = !cursor_mode_;
 2414|      4|                    break;
 2415|      4|                }
 2416|      0|                case 0x50:
  ------------------
  |  Branch (2416:17): [True: 0, False: 2.33k]
  ------------------
 2417|      0|                case 0x54:
  ------------------
  |  Branch (2417:17): [True: 0, False: 2.33k]
  ------------------
 2418|      0|                {
 2419|      0|                    array_tag_ = typed_array_tags::half_float;
 2420|      0|                    array_buffer_.clear();
 2421|      0|                    read(array_buffer_,ec);
 2422|      0|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2423|      0|                    {
 2424|      0|                        more_ = false;
 2425|      0|                        return;
 2426|      0|                    }
 2427|      0|                    const uint8_t tag = (uint8_t)raw_tag_;
 2428|      0|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2429|      0|                    auto ta = typed_array_cast<uint16_t>(array_buffer_);
 2430|      0|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2430:25): [True: 0, False: 0]
  ------------------
 2431|      0|                    {
 2432|      0|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2432:49): [True: 0, False: 0]
  ------------------
 2433|      0|                        {
 2434|      0|                            ta[i] = binary::byte_swap<uint16_t>(ta[i]);
 2435|      0|                        }
 2436|      0|                    }
 2437|      0|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2437:25): [True: 0, False: 0]
  ------------------
 2438|      0|                    {
 2439|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2439:29): [True: 0, False: 0]
  ------------------
 2440|      0|                        {
 2441|      0|                            ec = cbor_errc::bad_extents;
 2442|      0|                            more_ = false;
 2443|      0|                            return;
 2444|      0|                        }
 2445|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<uint16_t>>(ta, extents_, order_);
 2446|      0|                    }
 2447|      0|                    else
 2448|      0|                    {
 2449|      0|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<uint16_t,decode_half>>(ta);
 2450|      0|                    }
 2451|      0|                    typed_array_iter_->next(visitor, *this, ec);
 2452|      0|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2453|      0|                    more_ = !cursor_mode_;
 2454|      0|                    break;
 2455|      0|                }
 2456|    384|                case 0x51:
  ------------------
  |  Branch (2456:17): [True: 384, False: 1.95k]
  ------------------
 2457|    384|                case 0x55:
  ------------------
  |  Branch (2457:17): [True: 0, False: 2.33k]
  ------------------
 2458|    384|                {
 2459|    384|                    array_tag_ = typed_array_tags::float32;
 2460|    384|                    array_buffer_.clear();
 2461|    384|                    read(array_buffer_,ec);
 2462|    384|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    384|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 384]
  |  |  ------------------
  ------------------
 2463|      0|                    {
 2464|      0|                        more_ = false;
 2465|      0|                        return;
 2466|      0|                    }
 2467|    384|                    const uint8_t tag = (uint8_t)raw_tag_;
 2468|    384|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2469|    384|                    auto ta = typed_array_cast<float>(array_buffer_);
 2470|    384|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2470:25): [True: 384, False: 0]
  ------------------
 2471|    384|                    {
 2472|    464|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2472:49): [True: 80, False: 384]
  ------------------
 2473|     80|                        {
 2474|     80|                            ta[i] = binary::byte_swap<float>(ta[i]);
 2475|     80|                        }
 2476|    384|                    }
 2477|    384|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2477:25): [True: 0, False: 384]
  ------------------
 2478|      0|                    {
 2479|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2479:29): [True: 0, False: 0]
  ------------------
 2480|      0|                        {
 2481|      0|                            ec = cbor_errc::bad_extents;
 2482|      0|                            more_ = false;
 2483|      0|                            return;
 2484|      0|                        }
 2485|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<float>>(ta, extents_, order_);
 2486|      0|                    }
 2487|    384|                    else
 2488|    384|                    {
 2489|    384|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<float>>(ta);
 2490|    384|                    }
 2491|    384|                    typed_array_iter_->next(visitor, *this, ec);
 2492|    384|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2493|    384|                    more_ = !cursor_mode_;
 2494|    384|                    break;
 2495|    384|                }
 2496|    122|                case 0x52:
  ------------------
  |  Branch (2496:17): [True: 122, False: 2.21k]
  ------------------
 2497|    122|                case 0x56:
  ------------------
  |  Branch (2497:17): [True: 0, False: 2.33k]
  ------------------
 2498|    122|                {
 2499|    122|                    array_tag_ = typed_array_tags::float64 ;
 2500|    122|                    array_buffer_.clear();
 2501|    122|                    read(array_buffer_,ec);
 2502|    122|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    122|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 122]
  |  |  ------------------
  ------------------
 2503|      0|                    {
 2504|      0|                        more_ = false;
 2505|      0|                        return;
 2506|      0|                    }
 2507|    122|                    const uint8_t tag = (uint8_t)raw_tag_;
 2508|    122|                    jsoncons::endian e = get_typed_array_endianness(tag); 
 2509|    122|                    auto ta = typed_array_cast<double>(array_buffer_);
 2510|    122|                    if (e != jsoncons::endian::native)
  ------------------
  |  Branch (2510:25): [True: 122, False: 0]
  ------------------
 2511|    122|                    {
 2512|    122|                        for (std::size_t i = 0; i < ta.size(); ++i)
  ------------------
  |  Branch (2512:49): [True: 0, False: 122]
  ------------------
 2513|      0|                        {
 2514|      0|                            ta[i] = binary::byte_swap<double>(ta[i]);
 2515|      0|                        }
 2516|    122|                    }
 2517|    122|                    if (state_stack_.back().mode == parse_mode::multi_dim) // multi-dim array
  ------------------
  |  Branch (2517:25): [True: 0, False: 122]
  ------------------
 2518|      0|                    {
 2519|      0|                        if (mdarray_size_ != ta.size())
  ------------------
  |  Branch (2519:29): [True: 0, False: 0]
  ------------------
 2520|      0|                        {
 2521|      0|                            ec = cbor_errc::bad_extents;
 2522|      0|                            more_ = false;
 2523|      0|                            return;
 2524|      0|                        }
 2525|      0|                        typed_array_iter_ = jsoncons::make_unique<mdarray_iterator<double>>(ta, extents_, order_);
 2526|      0|                    }
 2527|    122|                    else
 2528|    122|                    {
 2529|    122|                        typed_array_iter_ = jsoncons::make_unique<sequential_typed_array_iterator<double>>(ta);
 2530|    122|                    }
 2531|    122|                    typed_array_iter_->next(visitor, *this, ec);
 2532|    122|                    state_stack_.emplace_back(parse_mode::typed_array, ta.size(), false);
 2533|    122|                    more_ = !cursor_mode_;
 2534|    122|                    break;
 2535|    122|                }
 2536|    140|                default:
  ------------------
  |  Branch (2536:17): [True: 140, False: 2.19k]
  ------------------
 2537|    140|                {
 2538|    140|                    read(bytes_buffer_,ec);
 2539|    140|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    140|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 140]
  |  |  ------------------
  ------------------
 2540|      0|                    {
 2541|      0|                        more_ = false;
 2542|      0|                        return;
 2543|      0|                    }
 2544|    140|                    visitor.byte_string_value(bytes_buffer_, raw_tag_, *this, ec);
 2545|    140|                    more_ = !cursor_mode_;
 2546|    140|                    break;
 2547|    140|                }
 2548|  2.33k|            }
 2549|  2.33k|            other_tags_[item_tag] = false;
 2550|  2.33k|        }
 2551|  2.72M|        else
 2552|  2.72M|        {
 2553|  2.72M|            read(bytes_buffer_,ec);
 2554|  2.72M|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.72M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 2.72M]
  |  |  ------------------
  ------------------
 2555|      7|            {
 2556|      7|                return;
 2557|      7|            }
 2558|  2.72M|            visitor.byte_string_value(bytes_buffer_, semantic_tag::none, *this, ec);
 2559|  2.72M|            more_ = !cursor_mode_;
 2560|  2.72M|        }
 2561|  2.72M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE28read_byte_string_from_sourceclINS3_6vectorIhS5_EEEEvRT_RNS3_10error_codeE:
  314|  2.72M|        {
  315|  2.72M|            source->read_byte_string(cont,ec);
  316|  2.72M|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringERNS3_6vectorIhS5_EERNS3_10error_codeE:
 1265|  2.72M|    {
 1266|  2.72M|        v.clear();
 1267|  2.72M|        auto c = source_.peek();
 1268|  2.72M|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  2.72M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.72M]
  |  |  ------------------
  ------------------
 1269|      0|        {
 1270|      0|            ec = cbor_errc::unexpected_eof;
 1271|      0|            return;
 1272|      0|        }
 1273|  2.72M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1274|  2.72M|        uint8_t info = get_additional_information_value(c.value);
 1275|       |
 1276|  2.72M|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::byte_string);
  ------------------
  |  |   45|  2.72M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 2.72M]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1277|       |
 1278|  2.72M|        switch(info)
 1279|  2.72M|        {
 1280|      4|            case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (1280:13): [True: 4, False: 2.72M]
  ------------------
 1281|      4|            {
 1282|      4|                auto func = [&v](Source& source, std::size_t length, std::error_code& ec) -> bool
 1283|      4|                {
 1284|      4|                    if (source_reader<Source>::read(source, v, length) != length)
 1285|      4|                    {
 1286|      4|                        ec = cbor_errc::unexpected_eof;
 1287|      4|                        return false;
 1288|      4|                    }
 1289|      4|                    return true;
 1290|      4|                };
 1291|      4|                iterate_string_chunks(func, major_type, ec);
 1292|      4|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 0]
  |  |  ------------------
  ------------------
 1293|      4|                {
 1294|      4|                    return;
 1295|      4|                }
 1296|      0|                break;
 1297|      4|            }
 1298|  2.72M|            default:
  ------------------
  |  Branch (1298:13): [True: 2.72M, False: 4]
  ------------------
 1299|  2.72M|            {
 1300|  2.72M|                std::size_t length = read_size(ec);
 1301|  2.72M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.72M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2.72M]
  |  |  ------------------
  ------------------
 1302|      0|                {
 1303|      0|                    return;
 1304|      0|                }
 1305|  2.72M|                if (source_reader<Source>::read(source_, v, length) != length)
  ------------------
  |  Branch (1305:21): [True: 4, False: 2.72M]
  ------------------
 1306|      4|                {
 1307|      4|                    ec = cbor_errc::unexpected_eof;
 1308|      4|                    return;
 1309|      4|                }
 1310|  2.72M|                if (!stringref_map_stack_.empty() &&
  ------------------
  |  Branch (1310:21): [True: 1.51k, False: 2.72M]
  ------------------
 1311|  1.51k|                    v.size() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1311:21): [True: 208, False: 1.30k]
  ------------------
 1312|    208|                {
 1313|    208|                    stringref_map_stack_.back().emplace_back(mapped_string(v, alloc_));
 1314|    208|                }
 1315|  2.72M|                break;
 1316|  2.72M|            }
 1317|       |
 1318|  2.72M|        }
 1319|  2.72M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21iterate_string_chunksIZNS8_16read_byte_stringERNS3_6vectorIhS5_EERNS3_10error_codeEEUlRS6_mSE_E_EEvRT_NS0_6detail15cbor_major_typeESE_:
 1323|      4|    {
 1324|      4|        int nesting_level = 0;
 1325|       |
 1326|      4|        bool done = false;
 1327|  1.68M|        while (!done)
  ------------------
  |  Branch (1327:16): [True: 1.68M, False: 0]
  ------------------
 1328|  1.68M|        {
 1329|  1.68M|            auto c = source_.peek();
 1330|  1.68M|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.68M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.68M]
  |  |  ------------------
  ------------------
 1331|      0|            {
 1332|      0|                ec = cbor_errc::unexpected_eof;
 1333|      0|                more_ = false;
 1334|      0|                return;
 1335|      0|            }
 1336|  1.68M|            if (nesting_level > 0 && c.value == 0xff)
  ------------------
  |  Branch (1336:17): [True: 1.68M, False: 4]
  |  Branch (1336:38): [True: 56.3k, False: 1.62M]
  ------------------
 1337|  56.3k|            {
 1338|  56.3k|                --nesting_level;
 1339|  56.3k|                if (nesting_level == 0)
  ------------------
  |  Branch (1339:21): [True: 0, False: 56.3k]
  ------------------
 1340|      0|                {
 1341|      0|                    done = true;
 1342|      0|                }
 1343|  56.3k|                source_.ignore(1);
 1344|  56.3k|                continue;
 1345|  56.3k|            }
 1346|       |
 1347|  1.62M|            jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1348|  1.62M|            if (major_type != type)
  ------------------
  |  Branch (1348:17): [True: 3, False: 1.62M]
  ------------------
 1349|      3|            {
 1350|      3|                ec = cbor_errc::illegal_chunked_string;
 1351|      3|                more_ = false;
 1352|      3|                return;
 1353|      3|            }
 1354|  1.62M|            uint8_t info = get_additional_information_value(c.value);
 1355|       |
 1356|  1.62M|            switch (info)
 1357|  1.62M|            {
 1358|  1.57M|                case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (1358:17): [True: 1.57M, False: 46.2k]
  ------------------
 1359|  1.57M|                {
 1360|  1.57M|                    ++nesting_level;
 1361|  1.57M|                    source_.ignore(1);
 1362|  1.57M|                    break;
 1363|      0|                }
 1364|  46.2k|                default: // definite length
  ------------------
  |  Branch (1364:17): [True: 46.2k, False: 1.57M]
  ------------------
 1365|  46.2k|                {
 1366|  46.2k|                    std::size_t length = read_size(ec);
 1367|  46.2k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  46.2k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 46.2k]
  |  |  ------------------
  ------------------
 1368|      0|                    {
 1369|      0|                        return;
 1370|      0|                    }
 1371|  46.2k|                    more_ = func(source_, length, ec);
 1372|  46.2k|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  46.2k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 46.2k]
  |  |  ------------------
  ------------------
 1373|      1|                    {
 1374|      1|                        return;
 1375|      1|                    }
 1376|  46.2k|                    if (nesting_level == 0)
  ------------------
  |  Branch (1376:25): [True: 0, False: 46.2k]
  ------------------
 1377|      0|                    {
 1378|      0|                        done = true;
 1379|      0|                    }
 1380|  46.2k|                    break;
 1381|  46.2k|                }
 1382|  1.62M|            }
 1383|  1.62M|        } 
 1384|      4|    }
_ZZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_byte_stringERNS3_6vectorIhS5_EERNS3_10error_codeEENKUlRS6_mSD_E_clESE_mSD_:
 1283|  46.2k|                {
 1284|  46.2k|                    if (source_reader<Source>::read(source, v, length) != length)
  ------------------
  |  Branch (1284:25): [True: 1, False: 46.2k]
  ------------------
 1285|      1|                    {
 1286|      1|                        ec = cbor_errc::unexpected_eof;
 1287|      1|                        return false;
 1288|      1|                    }
 1289|  46.2k|                    return true;
 1290|  46.2k|                };
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9read_sizeERNS3_10error_codeE:
 1249|  7.75M|    {
 1250|  7.75M|        uint64_t u = read_uint64(ec);
 1251|  7.75M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  7.75M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 7.75M]
  |  |  ------------------
  ------------------
 1252|      0|        {
 1253|      0|            return 0;
 1254|      0|        }
 1255|  7.75M|        std::size_t len = static_cast<std::size_t>(u);
 1256|  7.75M|        if (len != u)
  ------------------
  |  Branch (1256:13): [True: 0, False: 7.75M]
  ------------------
 1257|      0|        {
 1258|      0|            ec = cbor_errc::number_too_large;
 1259|      0|            more_ = false;
 1260|      0|        }
 1261|  7.75M|        return len;
 1262|  7.75M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringC2EOS9_:
  233|    560|        mapped_string(mapped_string&&) = default;
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringC2ERKNS3_6vectorIhS5_EERKS7_:
  222|    208|            : type(jsoncons::cbor::detail::cbor_major_type::byte_string), str(alloc), bytes(bytes,alloc)
  223|    208|        {
  224|    208|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_text_stringERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 1212|  1.07M|    {
 1213|  1.07M|        auto c = source_.peek();
 1214|  1.07M|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.07M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.07M]
  |  |  ------------------
  ------------------
 1215|      0|        {
 1216|      0|            ec = cbor_errc::unexpected_eof;
 1217|      0|            more_ = false;
 1218|      0|            return;
 1219|      0|        }
 1220|  1.07M|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1221|  1.07M|        uint8_t info = get_additional_information_value(c.value);
 1222|       |
 1223|  1.07M|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::text_string);
  ------------------
  |  |   45|  1.07M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 1.07M]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1224|  1.07M|        auto func = [&str](Source& source, std::size_t length, std::error_code& ec) -> bool
 1225|  1.07M|        {
 1226|  1.07M|            if (source_reader<Source>::read(source, str, length) != length)
 1227|  1.07M|            {
 1228|  1.07M|                ec = cbor_errc::unexpected_eof;
 1229|  1.07M|                return false;
 1230|  1.07M|            }
 1231|  1.07M|            return true;
 1232|  1.07M|        };
 1233|  1.07M|        iterate_string_chunks(func, major_type, ec);
 1234|  1.07M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.07M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 9, False: 1.07M]
  |  |  ------------------
  ------------------
 1235|      9|        {
 1236|      9|            return;
 1237|      9|        }
 1238|       |
 1239|  1.07M|        if (!stringref_map_stack_.empty() && 
  ------------------
  |  Branch (1239:13): [True: 994k, False: 78.0k]
  ------------------
 1240|   994k|            info != jsoncons::cbor::detail::additional_info::indefinite_length &&
  ------------------
  |  Branch (1240:13): [True: 994k, False: 0]
  ------------------
 1241|   994k|            str.length() >= jsoncons::cbor::detail::min_length_for_stringref(stringref_map_stack_.back().size()))
  ------------------
  |  Branch (1241:13): [True: 39, False: 994k]
  ------------------
 1242|     39|        {
 1243|     39|            stringref_map_stack_.back().emplace_back(mapped_string(str,alloc_));
 1244|     39|        }
 1245|       |
 1246|  1.07M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21iterate_string_chunksIZNS8_16read_text_stringERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeEEUlRS6_mSG_E_EEvRT_NS0_6detail15cbor_major_typeESG_:
 1323|  1.07M|    {
 1324|  1.07M|        int nesting_level = 0;
 1325|       |
 1326|  1.07M|        bool done = false;
 1327|  2.97M|        while (!done)
  ------------------
  |  Branch (1327:16): [True: 1.89M, False: 1.07M]
  ------------------
 1328|  1.89M|        {
 1329|  1.89M|            auto c = source_.peek();
 1330|  1.89M|            if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|  1.89M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 1.89M]
  |  |  ------------------
  ------------------
 1331|      1|            {
 1332|      1|                ec = cbor_errc::unexpected_eof;
 1333|      1|                more_ = false;
 1334|      1|                return;
 1335|      1|            }
 1336|  1.89M|            if (nesting_level > 0 && c.value == 0xff)
  ------------------
  |  Branch (1336:17): [True: 826k, False: 1.07M]
  |  Branch (1336:38): [True: 383k, False: 443k]
  ------------------
 1337|   383k|            {
 1338|   383k|                --nesting_level;
 1339|   383k|                if (nesting_level == 0)
  ------------------
  |  Branch (1339:21): [True: 0, False: 383k]
  ------------------
 1340|      0|                {
 1341|      0|                    done = true;
 1342|      0|                }
 1343|   383k|                source_.ignore(1);
 1344|   383k|                continue;
 1345|   383k|            }
 1346|       |
 1347|  1.51M|            jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(c.value);
 1348|  1.51M|            if (major_type != type)
  ------------------
  |  Branch (1348:17): [True: 1, False: 1.51M]
  ------------------
 1349|      1|            {
 1350|      1|                ec = cbor_errc::illegal_chunked_string;
 1351|      1|                more_ = false;
 1352|      1|                return;
 1353|      1|            }
 1354|  1.51M|            uint8_t info = get_additional_information_value(c.value);
 1355|       |
 1356|  1.51M|            switch (info)
 1357|  1.51M|            {
 1358|   441k|                case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (1358:17): [True: 441k, False: 1.07M]
  ------------------
 1359|   441k|                {
 1360|   441k|                    ++nesting_level;
 1361|   441k|                    source_.ignore(1);
 1362|   441k|                    break;
 1363|      0|                }
 1364|  1.07M|                default: // definite length
  ------------------
  |  Branch (1364:17): [True: 1.07M, False: 441k]
  ------------------
 1365|  1.07M|                {
 1366|  1.07M|                    std::size_t length = read_size(ec);
 1367|  1.07M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.07M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1.07M]
  |  |  ------------------
  ------------------
 1368|      0|                    {
 1369|      0|                        return;
 1370|      0|                    }
 1371|  1.07M|                    more_ = func(source_, length, ec);
 1372|  1.07M|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  1.07M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 7, False: 1.07M]
  |  |  ------------------
  ------------------
 1373|      7|                    {
 1374|      7|                        return;
 1375|      7|                    }
 1376|  1.07M|                    if (nesting_level == 0)
  ------------------
  |  Branch (1376:25): [True: 1.07M, False: 1.94k]
  ------------------
 1377|  1.07M|                    {
 1378|  1.07M|                        done = true;
 1379|  1.07M|                    }
 1380|  1.07M|                    break;
 1381|  1.07M|                }
 1382|  1.51M|            }
 1383|  1.51M|        } 
 1384|  1.07M|    }
_ZZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE16read_text_stringERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeEENKUlRS6_mSF_E_clESG_mSF_:
 1225|  1.07M|        {
 1226|  1.07M|            if (source_reader<Source>::read(source, str, length) != length)
  ------------------
  |  Branch (1226:17): [True: 7, False: 1.07M]
  ------------------
 1227|      7|            {
 1228|      7|                ec = cbor_errc::unexpected_eof;
 1229|      7|                return false;
 1230|      7|            }
 1231|  1.07M|            return true;
 1232|  1.07M|        };
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13mapped_stringC2ERKNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERKS7_:
  211|     39|            : type(jsoncons::cbor::detail::cbor_major_type::text_string), str(str.c_str(), str.size(), alloc), bytes(alloc)
  212|     39|        {
  213|     39|        }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11read_doubleERNS3_10error_codeE:
 1557|  1.46k|    {
 1558|  1.46k|        double val = 0;
 1559|       |
 1560|  1.46k|        uint8_t b;
 1561|  1.46k|        if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1561:13): [True: 0, False: 1.46k]
  ------------------
 1562|      0|        {
 1563|      0|            ec = cbor_errc::unexpected_eof;
 1564|      0|            more_ = false;
 1565|      0|            return 0;
 1566|      0|        }
 1567|  1.46k|        uint8_t info = get_additional_information_value(b);
 1568|  1.46k|        switch (info)
 1569|  1.46k|        {
 1570|    629|        case 0x1a: // Single-Precision Float (four-byte IEEE 754)
  ------------------
  |  Branch (1570:9): [True: 629, False: 839]
  ------------------
 1571|    629|            {
 1572|    629|                uint8_t buf[sizeof(float)];
 1573|    629|                if (source_.read(buf, sizeof(float)) !=sizeof(float)) 
  ------------------
  |  Branch (1573:21): [True: 0, False: 629]
  ------------------
 1574|      0|                {
 1575|      0|                    ec = cbor_errc::unexpected_eof;
 1576|      0|                    more_ = false;
 1577|      0|                    return 0;
 1578|      0|                }
 1579|    629|                val = binary::big_to_native<float>(buf, sizeof(buf));
 1580|    629|                break;
 1581|    629|            }
 1582|       |
 1583|    839|        case 0x1b: //  Double-Precision Float (eight-byte IEEE 754)
  ------------------
  |  Branch (1583:9): [True: 839, False: 629]
  ------------------
 1584|    839|            {
 1585|    839|                uint8_t buf[sizeof(double)];
 1586|    839|                if (source_.read(buf, sizeof(double)) != sizeof(double))
  ------------------
  |  Branch (1586:21): [True: 0, False: 839]
  ------------------
 1587|      0|                {
 1588|      0|                    ec = cbor_errc::unexpected_eof;
 1589|      0|                    more_ = false;
 1590|      0|                    return 0;
 1591|      0|                }
 1592|    839|                val = binary::big_to_native<double>(buf, sizeof(buf));
 1593|    839|                break;
 1594|    839|            }
 1595|      0|            default:
  ------------------
  |  Branch (1595:13): [True: 0, False: 1.46k]
  ------------------
 1596|      0|                break;
 1597|  1.46k|        }
 1598|       |        
 1599|  1.46k|        return val;
 1600|  1.46k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_decimal_fractionERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 1603|   368k|    {
 1604|   368k|        std::size_t size = read_size(ec);
 1605|   368k|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   368k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 368k]
  |  |  ------------------
  ------------------
 1606|      0|        {
 1607|      0|            return;
 1608|      0|        }
 1609|   368k|        if (size != 2)
  ------------------
  |  Branch (1609:13): [True: 0, False: 368k]
  ------------------
 1610|      0|        {
 1611|      0|            ec = cbor_errc::invalid_decimal_fraction;
 1612|      0|            more_ = false;
 1613|      0|            return;
 1614|      0|        }
 1615|       |
 1616|   368k|        auto c = source_.peek();
 1617|   368k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   368k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 368k]
  |  |  ------------------
  ------------------
 1618|      0|        {
 1619|      0|            ec = cbor_errc::unexpected_eof;
 1620|      0|            more_ = false;
 1621|      0|            return;
 1622|      0|        }
 1623|   368k|        int64_t exponent = 0;
 1624|   368k|        switch (get_major_type(c.value))
 1625|   368k|        {
 1626|    602|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1626:13): [True: 602, False: 368k]
  ------------------
 1627|    602|            {
 1628|    602|                exponent = read_uint64(ec);
 1629|    602|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    602|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 602]
  |  |  ------------------
  ------------------
 1630|      0|                {
 1631|      0|                    return;
 1632|      0|                }
 1633|    602|                break;
 1634|    602|            }
 1635|   368k|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1635:13): [True: 368k, False: 604]
  ------------------
 1636|   368k|            {
 1637|   368k|                exponent = read_int64(ec);
 1638|   368k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   368k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 368k]
  |  |  ------------------
  ------------------
 1639|      0|                {
 1640|      0|                    return;
 1641|      0|                }
 1642|   368k|                break;
 1643|   368k|            }
 1644|   368k|            default:
  ------------------
  |  Branch (1644:13): [True: 2, False: 368k]
  ------------------
 1645|      2|            {
 1646|      2|                ec = cbor_errc::invalid_decimal_fraction;
 1647|      2|                more_ = false;
 1648|      2|                return;
 1649|   368k|            }
 1650|   368k|        }
 1651|       |
 1652|   368k|        string_type str(alloc_);
 1653|       |
 1654|   368k|        c = source_.peek();
 1655|   368k|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|   368k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 368k]
  |  |  ------------------
  ------------------
 1656|      0|        {
 1657|      0|            ec = cbor_errc::unexpected_eof;
 1658|      0|            more_ = false;
 1659|      0|            return;
 1660|      0|        }
 1661|       |
 1662|   368k|        switch (get_major_type(c.value))
 1663|   368k|        {
 1664|    661|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1664:13): [True: 661, False: 368k]
  ------------------
 1665|    661|            {
 1666|    661|                uint64_t val = read_uint64(ec);
 1667|    661|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    661|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 661]
  |  |  ------------------
  ------------------
 1668|      0|                {
 1669|      0|                    return;
 1670|      0|                }
 1671|    661|                jsoncons::from_integer(val, str);
 1672|    661|                break;
 1673|    661|            }
 1674|   368k|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1674:13): [True: 368k, False: 662]
  ------------------
 1675|   368k|            {
 1676|   368k|                int64_t val = read_int64(ec);
 1677|   368k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   368k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 368k]
  |  |  ------------------
  ------------------
 1678|      0|                {
 1679|      0|                    return;
 1680|      0|                }
 1681|   368k|                jsoncons::from_integer(val, str);
 1682|   368k|                break;
 1683|   368k|            }
 1684|      1|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (1684:13): [True: 1, False: 368k]
  ------------------
 1685|      1|            {
 1686|      1|                uint8_t b;
 1687|      1|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1687:21): [True: 0, False: 1]
  ------------------
 1688|      0|                {
 1689|      0|                    ec = cbor_errc::unexpected_eof;
 1690|      0|                    more_ = false;
 1691|      0|                    return;
 1692|      0|                }
 1693|      1|                uint8_t tag = get_additional_information_value(b);
 1694|      1|                c = source_.peek();
 1695|      1|                if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1696|      0|                {
 1697|      0|                    ec = cbor_errc::unexpected_eof;
 1698|      0|                    more_ = false;
 1699|      0|                    return;
 1700|      0|                }
 1701|       |
 1702|      1|                if (get_major_type(c.value) == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (1702:21): [True: 1, False: 0]
  ------------------
 1703|      1|                {
 1704|      1|                    bytes_buffer_.clear();
 1705|      1|                    read_byte_string(bytes_buffer_, ec);
 1706|      1|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 1707|      1|                    {
 1708|      1|                        more_ = false;
 1709|      1|                        return;
 1710|      1|                    }
 1711|      0|                    if (tag == 2)
  ------------------
  |  Branch (1711:25): [True: 0, False: 0]
  ------------------
 1712|      0|                    {
 1713|      0|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1714|      0|                        n.write_string(str);
 1715|      0|                    }
 1716|      0|                    else if (tag == 3)
  ------------------
  |  Branch (1716:30): [True: 0, False: 0]
  ------------------
 1717|      0|                    {
 1718|      0|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1719|      0|                        n = -1 - n;
 1720|      0|                        n.write_string(str);
 1721|      0|                    }
 1722|      0|                }
 1723|      0|                break;
 1724|      1|            }
 1725|      0|            default:
  ------------------
  |  Branch (1725:13): [True: 0, False: 368k]
  ------------------
 1726|      0|            {
 1727|      0|                ec = cbor_errc::invalid_decimal_fraction;
 1728|      0|                more_ = false;
 1729|      0|                return;
 1730|      1|            }
 1731|   368k|        }
 1732|       |
 1733|   368k|        if (str.size() >= static_cast<std::size_t>((std::numeric_limits<int32_t>::max)()) || 
  ------------------
  |  Branch (1733:13): [True: 0, False: 368k]
  ------------------
 1734|   368k|            exponent >= (std::numeric_limits<int32_t>::max)() || 
  ------------------
  |  Branch (1734:13): [True: 0, False: 368k]
  ------------------
 1735|   368k|            exponent <= (std::numeric_limits<int32_t>::min)())
  ------------------
  |  Branch (1735:13): [True: 0, False: 368k]
  ------------------
 1736|      0|        {
 1737|      0|            ec = cbor_errc::invalid_decimal_fraction;
 1738|      0|            more_ = false;
 1739|      0|            return;
 1740|      0|        }
 1741|   368k|        else if (str.size() > 0)
  ------------------
  |  Branch (1741:18): [True: 368k, False: 0]
  ------------------
 1742|   368k|        {
 1743|   368k|            if (str[0] == '-')
  ------------------
  |  Branch (1743:17): [True: 368k, False: 661]
  ------------------
 1744|   368k|            {
 1745|   368k|                result.push_back('-');
 1746|   368k|                jsoncons::prettify_string(str.c_str()+1, str.size()-1, (int)exponent, -4, 17, result);
 1747|   368k|            }
 1748|    661|            else
 1749|    661|            {
 1750|    661|                jsoncons::prettify_string(str.c_str(), str.size(), (int)exponent, -4, 17, result);
 1751|    661|            }
 1752|   368k|        }
 1753|      0|        else
 1754|      0|        {
 1755|      0|            ec = cbor_errc::invalid_decimal_fraction;
 1756|      0|            more_ = false;
 1757|      0|            return;
 1758|      0|        }
 1759|   368k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE13read_bigfloatERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE:
 1762|    100|    {
 1763|    100|        std::size_t size = read_size(ec);
 1764|    100|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    100|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 100]
  |  |  ------------------
  ------------------
 1765|      0|        {
 1766|      0|            return;
 1767|      0|        }
 1768|    100|        if (size != 2)
  ------------------
  |  Branch (1768:13): [True: 0, False: 100]
  ------------------
 1769|      0|        {
 1770|      0|            ec = cbor_errc::invalid_bigfloat;
 1771|      0|            more_ = false;
 1772|      0|            return;
 1773|      0|        }
 1774|       |
 1775|    100|        auto c = source_.peek();
 1776|    100|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|    100|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 100]
  |  |  ------------------
  ------------------
 1777|      0|        {
 1778|      0|            ec = cbor_errc::unexpected_eof;
 1779|      0|            more_ = false;
 1780|      0|            return;
 1781|      0|        }
 1782|    100|        int64_t exponent = 0;
 1783|    100|        switch (get_major_type(c.value))
 1784|    100|        {
 1785|     99|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1785:13): [True: 99, False: 1]
  ------------------
 1786|     99|            {
 1787|     99|                exponent = read_uint64(ec);
 1788|     99|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     99|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 99]
  |  |  ------------------
  ------------------
 1789|      0|                {
 1790|      0|                    return;
 1791|      0|                }
 1792|     99|                break;
 1793|     99|            }
 1794|     99|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1794:13): [True: 1, False: 99]
  ------------------
 1795|      1|            {
 1796|      1|                exponent = read_int64(ec);
 1797|      1|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1798|      0|                {
 1799|      0|                    return;
 1800|      0|                }
 1801|      1|                break;
 1802|      1|            }
 1803|      1|            default:
  ------------------
  |  Branch (1803:13): [True: 0, False: 100]
  ------------------
 1804|      0|            {
 1805|      0|                ec = cbor_errc::invalid_bigfloat;
 1806|      0|                more_ = false;
 1807|      0|                return;
 1808|      1|            }
 1809|    100|        }
 1810|       |
 1811|    100|        c = source_.peek();
 1812|    100|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|    100|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 100]
  |  |  ------------------
  ------------------
 1813|      0|        {
 1814|      0|            ec = cbor_errc::unexpected_eof;
 1815|      0|            more_ = false;
 1816|      0|            return;
 1817|      0|        }
 1818|    100|        switch (get_major_type(c.value))
 1819|    100|        {
 1820|     97|            case jsoncons::cbor::detail::cbor_major_type::unsigned_integer:
  ------------------
  |  Branch (1820:13): [True: 97, False: 3]
  ------------------
 1821|     97|            {
 1822|     97|                uint64_t val = read_uint64(ec);
 1823|     97|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     97|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 97]
  |  |  ------------------
  ------------------
 1824|      0|                {
 1825|      0|                    return;
 1826|      0|                }
 1827|     97|                str.push_back('0');
 1828|     97|                str.push_back('x');
 1829|     97|                jsoncons::integer_to_hex(val, str);
 1830|     97|                break;
 1831|     97|            }
 1832|      0|            case jsoncons::cbor::detail::cbor_major_type::negative_integer:
  ------------------
  |  Branch (1832:13): [True: 0, False: 100]
  ------------------
 1833|      0|            {
 1834|      0|                int64_t val = read_int64(ec);
 1835|      0|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1836|      0|                {
 1837|      0|                    return;
 1838|      0|                }
 1839|      0|                str.push_back('-');
 1840|      0|                str.push_back('0');
 1841|      0|                str.push_back('x');
 1842|      0|                jsoncons::integer_to_hex(static_cast<uint64_t>(-val), str);
 1843|      0|                break;
 1844|      0|            }
 1845|      3|            case jsoncons::cbor::detail::cbor_major_type::semantic_tag:
  ------------------
  |  Branch (1845:13): [True: 3, False: 97]
  ------------------
 1846|      3|            {
 1847|      3|                uint8_t b;
 1848|      3|                if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (1848:21): [True: 0, False: 3]
  ------------------
 1849|      0|                {
 1850|      0|                    ec = cbor_errc::unexpected_eof;
 1851|      0|                    more_ = false;
 1852|      0|                    return;
 1853|      0|                }
 1854|      3|                uint8_t tag = get_additional_information_value(b);
 1855|       |
 1856|      3|                c = source_.peek();
 1857|      3|                if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
 1858|      0|                {
 1859|      0|                    ec = cbor_errc::unexpected_eof;
 1860|      0|                    more_ = false;
 1861|      0|                    return;
 1862|      0|                }
 1863|       |
 1864|      3|                if (get_major_type(c.value) == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (1864:21): [True: 3, False: 0]
  ------------------
 1865|      3|                {
 1866|      3|                    bytes_buffer_.clear(); 
 1867|      3|                    read_byte_string(bytes_buffer_, ec);
 1868|      3|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      3|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3]
  |  |  ------------------
  ------------------
 1869|      0|                    {
 1870|      0|                        more_ = false;
 1871|      0|                        return;
 1872|      0|                    }
 1873|      3|                    if (tag == 2)
  ------------------
  |  Branch (1873:25): [True: 1, False: 2]
  ------------------
 1874|      1|                    {
 1875|      1|                        str.push_back('0');
 1876|      1|                        str.push_back('x');
 1877|      1|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1878|      1|                        n.write_string_hex(str);
 1879|      1|                    }
 1880|      2|                    else if (tag == 3)
  ------------------
  |  Branch (1880:30): [True: 0, False: 2]
  ------------------
 1881|      0|                    {
 1882|      0|                        str.push_back('-');
 1883|      0|                        str.push_back('0');
 1884|      0|                        bigint n = bigint::from_bytes_be(1, bytes_buffer_.data(), bytes_buffer_.size());
 1885|      0|                        n = -1 - n;
 1886|      0|                        n.write_string_hex(str);
 1887|      0|                        str[2] = 'x'; // overwrite minus
 1888|      0|                    }
 1889|      3|                }
 1890|      3|                break;
 1891|      3|            }
 1892|      3|            default:
  ------------------
  |  Branch (1892:13): [True: 0, False: 100]
  ------------------
 1893|      0|            {
 1894|      0|                ec = cbor_errc::invalid_bigfloat;
 1895|      0|                more_ = false;
 1896|      0|                return;
 1897|      3|            }
 1898|    100|        }
 1899|       |
 1900|    100|        str.push_back('p');
 1901|    100|        if (exponent >=0)
  ------------------
  |  Branch (1901:13): [True: 99, False: 1]
  ------------------
 1902|     99|        {
 1903|     99|            jsoncons::integer_to_hex(static_cast<uint64_t>(exponent), str);
 1904|     99|        }
 1905|      1|        else
 1906|      1|        {
 1907|      1|            str.push_back('-');
 1908|      1|            jsoncons::integer_to_hex(static_cast<uint64_t>(-exponent), str);
 1909|      1|        }
 1910|    100|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE19read_mdarray_headerERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
 2564|      1|    {
 2565|      1|        uint8_t b;
 2566|      1|        if (source_.read(&b, 1) == 0)
  ------------------
  |  Branch (2566:13): [True: 0, False: 1]
  ------------------
 2567|      0|        {
 2568|      0|            ec = cbor_errc::unexpected_eof;
 2569|      0|            more_ = false;
 2570|      0|            return;
 2571|      0|        }
 2572|      1|        jsoncons::cbor::detail::cbor_major_type major_type = get_major_type(b);
 2573|      1|        JSONCONS_ASSERT(major_type == jsoncons::cbor::detail::cbor_major_type::array);
  ------------------
  |  |   45|      1|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (45:32): [True: 0, False: 1]
  |  |  ------------------
  |  |   46|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   47|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 2574|      1|        uint8_t info = get_additional_information_value(b);
 2575|       |       
 2576|      1|        read_extents(ec);   
 2577|      1|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 2578|      1|        {
 2579|      1|            return;
 2580|      1|        }
 2581|       |
 2582|      0|        read_tags(ec);
 2583|      0|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2584|      0|        {
 2585|      0|            return;
 2586|      0|        }
 2587|      0|        auto c = source_.peek();
 2588|      0|        if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2589|      0|        {
 2590|      0|            ec = cbor_errc::unexpected_eof;
 2591|      0|            more_ = false;
 2592|      0|            return;
 2593|      0|        }
 2594|      0|        major_type = get_major_type(c.value);
 2595|      0|        info = get_additional_information_value(c.value);
 2596|      0|        state_stack_.emplace_back(parse_mode::multi_dim, 0);
 2597|      0|        ++state_stack_.back().index;
 2598|       |
 2599|      0|        if (major_type == jsoncons::cbor::detail::cbor_major_type::array && order_ == mdarray_order::row_major)
  ------------------
  |  Branch (2599:13): [True: 0, False: 0]
  |  Branch (2599:77): [True: 0, False: 0]
  ------------------
 2600|      0|        {
 2601|      0|            begin_row_major_storage(info, ec);
 2602|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2603|      0|            {
 2604|      0|                return;
 2605|      0|            }
 2606|      0|            row_major_reader_ = mdarray_row_major_reader<Source,Allocator>(extents_, this);
 2607|      0|            if (!row_major_reader_.done())
  ------------------
  |  Branch (2607:17): [True: 0, False: 0]
  ------------------
 2608|      0|            {
 2609|      0|                row_major_reader_.next(visitor, *this, ec);
 2610|      0|            }
 2611|      0|        }
 2612|      0|        else if (major_type == jsoncons::cbor::detail::cbor_major_type::array && order_ == mdarray_order::column_major)
  ------------------
  |  Branch (2612:18): [True: 0, False: 0]
  |  Branch (2612:82): [True: 0, False: 0]
  ------------------
 2613|      0|        {
 2614|      0|            begin_array(visitor, info, ec);
 2615|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2616|      0|            {
 2617|      0|                return;
 2618|      0|            }
 2619|      0|        }
 2620|      0|        else if (major_type == jsoncons::cbor::detail::cbor_major_type::byte_string)
  ------------------
  |  Branch (2620:18): [True: 0, False: 0]
  ------------------
 2621|      0|        {
 2622|      0|            read_byte_string_from_source read(this);
 2623|      0|            read_byte_string(read, visitor, ec);
 2624|      0|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2625|      0|            {
 2626|      0|                return;
 2627|      0|            }
 2628|      0|        }
 2629|      0|        else
 2630|      0|        {
 2631|      0|            ec = cbor_errc::bad_mdarray;
 2632|      0|            return;
 2633|      0|        }
 2634|      0|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12read_extentsERNS3_10error_codeE:
 2637|      1|    {
 2638|      1|        extents_.clear();
 2639|       |
 2640|      1|        auto b = source_.peek();
 2641|      1|        if (JSONCONS_UNLIKELY(b.eof))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2642|      0|        {
 2643|      0|            ec = cbor_errc::unexpected_eof;
 2644|      0|            more_ = false;
 2645|      0|            return;
 2646|      0|        }
 2647|      1|        uint8_t info = get_additional_information_value(b.value);
 2648|       |
 2649|      1|        switch (info)
 2650|      1|        {
 2651|      0|            case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (2651:13): [True: 0, False: 1]
  ------------------
 2652|      0|            {
 2653|      0|                while (true)
  ------------------
  |  Branch (2653:24): [True: 0, Folded]
  ------------------
 2654|      0|                {
 2655|      0|                    auto c = source_.peek();
 2656|      0|                    if (JSONCONS_UNLIKELY(c.eof))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2657|      0|                    {
 2658|      0|                        ec = cbor_errc::unexpected_eof;
 2659|      0|                        more_ = false;
 2660|      0|                        return;
 2661|      0|                    }
 2662|      0|                    if (c.value == 0xff)
  ------------------
  |  Branch (2662:25): [True: 0, False: 0]
  ------------------
 2663|      0|                    {
 2664|      0|                        source_.ignore(1);
 2665|      0|                        return;
 2666|      0|                    }
 2667|      0|                    else
 2668|      0|                    {
 2669|      0|                        std::size_t extent = read_size(ec);
 2670|      0|                        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      0|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2671|      0|                        {
 2672|      0|                            more_ = false;
 2673|      0|                            return;
 2674|      0|                        }
 2675|      0|                        extents_.push_back(extent);
 2676|      0|                    }
 2677|      0|                }
 2678|      0|                break;
 2679|      0|            }
 2680|      1|            default:
  ------------------
  |  Branch (2680:13): [True: 1, False: 0]
  ------------------
 2681|      1|            {
 2682|      1|                std::size_t size = read_size(ec);
 2683|      1|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|      1|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2684|      0|                {
 2685|      0|                    more_ = false;
 2686|      0|                    return;
 2687|      0|                }
 2688|     20|                for (std::size_t i = 0; more_ && i < size; ++i)
  ------------------
  |  Branch (2688:41): [True: 20, False: 0]
  |  Branch (2688:50): [True: 19, False: 1]
  ------------------
 2689|     19|                {
 2690|     19|                    std::size_t extent = read_size(ec);
 2691|     19|                    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     19|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 19]
  |  |  ------------------
  ------------------
 2692|      0|                    {
 2693|      0|                        more_ = false;
 2694|      0|                        return;
 2695|      0|                    }
 2696|     19|                    extents_.push_back(extent);
 2697|     19|                }
 2698|      1|                break;
 2699|      1|            }
 2700|      1|        }
 2701|      1|        auto r = calculate_mdarray_size(extents_);
 2702|      1|        if (!r || *r == 0)
  ------------------
  |  Branch (2702:13): [True: 1, False: 0]
  |  Branch (2702:19): [True: 0, False: 0]
  ------------------
 2703|      1|        {
 2704|      1|            ec = cbor_errc::bad_extents;
 2705|      1|            more_ = false;
 2706|      1|            return;
 2707|      1|        }
 2708|      0|        mdarray_size_ = *r;
 2709|      0|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayERNS_24basic_item_event_visitorIcEEhRNS3_10error_codeE:
 1020|   344k|    {
 1021|   344k|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|   344k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 344k]
  |  |  ------------------
  ------------------
 1022|      0|        {
 1023|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
 1024|      0|            more_ = false;
 1025|      0|            return;
 1026|      0|        } 
 1027|   344k|        semantic_tag tag = semantic_tag::none;
 1028|   344k|        bool pop_stringref_map_stack = false;
 1029|   344k|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (1029:13): [True: 23, False: 344k]
  ------------------
 1030|     23|        {
 1031|     23|            stringref_map_stack_.emplace_back();
 1032|     23|            other_tags_[stringref_namespace_tag] = false;
 1033|     23|            pop_stringref_map_stack = true;
 1034|     23|        }
 1035|   344k|        switch (info)
 1036|   344k|        {
 1037|    117|            case jsoncons::cbor::detail::additional_info::indefinite_length:
  ------------------
  |  Branch (1037:13): [True: 117, False: 343k]
  ------------------
 1038|    117|            {
 1039|    117|                state_stack_.emplace_back(parse_mode::indefinite_array,0,pop_stringref_map_stack);
 1040|    117|                visitor.begin_array(tag, *this, ec);
 1041|    117|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|    117|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 117]
  |  |  ------------------
  ------------------
 1042|      0|                {
 1043|      0|                    return;
 1044|      0|                }
 1045|    117|                more_ = !cursor_mode_;
 1046|    117|                source_.ignore(1);
 1047|    117|                break;
 1048|    117|            }
 1049|   343k|            default: // definite length
  ------------------
  |  Branch (1049:13): [True: 343k, False: 117]
  ------------------
 1050|   343k|            {
 1051|   343k|                std::size_t len = read_size(ec);
 1052|   343k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   343k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 343k]
  |  |  ------------------
  ------------------
 1053|      0|                {
 1054|      0|                    return;
 1055|      0|                }
 1056|   343k|                state_stack_.emplace_back(parse_mode::array,len,pop_stringref_map_stack);
 1057|   343k|                visitor.begin_array(len, tag, *this, ec);
 1058|   343k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   343k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 343k]
  |  |  ------------------
  ------------------
 1059|      0|                {
 1060|      0|                    return;
 1061|      0|                }
 1062|   343k|                more_ = !cursor_mode_;
 1063|   343k|                break;
 1064|   343k|            }
 1065|   344k|        }
 1066|   344k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12begin_objectERNS_24basic_item_event_visitorIcEEhRNS3_10error_codeE:
 1144|  3.31M|    {
 1145|  3.31M|        if (JSONCONS_UNLIKELY(++nesting_depth_ > max_nesting_depth_))
  ------------------
  |  |   78|  3.31M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.31M]
  |  |  ------------------
  ------------------
 1146|      0|        {
 1147|      0|            ec = cbor_errc::max_nesting_depth_exceeded;
 1148|      0|            more_ = false;
 1149|      0|            return;
 1150|      0|        } 
 1151|  3.31M|        bool pop_stringref_map_stack = false;
 1152|  3.31M|        if (other_tags_[stringref_namespace_tag])
  ------------------
  |  Branch (1152:13): [True: 35, False: 3.31M]
  ------------------
 1153|     35|        {
 1154|     35|            stringref_map_stack_.emplace_back();
 1155|     35|            other_tags_[stringref_namespace_tag] = false;
 1156|     35|            pop_stringref_map_stack = true;
 1157|     35|        }
 1158|  3.31M|        switch (info)
 1159|  3.31M|        {
 1160|   122k|            case jsoncons::cbor::detail::additional_info::indefinite_length: 
  ------------------
  |  Branch (1160:13): [True: 122k, False: 3.19M]
  ------------------
 1161|   122k|            {
 1162|   122k|                state_stack_.emplace_back(parse_mode::indefinite_map_key,0,pop_stringref_map_stack);
 1163|   122k|                visitor.begin_object(semantic_tag::none, *this, ec);
 1164|   122k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   122k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 122k]
  |  |  ------------------
  ------------------
 1165|      0|                {
 1166|      0|                    return;
 1167|      0|                }
 1168|   122k|                more_ = !cursor_mode_;
 1169|   122k|                source_.ignore(1);
 1170|   122k|                break;
 1171|   122k|            }
 1172|  3.19M|            default: // definite_length
  ------------------
  |  Branch (1172:13): [True: 3.19M, False: 122k]
  ------------------
 1173|  3.19M|            {
 1174|  3.19M|                std::size_t len = read_size(ec);
 1175|  3.19M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.19M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.19M]
  |  |  ------------------
  ------------------
 1176|      0|                {
 1177|      0|                    return;
 1178|      0|                }
 1179|  3.19M|                state_stack_.emplace_back(parse_mode::map_key,len,pop_stringref_map_stack);
 1180|  3.19M|                visitor.begin_object(len, semantic_tag::none, *this, ec);
 1181|  3.19M|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.19M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.19M]
  |  |  ------------------
  ------------------
 1182|      0|                {
 1183|      0|                    return;
 1184|      0|                }
 1185|  3.19M|                more_ = !cursor_mode_;
 1186|  3.19M|                break;
 1187|  3.19M|            }
 1188|  3.31M|        }
 1189|  3.31M|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9end_arrayERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
 1069|   343k|    {
 1070|   343k|        --nesting_depth_;
 1071|       |
 1072|   343k|        visitor.end_array(*this, ec);
 1073|   343k|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|   343k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 343k]
  |  |  ------------------
  ------------------
 1074|      0|        {
 1075|      0|            return;
 1076|      0|        }
 1077|   343k|        more_ = !cursor_mode_;
 1078|   343k|        if (level() == mark_level_)
  ------------------
  |  Branch (1078:13): [True: 0, False: 343k]
  ------------------
 1079|      0|        {
 1080|      0|            more_ = false;
 1081|      0|        }
 1082|   343k|        if (state_stack_.back().pop_stringref_map_stack)
  ------------------
  |  Branch (1082:13): [True: 6, False: 343k]
  ------------------
 1083|      6|        {
 1084|      6|            stringref_map_stack_.pop_back();
 1085|      6|        }
 1086|   343k|        state_stack_.pop_back();
 1087|   343k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE21read_typed_array_itemERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
  676|  21.8k|    {
  677|  21.8k|        if (!typed_array_iter_->done())
  ------------------
  |  Branch (677:13): [True: 21.8k, False: 0]
  ------------------
  678|  21.8k|        {
  679|  21.8k|            typed_array_iter_->next(visitor, *this, ec);
  680|  21.8k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  21.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 21.8k]
  |  |  ------------------
  ------------------
  681|      0|            {
  682|      0|                return;
  683|      0|            }
  684|  21.8k|            more_ = !cursor_mode_;
  685|       |
  686|  21.8k|            if (typed_array_iter_->done())
  ------------------
  |  Branch (686:17): [True: 2.10k, False: 19.7k]
  ------------------
  687|  2.10k|            {
  688|  2.10k|                state_stack_.pop_back();
  689|  2.10k|            }
  690|  21.8k|        }
  691|  21.8k|    }
_ZN8jsoncons4cbor17basic_cbor_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10end_objectERNS_24basic_item_event_visitorIcEERNS3_10error_codeE:
 1192|  3.31M|    {
 1193|  3.31M|        --nesting_depth_;
 1194|  3.31M|        visitor.end_object(*this, ec);
 1195|  3.31M|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  3.31M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 3.31M]
  |  |  ------------------
  ------------------
 1196|      0|        {
 1197|      0|            return;
 1198|      0|        }
 1199|  3.31M|        more_ = !cursor_mode_;
 1200|  3.31M|        if (level() == mark_level_)
  ------------------
  |  Branch (1200:13): [True: 0, False: 3.31M]
  ------------------
 1201|      0|        {
 1202|      0|            more_ = false;
 1203|      0|        }
 1204|  3.31M|        if (state_stack_.back().pop_stringref_map_stack)
  ------------------
  |  Branch (1204:13): [True: 19, False: 3.31M]
  ------------------
 1205|     19|        {
 1206|     19|            stringref_map_stack_.pop_back();
 1207|     19|        }
 1208|  3.31M|        state_stack_.pop_back();
 1209|  3.31M|    }

_ZN8jsoncons4cbor17basic_cbor_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_13basic_istreamIcNS3_11char_traitsIcEEEEEEOT_RNS_18basic_json_visitorIcEERKNS0_19cbor_decode_optionsERKS7_:
   52|     43|       : parser_(std::forward<Sourceable>(source), options, alloc),
   53|     43|         adaptor_(visitor, alloc), visitor_(adaptor_)
   54|     43|    {
   55|     43|    }
_ZN8jsoncons4cbor17basic_cbor_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4readERNS3_10error_codeE:
   88|     43|    {
   89|     43|        parser_.reset();
   90|     43|        parser_.parse(visitor_, ec);
   91|     43|        if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     43|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 41, False: 2]
  |  |  ------------------
  ------------------
   92|     41|        {
   93|     41|            return;
   94|     41|        }
   95|     43|    }
_ZNK8jsoncons4cbor17basic_cbor_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4lineEv:
   98|     41|    {
   99|     41|        return parser_.line();
  100|     41|    }
_ZNK8jsoncons4cbor17basic_cbor_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE6columnEv:
  103|     41|    {
  104|     41|        return parser_.column();
  105|     41|    }

_ZN8jsoncons4cbor11decode_cborINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEJRNS4_19basic_istringstreamIcNS4_11char_traitsIcEES6_EEEEET_DpOT0_:
  255|     43|{
  256|     43|    auto result = try_decode_cbor<T>(std::forward<Args>(args)...); 
  257|     43|    if (!result)
  ------------------
  |  Branch (257:9): [True: 41, False: 2]
  ------------------
  258|     41|    {
  259|     41|        JSONCONS_THROW(ser_error(result.error().code(), result.error().line(), result.error().column()));
  ------------------
  |  |   35|     41|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  260|     41|    }
  261|      2|    return std::move(*result);
  262|     43|}
_ZN8jsoncons4cbor15try_decode_cborINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEENS4_9enable_ifIXsr10ext_traits13is_basic_jsonIT_EE5valueENS_6detail8expectedIS9_NS_10read_errorEEEE4typeERNS4_13basic_istreamIcNS4_11char_traitsIcEEEERKNS0_19cbor_decode_optionsE:
   78|     43|{
   79|     43|    using value_type = T;
   80|     43|    using result_type = read_result<value_type>;
   81|       |
   82|     43|    std::error_code ec;   
   83|     43|    jsoncons::json_decoder<T> decoder;
   84|     43|    auto adaptor = make_json_visitor_adaptor<json_visitor>(decoder);
   85|     43|    cbor_stream_reader reader(is, adaptor, options);
   86|     43|    reader.read(ec);
   87|     43|    if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|     43|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 41, False: 2]
  |  |  ------------------
  ------------------
   88|     41|    {
   89|     41|        return result_type{jsoncons::unexpect, ec, reader.line(), reader.column()};
   90|     41|    }
   91|      2|    if (JSONCONS_UNLIKELY(!decoder.is_valid()))
  ------------------
  |  |   78|      2|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
   92|      0|    {
   93|      0|        return result_type{jsoncons::unexpect, conv_errc::conversion_failed, reader.line(), reader.column()};
   94|      0|    }
   95|      2|    return result_type{decoder.get_result()};
   96|      2|}