LLVMFuzzerTestOneInput:
   10|  2.74k|{
   11|  2.74k|        std::string input(reinterpret_cast<const char*>(data), size);
   12|  2.74k|        json_decoder<ojson> decoder;
   13|  2.74k|        auto options = csv::csv_options{}
   14|  2.74k|            .assume_header(true)
   15|  2.74k|            .mapping_kind(csv::csv_mapping_kind::n_rows);
   16|  2.74k|        try {
   17|  2.74k|                csv::csv_string_reader reader1(input, decoder, options);
   18|  2.74k|                reader1.read();
   19|  2.74k|        }
   20|  2.74k|        catch (jsoncons::ser_error e) {}
   21|  2.74k|        catch (jsoncons::json_runtime_error<std::runtime_error> e) {}
   22|  2.74k|        catch (json_runtime_error<std::invalid_argument> e3) {}
   23|  2.74k|        return 0;
   24|  2.74k|}

_ZNK8jsoncons16allocator_holderINSt3__19allocatorIcEEE13get_allocatorEv:
   30|  3.93M|    {
   31|  3.93M|        return alloc_;
   32|  3.93M|    }
_ZN8jsoncons16allocator_holderINSt3__19allocatorIcEEEC2Ev:
   20|  3.93M|    allocator_holder() = default;

_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEED2Ev:
 2769|  94.1M|        {
 2770|  94.1M|             destroy();
 2771|  94.1M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE7destroyEv:
  893|  94.1M|        {
  894|  94.1M|            switch (storage_kind())
  895|  94.1M|            {
  896|  14.1k|                case json_storage_kind::long_str:
  ------------------
  |  Branch (896:17): [True: 14.1k, False: 94.1M]
  ------------------
  897|  14.1k|                {
  898|  14.1k|                    if (cast<long_string_storage>().ptr_ != nullptr)
  ------------------
  |  Branch (898:25): [True: 14.1k, False: 0]
  ------------------
  899|  14.1k|                    {
  900|  14.1k|                        long_string_storage::heap_string_factory_type::destroy(cast<long_string_storage>().ptr_);
  901|  14.1k|                    }
  902|  14.1k|                    break;
  903|      0|                }
  904|      0|                case json_storage_kind::byte_str:
  ------------------
  |  Branch (904:17): [True: 0, False: 94.1M]
  ------------------
  905|      0|                    if (cast<byte_string_storage>().ptr_ != nullptr)
  ------------------
  |  Branch (905:25): [True: 0, False: 0]
  ------------------
  906|      0|                    {
  907|      0|                        byte_string_storage::heap_string_factory_type::destroy(cast<byte_string_storage>().ptr_);
  908|      0|                    }
  909|      0|                    break;
  910|  3.93M|                case json_storage_kind::array:
  ------------------
  |  Branch (910:17): [True: 3.93M, False: 90.1M]
  ------------------
  911|  3.93M|                {
  912|  3.93M|                    if (cast<array_storage>().ptr_ != nullptr)
  ------------------
  |  Branch (912:25): [True: 3.93M, False: 0]
  ------------------
  913|  3.93M|                    {
  914|  3.93M|                        auto& stor = cast<array_storage>();
  915|  3.93M|                        typename array_storage::allocator_type alloc{stor.ptr_->get_allocator()};
  916|  3.93M|                        std::allocator_traits<typename array_storage::allocator_type>::destroy(alloc, ext_traits::to_plain_pointer(stor.ptr_));
  917|  3.93M|                        std::allocator_traits<typename array_storage::allocator_type>::deallocate(alloc, stor.ptr_,1);
  918|  3.93M|                    }
  919|  3.93M|                    break;
  920|      0|                }
  921|      0|                case json_storage_kind::object:
  ------------------
  |  Branch (921:17): [True: 0, False: 94.1M]
  ------------------
  922|      0|                {
  923|      0|                    if (cast<object_storage>().ptr_ != nullptr)
  ------------------
  |  Branch (923:25): [True: 0, False: 0]
  ------------------
  924|      0|                    {
  925|      0|                        auto& stor = cast<object_storage>();
  926|      0|                        typename object_storage::allocator_type alloc{stor.ptr_->get_allocator()};
  927|      0|                        std::allocator_traits<typename object_storage::allocator_type>::destroy(alloc, ext_traits::to_plain_pointer(stor.ptr_));
  928|      0|                        std::allocator_traits<typename object_storage::allocator_type>::deallocate(alloc, stor.ptr_,1);
  929|      0|                    }
  930|      0|                    break;
  931|      0|                }
  932|  90.1M|                default:
  ------------------
  |  Branch (932:17): [True: 90.1M, False: 3.95M]
  ------------------
  933|  90.1M|                    break;
  934|  94.1M|            }
  935|  94.1M|        }
_ZNK8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE12storage_kindEv:
 1457|   261M|        {
 1458|       |            // It is legal to access 'common_.storage_kind_' even though 
 1459|       |            // common_ is not the active member of the union because 'storage_kind_' 
 1460|       |            // is a part of the common initial sequence of all union members
 1461|       |            // as defined in 11.4-25 of the Standard.
 1462|   261M|            return static_cast<json_storage_kind>(common_.storage_kind_);
 1463|   261M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_19long_string_storageEEERT_v:
  999|  79.4k|        {
 1000|  79.4k|            return cast(identity<T>());
 1001|  79.4k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_19long_string_storageEEE:
 1090|  79.4k|        {
 1091|  79.4k|            return long_str_;
 1092|  79.4k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_13array_storageEEERT_v:
  999|  78.2M|        {
 1000|  78.2M|            return cast(identity<T>());
 1001|  78.2M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_13array_storageEEE:
 1120|  78.2M|        {
 1121|  78.2M|            return array_;
 1122|  78.2M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2EOS5_:
 2302|  66.1M|        {
 2303|  66.1M|            uninitialized_move(std::move(other));
 2304|  66.1M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE18uninitialized_moveEOS5_:
 1297|  66.1M|        {
 1298|  66.1M|            if (is_trivial_storage(other.storage_kind()))
  ------------------
  |  Branch (1298:17): [True: 53.6M, False: 12.4M]
  ------------------
 1299|  53.6M|            {
 1300|  53.6M|                std::memcpy(static_cast<void*>(this), &other, sizeof(basic_json));
 1301|  53.6M|            }
 1302|  12.4M|            else
 1303|  12.4M|            {
 1304|  12.4M|                switch (other.storage_kind())
 1305|  12.4M|                {
 1306|  18.4k|                    case json_storage_kind::long_str:
  ------------------
  |  Branch (1306:21): [True: 18.4k, False: 12.4M]
  ------------------
 1307|  18.4k|                        construct<long_string_storage>(other.cast<long_string_storage>());
 1308|  18.4k|                        other.construct<null_storage>();
 1309|  18.4k|                        break;
 1310|      0|                    case json_storage_kind::byte_str:
  ------------------
  |  Branch (1310:21): [True: 0, False: 12.4M]
  ------------------
 1311|      0|                        construct<byte_string_storage>(other.cast<byte_string_storage>());
 1312|      0|                        other.construct<null_storage>();
 1313|      0|                        break;
 1314|  12.4M|                    case json_storage_kind::array:
  ------------------
  |  Branch (1314:21): [True: 12.4M, False: 18.4k]
  ------------------
 1315|  12.4M|                        construct<array_storage>(other.cast<array_storage>());
 1316|  12.4M|                        other.construct<null_storage>();
 1317|  12.4M|                        break;
 1318|      0|                    case json_storage_kind::object:
  ------------------
  |  Branch (1318:21): [True: 0, False: 12.4M]
  ------------------
 1319|      0|                        construct<object_storage>(other.cast<object_storage>());
 1320|      0|                        other.construct<null_storage>();
 1321|      0|                        break;
 1322|      0|                    default:
  ------------------
  |  Branch (1322:21): [True: 0, False: 12.4M]
  ------------------
 1323|      0|                        JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1324|      0|                        break;
 1325|  12.4M|                }
 1326|  12.4M|            }
 1327|  66.1M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_19long_string_storageEJRS7_EEEvDpOT0_:
  990|  18.4k|        {
  991|  18.4k|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|  18.4k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE19long_string_storageC2ERKS6_:
  621|  18.4k|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::long_str)), short_str_length_(0), tag_(other.tag_), ptr_(other.ptr_)
  622|  18.4k|            {
  623|  18.4k|            }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_12null_storageEJEEEvDpOT0_:
  990|  12.4M|        {
  991|  12.4M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|  12.4M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_12null_storageEEERT_v:
  999|  12.6M|        {
 1000|  12.6M|            return cast(identity<T>());
 1001|  12.6M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_12null_storageEEE:
 1010|  12.6M|        {
 1011|  12.6M|            return null_;
 1012|  12.6M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE12null_storageC2ENS_12semantic_tagE:
  445|  12.6M|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::null)), short_str_length_(0), tag_(tag)
  446|  12.6M|            {
  447|  12.6M|            }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_13array_storageEJRS7_EEEvDpOT0_:
  990|  12.4M|        {
  991|  12.4M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|  12.4M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE13array_storageC2ERKS6_:
  722|  12.4M|                : storage_kind_(other.storage_kind_), short_str_length_(0), tag_(other.tag_), ptr_(other.ptr_)
  723|  12.4M|            {
  724|  12.4M|            }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE11array_rangeEv:
 4754|  3.40M|        {
 4755|  3.40M|            switch (storage_kind())
 4756|  3.40M|            {
 4757|  3.40M|                case json_storage_kind::array:
  ------------------
  |  Branch (4757:17): [True: 3.40M, False: 0]
  ------------------
 4758|  3.40M|                    return array_range_type(cast<array_storage>().value().begin(),
 4759|  3.40M|                        cast<array_storage>().value().end());
 4760|      0|                case json_storage_kind::json_ref:
  ------------------
  |  Branch (4760:17): [True: 0, False: 3.40M]
  ------------------
 4761|      0|                    return cast<json_ref_storage>().value().array_range();
 4762|      0|                default:
  ------------------
  |  Branch (4762:17): [True: 0, False: 3.40M]
  ------------------
 4763|      0|                    JSONCONS_THROW(json_runtime_error<std::domain_error>("Not an array"));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
 4764|  3.40M|            }
 4765|  3.40M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE13array_storage5valueEv:
  745|  41.5M|            {
  746|  41.5M|                return *ptr_;
  747|  41.5M|            }
_ZN8jsoncons5rangeINSt3__111__wrap_iterIPNS_10basic_jsonIcNS_23order_preserving_policyENS1_9allocatorIcEEEEEENS2_IPKS7_EEEC2ERKS9_SF_:
  343|  3.40M|            : first_(first), last_(last)
  344|  3.40M|        {
  345|  3.40M|        }
_ZNK8jsoncons5rangeINSt3__111__wrap_iterIPNS_10basic_jsonIcNS_23order_preserving_policyENS1_9allocatorIcEEEEEENS2_IPKS7_EEE5beginEv:
  348|  3.40M|        {
  349|  3.40M|            return first_;
  350|  3.40M|        }
_ZNK8jsoncons5rangeINSt3__111__wrap_iterIPNS_10basic_jsonIcNS_23order_preserving_policyENS1_9allocatorIcEEEEEENS2_IPKS7_EEE3endEv:
  352|  3.40M|        {
  353|  3.40M|            return last_;
  354|  3.40M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE5clearEv:
 4151|  3.40M|        {
 4152|  3.40M|            switch (storage_kind())
 4153|  3.40M|            {
 4154|  3.40M|                case json_storage_kind::array:
  ------------------
  |  Branch (4154:17): [True: 3.40M, False: 0]
  ------------------
 4155|  3.40M|                    cast<array_storage>().value().clear();
 4156|  3.40M|                    break;
 4157|      0|                case json_storage_kind::object:
  ------------------
  |  Branch (4157:17): [True: 0, False: 3.40M]
  ------------------
 4158|      0|                    cast<object_storage>().value().clear();
 4159|      0|                    break;
 4160|      0|                case json_storage_kind::json_ref:
  ------------------
  |  Branch (4160:17): [True: 0, False: 3.40M]
  ------------------
 4161|      0|                    cast<json_ref_storage>().value().clear();
 4162|      0|                    break;
 4163|      0|                default:
  ------------------
  |  Branch (4163:17): [True: 0, False: 3.40M]
  ------------------
 4164|      0|                    break;
 4165|  3.40M|            }
 4166|  3.40M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2Ev:
 2270|  2.74k|        {
 2271|  2.74k|            construct<empty_object_storage>(semantic_tag::none);
 2272|  2.74k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_20empty_object_storageEJNS_12semantic_tagEEEEvDpOT0_:
  990|  2.74k|        {
  991|  2.74k|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|  2.74k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_20empty_object_storageEEERT_v:
  999|  7.83k|        {
 1000|  7.83k|            return cast(identity<T>());
 1001|  7.83k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_20empty_object_storageEEE:
 1020|  7.83k|        {
 1021|  7.83k|            return empty_object_;
 1022|  7.83k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE20empty_object_storageC2ENS_12semantic_tagE:
  457|  2.74k|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::empty_object)), short_str_length_(0), tag_(tag)
  458|  2.74k|            {
  459|  2.74k|            }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE7reserveEm:
 3479|  3.93M|        {
 3480|  3.93M|            if (n > 0)
  ------------------
  |  Branch (3480:17): [True: 3.93M, False: 0]
  ------------------
 3481|  3.93M|            {
 3482|  3.93M|                switch (storage_kind())
 3483|  3.93M|                {
 3484|  3.93M|                    case json_storage_kind::array:
  ------------------
  |  Branch (3484:21): [True: 3.93M, False: 0]
  ------------------
 3485|  3.93M|                        cast<array_storage>().value().reserve(n);
 3486|  3.93M|                        break;
 3487|      0|                    case json_storage_kind::empty_object:
  ------------------
  |  Branch (3487:21): [True: 0, False: 3.93M]
  ------------------
 3488|      0|                        create_object_implicitly();
 3489|      0|                        cast<object_storage>().value().reserve(n);
 3490|      0|                        break;
 3491|      0|                    case json_storage_kind::object:
  ------------------
  |  Branch (3491:21): [True: 0, False: 3.93M]
  ------------------
 3492|      0|                        cast<object_storage>().value().reserve(n);
 3493|      0|                        break;
 3494|      0|                    case json_storage_kind::json_ref:
  ------------------
  |  Branch (3494:21): [True: 0, False: 3.93M]
  ------------------
 3495|      0|                        cast<json_ref_storage>().value().reserve(n);
 3496|      0|                        break;
 3497|      0|                    default:
  ------------------
  |  Branch (3497:21): [True: 0, False: 3.93M]
  ------------------
 3498|      0|                        break;
 3499|  3.93M|                }
 3500|  3.93M|            }
 3501|  3.93M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9push_backEOS5_:
 4696|  27.3M|        {
 4697|  27.3M|            switch (storage_kind())
 4698|  27.3M|            {
 4699|  27.3M|                case json_storage_kind::array:
  ------------------
  |  Branch (4699:17): [True: 27.3M, False: 0]
  ------------------
 4700|  27.3M|                    cast<array_storage>().value().push_back(std::move(val));
 4701|  27.3M|                    break;
 4702|      0|                case json_storage_kind::json_ref:
  ------------------
  |  Branch (4702:17): [True: 0, False: 27.3M]
  ------------------
 4703|      0|                    cast<json_ref_storage>().value().push_back(std::move(val));
 4704|      0|                    break;
 4705|      0|                default:
  ------------------
  |  Branch (4705:17): [True: 0, False: 27.3M]
  ------------------
 4706|      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
  ------------------
 4707|  27.3M|            }
 4708|  27.3M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEaSEOS5_:
 1448|  2.54k|        {
 1449|  2.54k|            if (this != &other)
  ------------------
  |  Branch (1449:17): [True: 2.54k, False: 0]
  ------------------
 1450|  2.54k|            {
 1451|  2.54k|                move_assignment(std::move(other));
 1452|  2.54k|            }
 1453|  2.54k|            return *this;
 1454|  2.54k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE15move_assignmentEOS5_:
 1410|  2.54k|        {
 1411|  2.54k|            if (is_trivial_storage(storage_kind()) && is_trivial_storage(other.storage_kind()))
  ------------------
  |  Branch (1411:17): [True: 2.54k, False: 0]
  |  Branch (1411:55): [True: 0, False: 2.54k]
  ------------------
 1412|      0|            {
 1413|      0|                std::memcpy(static_cast<void*>(this), &other, sizeof(basic_json));
 1414|      0|            }
 1415|  2.54k|            else
 1416|  2.54k|            {
 1417|  2.54k|                swap(other);
 1418|  2.54k|            }
 1419|  2.54k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4swapERS5_:
 1929|  2.54k|        {
 1930|  2.54k|            if (this == &other)
  ------------------
  |  Branch (1930:17): [True: 0, False: 2.54k]
  ------------------
 1931|      0|            {
 1932|      0|                return;
 1933|      0|            }
 1934|  2.54k|            if (is_trivial_storage(storage_kind()) && is_trivial_storage(other.storage_kind()))
  ------------------
  |  Branch (1934:17): [True: 2.54k, False: 0]
  |  Branch (1934:55): [True: 0, False: 2.54k]
  ------------------
 1935|      0|            {
 1936|      0|                basic_json temp;               
 1937|      0|                std::memcpy(static_cast<void*>(&temp), static_cast<void*>(&other), sizeof(basic_json));
 1938|      0|                std::memcpy(static_cast<void*>(&other), static_cast<void*>(this), sizeof(basic_json));
 1939|      0|                std::memcpy(static_cast<void*>(this), static_cast<void*>(&temp), sizeof(basic_json));
 1940|      0|            }
 1941|  2.54k|            else
 1942|  2.54k|            {
 1943|  2.54k|                switch (storage_kind())
 1944|  2.54k|                {
 1945|      0|                    case json_storage_kind::null: swap_l<null_storage>(other); break;
  ------------------
  |  Branch (1945:21): [True: 0, False: 2.54k]
  ------------------
 1946|  2.54k|                    case json_storage_kind::empty_object : swap_l<empty_object_storage>(other); break;
  ------------------
  |  Branch (1946:21): [True: 2.54k, False: 0]
  ------------------
 1947|      0|                    case json_storage_kind::boolean: swap_l<bool_storage>(other); break;
  ------------------
  |  Branch (1947:21): [True: 0, False: 2.54k]
  ------------------
 1948|      0|                    case json_storage_kind::int64: swap_l<int64_storage>(other); break;
  ------------------
  |  Branch (1948:21): [True: 0, False: 2.54k]
  ------------------
 1949|      0|                    case json_storage_kind::uint64: swap_l<uint64_storage>(other); break;
  ------------------
  |  Branch (1949:21): [True: 0, False: 2.54k]
  ------------------
 1950|      0|                    case json_storage_kind::half_float: swap_l<half_storage>(other); break;
  ------------------
  |  Branch (1950:21): [True: 0, False: 2.54k]
  ------------------
 1951|      0|                    case json_storage_kind::float64: swap_l<double_storage>(other); break;
  ------------------
  |  Branch (1951:21): [True: 0, False: 2.54k]
  ------------------
 1952|      0|                    case json_storage_kind::short_str: swap_l<short_string_storage>(other); break;
  ------------------
  |  Branch (1952:21): [True: 0, False: 2.54k]
  ------------------
 1953|      0|                    case json_storage_kind::long_str: swap_l<long_string_storage>(other); break;
  ------------------
  |  Branch (1953:21): [True: 0, False: 2.54k]
  ------------------
 1954|      0|                    case json_storage_kind::byte_str: swap_l<byte_string_storage>(other); break;
  ------------------
  |  Branch (1954:21): [True: 0, False: 2.54k]
  ------------------
 1955|      0|                    case json_storage_kind::array: swap_l<array_storage>(other); break;
  ------------------
  |  Branch (1955:21): [True: 0, False: 2.54k]
  ------------------
 1956|      0|                    case json_storage_kind::object: swap_l<object_storage>(other); break;
  ------------------
  |  Branch (1956:21): [True: 0, False: 2.54k]
  ------------------
 1957|      0|                    case json_storage_kind::const_json_ref: swap_l<const_json_ref_storage>(other); break;
  ------------------
  |  Branch (1957:21): [True: 0, False: 2.54k]
  ------------------
 1958|      0|                    case json_storage_kind::json_ref: swap_l<json_ref_storage>(other); break;
  ------------------
  |  Branch (1958:21): [True: 0, False: 2.54k]
  ------------------
 1959|      0|                    default:
  ------------------
  |  Branch (1959:21): [True: 0, False: 2.54k]
  ------------------
 1960|      0|                        JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1961|      0|                        break;
 1962|  2.54k|                }
 1963|  2.54k|            }
 1964|  2.54k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_20empty_object_storageEJRS7_EEEvDpOT0_:
  990|  2.54k|        {
  991|  2.54k|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|  2.54k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_12bool_storageEEERT_v:
  999|   171k|        {
 1000|   171k|            return cast(identity<T>());
 1001|   171k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_12bool_storageEEE:
 1030|   171k|        {
 1031|   171k|            return boolean_;
 1032|   171k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_13int64_storageEEERT_v:
  999|   388k|        {
 1000|   388k|            return cast(identity<T>());
 1001|   388k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_13int64_storageEEE:
 1040|   388k|        {
 1041|   388k|            return int64_;
 1042|   388k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_14uint64_storageEEERT_v:
  999|   196k|        {
 1000|   196k|            return cast(identity<T>());
 1001|   196k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_14uint64_storageEEE:
 1050|   196k|        {
 1051|   196k|            return uint64_;
 1052|   196k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_14double_storageEEERT_v:
  999|  47.7k|        {
 1000|  47.7k|            return cast(identity<T>());
 1001|  47.7k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_14double_storageEEE:
 1070|  47.7k|        {
 1071|  47.7k|            return float64_;
 1072|  47.7k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_20short_string_storageEEERT_v:
  999|  23.0M|        {
 1000|  23.0M|            return cast(identity<T>());
 1001|  23.0M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_20short_string_storageEEE:
 1080|  23.0M|        {
 1081|  23.0M|            return short_str_;
 1082|  23.0M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE6swap_lINS5_20empty_object_storageEEEvRS5_:
 1165|  2.54k|        {
 1166|  2.54k|            switch (other.storage_kind())
 1167|  2.54k|            {
 1168|      0|                case json_storage_kind::null         : swap_l_r<TypeL, null_storage>(other); break;
  ------------------
  |  Branch (1168:17): [True: 0, False: 2.54k]
  ------------------
 1169|      0|                case json_storage_kind::empty_object : swap_l_r<TypeL, empty_object_storage>(other); break;
  ------------------
  |  Branch (1169:17): [True: 0, False: 2.54k]
  ------------------
 1170|      0|                case json_storage_kind::boolean         : swap_l_r<TypeL, bool_storage>(other); break;
  ------------------
  |  Branch (1170:17): [True: 0, False: 2.54k]
  ------------------
 1171|      0|                case json_storage_kind::int64        : swap_l_r<TypeL, int64_storage>(other); break;
  ------------------
  |  Branch (1171:17): [True: 0, False: 2.54k]
  ------------------
 1172|      0|                case json_storage_kind::uint64       : swap_l_r<TypeL, uint64_storage>(other); break;
  ------------------
  |  Branch (1172:17): [True: 0, False: 2.54k]
  ------------------
 1173|      0|                case json_storage_kind::half_float         : swap_l_r<TypeL, half_storage>(other); break;
  ------------------
  |  Branch (1173:17): [True: 0, False: 2.54k]
  ------------------
 1174|      0|                case json_storage_kind::float64       : swap_l_r<TypeL, double_storage>(other); break;
  ------------------
  |  Branch (1174:17): [True: 0, False: 2.54k]
  ------------------
 1175|      0|                case json_storage_kind::short_str : swap_l_r<TypeL, short_string_storage>(other); break;
  ------------------
  |  Branch (1175:17): [True: 0, False: 2.54k]
  ------------------
 1176|      0|                case json_storage_kind::long_str  : swap_l_r<TypeL, long_string_storage>(other); break;
  ------------------
  |  Branch (1176:17): [True: 0, False: 2.54k]
  ------------------
 1177|      0|                case json_storage_kind::byte_str  : swap_l_r<TypeL, byte_string_storage>(other); break;
  ------------------
  |  Branch (1177:17): [True: 0, False: 2.54k]
  ------------------
 1178|  2.54k|                case json_storage_kind::array        : swap_l_r<TypeL, array_storage>(other); break;
  ------------------
  |  Branch (1178:17): [True: 2.54k, False: 0]
  ------------------
 1179|      0|                case json_storage_kind::object       : swap_l_r<TypeL, object_storage>(other); break;
  ------------------
  |  Branch (1179:17): [True: 0, False: 2.54k]
  ------------------
 1180|      0|                case json_storage_kind::const_json_ref : swap_l_r<TypeL, const_json_ref_storage>(other); break;
  ------------------
  |  Branch (1180:17): [True: 0, False: 2.54k]
  ------------------
 1181|      0|                case json_storage_kind::json_ref : swap_l_r<TypeL, json_ref_storage>(other); break;
  ------------------
  |  Branch (1181:17): [True: 0, False: 2.54k]
  ------------------
 1182|      0|                default:
  ------------------
  |  Branch (1182:17): [True: 0, False: 2.54k]
  ------------------
 1183|      0|                    JSONCONS_UNREACHABLE();
  ------------------
  |  |   79|      0|#define JSONCONS_UNREACHABLE() __builtin_unreachable()
  ------------------
 1184|      0|                    break;
 1185|  2.54k|            }
 1186|  2.54k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20empty_object_storageENS5_13array_storageEEEvRS5_:
 1151|  2.54k|        {
 1152|  2.54k|            swap_l_r(identity<TypeL>(), identity<TypeR>(), other);
 1153|  2.54k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20empty_object_storageENS5_13array_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_:
 1157|  2.54k|        {
 1158|  2.54k|            TypeR temp{other.cast<TypeR>()};
 1159|  2.54k|            other.construct<TypeL>(cast<TypeL>());
 1160|  2.54k|            construct<TypeR>(temp);
 1161|  2.54k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2ImEET_NS_12semantic_tagENS2_9enable_ifIXaasr10ext_traits19is_unsigned_integerIS7_EE5valuelestS7_Lm8EEiE4typeE:
 2609|   196k|        {
 2610|   196k|            construct<uint64_storage>(val, tag);
 2611|   196k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_14uint64_storageEJRmRNS_12semantic_tagEEEEvDpOT0_:
  990|   196k|        {
  991|   196k|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|   196k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE14uint64_storageC2EmNS_12semantic_tagE:
  511|   196k|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::uint64)), short_str_length_(0), tag_(tag),
  512|   196k|                  val_(val)
  513|   196k|            {
  514|   196k|            }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2IlEET_NS_12semantic_tagENS2_9enable_ifIXaasr10ext_traits17is_signed_integerIS7_EE5valuelestS7_Lm8EEiE4typeE:
 2640|   388k|        {
 2641|   388k|            construct<int64_storage>(val, tag);
 2642|   388k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_13int64_storageEJRlRNS_12semantic_tagEEEEvDpOT0_:
  990|   388k|        {
  991|   388k|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|   388k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE13int64_storageC2ElNS_12semantic_tagE:
  491|   388k|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::int64)), short_str_length_(0), tag_(tag),
  492|   388k|                  val_(val)
  493|   388k|            {
  494|   388k|            }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2EdNS_12semantic_tagE:
 2597|  47.7k|        {
 2598|  47.7k|            construct<double_storage>(val, tag);
 2599|  47.7k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_14double_storageEJRdRNS_12semantic_tagEEEEvDpOT0_:
  990|  47.7k|        {
  991|  47.7k|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|  47.7k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE14double_storageC2EdNS_12semantic_tagE:
  550|  47.7k|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::float64)), short_str_length_(0), tag_(tag),
  551|  47.7k|                  val_(val)
  552|  47.7k|            {
  553|  47.7k|            }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2ENS_16json_array_arg_tENS_12semantic_tagE:
 2396|  3.93M|        {
 2397|  3.93M|            auto ptr = create_array(Allocator());
 2398|  3.93M|            construct<array_storage>(ptr, tag);
 2399|  3.93M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE12create_arrayIJEEEPNS_10json_arrayIS5_NS2_6vectorEEERKS4_DpOT_:
  952|  3.93M|        {
  953|  3.93M|            using stor_allocator_type = typename array_storage::allocator_type;
  954|  3.93M|            stor_allocator_type stor_alloc(alloc);
  955|  3.93M|            auto ptr = std::allocator_traits<stor_allocator_type>::allocate(stor_alloc, 1);
  956|  3.93M|            JSONCONS_TRY
  ------------------
  |  |   37|  3.93M|    #define JSONCONS_TRY try
  ------------------
  957|  3.93M|            {
  958|  3.93M|                std::allocator_traits<stor_allocator_type>::construct(stor_alloc, ext_traits::to_plain_pointer(ptr), 
  959|  3.93M|                    std::forward<Args>(args)...);
  960|  3.93M|            }
  961|  3.93M|            JSONCONS_CATCH(...)
  962|  3.93M|            {
  963|      0|                std::allocator_traits<stor_allocator_type>::deallocate(stor_alloc, ptr,1);
  964|      0|                JSONCONS_RETHROW;
  ------------------
  |  |   36|      0|    #define JSONCONS_RETHROW throw
  ------------------
  965|      0|            }
  966|  3.93M|            return ptr;
  967|  3.93M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_13array_storageEJRPNS_10json_arrayIS5_NS2_6vectorEEERNS_12semantic_tagEEEEvDpOT0_:
  990|  3.93M|        {
  991|  3.93M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|  3.93M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE13array_storageC2EPNS_10json_arrayIS5_NS2_6vectorEEENS_12semantic_tagE:
  717|  3.93M|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::array)), short_str_length_(0), tag_(tag), ptr_(ptr)
  718|  3.93M|            {
  719|  3.93M|            }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2ENS_9null_typeENS_12semantic_tagE:
 2686|   156k|        {
 2687|   156k|            construct<null_storage>(tag);
 2688|   156k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_12null_storageEJRNS_12semantic_tagEEEEvDpOT0_:
  990|   156k|        {
  991|   156k|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|   156k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2EbNS_12semantic_tagE:
 2696|   171k|        {
 2697|   171k|            construct<bool_storage>(val,tag);
 2698|   171k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_12bool_storageEJRbRNS_12semantic_tagEEEEvDpOT0_:
  990|   171k|        {
  991|   171k|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|   171k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE12bool_storageC2EbNS_12semantic_tagE:
  470|   171k|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::boolean)), short_str_length_(0), tag_(tag),
  471|   171k|                  val_(val)
  472|   171k|            {
  473|   171k|            }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2ERKNS2_17basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagE:
 2544|  23.0M|            : basic_json(s.data(), s.size(), tag, allocator_type())
 2545|  23.0M|        {
 2546|  23.0M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2EPKcmNS_12semantic_tagERKS4_:
 2574|  23.0M|        {
 2575|  23.0M|            if (length <= short_string_storage::max_length)
  ------------------
  |  Branch (2575:17): [True: 23.0M, False: 14.1k]
  ------------------
 2576|  23.0M|            {
 2577|  23.0M|                construct<short_string_storage>(s, static_cast<uint8_t>(length), tag);
 2578|  23.0M|            }
 2579|  14.1k|            else
 2580|  14.1k|            {
 2581|  14.1k|                auto ptr = create_long_string(alloc, s, length);
 2582|  14.1k|                construct<long_string_storage>(ptr, tag);
 2583|  14.1k|            }
 2584|  23.0M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_20short_string_storageEJRPKchRNS_12semantic_tagEEEEvDpOT0_:
  990|  23.0M|        {
  991|  23.0M|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|  23.0M|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE20short_string_storageC2EPKchNS_12semantic_tagE:
  572|  23.0M|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::short_str)), short_str_length_(length), tag_(tag)
  573|  23.0M|            {
  574|  23.0M|                JSONCONS_ASSERT(length <= max_length);
  ------------------
  |  |   49|  23.0M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 23.0M]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  575|  23.0M|                std::memcpy(data_,p,length*sizeof(char_type));
  576|  23.0M|                data_[length] = 0;
  577|  23.0M|            }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE18create_long_stringERKS4_PKcm:
  938|  14.1k|        {
  939|  14.1k|            using heap_string_factory_type = jsoncons::heap::heap_string_factory<char_type,null_type,Allocator>;
  940|  14.1k|            return heap_string_factory_type::create(data, length, null_type(), alloc); 
  941|  14.1k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_19long_string_storageEJRPNS_4heap11heap_stringIcNS_9null_typeES4_EERNS_12semantic_tagEEEEvDpOT0_:
  990|  14.1k|        {
  991|  14.1k|            ::new (&cast<StorageType>()) StorageType(std::forward<Args>(args)...);
  992|  14.1k|        }
_ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE19long_string_storageC2EPNS_4heap11heap_stringIcNS_9null_typeES4_EENS_12semantic_tagE:
  616|  14.1k|                : storage_kind_(static_cast<uint8_t>(json_storage_kind::long_str)), short_str_length_(0), tag_(tag), ptr_(ptr)
  617|  14.1k|            {
  618|  14.1k|            }

_ZN8jsoncons12launder_castIPcNS_4heap11heap_stringIcNS_9null_typeENSt3__19allocatorIcEEEEEET_PT0_:
  243|  14.1k|    {
  244|  14.1k|    #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
  245|  14.1k|        return std::launder(reinterpret_cast<T>(u));
  246|       |    #elif defined(__GNUC__) &&  (__GNUC__ * 100 + __GNUC_MINOR__) > 800
  247|       |        return __builtin_launder(reinterpret_cast<T>(u));
  248|       |    #else
  249|       |        return reinterpret_cast<T>(u);
  250|       |    #endif
  251|  14.1k|    }
_ZN8jsoncons12launder_castIPNS_4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE9storage_tEcEET_PT0_:
  243|  14.1k|    {
  244|  14.1k|    #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
  245|  14.1k|        return std::launder(reinterpret_cast<T>(u));
  246|       |    #elif defined(__GNUC__) &&  (__GNUC__ * 100 + __GNUC_MINOR__) > 800
  247|       |        return __builtin_launder(reinterpret_cast<T>(u));
  248|       |    #else
  249|       |        return reinterpret_cast<T>(u);
  250|       |    #endif
  251|  14.1k|    }
_ZN8jsoncons28string_view_constant_of_typeIcEENSt3__117basic_string_viewIT_NS1_11char_traitsIS3_EEEEPKcPKw:
  231|  10.9k|    {
  232|  10.9k|        return jsoncons::string_view(c);
  233|  10.9k|    }

_ZN8jsoncons6detail4spanIKcLm18446744073709551615EEC2Ev:
   58|  15.1k|        {
   59|  15.1k|        }
_ZN8jsoncons6detail4spanIKcLm18446744073709551615EEC2EPS2_m:
   61|  5.48k|            : data_(data), size_(size)
   62|  5.48k|        {
   63|  5.48k|        }
_ZNK8jsoncons6detail4spanIKcLm18446744073709551615EE4sizeEv:
  116|  23.3k|        {
  117|  23.3k|            return size_;
  118|  23.3k|        }
_ZNK8jsoncons6detail4spanIKcLm18446744073709551615EE4dataEv:
  111|  5.48k|        {
  112|  5.48k|            return data_;
  113|  5.48k|        }

_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEED2Ev:
  105|  3.93M|        {
  106|  3.93M|            flatten_and_destroy();
  107|  3.93M|        }
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEE19flatten_and_destroyEv:
  248|  3.93M|        {
  249|  7.95M|            while (!data_.empty())
  ------------------
  |  Branch (249:20): [True: 4.01M, False: 3.93M]
  ------------------
  250|  4.01M|            {
  251|  4.01M|                value_type current = std::move(data_.back());
  252|  4.01M|                data_.pop_back();
  253|  4.01M|                switch (current.storage_kind())
  254|  4.01M|                {
  255|  3.40M|                    case json_storage_kind::array:
  ------------------
  |  Branch (255:21): [True: 3.40M, False: 612k]
  ------------------
  256|  3.40M|                    {
  257|  3.40M|                        for (auto&& item : current.array_range())
  ------------------
  |  Branch (257:42): [True: 23.3M, False: 3.40M]
  ------------------
  258|  23.3M|                        {
  259|  23.3M|                            if ((item.storage_kind() == json_storage_kind::array || item.storage_kind() == json_storage_kind::object)
  ------------------
  |  Branch (259:34): [True: 0, False: 23.3M]
  |  Branch (259:85): [True: 0, False: 23.3M]
  ------------------
  260|      0|                                && !item.empty()) // non-empty object or array
  ------------------
  |  Branch (260:36): [True: 0, False: 0]
  ------------------
  261|      0|                            {
  262|      0|                                data_.push_back(std::move(item));
  263|      0|                            }
  264|  23.3M|                        }
  265|  3.40M|                        current.clear();                           
  266|  3.40M|                        break;
  267|      0|                    }
  268|      0|                    case json_storage_kind::object:
  ------------------
  |  Branch (268:21): [True: 0, False: 4.01M]
  ------------------
  269|      0|                    {
  270|      0|                        for (auto&& kv : current.object_range())
  ------------------
  |  Branch (270:40): [True: 0, False: 0]
  ------------------
  271|      0|                        {
  272|      0|                            if ((kv.value().storage_kind() == json_storage_kind::array || kv.value().storage_kind() == json_storage_kind::object)
  ------------------
  |  Branch (272:34): [True: 0, False: 0]
  |  Branch (272:91): [True: 0, False: 0]
  ------------------
  273|      0|                                && !kv.value().empty()) // non-empty object or array
  ------------------
  |  Branch (273:36): [True: 0, False: 0]
  ------------------
  274|      0|                            {
  275|      0|                                data_.push_back(std::move(kv.value()));
  276|      0|                            }
  277|      0|                        }
  278|      0|                        current.clear();                           
  279|      0|                        break;
  280|      0|                    }
  281|   612k|                    default:
  ------------------
  |  Branch (281:21): [True: 612k, False: 3.40M]
  ------------------
  282|   612k|                        break;
  283|  4.01M|                }
  284|  4.01M|            }
  285|  3.93M|        }
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEE5beginEv:
  222|  3.40M|        iterator begin() {return data_.begin();}
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEE3endEv:
  224|  3.40M|        iterator end() {return data_.end();}
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEE5clearEv:
  142|  3.40M|        void clear() {data_.clear();}
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEE7reserveEm:
  153|  3.93M|        void reserve(std::size_t n) {data_.reserve(n);}
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEE9push_backIS6_S5_EENS3_9enable_ifIXsr3std16allocator_traitsIT0_E15is_always_equalE5valueEvE4typeEOT_:
  178|  27.3M|        {
  179|  27.3M|            data_.emplace_back(std::forward<T>(value));
  180|  27.3M|        }
_ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEEC2Ev:
   46|  3.93M|        json_array() = default;

_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_EC2ERKS5_S9_:
   74|  2.74k|        : alloc_(alloc),
   75|  2.74k|          result_(),
   76|  2.74k|          name_(alloc),
   77|  2.74k|          item_stack_(alloc),
   78|  2.74k|          structure_stack_(temp_alloc)
   79|  2.74k|    {
   80|       |        //item_stack_.reserve(1000);
   81|       |        //structure_stack_.reserve(100);
   82|  2.74k|        structure_stack_.emplace_back(json_structure_kind::root_kind, 0);
   83|  2.74k|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E14json_structureC2ENS7_19json_structure_kindEm:
   51|  3.94M|            : structure_kind(type), structure_index(offset)
   52|  3.94M|        {
   53|  3.94M|        }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E15visit_end_arrayERKNS_11ser_contextERNS3_10error_codeE:
  186|  3.93M|    {
  187|  3.93M|        JSONCONS_ASSERT(structure_stack_.size() > 1);
  ------------------
  |  |   49|  3.93M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 3.93M]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  188|  3.93M|        JSONCONS_ASSERT(structure_stack_.back().structure_kind == json_structure_kind::array_kind);
  ------------------
  |  |   49|  3.93M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 3.93M]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  189|  3.93M|        const size_t structure_index = structure_stack_.back().structure_index;
  190|  3.93M|        JSONCONS_ASSERT(item_stack_.size() > structure_index);
  ------------------
  |  |   49|  3.93M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 3.93M]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  191|       |
  192|  3.93M|        auto& structure = structure_stack_[structure_stack_.size()-2];
  193|  3.93M|        auto& arr = item_stack_[structure_index].value;
  194|  3.93M|        const size_t size = item_stack_.size() - (structure_index + 1);
  195|       |
  196|  3.93M|        if (size > 0)
  ------------------
  |  Branch (196:13): [True: 3.93M, False: 166]
  ------------------
  197|  3.93M|        {
  198|  3.93M|            arr.reserve(size);
  199|  3.93M|            auto first = item_stack_.begin() + (structure_index+1);
  200|  3.93M|            auto last = first + size;
  201|  31.3M|            for (auto it = first; it != last; ++it)
  ------------------
  |  Branch (201:35): [True: 27.3M, False: 3.93M]
  ------------------
  202|  27.3M|            {
  203|  27.3M|                arr.push_back(std::move((*it).value));
  204|  27.3M|            }
  205|  3.93M|            item_stack_.erase(first, item_stack_.end());
  206|  3.93M|        }
  207|       |
  208|  3.93M|        if (structure.structure_kind == json_structure_kind::root_kind)
  ------------------
  |  Branch (208:13): [True: 2.54k, False: 3.93M]
  ------------------
  209|  2.54k|        {
  210|  2.54k|            result_ = std::move(item_stack_.front().value);
  211|  2.54k|            item_stack_.pop_back();
  212|  2.54k|            is_valid_ = true;
  213|  2.54k|        }
  214|       |
  215|  3.93M|        structure_stack_.pop_back();
  216|  3.93M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.93M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  217|  3.93M|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  311|   196k|    {
  312|   196k|        switch (structure_stack_.back().structure_kind)
  ------------------
  |  Branch (312:17): [True: 196k, False: 0]
  ------------------
  313|   196k|        {
  314|      0|            case json_structure_kind::object_kind:
  ------------------
  |  Branch (314:13): [True: 0, False: 196k]
  ------------------
  315|      0|                item_stack_.emplace_back(std::move(name_), index_++, value, tag);
  316|      0|                break;
  317|   196k|            case json_structure_kind::array_kind:
  ------------------
  |  Branch (317:13): [True: 196k, False: 0]
  ------------------
  318|   196k|                item_stack_.emplace_back(key_type(alloc_), 0, value, tag);
  319|   196k|                break;
  320|      0|            case json_structure_kind::root_kind:
  ------------------
  |  Branch (320:13): [True: 0, False: 196k]
  ------------------
  321|      0|                result_ = Json(value,tag);
  322|      0|                is_valid_ = true;
  323|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  324|   196k|        }
  325|   196k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   196k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  326|   196k|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  290|   388k|    {
  291|   388k|        switch (structure_stack_.back().structure_kind)
  ------------------
  |  Branch (291:17): [True: 388k, False: 0]
  ------------------
  292|   388k|        {
  293|      0|            case json_structure_kind::object_kind:
  ------------------
  |  Branch (293:13): [True: 0, False: 388k]
  ------------------
  294|      0|                item_stack_.emplace_back(std::move(name_), index_++, value, tag);
  295|      0|                break;
  296|   388k|            case json_structure_kind::array_kind:
  ------------------
  |  Branch (296:13): [True: 388k, False: 0]
  ------------------
  297|   388k|                item_stack_.emplace_back(key_type(alloc_), 0, value, tag);
  298|   388k|                break;
  299|      0|            case json_structure_kind::root_kind:
  ------------------
  |  Branch (299:13): [True: 0, False: 388k]
  ------------------
  300|      0|                result_ = Json(value,tag);
  301|      0|                is_valid_ = true;
  302|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  303|   388k|        }
  304|   388k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   388k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  305|   388k|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  353|  47.7k|    {
  354|  47.7k|        switch (structure_stack_.back().structure_kind)
  ------------------
  |  Branch (354:17): [True: 47.7k, False: 0]
  ------------------
  355|  47.7k|        {
  356|      0|            case json_structure_kind::object_kind:
  ------------------
  |  Branch (356:13): [True: 0, False: 47.7k]
  ------------------
  357|      0|                item_stack_.emplace_back(std::move(name_), index_++, value, tag);
  358|      0|                break;
  359|  47.7k|            case json_structure_kind::array_kind:
  ------------------
  |  Branch (359:13): [True: 47.7k, False: 0]
  ------------------
  360|  47.7k|                item_stack_.emplace_back(key_type(alloc_), 0, value, tag);
  361|  47.7k|                break;
  362|      0|            case json_structure_kind::root_kind:
  ------------------
  |  Branch (362:13): [True: 0, False: 47.7k]
  ------------------
  363|      0|                result_ = Json(value, tag);
  364|      0|                is_valid_ = true;
  365|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  366|  47.7k|        }
  367|  47.7k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  47.7k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  368|  47.7k|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E11visit_flushEv:
  122|  2.63k|    {
  123|  2.63k|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  171|  3.93M|    {
  172|  3.93M|        if (structure_stack_.back().structure_kind == json_structure_kind::object_kind)
  ------------------
  |  Branch (172:13): [True: 0, False: 3.93M]
  ------------------
  173|      0|        {
  174|      0|            structure_stack_.emplace_back(json_structure_kind::array_kind, item_stack_.size());
  175|      0|            item_stack_.emplace_back(std::move(name_), index_++, json_array_arg, tag);
  176|      0|        }
  177|  3.93M|        else
  178|  3.93M|        {
  179|  3.93M|            structure_stack_.emplace_back(json_structure_kind::array_kind, item_stack_.size());
  180|  3.93M|            item_stack_.emplace_back(key_type(alloc_), 0, json_array_arg, tag);
  181|  3.93M|        }
  182|  3.93M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.93M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  183|  3.93M|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  389|   156k|    {
  390|   156k|        switch (structure_stack_.back().structure_kind)
  ------------------
  |  Branch (390:17): [True: 156k, False: 0]
  ------------------
  391|   156k|        {
  392|      0|            case json_structure_kind::object_kind:
  ------------------
  |  Branch (392:13): [True: 0, False: 156k]
  ------------------
  393|      0|                item_stack_.emplace_back(std::move(name_), index_++, null_type(), tag);
  394|      0|                break;
  395|   156k|            case json_structure_kind::array_kind:
  ------------------
  |  Branch (395:13): [True: 156k, False: 0]
  ------------------
  396|   156k|                item_stack_.emplace_back(key_type(alloc_), 0, null_type(), tag);
  397|   156k|                break;
  398|      0|            case json_structure_kind::root_kind:
  ------------------
  |  Branch (398:13): [True: 0, False: 156k]
  ------------------
  399|      0|                result_ = Json(null_type(), tag);
  400|      0|                is_valid_ = true;
  401|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  402|   156k|        }
  403|   156k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   156k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  404|   156k|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  371|   171k|    {
  372|   171k|        switch (structure_stack_.back().structure_kind)
  ------------------
  |  Branch (372:17): [True: 171k, False: 0]
  ------------------
  373|   171k|        {
  374|      0|            case json_structure_kind::object_kind:
  ------------------
  |  Branch (374:13): [True: 0, False: 171k]
  ------------------
  375|      0|                item_stack_.emplace_back(std::move(name_), index_++, value, tag);
  376|      0|                break;
  377|   171k|            case json_structure_kind::array_kind:
  ------------------
  |  Branch (377:13): [True: 171k, False: 0]
  ------------------
  378|   171k|                item_stack_.emplace_back(key_type(alloc_), 0, value, tag);
  379|   171k|                break;
  380|      0|            case json_structure_kind::root_kind:
  ------------------
  |  Branch (380:13): [True: 0, False: 171k]
  ------------------
  381|      0|                result_ = Json(value, tag);
  382|      0|                is_valid_ = true;
  383|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  384|   171k|        }
  385|   171k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   171k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  386|   171k|    }
_ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E12visit_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  226|  23.0M|    {
  227|  23.0M|        auto& structure = structure_stack_.back();
  228|  23.0M|        switch (structure.structure_kind)
  ------------------
  |  Branch (228:17): [True: 23.0M, False: 0]
  ------------------
  229|  23.0M|        {
  230|      0|            case json_structure_kind::object_kind:
  ------------------
  |  Branch (230:13): [True: 0, False: 23.0M]
  ------------------
  231|      0|                item_stack_.emplace_back(std::move(name_), index_++, sv, tag);
  232|      0|                break;
  233|  23.0M|            case json_structure_kind::array_kind:
  ------------------
  |  Branch (233:13): [True: 23.0M, False: 0]
  ------------------
  234|  23.0M|                item_stack_.emplace_back(key_type(alloc_), 0, sv, tag);
  235|  23.0M|                break;
  236|      0|            case json_structure_kind::root_kind:
  ------------------
  |  Branch (236:13): [True: 0, False: 23.0M]
  ------------------
  237|      0|                result_ = Json(sv, tag, alloc_);
  238|      0|                is_valid_ = true;
  239|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  240|  23.0M|        }
  241|  23.0M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  23.0M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  242|  23.0M|    }

_ZN8jsoncons15make_error_codeENS_9json_errcE:
  141|     12|    {
  142|     12|        return std::error_code(static_cast<int>(result),json_error_category());
  143|     12|    }
_ZN8jsoncons19json_error_categoryEv:
  135|     12|    {
  136|     12|      static json_error_category_impl instance;
  137|     12|      return instance;
  138|     12|    }
_ZNK8jsoncons24json_error_category_impl7messageEi:
   63|     12|        {
   64|     12|            switch (static_cast<json_errc>(ev))
   65|     12|            {
   66|      0|                case json_errc::unexpected_eof:
  ------------------
  |  Branch (66:17): [True: 0, False: 12]
  ------------------
   67|      0|                    return "Unexpected end of file";
   68|      0|                case json_errc::source_error:
  ------------------
  |  Branch (68:17): [True: 0, False: 12]
  ------------------
   69|      0|                    return "Source error";
   70|      0|                case json_errc::syntax_error:
  ------------------
  |  Branch (70:17): [True: 0, False: 12]
  ------------------
   71|      0|                    return "JSON syntax_error";
   72|      0|                case json_errc::extra_character:
  ------------------
  |  Branch (72:17): [True: 0, False: 12]
  ------------------
   73|      0|                    return "Unexpected non-whitespace character after JSON text";
   74|      0|                case json_errc::max_nesting_depth_exceeded:
  ------------------
  |  Branch (74:17): [True: 0, False: 12]
  ------------------
   75|      0|                    return "Data item nesting exceeds limit in options";
   76|      0|                case json_errc::single_quote:
  ------------------
  |  Branch (76:17): [True: 0, False: 12]
  ------------------
   77|      0|                    return "JSON strings cannot be quoted with single quotes";
   78|      0|                case json_errc::illegal_character_in_string:
  ------------------
  |  Branch (78:17): [True: 0, False: 12]
  ------------------
   79|      0|                    return "Illegal character in string";
   80|      0|                case json_errc::extra_comma:
  ------------------
  |  Branch (80:17): [True: 0, False: 12]
  ------------------
   81|      0|                    return "Extra comma";
   82|      0|                case json_errc::expected_key:
  ------------------
  |  Branch (82:17): [True: 0, False: 12]
  ------------------
   83|      0|                    return "Expected object member key";
   84|      0|                case json_errc::expected_value:
  ------------------
  |  Branch (84:17): [True: 0, False: 12]
  ------------------
   85|      0|                    return "Expected value";
   86|      0|                case json_errc::invalid_value:
  ------------------
  |  Branch (86:17): [True: 0, False: 12]
  ------------------
   87|      0|                    return "Invalid value";
   88|      0|                case json_errc::expected_colon:
  ------------------
  |  Branch (88:17): [True: 0, False: 12]
  ------------------
   89|      0|                    return "Expected name separator ':'";
   90|      0|                case json_errc::illegal_control_character:
  ------------------
  |  Branch (90:17): [True: 0, False: 12]
  ------------------
   91|      0|                    return "Illegal control character in string";
   92|      0|                case json_errc::illegal_escaped_character:
  ------------------
  |  Branch (92:17): [True: 0, False: 12]
  ------------------
   93|      0|                    return "Illegal escaped character in string";
   94|      0|                case json_errc::expected_codepoint_surrogate_pair:
  ------------------
  |  Branch (94:17): [True: 0, False: 12]
  ------------------
   95|      0|                    return "Invalid codepoint, expected another \\u token to begin the second half of a codepoint surrogate pair.";
   96|      0|                case json_errc::invalid_hex_escape_sequence:
  ------------------
  |  Branch (96:17): [True: 0, False: 12]
  ------------------
   97|      0|                    return "Invalid codepoint, expected hexadecimal digit.";
   98|      0|                case json_errc::invalid_unicode_escape_sequence:
  ------------------
  |  Branch (98:17): [True: 0, False: 12]
  ------------------
   99|      0|                    return "Invalid codepoint, expected four hexadecimal digits.";
  100|      0|                case json_errc::leading_zero:
  ------------------
  |  Branch (100:17): [True: 0, False: 12]
  ------------------
  101|      0|                    return "A number cannot have a leading zero";
  102|      0|                case json_errc::invalid_number:
  ------------------
  |  Branch (102:17): [True: 0, False: 12]
  ------------------
  103|      0|                    return "Invalid number";
  104|      0|                case json_errc::expected_comma_or_rbrace:
  ------------------
  |  Branch (104:17): [True: 0, False: 12]
  ------------------
  105|      0|                    return "Expected comma or right brace '}'";
  106|      0|                case json_errc::expected_comma_or_rbracket:
  ------------------
  |  Branch (106:17): [True: 0, False: 12]
  ------------------
  107|      0|                    return "Expected comma or right bracket ']'";
  108|      0|                case json_errc::unexpected_rbrace:
  ------------------
  |  Branch (108:17): [True: 0, False: 12]
  ------------------
  109|      0|                    return "Unexpected right brace '}'";
  110|      0|                case json_errc::unexpected_rbracket:
  ------------------
  |  Branch (110:17): [True: 0, False: 12]
  ------------------
  111|      0|                    return "Unexpected right bracket ']'";
  112|      0|                case json_errc::illegal_comment:
  ------------------
  |  Branch (112:17): [True: 0, False: 12]
  ------------------
  113|      0|                    return "Illegal comment";
  114|      0|                case json_errc::bad_continuation_byte:
  ------------------
  |  Branch (114:17): [True: 0, False: 12]
  ------------------
  115|      0|                    return "Expected continuation byte";
  116|      0|                case json_errc::over_long_utf8_sequence:
  ------------------
  |  Branch (116:17): [True: 0, False: 12]
  ------------------
  117|      0|                    return "Over long UTF-8 sequence";
  118|      0|                case json_errc::illegal_codepoint:
  ------------------
  |  Branch (118:17): [True: 0, False: 12]
  ------------------
  119|      0|                    return "Illegal codepoint (>= 0xd800 && <= 0xdfff)";
  120|      0|                case json_errc::illegal_surrogate_value:
  ------------------
  |  Branch (120:17): [True: 0, False: 12]
  ------------------
  121|      0|                    return "UTF-16 surrogate values are illegal in UTF-32";
  122|      0|                case json_errc::unpaired_high_surrogate:
  ------------------
  |  Branch (122:17): [True: 0, False: 12]
  ------------------
  123|      0|                    return "Expected low surrogate following the high surrogate";
  124|     12|                case json_errc::illegal_unicode_character:
  ------------------
  |  Branch (124:17): [True: 12, False: 0]
  ------------------
  125|     12|                    return "Illegal unicode character";
  126|      0|                case json_errc::unexpected_character:
  ------------------
  |  Branch (126:17): [True: 0, False: 12]
  ------------------
  127|      0|                    return "Unexpected character";
  128|      0|                default:
  ------------------
  |  Branch (128:17): [True: 0, False: 12]
  ------------------
  129|      0|                    return "Unknown JSON parser error";
  130|     12|                }
  131|     12|        }

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

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

_ZN8jsoncons19typed_array_visitorD2Ev:
   33|  8.24k|        virtual ~typed_array_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  414|   196k|        {
  415|   196k|            visit_uint64(value, tag, context, ec);
  416|   196k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   196k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  417|   196k|        }
_ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE:
  351|  3.93M|        {
  352|  3.93M|            visit_end_array(context, ec);
  353|  3.93M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.93M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  354|  3.93M|        }
_ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  423|   388k|        {
  424|   388k|            visit_int64(value, tag, context, ec);
  425|   388k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   388k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  426|   388k|        }
_ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  441|  47.7k|        {
  442|  47.7k|            visit_double(value, tag, context, ec);
  443|  47.7k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  47.7k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  444|  47.7k|        }
_ZN8jsoncons18basic_json_visitorIcEC2Ev:
  103|  8.24k|        basic_json_visitor() = default;
_ZN8jsoncons26basic_default_json_visitorIcEC2Ev:
  811|  2.74k|        basic_default_json_visitor() = default;
_ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  365|   156k|        {
  366|   156k|            visit_null(tag, context, ec);
  367|   156k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   156k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  368|   156k|        }
_ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE:
  383|  23.0M|        {
  384|  23.0M|            visit_string(value, tag, context, ec);
  385|  23.0M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  23.0M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  386|  23.0M|        }
_ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  374|   171k|        {
  375|   171k|            visit_bool(value, tag, context, ec);
  376|   171k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|   171k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  377|   171k|        }
_ZN8jsoncons18basic_json_visitorIcE5flushEv:
  108|  2.63k|        {
  109|  2.63k|            visit_flush();
  110|  2.63k|        }
_ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE:
  339|  3.93M|        {
  340|  3.93M|            visit_begin_array(tag, context, ec);
  341|  3.93M|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  276|  3.93M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  342|  3.93M|        }

_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJRmRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|   196k|        : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|   196k|    {
   45|   196k|    }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2EOS7_:
   49|  34.7M|    index_key_value(index_key_value&&) = default;
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJRlRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|   388k|        : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|   388k|    {
   45|   388k|    }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJRdRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|  47.7k|        : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|  47.7k|    {
   45|  47.7k|    }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJRKNS_16json_array_arg_tERNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|  3.93M|        : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|  3.93M|    {
   45|  3.93M|    }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJNS_9null_typeERNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|   156k|        : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|   156k|    {
   45|   156k|    }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJRbRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_:
   43|   171k|        : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|   171k|    {
   45|   171k|    }
_ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJRKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERNS_12semantic_tagEEEEONS3_12basic_stringIcSB_S5_EElDpOT_:
   43|  23.0M|        : name(std::move(Name)), index(Index), value(std::forward<Args>(args)...)
   44|  23.0M|    {
   45|  23.0M|    }

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

_ZN8jsoncons13string_sourceIcEC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_PNS3_9enable_ifIXsr10ext_traits14is_sequence_ofISA_cEE5valueEvE4typeE:
  481|  2.74k|        : data_(s.data()), current_(s.data()), end_(s.data()+s.size())
  482|  2.74k|    {
  483|  2.74k|    }
_ZNK8jsoncons13string_sourceIcE8is_errorEv:
  499|  2.74k|    {
  500|  2.74k|        return false;  
  501|  2.74k|    }
_ZNK8jsoncons13string_sourceIcE3eofEv:
  494|  17.8k|    {
  495|  17.8k|        return current_ == end_;  
  496|  17.8k|    }
_ZN8jsoncons13string_sourceIcE10read_chunkEv:
  533|  2.74k|    {
  534|  2.74k|        const value_type* data = current_;
  535|  2.74k|        std::size_t length = end_ - current_;
  536|  2.74k|        current_ = end_;
  537|       |
  538|  2.74k|        return span<const value_type>(data, length);
  539|  2.74k|    }

_ZN8jsoncons19text_source_adaptorINS_13string_sourceIcEEEC2IRNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEOT_:
   38|  2.74k|            : source_(std::forward<Sourceable>(source)), bof_(true)
   39|  2.74k|        {
   40|  2.74k|        }
_ZNK8jsoncons19text_source_adaptorINS_13string_sourceIcEEE8is_errorEv:
   48|  2.74k|        {
   49|  2.74k|            return source_.is_error();  
   50|  2.74k|        }
_ZN8jsoncons19text_source_adaptorINS_13string_sourceIcEEE10read_chunkERNSt3__110error_codeE:
   53|  17.8k|        {
   54|  17.8k|            if (source_.eof())
  ------------------
  |  Branch (54:17): [True: 15.1k, False: 2.74k]
  ------------------
   55|  15.1k|            {
   56|  15.1k|                return span<const value_type>();
   57|  15.1k|            }
   58|       |
   59|  2.74k|            auto s = source_.read_chunk();
   60|  2.74k|            const value_type* data = s.data();
   61|  2.74k|            std::size_t length = s.size();
   62|       |
   63|  2.74k|            if (bof_ && length > 0)
  ------------------
  |  Branch (63:17): [True: 2.74k, False: 0]
  |  Branch (63:25): [True: 2.74k, False: 0]
  ------------------
   64|  2.74k|            {
   65|  2.74k|                auto r = unicode_traits::detect_encoding_from_bom(data, length);
   66|  2.74k|                if (!(r.encoding == unicode_traits::encoding_kind::utf8 || r.encoding == unicode_traits::encoding_kind::undetected))
  ------------------
  |  Branch (66:23): [True: 4, False: 2.74k]
  |  Branch (66:76): [True: 2.73k, False: 12]
  ------------------
   67|     12|                {
   68|     12|                    ec = json_errc::illegal_unicode_character;
   69|     12|                    return span<const value_type>();
   70|     12|                }
   71|  2.73k|                length -= (r.ptr - data);
   72|  2.73k|                data = r.ptr;
   73|  2.73k|                bof_ = false;
   74|  2.73k|            }
   75|  2.73k|            return span<const value_type>(data, length);           
   76|  2.74k|        }

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

_ZN8jsoncons10ext_traits16to_plain_pointerINS_4heap11heap_stringIcNS_9null_typeENSt3__19allocatorIcEEEEEEPT_SA_:
  241|  14.1k|    {       
  242|  14.1k|        return (ptr);
  243|  14.1k|    }  
_ZN8jsoncons10ext_traits16to_plain_pointerINS_10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS5_6vectorEEEEEPT_SC_:
  241|  7.87M|    {       
  242|  7.87M|        return (ptr);
  243|  7.87M|    }  
_ZN8jsoncons10ext_traits16to_plain_pointerIcEEPT_S3_:
  241|  14.1k|    {       
  242|  14.1k|        return (ptr);
  243|  14.1k|    }  
_ZN8jsoncons10ext_traits14integer_limitsIlvE6lowestEv:
  110|   389k|        {
  111|   389k|            return std::numeric_limits<T>::lowest();
  112|   389k|        }

_ZN8jsoncons14dec_to_integerIlcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  327|   390k|{
  328|   390k|    if (length == 0)
  ------------------
  |  Branch (328:9): [True: 0, False: 390k]
  ------------------
  329|      0|    {
  330|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  331|      0|    }
  332|       |
  333|   390k|    bool sign = *s == '-';
  334|   390k|    s += sign;
  335|   390k|    length -= sign;
  336|       |
  337|   390k|    using U = typename ext_traits::make_unsigned<T>::type;
  338|       |
  339|   390k|    U num;
  340|   390k|    auto ru = dec_to_integer(s, length, num);
  341|   390k|    if (ru.ec != std::errc{})
  ------------------
  |  Branch (341:9): [True: 877, False: 389k]
  ------------------
  342|    877|    {
  343|    877|        return to_number_result<CharT>(ru.ptr, ru.ec);
  344|    877|    }
  345|   389k|    if (sign)
  ------------------
  |  Branch (345:9): [True: 389k, False: 0]
  ------------------
  346|   389k|    {
  347|   389k|        if (num > static_cast<U>(-((ext_traits::integer_limits<T>::lowest)()+T(1))) + U(1))
  ------------------
  |  Branch (347:13): [True: 852, False: 388k]
  ------------------
  348|    852|        {
  349|    852|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  350|    852|        }
  351|   388k|        else
  352|   388k|        {
  353|   388k|            value = static_cast<T>(U(0) - num);
  354|   388k|            return to_number_result<CharT>(ru.ptr, std::errc{});
  355|   388k|        }
  356|   389k|    }
  357|      0|    else
  358|      0|    {
  359|      0|        if (num > static_cast<U>((ext_traits::integer_limits<T>::max)()))
  ------------------
  |  Branch (359:13): [True: 0, False: 0]
  ------------------
  360|      0|        {
  361|      0|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  362|      0|        }
  363|      0|        else
  364|      0|        {
  365|      0|            value = static_cast<T>(num);
  366|      0|            return to_number_result<CharT>(ru.ptr, std::errc{});
  367|      0|        }
  368|      0|    }
  369|   389k|}
_ZN8jsoncons16to_number_resultIcEC2EPKcNSt3__14errcE:
  141|   981k|        : ptr(ptr_), ec(ec_)
  142|   981k|    {
  143|   981k|    }
_ZN8jsoncons14dec_to_integerImcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedntsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  265|   589k|{
  266|   589k|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   78|   589k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 0, False: 589k]
  |  |  ------------------
  ------------------
  267|      0|    {
  268|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  269|      0|    }
  270|       |
  271|   589k|    static constexpr T max_value = (ext_traits::integer_limits<T>::max)();
  272|   589k|    static constexpr T max_value_div_10 = max_value / 10;
  273|       |
  274|   589k|    T num = 0;
  275|   589k|    const CharT* cur = s;
  276|   589k|    const CharT* last = s + length;
  277|   589k|    static constexpr std::size_t digits10 = static_cast<std::size_t>(ext_traits::integer_limits<T>::digits10);
  278|   589k|    const std::size_t n = (std::min)(digits10, length);
  279|   589k|    const CharT* stop = s + n;
  280|       |     
  281|  1.28M|    while (cur < stop)
  ------------------
  |  Branch (281:12): [True: 693k, False: 589k]
  ------------------
  282|   693k|    {
  283|   693k|        uint8_t d;
  284|   693k|        if (JSONCONS_LIKELY((d = static_cast<uint8_t>(*cur - '0')) <= 9) )
  ------------------
  |  |   77|   693k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:28): [True: 693k, False: 0]
  |  |  ------------------
  ------------------
  285|   693k|        {
  286|   693k|            num = static_cast<T>(d) + num*10;
  287|   693k|        }
  288|      0|        else
  289|      0|        {
  290|      0|            return to_number_result<CharT>(cur, std::errc::invalid_argument);
  291|      0|        }
  292|   693k|        ++cur;
  293|   693k|    }
  294|   589k|    if (cur == last)
  ------------------
  |  Branch (294:9): [True: 585k, False: 3.68k]
  ------------------
  295|   585k|    {
  296|   585k|        value = num;
  297|   585k|        return to_number_result<CharT>(cur, std::errc{});
  298|   585k|    }
  299|  3.68k|    if (cur+1 != last)
  ------------------
  |  Branch (299:9): [True: 1.19k, False: 2.48k]
  ------------------
  300|  1.19k|    {
  301|  1.19k|        return to_number_result<CharT>(cur, std::errc::result_out_of_range);
  302|  1.19k|    }
  303|  2.48k|    if (is_digit(*cur))
  ------------------
  |  Branch (303:9): [True: 2.48k, False: 0]
  ------------------
  304|  2.48k|    {
  305|  2.48k|        if (num > max_value_div_10)
  ------------------
  |  Branch (305:13): [True: 902, False: 1.58k]
  ------------------
  306|    902|        {
  307|    902|            return to_number_result<CharT>(cur, std::errc::result_out_of_range);
  308|    902|        }
  309|  1.58k|        uint8_t d = static_cast<uint8_t>(*cur - '0');
  310|  1.58k|        num = num*10;
  311|  1.58k|        if (num > max_value - d)
  ------------------
  |  Branch (311:13): [True: 936, False: 650]
  ------------------
  312|    936|        {
  313|    936|            return to_number_result<CharT>(s, std::errc::result_out_of_range);
  314|    936|        }
  315|    650|        num += d;
  316|    650|        ++cur;
  317|    650|        value = num;
  318|    650|        return to_number_result<CharT>(cur, std::errc{});
  319|  1.58k|    }
  320|       |    
  321|      0|    return to_number_result<CharT>(cur, std::errc::invalid_argument);
  322|  2.48k|}
_ZN8jsoncons8is_digitEc:
   83|  2.48k|constexpr bool is_digit(char d) {
   84|  2.48k|    return is_type(static_cast<uint8_t>(d), (uint8_t)(DIGIT_TYPE_ZERO | DIGIT_TYPE_NONZERO));
   85|  2.48k|}
_ZN8jsoncons7is_typeEhh:
   68|  2.48k|constexpr bool is_type(uint8_t d, uint8_t type) {
   69|  2.48k|    return (digi_table[d] & type) != 0;
   70|  2.48k|}
_ZNK8jsoncons16to_number_resultIcEcvbEv:
  150|   589k|    {
  151|   589k|        return ec == std::errc{};
  152|   589k|    }
_ZN8jsoncons16decstr_to_doubleEPKcmRd:
  866|  47.7k|{
  867|  47.7k|    const char* cur = s+length;
  868|  47.7k|    char *end = nullptr;
  869|  47.7k|    val = strtod(s, &end);
  870|  47.7k|    const char* str_end = end;
  871|  47.7k|    if (JSONCONS_UNLIKELY(end < cur))
  ------------------
  |  |   78|  47.7k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 47.7k]
  |  |  ------------------
  ------------------
  872|      4|    {
  873|      4|        if (*end == '.')
  ------------------
  |  Branch (873:13): [True: 0, False: 4]
  ------------------
  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|      4|        if (JSONCONS_UNLIKELY(str_end != cur))
  ------------------
  |  |   78|      4|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  883|      4|        {
  884|      4|            return to_number_result<char>{str_end,std::errc::invalid_argument};
  885|      4|        }
  886|      4|    }
  887|  47.7k|    if (JSONCONS_UNLIKELY(val <= -HUGE_VAL || val >= HUGE_VAL))
  ------------------
  |  |   78|  93.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 1.87k, False: 45.8k]
  |  |  |  Branch (78:50): [True: 1.51k, False: 46.1k]
  |  |  |  Branch (78:50): [True: 359, False: 45.8k]
  |  |  ------------------
  ------------------
  888|  1.87k|    {
  889|  1.87k|        return to_number_result<char>{str_end, std::errc::result_out_of_range};
  890|  1.87k|    }
  891|  45.8k|    return to_number_result<char>{str_end};
  892|  47.7k|}
_ZN8jsoncons16to_number_resultIcEC2EPKc:
  137|  45.8k|        : ptr(ptr_), ec(std::errc{})
  138|  45.8k|    {
  139|  45.8k|    }

_ZN8jsoncons14unicode_traits24detect_encoding_from_bomIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m:
   66|  2.74k|    {
   67|  2.74k|        static constexpr uint8_t bom_utf8[] = {0xef,0xbb,0xbf}; 
   68|  2.74k|        static constexpr uint8_t bom_utf16le[] = {0xff,0xfe}; 
   69|  2.74k|        static constexpr uint8_t bom_utf16be[] = {0xfe,0xff}; 
   70|  2.74k|        static constexpr uint8_t bom_utf32le[] = {0xff,0xfe,0x00,0x00}; 
   71|  2.74k|        static constexpr uint8_t bom_utf32be[] = {0x00,0x00,0xfe,0xff}; 
   72|       |
   73|  2.74k|        if (length >= 4 && !memcmp(data,bom_utf32le,4))
  ------------------
  |  Branch (73:13): [True: 2.49k, False: 254]
  |  Branch (73:28): [True: 1, False: 2.49k]
  ------------------
   74|      1|        {
   75|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32le};
   76|      1|        }
   77|  2.74k|        else if (length >= 4 && !memcmp(data,bom_utf32be,4))
  ------------------
  |  Branch (77:18): [True: 2.49k, False: 254]
  |  Branch (77:33): [True: 1, False: 2.49k]
  ------------------
   78|      1|        {
   79|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32be};
   80|      1|        }
   81|  2.74k|        else if (length >= 2 && !memcmp(data,bom_utf16le,2))
  ------------------
  |  Branch (81:18): [True: 2.71k, False: 30]
  |  Branch (81:33): [True: 8, False: 2.70k]
  ------------------
   82|      8|        {
   83|      8|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16le};
   84|      8|        }
   85|  2.73k|        else if (length >= 2 && !memcmp(data,bom_utf16be,2))
  ------------------
  |  Branch (85:18): [True: 2.70k, False: 30]
  |  Branch (85:33): [True: 2, False: 2.70k]
  ------------------
   86|      2|        {
   87|      2|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16be};
   88|      2|        }
   89|  2.73k|        else if (length >= 3 && !memcmp(data,bom_utf8,3))
  ------------------
  |  Branch (89:18): [True: 2.60k, False: 132]
  |  Branch (89:33): [True: 4, False: 2.60k]
  ------------------
   90|      4|        {
   91|      4|            return detect_encoding_result<CharT>{data+3,encoding_kind::utf8};
   92|      4|        }
   93|  2.73k|        else
   94|  2.73k|        {
   95|  2.73k|            return detect_encoding_result<CharT>{data,encoding_kind::undetected};
   96|  2.73k|        }
   97|  2.74k|    }

_ZN8jsoncons3csv15make_error_codeENS0_8csv_errcE:
   76|     99|{
   77|     99|    return std::error_code(static_cast<int>(result),csv_error_category());
   78|     99|}
_ZN8jsoncons3csv18csv_error_categoryEv:
   69|     99|{
   70|     99|  static csv_error_category_impl instance;
   71|     99|  return instance;
   72|     99|}
_ZNK8jsoncons3csv23csv_error_category_impl7messageEi:
   40|     99|    {
   41|     99|        switch (static_cast<csv_errc>(ev))
   42|     99|        {
   43|      0|            case csv_errc::unexpected_eof:
  ------------------
  |  Branch (43:13): [True: 0, False: 99]
  ------------------
   44|      0|                return "Unexpected end of file";
   45|      1|            case csv_errc::source_error:
  ------------------
  |  Branch (45:13): [True: 1, False: 98]
  ------------------
   46|      1|                return "Source error";
   47|      0|            case csv_errc::expected_quote:
  ------------------
  |  Branch (47:13): [True: 0, False: 99]
  ------------------
   48|      0|                return "Expected quote character";
   49|      0|            case csv_errc::syntax_error:
  ------------------
  |  Branch (49:13): [True: 0, False: 99]
  ------------------
   50|      0|                return "CSV syntax error";
   51|      0|            case csv_errc::invalid_parse_state:
  ------------------
  |  Branch (51:13): [True: 0, False: 99]
  ------------------
   52|      0|                return "Invalid CSV parser state";
   53|      0|            case csv_errc::invalid_escaped_char:
  ------------------
  |  Branch (53:13): [True: 0, False: 99]
  ------------------
   54|      0|                return "Invalid character following quote escape character";
   55|     94|            case csv_errc::unexpected_char_between_fields:
  ------------------
  |  Branch (55:13): [True: 94, False: 5]
  ------------------
   56|     94|                return "Unexpected character between fields";
   57|      0|            case csv_errc::max_nesting_depth_exceeded:
  ------------------
  |  Branch (57:13): [True: 0, False: 99]
  ------------------
   58|      0|                return "Data item nesting exceeds limit in options";
   59|      4|            case csv_errc::invalid_number:
  ------------------
  |  Branch (59:13): [True: 4, False: 95]
  ------------------
   60|      4|                return "Invalid number";
   61|      0|            default:
  ------------------
  |  Branch (61:13): [True: 0, False: 99]
  ------------------
   62|      0|                return "Unknown CSV parser error";
   63|     99|        }
   64|     99|    }

_ZN8jsoncons3csv17basic_csv_optionsIcEC1Ev:
  732|  2.74k|    basic_csv_options() = default;
_ZN8jsoncons3csv24basic_csv_options_commonIcEC2Ev:
  303|  2.74k|      : flat_{true},                  
  304|  2.74k|        enable_nan_to_num_{false},    
  305|  2.74k|        enable_inf_to_num_{false},    
  306|  2.74k|        enable_neginf_to_num_{false}, 
  307|  2.74k|        enable_nan_to_str_{false},    
  308|  2.74k|        enable_inf_to_str_{false},    
  309|  2.74k|        enable_neginf_to_str_{false}, 
  310|  2.74k|        enable_str_to_nan_{false},    
  311|  2.74k|        enable_str_to_inf_{false},    
  312|  2.74k|        enable_str_to_neginf_{false}
  313|  2.74k|    {
  314|  2.74k|    }
_ZN8jsoncons3csv24basic_csv_decode_optionsIcEC2Ev:
  495|  2.74k|        : assume_header_(false),
  496|  2.74k|          ignore_empty_values_(false),
  497|  2.74k|          ignore_empty_lines_(true),
  498|  2.74k|          trim_leading_(false),
  499|  2.74k|          trim_trailing_(false),
  500|  2.74k|          trim_leading_inside_quotes_(false),
  501|  2.74k|          trim_trailing_inside_quotes_(false),
  502|  2.74k|          unquoted_empty_value_is_null_(false),
  503|  2.74k|          infer_types_(true),
  504|  2.74k|          lossless_number_(false)
  505|  2.74k|    {}
_ZN8jsoncons3csv24basic_csv_encode_optionsIcEC2Ev:
  640|  2.74k|    {
  641|  2.74k|        line_delimiter_.push_back('\n');
  642|  2.74k|    }
_ZN8jsoncons3csv24basic_csv_options_commonIcED2Ev:
  320|  5.49k|    virtual ~basic_csv_options_common() = default;
_ZN8jsoncons3csv17basic_csv_optionsIcEC1ERKS2_:
  733|  2.74k|    basic_csv_options(const basic_csv_options&) = default;
_ZN8jsoncons3csv24basic_csv_options_commonIcEC2ERKS2_:
  316|  2.74k|    basic_csv_options_common(const basic_csv_options_common&) = default;
_ZN8jsoncons3csv24basic_csv_decode_optionsIcEC2ERKS2_:
  507|  2.74k|    basic_csv_decode_options(const basic_csv_decode_options& other) = default;
_ZN8jsoncons3csv24basic_csv_encode_optionsIcEC2ERKS2_:
  644|  2.74k|    basic_csv_encode_options(const basic_csv_encode_options& other) = default;
_ZN8jsoncons3csv17basic_csv_optionsIcE13assume_headerEb:
  757|  2.74k|    {
  758|  2.74k|        this->assume_header_ = value;
  759|  2.74k|        return *this;
  760|  2.74k|    }
_ZN8jsoncons3csv17basic_csv_optionsIcE12mapping_kindENS0_16csv_mapping_kindE:
  909|  2.74k|    {
  910|  2.74k|        this->mapping_kind_ = value;
  911|  2.74k|        return *this;
  912|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE13assume_headerEv:
  540|  2.74k|    {
  541|  2.74k|        return assume_header_;
  542|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE15comment_starterEv:
  600|  2.74k|    {
  601|  2.74k|        return comment_starter_;
  602|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE15field_delimiterEv:
  334|  2.74k|    {
  335|  2.74k|        return field_delimiter_;
  336|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE12header_linesEv:
  535|  2.74k|    {
  536|  2.74k|        return (assume_header_ && header_lines_ <= 1) ? 1 : header_lines_;
  ------------------
  |  Branch (536:17): [True: 2.74k, False: 0]
  |  Branch (536:35): [True: 2.74k, False: 0]
  ------------------
  537|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE19ignore_empty_valuesEv:
  545|  2.74k|    {
  546|  2.74k|        return ignore_empty_values_;
  547|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE18ignore_empty_linesEv:
  550|  2.74k|    {
  551|  2.74k|        return ignore_empty_lines_;
  552|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE11infer_typesEv:
  590|  2.74k|    {
  591|  2.74k|        return infer_types_;
  592|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE15lossless_numberEv:
  595|  2.74k|    {
  596|  2.74k|        return lossless_number_;
  597|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE12mapping_kindEv:
  605|  2.74k|    {
  606|  2.74k|        return mapping_kind_ != csv_mapping_kind() ? mapping_kind_ : (assume_header() || this->column_names().size() > 0 ? csv_mapping_kind::n_objects : csv_mapping_kind::n_rows);
  ------------------
  |  Branch (606:16): [True: 2.74k, False: 0]
  |  Branch (606:71): [True: 0, False: 0]
  |  Branch (606:90): [True: 0, False: 0]
  ------------------
  607|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE9max_linesEv:
  610|  2.74k|    {
  611|  2.74k|        return max_lines_;
  612|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE10quote_charEv:
  344|  2.74k|    {
  345|  2.74k|        return quote_char_;
  346|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE17quote_escape_charEv:
  349|  2.74k|    {
  350|  2.74k|        return quote_escape_char_;
  351|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE18subfield_delimiterEv:
  339|  2.74k|    {
  340|  2.74k|        return subfield_delimiter_;
  341|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE12trim_leadingEv:
  555|  2.74k|    {
  556|  2.74k|        return trim_leading_;
  557|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE26trim_leading_inside_quotesEv:
  565|  2.74k|    {
  566|  2.74k|        return trim_leading_inside_quotes_;
  567|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE13trim_trailingEv:
  560|  2.74k|    {
  561|  2.74k|        return trim_trailing_;
  562|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE27trim_trailing_inside_quotesEv:
  570|  2.74k|    {
  571|  2.74k|        return trim_trailing_inside_quotes_;
  572|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE28unquoted_empty_value_is_nullEv:
  585|  2.74k|    {
  586|  2.74k|        return unquoted_empty_value_is_null_;
  587|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE17enable_str_to_nanEv:
  384|  2.74k|    {
  385|  2.74k|        return enable_str_to_nan_;
  386|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE17enable_str_to_infEv:
  394|  2.74k|    {
  395|  2.74k|        return enable_str_to_inf_;
  396|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE20enable_str_to_neginfEv:
  404|  2.74k|    {
  405|  2.74k|        return enable_str_to_neginf_ || enable_str_to_inf_;
  ------------------
  |  Branch (405:16): [True: 0, False: 2.74k]
  |  Branch (405:41): [True: 0, False: 2.74k]
  ------------------
  406|  2.74k|    }
_ZN8jsoncons3csv6detail18parse_column_typesIcNSt3__16vectorINS0_13csv_type_infoENS3_9allocatorIS5_EEEEEEvRKNS3_12basic_stringIT_NS3_11char_traitsISA_EENS6_ISA_EEEERT0_:
  119|  2.74k|{
  120|  2.74k|    const std::map<jsoncons::basic_string_view<CharT>,csv_column_type> type_dictionary =
  121|  2.74k|    {
  122|       |
  123|  2.74k|        {JSONCONS_STRING_VIEW_CONSTANT(CharT,"string"),csv_column_type::string_t},
  ------------------
  |  |  264|  2.74k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  260|  2.74k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  257|  2.74k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  124|  2.74k|        {JSONCONS_STRING_VIEW_CONSTANT(CharT,"integer"),csv_column_type::integer_t},
  ------------------
  |  |  264|  2.74k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  260|  2.74k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  257|  2.74k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  125|  2.74k|        {JSONCONS_STRING_VIEW_CONSTANT(CharT,"float"),csv_column_type::float_t},
  ------------------
  |  |  264|  2.74k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  260|  2.74k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  257|  2.74k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  126|  2.74k|        {JSONCONS_STRING_VIEW_CONSTANT(CharT,"boolean"),csv_column_type::boolean_t}
  ------------------
  |  |  264|  2.74k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  260|  2.74k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  257|  2.74k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  127|  2.74k|    };
  128|       |
  129|  2.74k|    column_state state = column_state::sequence;
  130|  2.74k|    int depth = 0;
  131|  2.74k|    std::basic_string<CharT> buffer;
  132|       |
  133|  2.74k|    auto p = types.begin();
  134|  2.74k|    while (p != types.end())
  ------------------
  |  Branch (134:12): [True: 0, False: 2.74k]
  ------------------
  135|      0|    {
  136|      0|        switch (state)
  ------------------
  |  Branch (136:17): [True: 0, False: 0]
  ------------------
  137|      0|        {
  138|      0|            case column_state::sequence:
  ------------------
  |  Branch (138:13): [True: 0, False: 0]
  ------------------
  139|      0|            {
  140|      0|                switch (*p)
  141|      0|                {
  142|      0|                case ' ': case '\t':case '\r': case '\n':
  ------------------
  |  Branch (142:17): [True: 0, False: 0]
  |  Branch (142:27): [True: 0, False: 0]
  |  Branch (142:37): [True: 0, False: 0]
  |  Branch (142:48): [True: 0, False: 0]
  ------------------
  143|      0|                    ++p;
  144|      0|                    break;
  145|      0|                case '[':
  ------------------
  |  Branch (145:17): [True: 0, False: 0]
  ------------------
  146|      0|                    ++depth;
  147|      0|                    ++p;
  148|      0|                    break;
  149|      0|                case ']':
  ------------------
  |  Branch (149:17): [True: 0, False: 0]
  ------------------
  150|      0|                    JSONCONS_ASSERT(depth > 0);
  ------------------
  |  |   49|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  151|      0|                    --depth;
  152|      0|                    ++p;
  153|      0|                    break;
  154|      0|                case '*':
  ------------------
  |  Branch (154:17): [True: 0, False: 0]
  ------------------
  155|      0|                    {
  156|      0|                        JSONCONS_ASSERT(column_types.size() != 0);
  ------------------
  |  |   49|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  157|      0|                        std::size_t offset = 0;
  158|      0|                        std::size_t level = column_types.size() > 0 ? column_types.back().level: 0;
  ------------------
  |  Branch (158:45): [True: 0, False: 0]
  ------------------
  159|      0|                        if (level > 0)
  ------------------
  |  Branch (159:29): [True: 0, False: 0]
  ------------------
  160|      0|                        {
  161|      0|                            for (auto it = column_types.rbegin();
  162|      0|                                 it != column_types.rend() && level == (*it).level;
  ------------------
  |  Branch (162:34): [True: 0, False: 0]
  |  Branch (162:34): [True: 0, False: 0]
  |  Branch (162:63): [True: 0, False: 0]
  ------------------
  163|      0|                                 ++it)
  164|      0|                            {
  165|      0|                                ++offset;
  166|      0|                            }
  167|      0|                        }
  168|      0|                        else
  169|      0|                        {
  170|      0|                            offset = 1;
  171|      0|                        }
  172|      0|                        column_types.emplace_back(csv_column_type::repeat_t,depth,offset);
  173|      0|                        ++p;
  174|      0|                        break;
  175|      0|                    }
  176|      0|                default:
  ------------------
  |  Branch (176:17): [True: 0, False: 0]
  ------------------
  177|      0|                    buffer.clear();
  178|      0|                    state = column_state::label;
  179|      0|                    break;
  180|      0|                }
  181|      0|                break;
  182|      0|            }
  183|      0|            case column_state::label:
  ------------------
  |  Branch (183:13): [True: 0, False: 0]
  ------------------
  184|      0|            {
  185|      0|                switch (*p)
  186|      0|                {
  187|      0|                    case '*':
  ------------------
  |  Branch (187:21): [True: 0, False: 0]
  ------------------
  188|      0|                    {
  189|      0|                        auto it = type_dictionary.find(buffer);
  190|      0|                        if (it != type_dictionary.end())
  ------------------
  |  Branch (190:29): [True: 0, False: 0]
  ------------------
  191|      0|                        {
  192|      0|                            column_types.emplace_back((*it).second,depth);
  193|      0|                            buffer.clear();
  194|      0|                        }
  195|      0|                        else
  196|      0|                        {
  197|      0|                            JSONCONS_ASSERT(false);
  ------------------
  |  |   49|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, Folded]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  198|      0|                        }
  199|      0|                        state = column_state::sequence;
  200|      0|                        break;
  201|      0|                    }
  202|      0|                    case ',':
  ------------------
  |  Branch (202:21): [True: 0, False: 0]
  ------------------
  203|      0|                    {
  204|      0|                        auto it = type_dictionary.find(buffer);
  205|      0|                        if (it != type_dictionary.end())
  ------------------
  |  Branch (205:29): [True: 0, False: 0]
  ------------------
  206|      0|                        {
  207|      0|                            column_types.emplace_back((*it).second,depth);
  208|      0|                            buffer.clear();
  209|      0|                        }
  210|      0|                        else
  211|      0|                        {
  212|      0|                            JSONCONS_ASSERT(false);
  ------------------
  |  |   49|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, Folded]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  213|      0|                        }
  214|      0|                        ++p;
  215|      0|                        state = column_state::sequence;
  216|      0|                        break;
  217|      0|                    }
  218|      0|                    case ']':
  ------------------
  |  Branch (218:21): [True: 0, False: 0]
  ------------------
  219|      0|                    {
  220|      0|                        JSONCONS_ASSERT(depth > 0);
  ------------------
  |  |   49|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  221|      0|                        auto it = type_dictionary.find(buffer);
  222|      0|                        if (it != type_dictionary.end())
  ------------------
  |  Branch (222:29): [True: 0, False: 0]
  ------------------
  223|      0|                        {
  224|      0|                            column_types.emplace_back((*it).second,depth);
  225|      0|                            buffer.clear();
  226|      0|                        }
  227|      0|                        else
  228|      0|                        {
  229|      0|                            JSONCONS_ASSERT(false);
  ------------------
  |  |   49|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, Folded]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  230|      0|                        }
  231|      0|                        --depth;
  232|      0|                        ++p;
  233|      0|                        state = column_state::sequence;
  234|      0|                        break;
  235|      0|                    }
  236|      0|                    default:
  ------------------
  |  Branch (236:21): [True: 0, False: 0]
  ------------------
  237|      0|                    {
  238|      0|                        buffer.push_back(*p);
  239|      0|                        ++p;
  240|      0|                        break;
  241|      0|                    }
  242|      0|                }
  243|      0|                break;
  244|      0|            }
  245|      0|        }
  246|      0|    }
  247|  2.74k|    if (state == column_state::label)
  ------------------
  |  Branch (247:9): [True: 0, False: 2.74k]
  ------------------
  248|      0|    {
  249|      0|        auto it = type_dictionary.find(buffer);
  250|      0|        if (it != type_dictionary.end())
  ------------------
  |  Branch (250:13): [True: 0, False: 0]
  ------------------
  251|      0|        {
  252|      0|            column_types.emplace_back((*it).second,depth);
  253|      0|            buffer.clear();
  254|      0|        }
  255|      0|        else
  256|      0|        {
  257|      0|            JSONCONS_ASSERT(false);
  ------------------
  |  |   49|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, Folded]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  258|      0|        }
  259|      0|    }
  260|  2.74k|}
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE12column_typesEv:
  615|  2.74k|    {
  616|  2.74k|        return column_types_;
  617|  2.74k|    }
_ZN8jsoncons3csv6detail18parse_column_namesIcNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEEEvRKNS5_IT_NS6_ISD_EENS8_ISD_EEEERT0_:
   66|  5.49k|{
   67|  5.49k|    column_state state = column_state::sequence;
   68|  5.49k|    typename Container::value_type buffer(cont.get_allocator());
   69|       |
   70|  5.49k|    auto p = names.begin();
   71|  5.49k|    while (p != names.end())
  ------------------
  |  Branch (71:12): [True: 0, False: 5.49k]
  ------------------
   72|      0|    {
   73|      0|        switch (state)
  ------------------
  |  Branch (73:17): [True: 0, False: 0]
  ------------------
   74|      0|        {
   75|      0|            case column_state::sequence:
  ------------------
  |  Branch (75:13): [True: 0, False: 0]
  ------------------
   76|      0|            {
   77|      0|                switch (*p)
   78|      0|                {
   79|      0|                    case ' ': case '\t':case '\r': case '\n':
  ------------------
  |  Branch (79:21): [True: 0, False: 0]
  |  Branch (79:31): [True: 0, False: 0]
  |  Branch (79:41): [True: 0, False: 0]
  |  Branch (79:52): [True: 0, False: 0]
  ------------------
   80|      0|                        ++p;
   81|      0|                        break;
   82|      0|                    default:
  ------------------
  |  Branch (82:21): [True: 0, False: 0]
  ------------------
   83|      0|                        buffer.clear();
   84|      0|                        state = column_state::label;
   85|      0|                        break;
   86|      0|                }
   87|      0|                break;
   88|      0|            }
   89|      0|            case column_state::label:
  ------------------
  |  Branch (89:13): [True: 0, False: 0]
  ------------------
   90|      0|            {
   91|      0|                switch (*p)
   92|      0|                {
   93|      0|                case ',':
  ------------------
  |  Branch (93:17): [True: 0, False: 0]
  ------------------
   94|      0|                    cont.push_back(buffer);
   95|      0|                    buffer.clear();
   96|      0|                    ++p;
   97|      0|                    state = column_state::sequence;
   98|      0|                    break;
   99|      0|                default:
  ------------------
  |  Branch (99:17): [True: 0, False: 0]
  ------------------
  100|      0|                    buffer.push_back(*p);
  101|      0|                    ++p;
  102|      0|                    break;
  103|      0|                }
  104|      0|                break;
  105|      0|            }
  106|      0|        }
  107|      0|    }
  108|  5.49k|    if (state == column_state::label)
  ------------------
  |  Branch (108:9): [True: 0, False: 5.49k]
  ------------------
  109|      0|    {
  110|      0|        cont.push_back(buffer);
  111|      0|        buffer.clear();
  112|      0|    }
  113|       |
  114|  5.49k|} // namespace detail
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE15column_defaultsEv:
  620|  2.74k|    {
  621|  2.74k|        return column_defaults_;
  622|  2.74k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE12column_namesEv:
  354|  2.74k|    {
  355|  2.74k|        return column_names_;
  356|  2.74k|    }

_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEED2Ev:
  743|  2.74k|    {
  744|  2.74k|    }
_ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE4lineEv:
 1505|    111|    {
 1506|    111|        return line_;
 1507|    111|    }
_ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE6columnEv:
 1510|    111|    {
 1511|    111|        return column_;
 1512|    111|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEEC2ERKNS0_24basic_csv_decode_optionsIcEERKS4_:
  631|  2.74k|       : alloc_(alloc),
  632|  2.74k|         state_(csv_parse_state::start),
  633|  2.74k|         err_handler_(default_csv_parsing()),
  634|  2.74k|         assume_header_(options.assume_header()),                  
  635|  2.74k|         comment_starter_(options.comment_starter()),
  636|  2.74k|         field_delimiter_(options.field_delimiter()),
  637|  2.74k|         header_lines_(options.header_lines()),
  638|  2.74k|         ignore_empty_values_(options.ignore_empty_values()),
  639|  2.74k|         ignore_empty_lines_(options.ignore_empty_lines()),
  640|  2.74k|         infer_types_(options.infer_types()),
  641|  2.74k|         lossless_number_(options.lossless_number()), 
  642|  2.74k|         mapping_kind_(options.mapping_kind()),
  643|  2.74k|         max_lines_(options.max_lines()),
  644|  2.74k|         quote_char_(options.quote_char()),
  645|  2.74k|         quote_escape_char_(options.quote_escape_char()),
  646|  2.74k|         subfield_delimiter_(options.subfield_delimiter()),
  647|  2.74k|         trim_leading_(options.trim_leading()),
  648|  2.74k|         trim_leading_inside_quotes_(options.trim_leading_inside_quotes()),
  649|  2.74k|         trim_trailing_(options.trim_trailing()),
  650|  2.74k|         trim_trailing_inside_quotes_(options.trim_trailing_inside_quotes()),
  651|  2.74k|         unquoted_empty_value_is_null_(options.unquoted_empty_value_is_null()),
  652|  2.74k|         m_columns_filter_(alloc),
  653|  2.74k|         stack_(alloc),
  654|  2.74k|         column_names_(alloc),
  655|  2.74k|         column_types_(alloc),
  656|  2.74k|         column_defaults_(alloc),
  657|  2.74k|         state_stack_(alloc),
  658|  2.74k|         buffer_(alloc)
  659|  2.74k|    {
  660|  2.74k|        if (options.enable_str_to_nan())
  ------------------
  |  Branch (660:13): [True: 0, False: 2.74k]
  ------------------
  661|      0|        {
  662|      0|            string_double_map_.emplace_back(options.nan_to_str(),std::nan(""));
  663|      0|        }
  664|  2.74k|        if (options.enable_str_to_inf())
  ------------------
  |  Branch (664:13): [True: 0, False: 2.74k]
  ------------------
  665|      0|        {
  666|      0|            string_double_map_.emplace_back(options.inf_to_str(),std::numeric_limits<double>::infinity());
  667|      0|        }
  668|  2.74k|        if (options.enable_str_to_neginf())
  ------------------
  |  Branch (668:13): [True: 0, False: 2.74k]
  ------------------
  669|      0|        {
  670|      0|            string_double_map_.emplace_back(options.neginf_to_str(),-std::numeric_limits<double>::infinity());
  671|      0|        }
  672|       |
  673|  2.74k|        jsoncons::csv::detail::parse_column_types(options.column_types(), column_types_);
  674|  2.74k|        jsoncons::csv::detail::parse_column_names(options.column_defaults(), column_defaults_);
  675|  2.74k|        jsoncons::csv::detail::parse_column_names(options.column_names(), column_names_);
  676|  2.74k|        min_column_names_ = column_names_.size();
  677|  2.74k|        initialize();
  678|  2.74k|    }
_ZN8jsoncons3csv6detail16m_columns_filterIcNSt3__19allocatorIcEEEC2ERKS5_:
  258|  2.74k|            : alloc_(alloc),
  259|  2.74k|              column_names_(alloc),
  260|  2.74k|              cached_events_(alloc)
  261|  2.74k|        {
  262|  2.74k|        }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE10initializeEv:
 1516|  2.74k|    {
 1517|  2.74k|        stack_.reserve(default_depth);
 1518|  2.74k|        stack_.push_back(csv_mode::initial);
 1519|  2.74k|        stack_.push_back((header_lines_ > 0) ? csv_mode::header : csv_mode::data);
  ------------------
  |  Branch (1519:26): [True: 2.74k, False: 0]
  ------------------
 1520|  2.74k|    }
_ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE7stoppedEv:
  778|  20.5k|    {
  779|  20.5k|        return !more_;
  780|  20.5k|    }
_ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE16source_exhaustedEv:
  783|  17.8k|    {
  784|  17.8k|        return input_ptr_ == input_end_;
  785|  17.8k|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE6updateEPKcm:
 1498|  2.73k|    {
 1499|  2.73k|        begin_input_ = data;
 1500|  2.73k|        input_end_ = data + length;
 1501|  2.73k|        input_ptr_ = begin_input_;
 1502|  2.73k|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE10parse_someERNS_18basic_json_visitorIcEERNS2_10error_codeE:
  832|  17.8k|    {
  833|  17.8k|        basic_json_visitor<CharT>& local_visitor = (mapping_kind_ == csv_mapping_kind::m_columns) 
  ------------------
  |  Branch (833:52): [True: 0, False: 17.8k]
  ------------------
  834|  17.8k|            ? m_columns_filter_ : visitor;
  835|       |
  836|  17.8k|        switch (mapping_kind_)
  837|  17.8k|        {
  838|      0|            case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (838:13): [True: 0, False: 17.8k]
  ------------------
  839|      0|                cursor_mode_ = false;
  840|      0|                break;
  841|  17.8k|            default:
  ------------------
  |  Branch (841:13): [True: 17.8k, False: 0]
  ------------------
  842|  17.8k|                break;
  843|  17.8k|        } 
  844|       |
  845|  17.8k|        const CharT* local_input_end = input_end_;
  846|       |
  847|  17.8k|        if (input_ptr_ == local_input_end && more_)
  ------------------
  |  Branch (847:13): [True: 15.1k, False: 2.73k]
  |  Branch (847:46): [True: 15.1k, False: 0]
  ------------------
  848|  15.1k|        {
  849|  15.1k|            switch (state_)
  850|  15.1k|            {
  851|      1|                case csv_parse_state::start:
  ------------------
  |  Branch (851:17): [True: 1, False: 15.1k]
  ------------------
  852|      1|                    ec = csv_errc::source_error;
  853|      1|                    more_ = false;
  854|      1|                    return;
  855|  2.27k|                case csv_parse_state::before_unquoted_field:
  ------------------
  |  Branch (855:17): [True: 2.27k, False: 12.8k]
  ------------------
  856|  2.27k|                case csv_parse_state::before_last_unquoted_field:
  ------------------
  |  Branch (856:17): [True: 0, False: 15.1k]
  ------------------
  857|  2.27k|                    end_unquoted_string_value(local_visitor, ec);
  858|  2.27k|                    state_ = csv_parse_state::before_last_unquoted_field_tail;
  859|  2.27k|                    break;
  860|  2.26k|                case csv_parse_state::before_last_unquoted_field_tail:
  ------------------
  |  Branch (860:17): [True: 2.26k, False: 12.8k]
  ------------------
  861|  2.26k|                    if (stack_.back() == csv_mode::subfields)
  ------------------
  |  Branch (861:25): [True: 0, False: 2.26k]
  ------------------
  862|      0|                    {
  863|      0|                        stack_.pop_back();
  864|      0|                        local_visitor.end_array(*this, ec);
  865|      0|                        more_ = !cursor_mode_;
  866|      0|                        if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (866:29): [True: 0, False: 0]
  ------------------
  867|      0|                        {
  868|      0|                            if (level() == mark_level_)
  ------------------
  |  Branch (868:33): [True: 0, False: 0]
  ------------------
  869|      0|                            {
  870|      0|                                more_ = false;
  871|      0|                            }
  872|      0|                        }
  873|      0|                        --level_;
  874|      0|                    }
  875|  2.26k|                    ++column_index_;
  876|  2.26k|                    state_ = csv_parse_state::end_record;
  877|  2.26k|                    break;
  878|    234|                case csv_parse_state::before_unquoted_string: 
  ------------------
  |  Branch (878:17): [True: 234, False: 14.8k]
  ------------------
  879|    234|                    buffer_.clear();
  880|    234|                    JSONCONS_FALLTHROUGH;
  ------------------
  |  |  564|    234|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  881|  2.27k|                case csv_parse_state::unquoted_string: 
  ------------------
  |  Branch (881:17): [True: 2.03k, False: 13.0k]
  ------------------
  882|  2.27k|                    if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (882:25): [True: 0, False: 2.27k]
  |  Branch (882:42): [True: 0, False: 2.27k]
  ------------------
  883|      0|                    {
  884|      0|                        trim_string_buffer(trim_leading_,trim_trailing_);
  885|      0|                    }
  886|  2.27k|                    if (ignore_empty_values_ && buffer_.empty())
  ------------------
  |  Branch (886:25): [True: 0, False: 2.27k]
  |  Branch (886:49): [True: 0, False: 0]
  ------------------
  887|      0|                    {
  888|      0|                        state_ = csv_parse_state::end_record;
  889|      0|                    }
  890|  2.27k|                    else
  891|  2.27k|                    {
  892|  2.27k|                        before_value(local_visitor, ec);
  893|  2.27k|                        state_ = csv_parse_state::before_unquoted_field;
  894|  2.27k|                    }
  895|  2.27k|                    break;
  896|     34|                case csv_parse_state::before_last_quoted_field:
  ------------------
  |  Branch (896:17): [True: 34, False: 15.0k]
  ------------------
  897|     34|                    end_quoted_string_value(local_visitor, ec);
  898|     34|                    ++column_index_;
  899|     34|                    state_ = csv_parse_state::end_record;
  900|     34|                    break;
  901|     34|                case csv_parse_state::escaped_value:
  ------------------
  |  Branch (901:17): [True: 34, False: 15.0k]
  ------------------
  902|     34|                    if (quote_escape_char_ == quote_char_)
  ------------------
  |  Branch (902:25): [True: 34, False: 0]
  ------------------
  903|     34|                    {
  904|     34|                        if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (904:31): [True: 0, False: 34]
  |  Branch (904:55): [True: 0, False: 0]
  ------------------
  905|     34|                        {
  906|     34|                            before_value(local_visitor, ec);
  907|     34|                            ++column_;
  908|     34|                            state_ = csv_parse_state::before_last_quoted_field;
  909|     34|                        }
  910|      0|                        else
  911|      0|                        {
  912|      0|                            state_ = csv_parse_state::end_record;
  913|      0|                        }
  914|     34|                    }
  915|      0|                    else
  916|      0|                    {
  917|      0|                        ec = csv_errc::invalid_escaped_char;
  918|      0|                        more_ = false;
  919|      0|                        return;
  920|      0|                    }
  921|     34|                    break;
  922|  2.63k|                case csv_parse_state::end_record:
  ------------------
  |  Branch (922:17): [True: 2.63k, False: 12.4k]
  ------------------
  923|  2.63k|                    if (column_index_ > 0)
  ------------------
  |  Branch (923:25): [True: 2.31k, False: 319]
  ------------------
  924|  2.31k|                    {
  925|  2.31k|                        end_record(local_visitor, ec);
  926|  2.31k|                    }
  927|  2.63k|                    state_ = csv_parse_state::no_more_records;
  928|  2.63k|                    break;
  929|  2.63k|                case csv_parse_state::no_more_records: 
  ------------------
  |  Branch (929:17): [True: 2.63k, False: 12.4k]
  ------------------
  930|  2.63k|                    switch (stack_.back()) 
  931|  2.63k|                    {
  932|    118|                        case csv_mode::header:
  ------------------
  |  Branch (932:25): [True: 118, False: 2.52k]
  ------------------
  933|    118|                            stack_.pop_back();
  934|    118|                            break;
  935|  2.52k|                        case csv_mode::data:
  ------------------
  |  Branch (935:25): [True: 2.52k, False: 118]
  ------------------
  936|  2.52k|                            stack_.pop_back();
  937|  2.52k|                            break;
  938|      0|                        default:
  ------------------
  |  Branch (938:25): [True: 0, False: 2.63k]
  ------------------
  939|      0|                            break;
  940|  2.63k|                    }
  941|  2.63k|                    local_visitor.end_array(*this, ec);
  942|  2.63k|                    more_ = !cursor_mode_;
  943|  2.63k|                    if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (943:25): [True: 2.63k, False: 0]
  ------------------
  944|  2.63k|                    {
  945|  2.63k|                        if (level() == mark_level_)
  ------------------
  |  Branch (945:29): [True: 0, False: 2.63k]
  ------------------
  946|      0|                        {
  947|      0|                            more_ = false;
  948|      0|                        }
  949|  2.63k|                    }
  950|  2.63k|                    --level_;
  951|       |                    
  952|  2.63k|                    if (mapping_kind_ == csv_mapping_kind::m_columns)
  ------------------
  |  Branch (952:25): [True: 0, False: 2.63k]
  ------------------
  953|      0|                    {
  954|      0|                        if (!m_columns_filter_.done())
  ------------------
  |  Branch (954:29): [True: 0, False: 0]
  ------------------
  955|      0|                        {
  956|      0|                            more_ = m_columns_filter_.replay_parse_events(visitor, actual_cursor_mode_, mark_level_);
  957|      0|                        }
  958|      0|                        else
  959|      0|                        {
  960|      0|                            state_ = csv_parse_state::accept;
  961|      0|                        }
  962|      0|                    }
  963|  2.63k|                    else
  964|  2.63k|                    {
  965|  2.63k|                        state_ = csv_parse_state::accept;
  966|  2.63k|                    }
  967|  2.63k|                    break;
  968|  2.63k|                case csv_parse_state::accept:
  ------------------
  |  Branch (968:17): [True: 2.63k, False: 12.4k]
  ------------------
  969|  2.63k|                    if (!(stack_.size() == 1 && stack_.back() == csv_mode::initial))
  ------------------
  |  Branch (969:27): [True: 2.63k, False: 0]
  |  Branch (969:49): [True: 2.63k, False: 0]
  ------------------
  970|      0|                    {
  971|      0|                        err_handler_(csv_errc::unexpected_eof, *this);
  972|      0|                        ec = csv_errc::unexpected_eof;
  973|      0|                        more_ = false;
  974|      0|                        return;
  975|      0|                    }
  976|  2.63k|                    stack_.pop_back();
  977|  2.63k|                    local_visitor.flush();
  978|  2.63k|                    state_ = csv_parse_state::done;
  979|  2.63k|                    more_ = false;
  980|  2.63k|                    return;
  981|    336|                default:
  ------------------
  |  Branch (981:17): [True: 336, False: 14.7k]
  ------------------
  982|    336|                    state_ = csv_parse_state::end_record;
  983|    336|                    break;
  984|  15.1k|            }
  985|  15.1k|        }
  986|       |
  987|   174M|        for (; (input_ptr_ < local_input_end) && more_;)
  ------------------
  |  Branch (987:16): [True: 174M, False: 15.1k]
  |  Branch (987:50): [True: 174M, False: 1]
  ------------------
  988|   174M|        {
  989|   174M|            CharT curr_char = *input_ptr_;
  990|       |
  991|   174M|            switch (state_) 
  992|   174M|            {
  993|  5.08M|                case csv_parse_state::cr:
  ------------------
  |  Branch (993:17): [True: 5.08M, False: 169M]
  ------------------
  994|  5.08M|                    ++line_;
  995|  5.08M|                    column_ = 1;
  996|  5.08M|                    switch (*input_ptr_)
  997|  5.08M|                    {
  998|  9.48k|                        case '\n':
  ------------------
  |  Branch (998:25): [True: 9.48k, False: 5.07M]
  ------------------
  999|  9.48k|                            ++input_ptr_;
 1000|  9.48k|                            state_ = pop_state();
 1001|  9.48k|                            break;
 1002|  5.07M|                        default:
  ------------------
  |  Branch (1002:25): [True: 5.07M, False: 9.48k]
  ------------------
 1003|  5.07M|                            state_ = pop_state();
 1004|  5.07M|                            break;
 1005|  5.08M|                    }
 1006|  5.08M|                    break;
 1007|  5.08M|                case csv_parse_state::start:
  ------------------
  |  Branch (1007:17): [True: 2.73k, False: 174M]
  ------------------
 1008|  2.73k|                    if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (1008:25): [True: 2.73k, False: 0]
  ------------------
 1009|  2.73k|                    {
 1010|  2.73k|                        local_visitor.begin_array(semantic_tag::none, *this, ec);
 1011|  2.73k|                        more_ = !cursor_mode_;
 1012|  2.73k|                        ++level_;
 1013|  2.73k|                    }
 1014|  2.73k|                    if (assume_header_ && mapping_kind_ == csv_mapping_kind::n_rows && !column_names_.empty())
  ------------------
  |  Branch (1014:25): [True: 2.73k, False: 0]
  |  Branch (1014:43): [True: 2.73k, False: 0]
  |  Branch (1014:88): [True: 0, False: 2.73k]
  ------------------
 1015|      0|                    {
 1016|      0|                        column_index_ = 0; 
 1017|      0|                        local_visitor.begin_array(semantic_tag::none, *this, ec);
 1018|      0|                        ++level_;
 1019|      0|                        more_ = !cursor_mode_;
 1020|      0|                        state_ = csv_parse_state::expect_comment_or_record;
 1021|      0|                    }
 1022|  2.73k|                    else
 1023|  2.73k|                    {
 1024|  2.73k|                        state_ = csv_parse_state::expect_comment_or_record;
 1025|  2.73k|                    }
 1026|  2.73k|                    break;
 1027|  7.26M|                case csv_parse_state::comment: 
  ------------------
  |  Branch (1027:17): [True: 7.26M, False: 167M]
  ------------------
 1028|  7.26M|                    switch (curr_char)
 1029|  7.26M|                    {
 1030|  1.75M|                        case '\n':
  ------------------
  |  Branch (1030:25): [True: 1.75M, False: 5.50M]
  ------------------
 1031|  1.75M|                        {
 1032|  1.75M|                            ++line_;
 1033|  1.75M|                            if (stack_.back() == csv_mode::header)
  ------------------
  |  Branch (1033:33): [True: 1.50M, False: 254k]
  ------------------
 1034|  1.50M|                            {
 1035|  1.50M|                                ++header_line_offset_;
 1036|  1.50M|                            }
 1037|  1.75M|                            column_ = 1;
 1038|  1.75M|                            state_ = csv_parse_state::expect_comment_or_record;
 1039|  1.75M|                            break;
 1040|      0|                        }
 1041|  14.5k|                        case '\r':
  ------------------
  |  Branch (1041:25): [True: 14.5k, False: 7.25M]
  ------------------
 1042|  14.5k|                            ++line_;
 1043|  14.5k|                            if (stack_.back() == csv_mode::header)
  ------------------
  |  Branch (1043:33): [True: 1.77k, False: 12.8k]
  ------------------
 1044|  1.77k|                            {
 1045|  1.77k|                                ++header_line_offset_;
 1046|  1.77k|                            }
 1047|  14.5k|                            column_ = 1;
 1048|  14.5k|                            state_ = csv_parse_state::expect_comment_or_record;
 1049|  14.5k|                            push_state(state_);
 1050|  14.5k|                            state_ = csv_parse_state::cr;
 1051|  14.5k|                            break;
 1052|  5.49M|                        default:
  ------------------
  |  Branch (1052:25): [True: 5.49M, False: 1.77M]
  ------------------
 1053|  5.49M|                            ++column_;
 1054|  5.49M|                            break;
 1055|  7.26M|                    }
 1056|  7.26M|                    ++input_ptr_;
 1057|  7.26M|                    break;
 1058|       |                
 1059|  10.0M|                case csv_parse_state::expect_comment_or_record:
  ------------------
  |  Branch (1059:17): [True: 10.0M, False: 164M]
  ------------------
 1060|  10.0M|                    buffer_.clear();
 1061|  10.0M|                    if (curr_char == comment_starter_)
  ------------------
  |  Branch (1061:25): [True: 1.77M, False: 8.28M]
  ------------------
 1062|  1.77M|                    {
 1063|  1.77M|                        state_ = csv_parse_state::comment;
 1064|  1.77M|                        ++column_;
 1065|  1.77M|                        ++input_ptr_;
 1066|  1.77M|                    }
 1067|  8.28M|                    else
 1068|  8.28M|                    {
 1069|  8.28M|                        state_ = csv_parse_state::expect_record;
 1070|  8.28M|                    }
 1071|  10.0M|                    break;
 1072|  3.16M|                case csv_parse_state::quoted_string: 
  ------------------
  |  Branch (1072:17): [True: 3.16M, False: 171M]
  ------------------
 1073|  3.16M|                    {
 1074|  3.16M|                        if (curr_char == quote_escape_char_)
  ------------------
  |  Branch (1074:29): [True: 5.81k, False: 3.15M]
  ------------------
 1075|  5.81k|                        {
 1076|  5.81k|                            state_ = csv_parse_state::escaped_value;
 1077|  5.81k|                        }
 1078|  3.15M|                        else if (curr_char == quote_char_)
  ------------------
  |  Branch (1078:34): [True: 0, False: 3.15M]
  ------------------
 1079|      0|                        {
 1080|      0|                            state_ = csv_parse_state::between_values;
 1081|      0|                        }
 1082|  3.15M|                        else
 1083|  3.15M|                        {
 1084|  3.15M|                            buffer_.push_back(static_cast<CharT>(curr_char));
 1085|  3.15M|                        }
 1086|  3.16M|                    }
 1087|  3.16M|                    ++column_;
 1088|  3.16M|                    ++input_ptr_;
 1089|  3.16M|                    break;
 1090|  5.78k|                case csv_parse_state::escaped_value: 
  ------------------
  |  Branch (1090:17): [True: 5.78k, False: 174M]
  ------------------
 1091|  5.78k|                    {
 1092|  5.78k|                        if (curr_char == quote_char_)
  ------------------
  |  Branch (1092:29): [True: 2.75k, False: 3.02k]
  ------------------
 1093|  2.75k|                        {
 1094|  2.75k|                            buffer_.push_back(static_cast<CharT>(curr_char));
 1095|  2.75k|                            state_ = csv_parse_state::quoted_string;
 1096|  2.75k|                            ++column_;
 1097|  2.75k|                            ++input_ptr_;
 1098|  2.75k|                        }
 1099|  3.02k|                        else if (quote_escape_char_ == quote_char_)
  ------------------
  |  Branch (1099:34): [True: 3.02k, False: 0]
  ------------------
 1100|  3.02k|                        {
 1101|  3.02k|                            state_ = csv_parse_state::between_values;
 1102|  3.02k|                        }
 1103|      0|                        else
 1104|      0|                        {
 1105|      0|                            ec = csv_errc::invalid_escaped_char;
 1106|      0|                            more_ = false;
 1107|      0|                            return;
 1108|      0|                        }
 1109|  5.78k|                    }
 1110|  5.78k|                    break;
 1111|  5.78k|                case csv_parse_state::between_values:
  ------------------
  |  Branch (1111:17): [True: 3.51k, False: 174M]
  ------------------
 1112|  3.51k|                    switch (curr_char)
 1113|  3.51k|                    {
 1114|    332|                        case '\r':
  ------------------
  |  Branch (1114:25): [True: 332, False: 3.18k]
  ------------------
 1115|  1.19k|                        case '\n':
  ------------------
  |  Branch (1115:25): [True: 860, False: 2.65k]
  ------------------
 1116|  1.19k|                        {
 1117|  1.19k|                            if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (1117:33): [True: 0, False: 1.19k]
  |  Branch (1117:50): [True: 0, False: 1.19k]
  ------------------
 1118|      0|                            {
 1119|      0|                                trim_string_buffer(trim_leading_,trim_trailing_);
 1120|      0|                            }
 1121|  1.19k|                            if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1121:35): [True: 0, False: 1.19k]
  |  Branch (1121:59): [True: 0, False: 0]
  ------------------
 1122|  1.19k|                            {
 1123|  1.19k|                                before_value(local_visitor, ec);
 1124|  1.19k|                                state_ = csv_parse_state::before_last_quoted_field;
 1125|  1.19k|                            }
 1126|      0|                            else
 1127|      0|                            {
 1128|      0|                                state_ = csv_parse_state::end_record;
 1129|      0|                            }
 1130|  1.19k|                            break;
 1131|    332|                        }
 1132|  2.32k|                        default:
  ------------------
  |  Branch (1132:25): [True: 2.32k, False: 1.19k]
  ------------------
 1133|  2.32k|                            if (curr_char == field_delimiter_)
  ------------------
  |  Branch (1133:33): [True: 1.72k, False: 599]
  ------------------
 1134|  1.72k|                            {
 1135|  1.72k|                                if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (1135:37): [True: 0, False: 1.72k]
  |  Branch (1135:54): [True: 0, False: 1.72k]
  ------------------
 1136|      0|                                {
 1137|      0|                                    trim_string_buffer(trim_leading_,trim_trailing_);
 1138|      0|                                }
 1139|  1.72k|                                before_value(local_visitor, ec);
 1140|  1.72k|                                state_ = csv_parse_state::before_quoted_field;
 1141|  1.72k|                            }
 1142|    599|                            else if (subfield_delimiter_ != char_type() && curr_char == subfield_delimiter_)
  ------------------
  |  Branch (1142:38): [True: 0, False: 599]
  |  Branch (1142:76): [True: 0, False: 0]
  ------------------
 1143|      0|                            {
 1144|      0|                                if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (1144:37): [True: 0, False: 0]
  |  Branch (1144:54): [True: 0, False: 0]
  ------------------
 1145|      0|                                {
 1146|      0|                                    trim_string_buffer(trim_leading_,trim_trailing_);
 1147|      0|                                }
 1148|      0|                                before_value(local_visitor, ec);
 1149|      0|                                state_ = csv_parse_state::before_quoted_subfield;
 1150|      0|                            }
 1151|    599|                            else if (curr_char == ' ' || curr_char == '\t')
  ------------------
  |  Branch (1151:38): [True: 303, False: 296]
  |  Branch (1151:58): [True: 202, False: 94]
  ------------------
 1152|    505|                            {
 1153|    505|                                ++column_;
 1154|    505|                                ++input_ptr_;
 1155|    505|                            }
 1156|     94|                            else
 1157|     94|                            {
 1158|     94|                                ec = csv_errc::unexpected_char_between_fields;
 1159|     94|                                more_ = false;
 1160|     94|                                return;
 1161|     94|                            }
 1162|  2.22k|                            break;
 1163|  3.51k|                    }
 1164|  3.42k|                    break;
 1165|  20.1M|                case csv_parse_state::before_unquoted_string: 
  ------------------
  |  Branch (1165:17): [True: 20.1M, False: 154M]
  ------------------
 1166|  20.1M|                {
 1167|  20.1M|                    buffer_.clear();
 1168|  20.1M|                    state_ = csv_parse_state::unquoted_string;
 1169|  20.1M|                    break;
 1170|  3.51k|                }
 1171|  20.1M|                case csv_parse_state::before_unquoted_field:
  ------------------
  |  Branch (1171:17): [True: 20.1M, False: 154M]
  ------------------
 1172|  20.1M|                    end_unquoted_string_value(local_visitor, ec);
 1173|  20.1M|                    state_ = csv_parse_state::before_unquoted_field_tail;
 1174|  20.1M|                    break;
 1175|  20.1M|                case csv_parse_state::before_unquoted_field_tail:
  ------------------
  |  Branch (1175:17): [True: 20.1M, False: 154M]
  ------------------
 1176|  20.1M|                {
 1177|  20.1M|                    if (stack_.back() == csv_mode::subfields)
  ------------------
  |  Branch (1177:25): [True: 0, False: 20.1M]
  ------------------
 1178|      0|                    {
 1179|      0|                        stack_.pop_back();
 1180|      0|                        local_visitor.end_array(*this, ec);
 1181|      0|                        more_ = !cursor_mode_;
 1182|      0|                        if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (1182:29): [True: 0, False: 0]
  ------------------
 1183|      0|                        {
 1184|      0|                            if (level() == mark_level_)
  ------------------
  |  Branch (1184:33): [True: 0, False: 0]
  ------------------
 1185|      0|                            {
 1186|      0|                                more_ = false;
 1187|      0|                            }
 1188|      0|                        }
 1189|      0|                        --level_;
 1190|      0|                    }
 1191|  20.1M|                    ++column_index_;
 1192|  20.1M|                    state_ = csv_parse_state::before_unquoted_string;
 1193|  20.1M|                    ++column_;
 1194|  20.1M|                    ++input_ptr_;
 1195|  20.1M|                    break;
 1196|  3.51k|                }
 1197|      0|                case csv_parse_state::before_unquoted_field_tail1:
  ------------------
  |  Branch (1197:17): [True: 0, False: 174M]
  ------------------
 1198|      0|                {
 1199|      0|                    if (stack_.back() == csv_mode::subfields)
  ------------------
  |  Branch (1199:25): [True: 0, False: 0]
  ------------------
 1200|      0|                    {
 1201|      0|                        stack_.pop_back();
 1202|      0|                        local_visitor.end_array(*this, ec);
 1203|      0|                        more_ = !cursor_mode_;
 1204|      0|                        if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (1204:29): [True: 0, False: 0]
  ------------------
 1205|      0|                        {
 1206|      0|                            if (level() == mark_level_)
  ------------------
  |  Branch (1206:33): [True: 0, False: 0]
  ------------------
 1207|      0|                            {
 1208|      0|                                more_ = false;
 1209|      0|                            }
 1210|      0|                        }
 1211|      0|                        --level_;
 1212|      0|                    }
 1213|      0|                    state_ = csv_parse_state::end_record;
 1214|      0|                    ++column_;
 1215|      0|                    ++input_ptr_;
 1216|      0|                    break;
 1217|  3.51k|                }
 1218|       |
 1219|  3.93M|                case csv_parse_state::before_last_unquoted_field:
  ------------------
  |  Branch (1219:17): [True: 3.93M, False: 170M]
  ------------------
 1220|  3.93M|                    end_unquoted_string_value(local_visitor, ec);
 1221|  3.93M|                    state_ = csv_parse_state::before_last_unquoted_field_tail;
 1222|  3.93M|                    break;
 1223|       |
 1224|  3.93M|                case csv_parse_state::before_last_unquoted_field_tail:
  ------------------
  |  Branch (1224:17): [True: 3.93M, False: 170M]
  ------------------
 1225|  3.93M|                    if (stack_.back() == csv_mode::subfields)
  ------------------
  |  Branch (1225:25): [True: 0, False: 3.93M]
  ------------------
 1226|      0|                    {
 1227|      0|                        stack_.pop_back();
 1228|      0|                        local_visitor.end_array(*this, ec);
 1229|      0|                        more_ = !cursor_mode_;
 1230|      0|                        if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (1230:29): [True: 0, False: 0]
  ------------------
 1231|      0|                        {
 1232|      0|                            if (level() == mark_level_)
  ------------------
  |  Branch (1232:33): [True: 0, False: 0]
  ------------------
 1233|      0|                            {
 1234|      0|                                more_ = false;
 1235|      0|                            }
 1236|      0|                        }
 1237|      0|                        --level_;
 1238|      0|                    }
 1239|  3.93M|                    ++column_index_;
 1240|  3.93M|                    state_ = csv_parse_state::end_record;
 1241|  3.93M|                    break;
 1242|       |
 1243|      0|                case csv_parse_state::before_unquoted_subfield:
  ------------------
  |  Branch (1243:17): [True: 0, False: 174M]
  ------------------
 1244|      0|                    if (stack_.back() == csv_mode::data)
  ------------------
  |  Branch (1244:25): [True: 0, False: 0]
  ------------------
 1245|      0|                    {
 1246|      0|                        stack_.push_back(csv_mode::subfields);
 1247|      0|                        local_visitor.begin_array(semantic_tag::none, *this, ec);
 1248|      0|                        more_ = !cursor_mode_;
 1249|      0|                        ++level_;
 1250|      0|                    }
 1251|      0|                    state_ = csv_parse_state::before_unquoted_subfield_tail;
 1252|      0|                    break; 
 1253|      0|                case csv_parse_state::before_unquoted_subfield_tail:
  ------------------
  |  Branch (1253:17): [True: 0, False: 174M]
  ------------------
 1254|      0|                    end_unquoted_string_value(local_visitor, ec);
 1255|      0|                    state_ = csv_parse_state::before_unquoted_string;
 1256|      0|                    ++column_;
 1257|      0|                    ++input_ptr_;
 1258|      0|                    break;
 1259|  1.72k|                case csv_parse_state::before_quoted_field:
  ------------------
  |  Branch (1259:17): [True: 1.72k, False: 174M]
  ------------------
 1260|  1.72k|                    end_quoted_string_value(local_visitor, ec);
 1261|  1.72k|                    state_ = csv_parse_state::before_unquoted_field_tail; // return to unquoted
 1262|  1.72k|                    break;
 1263|      0|                case csv_parse_state::before_quoted_subfield:
  ------------------
  |  Branch (1263:17): [True: 0, False: 174M]
  ------------------
 1264|      0|                    if (stack_.back() == csv_mode::data)
  ------------------
  |  Branch (1264:25): [True: 0, False: 0]
  ------------------
 1265|      0|                    {
 1266|      0|                        stack_.push_back(csv_mode::subfields);
 1267|      0|                        local_visitor.begin_array(semantic_tag::none, *this, ec);
 1268|      0|                        more_ = !cursor_mode_;
 1269|      0|                        ++level_;
 1270|      0|                    }
 1271|      0|                    state_ = csv_parse_state::before_quoted_subfield_tail;
 1272|      0|                    break; 
 1273|      0|                case csv_parse_state::before_quoted_subfield_tail:
  ------------------
  |  Branch (1273:17): [True: 0, False: 174M]
  ------------------
 1274|      0|                    end_quoted_string_value(local_visitor, ec);
 1275|      0|                    state_ = csv_parse_state::before_unquoted_string;
 1276|      0|                    ++column_;
 1277|      0|                    ++input_ptr_;
 1278|      0|                    break;
 1279|  1.19k|                case csv_parse_state::before_last_quoted_field:
  ------------------
  |  Branch (1279:17): [True: 1.19k, False: 174M]
  ------------------
 1280|  1.19k|                    end_quoted_string_value(local_visitor, ec);
 1281|  1.19k|                    state_ = csv_parse_state::before_last_quoted_field_tail;
 1282|  1.19k|                    break;
 1283|  1.19k|                case csv_parse_state::before_last_quoted_field_tail:
  ------------------
  |  Branch (1283:17): [True: 1.19k, False: 174M]
  ------------------
 1284|  1.19k|                    if (stack_.back() == csv_mode::subfields)
  ------------------
  |  Branch (1284:25): [True: 0, False: 1.19k]
  ------------------
 1285|      0|                    {
 1286|      0|                        stack_.pop_back();
 1287|      0|                        local_visitor.end_array(*this, ec);
 1288|      0|                        more_ = !cursor_mode_;
 1289|      0|                        if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (1289:29): [True: 0, False: 0]
  ------------------
 1290|      0|                        {
 1291|      0|                            if (level() == mark_level_)
  ------------------
  |  Branch (1291:33): [True: 0, False: 0]
  ------------------
 1292|      0|                            {
 1293|      0|                                more_ = false;
 1294|      0|                            }
 1295|      0|                        }
 1296|      0|                        --level_;
 1297|      0|                    }
 1298|  1.19k|                    ++column_index_;
 1299|  1.19k|                    state_ = csv_parse_state::end_record;
 1300|  1.19k|                    break;
 1301|  65.8M|                case csv_parse_state::unquoted_string: 
  ------------------
  |  Branch (1301:17): [True: 65.8M, False: 108M]
  ------------------
 1302|  65.8M|                {
 1303|  65.8M|                    switch (curr_char)
 1304|  65.8M|                    {
 1305|  1.32M|                        case '\n':
  ------------------
  |  Branch (1305:25): [True: 1.32M, False: 64.5M]
  ------------------
 1306|  3.93M|                        case '\r':
  ------------------
  |  Branch (1306:25): [True: 2.61M, False: 63.2M]
  ------------------
 1307|  3.93M|                        {
 1308|  3.93M|                            if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (1308:33): [True: 0, False: 3.93M]
  |  Branch (1308:50): [True: 0, False: 3.93M]
  ------------------
 1309|      0|                            {
 1310|      0|                                trim_string_buffer(trim_leading_,trim_trailing_);
 1311|      0|                            }
 1312|  3.93M|                            if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1312:35): [True: 0, False: 3.93M]
  |  Branch (1312:59): [True: 0, False: 0]
  ------------------
 1313|  3.93M|                            {
 1314|  3.93M|                                before_value(local_visitor, ec);
 1315|  3.93M|                                state_ = csv_parse_state::before_last_unquoted_field;
 1316|  3.93M|                            }
 1317|      0|                            else
 1318|      0|                            {
 1319|      0|                                state_ = csv_parse_state::end_record;
 1320|      0|                            }
 1321|  3.93M|                            break;
 1322|  1.32M|                        }
 1323|  61.9M|                        default:
  ------------------
  |  Branch (1323:25): [True: 61.9M, False: 3.93M]
  ------------------
 1324|  61.9M|                            if (curr_char == field_delimiter_)
  ------------------
  |  Branch (1324:33): [True: 20.1M, False: 41.7M]
  ------------------
 1325|  20.1M|                            {
 1326|  20.1M|                                if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (1326:37): [True: 0, False: 20.1M]
  |  Branch (1326:54): [True: 0, False: 20.1M]
  ------------------
 1327|      0|                                {
 1328|      0|                                    trim_string_buffer(trim_leading_,trim_trailing_);
 1329|      0|                                }
 1330|  20.1M|                                before_value(local_visitor, ec);
 1331|  20.1M|                                state_ = csv_parse_state::before_unquoted_field;
 1332|  20.1M|                            }
 1333|  41.7M|                            else if (subfield_delimiter_ != char_type() && curr_char == subfield_delimiter_)
  ------------------
  |  Branch (1333:38): [True: 0, False: 41.7M]
  |  Branch (1333:76): [True: 0, False: 0]
  ------------------
 1334|      0|                            {
 1335|      0|                                if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (1335:37): [True: 0, False: 0]
  |  Branch (1335:54): [True: 0, False: 0]
  ------------------
 1336|      0|                                {
 1337|      0|                                    trim_string_buffer(trim_leading_,trim_trailing_);
 1338|      0|                                }
 1339|      0|                                before_value(local_visitor, ec);
 1340|      0|                                state_ = csv_parse_state::before_unquoted_subfield;
 1341|      0|                            }
 1342|  41.7M|                            else if (curr_char == quote_char_)
  ------------------
  |  Branch (1342:38): [True: 1.47k, False: 41.7M]
  ------------------
 1343|  1.47k|                            {
 1344|  1.47k|                                buffer_.clear();
 1345|  1.47k|                                state_ = csv_parse_state::quoted_string;
 1346|  1.47k|                                ++column_;
 1347|  1.47k|                                ++input_ptr_;
 1348|  1.47k|                            }
 1349|  41.7M|                            else
 1350|  41.7M|                            {
 1351|  41.7M|                                buffer_.push_back(static_cast<CharT>(curr_char));
 1352|  41.7M|                                ++column_;
 1353|  41.7M|                                ++input_ptr_;
 1354|  41.7M|                            }
 1355|  61.9M|                            break;
 1356|  65.8M|                    }
 1357|  65.8M|                    break;
 1358|  65.8M|                }
 1359|  65.8M|                case csv_parse_state::expect_record: 
  ------------------
  |  Branch (1359:17): [True: 10.7M, False: 163M]
  ------------------
 1360|  10.7M|                {
 1361|  10.7M|                    switch (curr_char)
 1362|  10.7M|                    {
 1363|  4.35M|                        case '\n':
  ------------------
  |  Branch (1363:25): [True: 4.35M, False: 6.39M]
  ------------------
 1364|  4.35M|                        {
 1365|  4.35M|                            if (!ignore_empty_lines_)
  ------------------
  |  Branch (1365:33): [True: 0, False: 4.35M]
  ------------------
 1366|      0|                            {
 1367|      0|                                begin_record(local_visitor, ec);
 1368|      0|                                state_ = csv_parse_state::end_record;
 1369|      0|                            }
 1370|  4.35M|                            else
 1371|  4.35M|                            {
 1372|  4.35M|                                ++line_;
 1373|  4.35M|                                column_ = 1;
 1374|  4.35M|                                state_ = csv_parse_state::expect_comment_or_record;
 1375|  4.35M|                                ++input_ptr_;
 1376|  4.35M|                            }
 1377|  4.35M|                            break;
 1378|      0|                        }
 1379|  2.45M|                        case '\r':
  ------------------
  |  Branch (1379:25): [True: 2.45M, False: 8.28M]
  ------------------
 1380|  2.45M|                            if (!ignore_empty_lines_)
  ------------------
  |  Branch (1380:33): [True: 0, False: 2.45M]
  ------------------
 1381|      0|                            {
 1382|      0|                                begin_record(local_visitor, ec);
 1383|      0|                                state_ = csv_parse_state::end_record;
 1384|      0|                            }
 1385|  2.45M|                            else
 1386|  2.45M|                            {
 1387|  2.45M|                                ++input_ptr_;
 1388|  2.45M|                                push_state(state_);
 1389|  2.45M|                                state_ = csv_parse_state::cr;
 1390|  2.45M|                            }
 1391|  2.45M|                            break;
 1392|  6.88k|                        case ' ':
  ------------------
  |  Branch (1392:25): [True: 6.88k, False: 10.7M]
  ------------------
 1393|  64.9k|                        case '\t':
  ------------------
  |  Branch (1393:25): [True: 58.1k, False: 10.6M]
  ------------------
 1394|  64.9k|                            if (!trim_leading_)
  ------------------
  |  Branch (1394:33): [True: 64.9k, False: 0]
  ------------------
 1395|  64.9k|                            {
 1396|  64.9k|                                buffer_.push_back(static_cast<CharT>(curr_char));
 1397|  64.9k|                                begin_record(local_visitor, ec);
 1398|  64.9k|                                state_ = csv_parse_state::unquoted_string;
 1399|  64.9k|                            }
 1400|  64.9k|                            ++column_;
 1401|  64.9k|                            ++input_ptr_;
 1402|  64.9k|                            break;
 1403|  3.87M|                        default:
  ------------------
  |  Branch (1403:25): [True: 3.87M, False: 6.87M]
  ------------------
 1404|  3.87M|                            begin_record(local_visitor, ec);
 1405|  3.87M|                            if (curr_char == quote_char_)
  ------------------
  |  Branch (1405:33): [True: 1.68k, False: 3.86M]
  ------------------
 1406|  1.68k|                            {
 1407|  1.68k|                                buffer_.clear();
 1408|  1.68k|                                state_ = csv_parse_state::quoted_string;
 1409|  1.68k|                                ++column_;
 1410|  1.68k|                                ++input_ptr_;
 1411|  1.68k|                            }
 1412|  3.86M|                            else
 1413|  3.86M|                            {
 1414|  3.86M|                                state_ = csv_parse_state::unquoted_string;
 1415|  3.86M|                            }
 1416|  3.87M|                            break;
 1417|  10.7M|                        }
 1418|  10.7M|                    break;
 1419|  10.7M|                    }
 1420|  10.7M|                case csv_parse_state::end_record: 
  ------------------
  |  Branch (1420:17): [True: 3.93M, False: 170M]
  ------------------
 1421|  3.93M|                {
 1422|  3.93M|                    switch (curr_char)
 1423|  3.93M|                    {
 1424|  1.32M|                        case '\n':
  ------------------
  |  Branch (1424:25): [True: 1.32M, False: 2.61M]
  ------------------
 1425|  1.32M|                        {
 1426|  1.32M|                            ++line_;
 1427|  1.32M|                            column_ = 1;
 1428|  1.32M|                            state_ = csv_parse_state::expect_comment_or_record;
 1429|  1.32M|                            end_record(local_visitor, ec);
 1430|  1.32M|                            ++input_ptr_;
 1431|  1.32M|                            break;
 1432|      0|                        }
 1433|  2.61M|                        case '\r':
  ------------------
  |  Branch (1433:25): [True: 2.61M, False: 1.32M]
  ------------------
 1434|  2.61M|                            ++line_;
 1435|  2.61M|                            column_ = 1;
 1436|  2.61M|                            state_ = csv_parse_state::expect_comment_or_record;
 1437|  2.61M|                            end_record(local_visitor, ec);
 1438|  2.61M|                            push_state(state_);
 1439|  2.61M|                            state_ = csv_parse_state::cr;
 1440|  2.61M|                            ++input_ptr_;
 1441|  2.61M|                            break;
 1442|      0|                        case ' ':
  ------------------
  |  Branch (1442:25): [True: 0, False: 3.93M]
  ------------------
 1443|      0|                        case '\t':
  ------------------
  |  Branch (1443:25): [True: 0, False: 3.93M]
  ------------------
 1444|      0|                            ++column_;
 1445|      0|                            ++input_ptr_;
 1446|      0|                            break;
 1447|      0|                        default:
  ------------------
  |  Branch (1447:25): [True: 0, False: 3.93M]
  ------------------
 1448|      0|                            err_handler_(csv_errc::syntax_error, *this);
 1449|      0|                            ec = csv_errc::syntax_error;
 1450|      0|                            more_ = false;
 1451|      0|                            return;
 1452|  3.93M|                        }
 1453|  3.93M|                    break;
 1454|  3.93M|                }
 1455|  3.93M|                default:
  ------------------
  |  Branch (1455:17): [True: 0, False: 174M]
  ------------------
 1456|      0|                    err_handler_(csv_errc::invalid_parse_state, *this);
 1457|      0|                    ec = csv_errc::invalid_parse_state;
 1458|      0|                    more_ = false;
 1459|      0|                    return;
 1460|   174M|            }
 1461|   174M|            if (line_ > max_lines_)
  ------------------
  |  Branch (1461:17): [True: 0, False: 174M]
  ------------------
 1462|      0|            {
 1463|      0|                state_ = csv_parse_state::done;
 1464|      0|                more_ = false;
 1465|      0|            }
 1466|   174M|        }
 1467|  15.2k|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE25end_unquoted_string_valueERNS_18basic_json_visitorIcEERNS2_10error_codeE:
 1756|  24.0M|    {
 1757|  24.0M|        switch (stack_.back())
 1758|  24.0M|        {
 1759|  11.4M|            case csv_mode::data:
  ------------------
  |  Branch (1759:13): [True: 11.4M, False: 12.5M]
  ------------------
 1760|  11.4M|            case csv_mode::subfields:
  ------------------
  |  Branch (1760:13): [True: 0, False: 24.0M]
  ------------------
 1761|  11.4M|                switch (mapping_kind_)
  ------------------
  |  Branch (1761:25): [True: 11.4M, False: 0]
  ------------------
 1762|  11.4M|                {
 1763|  11.4M|                case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1763:17): [True: 11.4M, False: 0]
  ------------------
 1764|  11.4M|                    if (unquoted_empty_value_is_null_ && buffer_.empty())
  ------------------
  |  Branch (1764:25): [True: 0, False: 11.4M]
  |  Branch (1764:58): [True: 0, False: 0]
  ------------------
 1765|      0|                    {
 1766|      0|                        visitor.null_value(semantic_tag::none, *this, ec);
 1767|      0|                        more_ = !cursor_mode_;
 1768|      0|                    }
 1769|  11.4M|                    else
 1770|  11.4M|                    {
 1771|  11.4M|                        end_value(visitor, infer_types_, ec);
 1772|  11.4M|                    }
 1773|  11.4M|                    break;
 1774|      0|                case csv_mapping_kind::n_objects:
  ------------------
  |  Branch (1774:17): [True: 0, False: 11.4M]
  ------------------
 1775|      0|                    if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1775:27): [True: 0, False: 0]
  |  Branch (1775:51): [True: 0, False: 0]
  ------------------
 1776|      0|                    {
 1777|      0|                        if (column_index_ < column_names_.size() + offset_)
  ------------------
  |  Branch (1777:29): [True: 0, False: 0]
  ------------------
 1778|      0|                        {
 1779|      0|                            if (unquoted_empty_value_is_null_ && buffer_.empty())
  ------------------
  |  Branch (1779:33): [True: 0, False: 0]
  |  Branch (1779:66): [True: 0, False: 0]
  ------------------
 1780|      0|                            {
 1781|      0|                                visitor.null_value(semantic_tag::none, *this, ec);
 1782|      0|                                more_ = !cursor_mode_;
 1783|      0|                            }
 1784|      0|                            else
 1785|      0|                            {
 1786|      0|                                end_value(visitor, infer_types_, ec);
 1787|      0|                            }
 1788|      0|                        }
 1789|      0|                        else if (depth_ > 0)
  ------------------
  |  Branch (1789:34): [True: 0, False: 0]
  ------------------
 1790|      0|                        {
 1791|      0|                            if (unquoted_empty_value_is_null_ && buffer_.empty())
  ------------------
  |  Branch (1791:33): [True: 0, False: 0]
  |  Branch (1791:66): [True: 0, False: 0]
  ------------------
 1792|      0|                            {
 1793|      0|                                visitor.null_value(semantic_tag::none, *this, ec);
 1794|      0|                                more_ = !cursor_mode_;
 1795|      0|                            }
 1796|      0|                            else
 1797|      0|                            {
 1798|      0|                                end_value(visitor, infer_types_, ec);
 1799|      0|                            }
 1800|      0|                        }
 1801|      0|                    }
 1802|      0|                    break;
 1803|      0|                case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (1803:17): [True: 0, False: 11.4M]
  ------------------
 1804|      0|                    if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1804:27): [True: 0, False: 0]
  |  Branch (1804:51): [True: 0, False: 0]
  ------------------
 1805|      0|                    {
 1806|      0|                        end_value(visitor, infer_types_, ec);
 1807|      0|                    }
 1808|      0|                    else
 1809|      0|                    {
 1810|      0|                        m_columns_filter_.skip_column();
 1811|      0|                    }
 1812|      0|                    break;
 1813|  11.4M|                }
 1814|  11.4M|                break;
 1815|  12.5M|            default:
  ------------------
  |  Branch (1815:13): [True: 12.5M, False: 11.4M]
  ------------------
 1816|  12.5M|                break;
 1817|  24.0M|        }
 1818|  24.0M|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE9end_valueERNS_18basic_json_visitorIcEEbRNS2_10error_codeE:
 1884|  11.4M|    {
 1885|  11.4M|        auto it = std::find_if(string_double_map_.begin(), string_double_map_.end(), string_maps_to_double{ buffer_ });
 1886|  11.4M|        if (it != string_double_map_.end())
  ------------------
  |  Branch (1886:13): [True: 0, False: 11.4M]
  ------------------
 1887|      0|        {
 1888|      0|            visitor.double_value((*it).second, semantic_tag::none, *this, ec);
 1889|      0|            more_ = !cursor_mode_;
 1890|      0|        }
 1891|  11.4M|        else if (column_index_ < column_types_.size() + offset_)
  ------------------
  |  Branch (1891:18): [True: 0, False: 11.4M]
  ------------------
 1892|      0|        {
 1893|      0|            if (column_types_[column_index_ - offset_].col_type == csv_column_type::repeat_t)
  ------------------
  |  Branch (1893:17): [True: 0, False: 0]
  ------------------
 1894|      0|            {
 1895|      0|                offset_ = offset_ + column_types_[column_index_ - offset_].rep_count;
 1896|      0|                if (column_index_ - offset_ + 1 < column_types_.size())
  ------------------
  |  Branch (1896:21): [True: 0, False: 0]
  ------------------
 1897|      0|                {
 1898|      0|                    if (column_index_ == offset_ || depth_ > column_types_[column_index_-offset_].level)
  ------------------
  |  Branch (1898:25): [True: 0, False: 0]
  |  Branch (1898:53): [True: 0, False: 0]
  ------------------
 1899|      0|                    {
 1900|      0|                        visitor.end_array(*this, ec);
 1901|      0|                        more_ = !cursor_mode_;
 1902|      0|                        if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (1902:29): [True: 0, False: 0]
  ------------------
 1903|      0|                        {
 1904|      0|                            if (level() == mark_level_)
  ------------------
  |  Branch (1904:33): [True: 0, False: 0]
  ------------------
 1905|      0|                            {
 1906|      0|                                more_ = false;
 1907|      0|                            }
 1908|      0|                        }
 1909|      0|                        --level_;
 1910|      0|                    }
 1911|      0|                    depth_ = column_index_ == offset_ ? 0 : column_types_[column_index_ - offset_].level;
  ------------------
  |  Branch (1911:30): [True: 0, False: 0]
  ------------------
 1912|      0|                }
 1913|      0|            }
 1914|      0|            if (depth_ < column_types_[column_index_ - offset_].level)
  ------------------
  |  Branch (1914:17): [True: 0, False: 0]
  ------------------
 1915|      0|            {
 1916|      0|                visitor.begin_array(semantic_tag::none, *this, ec);
 1917|      0|                more_ = !cursor_mode_;
 1918|      0|                depth_ = column_types_[column_index_ - offset_].level;
 1919|      0|                ++level_;
 1920|      0|            }
 1921|      0|            else if (depth_ > column_types_[column_index_ - offset_].level)
  ------------------
  |  Branch (1921:22): [True: 0, False: 0]
  ------------------
 1922|      0|            {
 1923|      0|                visitor.end_array(*this, ec);
 1924|      0|                more_ = !cursor_mode_;
 1925|      0|                if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (1925:21): [True: 0, False: 0]
  ------------------
 1926|      0|                {
 1927|      0|                    if (level() == mark_level_)
  ------------------
  |  Branch (1927:25): [True: 0, False: 0]
  ------------------
 1928|      0|                    {
 1929|      0|                        more_ = false;
 1930|      0|                    }
 1931|      0|                }
 1932|      0|                --level_;
 1933|      0|                depth_ = column_types_[column_index_ - offset_].level;
 1934|      0|            }
 1935|      0|            switch (column_types_[column_index_ - offset_].col_type)
 1936|      0|            {
 1937|      0|                case csv_column_type::integer_t:
  ------------------
  |  Branch (1937:17): [True: 0, False: 0]
  ------------------
 1938|      0|                    {
 1939|      0|                        std::basic_istringstream<CharT,std::char_traits<CharT>,char_allocator_type> iss{buffer_};
 1940|      0|                        int64_t val;
 1941|      0|                        iss >> val;
 1942|      0|                        if (!iss.fail())
  ------------------
  |  Branch (1942:29): [True: 0, False: 0]
  ------------------
 1943|      0|                        {
 1944|      0|                            visitor.int64_value(val, semantic_tag::none, *this, ec);
 1945|      0|                            more_ = !cursor_mode_;
 1946|      0|                        }
 1947|      0|                        else
 1948|      0|                        {
 1949|      0|                            if (column_index_ - offset_ < column_defaults_.size() && column_defaults_[column_index_ - offset_].length() > 0)
  ------------------
  |  Branch (1949:33): [True: 0, False: 0]
  |  Branch (1949:86): [True: 0, False: 0]
  ------------------
 1950|      0|                            {
 1951|      0|                                basic_json_parser<CharT,temp_allocator_type> parser(alloc_);
 1952|      0|                                parser.update(column_defaults_[column_index_ - offset_].data(),column_defaults_[column_index_ - offset_].length());
 1953|      0|                                parser.parse_some(visitor);
 1954|      0|                                parser.finish_parse(visitor);
 1955|      0|                            }
 1956|      0|                            else
 1957|      0|                            {
 1958|      0|                                visitor.null_value(semantic_tag::none, *this, ec);
 1959|      0|                                more_ = !cursor_mode_;
 1960|      0|                            }
 1961|      0|                        }
 1962|      0|                    }
 1963|      0|                    break;
 1964|      0|                case csv_column_type::float_t:
  ------------------
  |  Branch (1964:17): [True: 0, False: 0]
  ------------------
 1965|      0|                    {
 1966|      0|                        if (lossless_number_)
  ------------------
  |  Branch (1966:29): [True: 0, False: 0]
  ------------------
 1967|      0|                        {
 1968|      0|                            visitor.string_value(buffer_,semantic_tag::bigdec, *this, ec);
 1969|      0|                            more_ = !cursor_mode_;
 1970|      0|                        }
 1971|      0|                        else
 1972|      0|                        {
 1973|      0|                            std::basic_istringstream<CharT, std::char_traits<CharT>, char_allocator_type> iss{ buffer_ };
 1974|      0|                            double val;
 1975|      0|                            iss >> val;
 1976|      0|                            if (!iss.fail())
  ------------------
  |  Branch (1976:33): [True: 0, False: 0]
  ------------------
 1977|      0|                            {
 1978|      0|                                visitor.double_value(val, semantic_tag::none, *this, ec);
 1979|      0|                                more_ = !cursor_mode_;
 1980|      0|                            }
 1981|      0|                            else
 1982|      0|                            {
 1983|      0|                                if (column_index_ - offset_ < column_defaults_.size() && column_defaults_[column_index_ - offset_].length() > 0)
  ------------------
  |  Branch (1983:37): [True: 0, False: 0]
  |  Branch (1983:90): [True: 0, False: 0]
  ------------------
 1984|      0|                                {
 1985|      0|                                    basic_json_parser<CharT,temp_allocator_type> parser(alloc_);
 1986|      0|                                    parser.update(column_defaults_[column_index_ - offset_].data(),column_defaults_[column_index_ - offset_].length());
 1987|      0|                                    parser.parse_some(visitor);
 1988|      0|                                    parser.finish_parse(visitor);
 1989|      0|                                }
 1990|      0|                                else
 1991|      0|                                {
 1992|      0|                                    visitor.null_value(semantic_tag::none, *this, ec);
 1993|      0|                                    more_ = !cursor_mode_;
 1994|      0|                                }
 1995|      0|                            }
 1996|      0|                        }
 1997|      0|                    }
 1998|      0|                    break;
 1999|      0|                case csv_column_type::boolean_t:
  ------------------
  |  Branch (1999:17): [True: 0, False: 0]
  ------------------
 2000|      0|                    {
 2001|      0|                        if (buffer_.length() == 1 && buffer_[0] == '0')
  ------------------
  |  Branch (2001:29): [True: 0, False: 0]
  |  Branch (2001:54): [True: 0, False: 0]
  ------------------
 2002|      0|                        {
 2003|      0|                            visitor.bool_value(false, semantic_tag::none, *this, ec);
 2004|      0|                            more_ = !cursor_mode_;
 2005|      0|                        }
 2006|      0|                        else if (buffer_.length() == 1 && buffer_[0] == '1')
  ------------------
  |  Branch (2006:34): [True: 0, False: 0]
  |  Branch (2006:59): [True: 0, False: 0]
  ------------------
 2007|      0|                        {
 2008|      0|                            visitor.bool_value(true, semantic_tag::none, *this, ec);
 2009|      0|                            more_ = !cursor_mode_;
 2010|      0|                        }
 2011|      0|                        else if (buffer_.length() == 5 && ((buffer_[0] == 'f' || buffer_[0] == 'F') && (buffer_[1] == 'a' || buffer_[1] == 'A') && (buffer_[2] == 'l' || buffer_[2] == 'L') && (buffer_[3] == 's' || buffer_[3] == 'S') && (buffer_[4] == 'e' || buffer_[4] == 'E')))
  ------------------
  |  Branch (2011:34): [True: 0, False: 0]
  |  Branch (2011:61): [True: 0, False: 0]
  |  Branch (2011:82): [True: 0, False: 0]
  |  Branch (2011:105): [True: 0, False: 0]
  |  Branch (2011:126): [True: 0, False: 0]
  |  Branch (2011:149): [True: 0, False: 0]
  |  Branch (2011:170): [True: 0, False: 0]
  |  Branch (2011:193): [True: 0, False: 0]
  |  Branch (2011:214): [True: 0, False: 0]
  |  Branch (2011:237): [True: 0, False: 0]
  |  Branch (2011:258): [True: 0, False: 0]
  ------------------
 2012|      0|                        {
 2013|      0|                            visitor.bool_value(false, semantic_tag::none, *this, ec);
 2014|      0|                            more_ = !cursor_mode_;
 2015|      0|                        }
 2016|      0|                        else if (buffer_.length() == 4 && ((buffer_[0] == 't' || buffer_[0] == 'T') && (buffer_[1] == 'r' || buffer_[1] == 'R') && (buffer_[2] == 'u' || buffer_[2] == 'U') && (buffer_[3] == 'e' || buffer_[3] == 'E')))
  ------------------
  |  Branch (2016:34): [True: 0, False: 0]
  |  Branch (2016:61): [True: 0, False: 0]
  |  Branch (2016:82): [True: 0, False: 0]
  |  Branch (2016:105): [True: 0, False: 0]
  |  Branch (2016:126): [True: 0, False: 0]
  |  Branch (2016:149): [True: 0, False: 0]
  |  Branch (2016:170): [True: 0, False: 0]
  |  Branch (2016:193): [True: 0, False: 0]
  |  Branch (2016:214): [True: 0, False: 0]
  ------------------
 2017|      0|                        {
 2018|      0|                            visitor.bool_value(true, semantic_tag::none, *this, ec);
 2019|      0|                            more_ = !cursor_mode_;
 2020|      0|                        }
 2021|      0|                        else
 2022|      0|                        {
 2023|      0|                            if (column_index_ - offset_ < column_defaults_.size() && column_defaults_[column_index_ - offset_].length() > 0)
  ------------------
  |  Branch (2023:33): [True: 0, False: 0]
  |  Branch (2023:86): [True: 0, False: 0]
  ------------------
 2024|      0|                            {
 2025|      0|                                basic_json_parser<CharT,temp_allocator_type> parser(alloc_);
 2026|      0|                                parser.update(column_defaults_[column_index_ - offset_].data(),column_defaults_[column_index_ - offset_].length());
 2027|      0|                                parser.parse_some(visitor);
 2028|      0|                                parser.finish_parse(visitor);
 2029|      0|                            }
 2030|      0|                            else
 2031|      0|                            {
 2032|      0|                                visitor.null_value(semantic_tag::none, *this, ec);
 2033|      0|                                more_ = !cursor_mode_;
 2034|      0|                            }
 2035|      0|                        }
 2036|      0|                    }
 2037|      0|                    break;
 2038|      0|                default:
  ------------------
  |  Branch (2038:17): [True: 0, False: 0]
  ------------------
 2039|      0|                    if (buffer_.length() > 0)
  ------------------
  |  Branch (2039:25): [True: 0, False: 0]
  ------------------
 2040|      0|                    {
 2041|      0|                        visitor.string_value(buffer_, semantic_tag::none, *this, ec);
 2042|      0|                        more_ = !cursor_mode_;
 2043|      0|                    }
 2044|      0|                    else
 2045|      0|                    {
 2046|      0|                        if (column_index_ < column_defaults_.size() + offset_ && column_defaults_[column_index_ - offset_].length() > 0)
  ------------------
  |  Branch (2046:29): [True: 0, False: 0]
  |  Branch (2046:82): [True: 0, False: 0]
  ------------------
 2047|      0|                        {
 2048|      0|                            basic_json_parser<CharT,temp_allocator_type> parser(alloc_);
 2049|      0|                            parser.update(column_defaults_[column_index_ - offset_].data(),column_defaults_[column_index_ - offset_].length());
 2050|      0|                            parser.parse_some(visitor);
 2051|      0|                            parser.finish_parse(visitor);
 2052|      0|                        }
 2053|      0|                        else
 2054|      0|                        {
 2055|      0|                            visitor.string_value(string_view_type(), semantic_tag::none, *this, ec);
 2056|      0|                            more_ = !cursor_mode_;
 2057|      0|                        }
 2058|      0|                    }
 2059|      0|                    break;  
 2060|      0|            }
 2061|      0|        }
 2062|  11.4M|        else
 2063|  11.4M|        {
 2064|  11.4M|            if (infer_types)
  ------------------
  |  Branch (2064:17): [True: 11.4M, False: 2.01k]
  ------------------
 2065|  11.4M|            {
 2066|  11.4M|                end_value_with_numeric_check(visitor, ec);
 2067|  11.4M|            }
 2068|  2.01k|            else
 2069|  2.01k|            {
 2070|  2.01k|                visitor.string_value(buffer_, semantic_tag::none, *this, ec);
 2071|  2.01k|                more_ = !cursor_mode_;
 2072|  2.01k|            }
 2073|  11.4M|        }
 2074|  11.4M|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE28end_value_with_numeric_checkERNS_18basic_json_visitorIcEERNS2_10error_codeE:
 2097|  11.4M|    {
 2098|  11.4M|        numeric_check_state state = numeric_check_state::initial;
 2099|  11.4M|        bool is_negative = false;
 2100|       |        //int precision = 0;
 2101|       |        //uint8_t decimal_places = 0;
 2102|       |
 2103|  11.4M|        auto last = buffer_.end();
 2104|       |
 2105|  11.4M|        std::string buffer;
 2106|  26.2M|        for (auto p = buffer_.begin(); state != numeric_check_state::not_a_number && p != last; ++p)
  ------------------
  |  Branch (2106:40): [True: 23.4M, False: 2.79M]
  |  Branch (2106:86): [True: 14.7M, False: 8.70M]
  ------------------
 2107|  14.7M|        {
 2108|  14.7M|            switch (state)
 2109|  14.7M|            {
 2110|  3.79M|                case numeric_check_state::initial:
  ------------------
  |  Branch (2110:17): [True: 3.79M, False: 10.9M]
  ------------------
 2111|  3.79M|                {
 2112|  3.79M|                    switch (*p)
 2113|  3.79M|                    {
 2114|   182k|                    case 'n':case 'N':
  ------------------
  |  Branch (2114:21): [True: 1.54k, False: 3.79M]
  |  Branch (2114:30): [True: 180k, False: 3.61M]
  ------------------
 2115|   182k|                        if ((last-p) == 4 && (p[1] == 'u' || p[1] == 'U') && (p[2] == 'l' || p[2] == 'L') && (p[3] == 'l' || p[3] == 'L'))
  ------------------
  |  Branch (2115:29): [True: 162k, False: 20.1k]
  |  Branch (2115:47): [True: 5.26k, False: 156k]
  |  Branch (2115:62): [True: 154k, False: 2.21k]
  |  Branch (2115:79): [True: 156k, False: 3.41k]
  |  Branch (2115:94): [True: 797, False: 2.61k]
  |  Branch (2115:111): [True: 91.6k, False: 65.5k]
  |  Branch (2115:126): [True: 64.5k, False: 1.00k]
  ------------------
 2116|   156k|                        {
 2117|   156k|                            state = numeric_check_state::null;
 2118|   156k|                        }
 2119|  26.0k|                        else
 2120|  26.0k|                        {
 2121|  26.0k|                            state = numeric_check_state::not_a_number;
 2122|  26.0k|                        }
 2123|   182k|                        break;
 2124|   180k|                    case 't':case 'T':
  ------------------
  |  Branch (2124:21): [True: 3.77k, False: 3.79M]
  |  Branch (2124:30): [True: 176k, False: 3.61M]
  ------------------
 2125|   180k|                        if ((last-p) == 4 && (p[1] == 'r' || p[1] == 'R') && (p[2] == 'u' || p[2] == 'U') && (p[3] == 'e' || p[3] == 'U'))
  ------------------
  |  Branch (2125:29): [True: 170k, False: 10.2k]
  |  Branch (2125:47): [True: 163k, False: 6.88k]
  |  Branch (2125:62): [True: 6.01k, False: 874]
  |  Branch (2125:79): [True: 168k, False: 1.30k]
  |  Branch (2125:94): [True: 799, False: 506]
  |  Branch (2125:111): [True: 166k, False: 2.06k]
  |  Branch (2125:126): [True: 793, False: 1.27k]
  ------------------
 2126|   167k|                        {
 2127|   167k|                            state = numeric_check_state::boolean_true;
 2128|   167k|                        }
 2129|  12.8k|                        else
 2130|  12.8k|                        {
 2131|  12.8k|                            state = numeric_check_state::not_a_number;
 2132|  12.8k|                        }
 2133|   180k|                        break;
 2134|  15.8k|                    case 'f':case 'F':
  ------------------
  |  Branch (2134:21): [True: 6.16k, False: 3.78M]
  |  Branch (2134:30): [True: 9.70k, False: 3.78M]
  ------------------
 2135|  15.8k|                        if ((last-p) == 5 && (p[1] == 'a' || p[1] == 'A') && (p[2] == 'l' || p[2] == 'L') && (p[3] == 's' || p[3] == 'S') && (p[4] == 'e' || p[4] == 'E'))
  ------------------
  |  Branch (2135:29): [True: 9.16k, False: 6.71k]
  |  Branch (2135:47): [True: 3.75k, False: 5.40k]
  |  Branch (2135:62): [True: 5.14k, False: 266]
  |  Branch (2135:79): [True: 7.21k, False: 1.68k]
  |  Branch (2135:94): [True: 550, False: 1.13k]
  |  Branch (2135:111): [True: 3.72k, False: 4.04k]
  |  Branch (2135:126): [True: 3.50k, False: 540]
  |  Branch (2135:143): [True: 1.29k, False: 5.93k]
  |  Branch (2135:158): [True: 2.57k, False: 3.35k]
  ------------------
 2136|  3.86k|                        {
 2137|  3.86k|                            state = numeric_check_state::boolean_false;
 2138|  3.86k|                        }
 2139|  12.0k|                        else
 2140|  12.0k|                        {
 2141|  12.0k|                            state = numeric_check_state::not_a_number;
 2142|  12.0k|                        }
 2143|  15.8k|                        break;
 2144|   442k|                    case '-':
  ------------------
  |  Branch (2144:21): [True: 442k, False: 3.35M]
  ------------------
 2145|   442k|                        is_negative = true;
 2146|   442k|                        buffer.push_back(*p);
 2147|   442k|                        state = numeric_check_state::minus;
 2148|   442k|                        break;
 2149|  82.3k|                    case '0':
  ------------------
  |  Branch (2149:21): [True: 82.3k, False: 3.71M]
  ------------------
 2150|       |                        //++precision;
 2151|  82.3k|                        buffer.push_back(*p);
 2152|  82.3k|                        state = numeric_check_state::zero;
 2153|  82.3k|                        break;
 2154|   180k|                    case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2154:21): [True: 12.5k, False: 3.78M]
  |  Branch (2154:30): [True: 8.15k, False: 3.78M]
  |  Branch (2154:39): [True: 134k, False: 3.66M]
  |  Branch (2154:48): [True: 6.20k, False: 3.78M]
  |  Branch (2154:57): [True: 6.21k, False: 3.78M]
  |  Branch (2154:66): [True: 2.91k, False: 3.79M]
  |  Branch (2154:75): [True: 6.83k, False: 3.78M]
  |  Branch (2154:84): [True: 1.97k, False: 3.79M]
  |  Branch (2154:93): [True: 1.65k, False: 3.79M]
  ------------------
 2155|       |                        //++precision;
 2156|   180k|                        buffer.push_back(*p);
 2157|   180k|                        state = numeric_check_state::integer;
 2158|   180k|                        break;
 2159|  2.71M|                    default:
  ------------------
  |  Branch (2159:21): [True: 2.71M, False: 1.08M]
  ------------------
 2160|  2.71M|                        state = numeric_check_state::not_a_number;
 2161|  2.71M|                        break;
 2162|  3.79M|                    }
 2163|  3.79M|                    break;
 2164|  3.79M|                }
 2165|  3.79M|                case numeric_check_state::zero:
  ------------------
  |  Branch (2165:17): [True: 49.1k, False: 14.7M]
  ------------------
 2166|  49.1k|                {
 2167|  49.1k|                    switch (*p)
 2168|  49.1k|                    {
 2169|  35.3k|                        case '.':
  ------------------
  |  Branch (2169:25): [True: 35.3k, False: 13.7k]
  ------------------
 2170|  35.3k|                        {
 2171|  35.3k|                            buffer.push_back('.');
 2172|  35.3k|                            state = numeric_check_state::fraction1;
 2173|  35.3k|                        }
 2174|  35.3k|                        break;
 2175|  3.29k|                    case 'e':case 'E':
  ------------------
  |  Branch (2175:21): [True: 1.38k, False: 47.7k]
  |  Branch (2175:30): [True: 1.91k, False: 47.2k]
  ------------------
 2176|  3.29k|                        buffer.push_back(*p);
 2177|  3.29k|                        state = numeric_check_state::exp1;
 2178|  3.29k|                        break;
 2179|  10.5k|                    default:
  ------------------
  |  Branch (2179:21): [True: 10.5k, False: 38.6k]
  ------------------
 2180|  10.5k|                        state = numeric_check_state::not_a_number;
 2181|  10.5k|                        break;
 2182|  49.1k|                    }
 2183|  49.1k|                    break;
 2184|  49.1k|                }
 2185|  9.34M|                case numeric_check_state::integer:
  ------------------
  |  Branch (2185:17): [True: 9.34M, False: 5.40M]
  ------------------
 2186|  9.34M|                {
 2187|  9.34M|                    switch (*p)
 2188|  9.34M|                    {
 2189|  9.31M|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2189:21): [True: 7.16M, False: 2.17M]
  |  Branch (2189:30): [True: 187k, False: 9.15M]
  |  Branch (2189:39): [True: 140k, False: 9.20M]
  |  Branch (2189:48): [True: 569k, False: 8.77M]
  |  Branch (2189:57): [True: 26.0k, False: 9.31M]
  |  Branch (2189:66): [True: 592k, False: 8.75M]
  |  Branch (2189:75): [True: 32.9k, False: 9.31M]
  |  Branch (2189:84): [True: 27.7k, False: 9.31M]
  |  Branch (2189:93): [True: 426k, False: 8.91M]
  |  Branch (2189:102): [True: 147k, False: 9.19M]
  ------------------
 2190|       |                        //++precision;
 2191|  9.31M|                        buffer.push_back(*p);
 2192|  9.31M|                        break;
 2193|  10.6k|                    case '.':
  ------------------
  |  Branch (2193:21): [True: 10.6k, False: 9.33M]
  ------------------
 2194|  10.6k|                        buffer.push_back('.');
 2195|  10.6k|                        state = numeric_check_state::fraction1;
 2196|  10.6k|                        break;
 2197|  11.7k|                    case 'e':case 'E':
  ------------------
  |  Branch (2197:21): [True: 6.02k, False: 9.33M]
  |  Branch (2197:30): [True: 5.76k, False: 9.34M]
  ------------------
 2198|  11.7k|                        buffer.push_back(*p);
 2199|  11.7k|                        state = numeric_check_state::exp1;
 2200|  11.7k|                        break;
 2201|  6.01k|                    default:
  ------------------
  |  Branch (2201:21): [True: 6.01k, False: 9.33M]
  ------------------
 2202|  6.01k|                        state = numeric_check_state::not_a_number;
 2203|  6.01k|                        break;
 2204|  9.34M|                    }
 2205|  9.34M|                    break;
 2206|  9.34M|                }
 2207|  9.34M|                case numeric_check_state::minus:
  ------------------
  |  Branch (2207:17): [True: 411k, False: 14.3M]
  ------------------
 2208|   411k|                {
 2209|   411k|                    switch (*p)
 2210|   411k|                    {
 2211|   382k|                    case '0':
  ------------------
  |  Branch (2211:21): [True: 382k, False: 28.5k]
  ------------------
 2212|       |                        //++precision;
 2213|   382k|                        buffer.push_back(*p);
 2214|   382k|                        state = numeric_check_state::zero;
 2215|   382k|                        break;
 2216|  20.8k|                    case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2216:21): [True: 3.23k, False: 407k]
  |  Branch (2216:30): [True: 983, False: 410k]
  |  Branch (2216:39): [True: 8.29k, False: 402k]
  |  Branch (2216:48): [True: 1.63k, False: 409k]
  |  Branch (2216:57): [True: 805, False: 410k]
  |  Branch (2216:66): [True: 889, False: 410k]
  |  Branch (2216:75): [True: 435, False: 410k]
  |  Branch (2216:84): [True: 719, False: 410k]
  |  Branch (2216:93): [True: 3.83k, False: 407k]
  ------------------
 2217|       |                        //++precision;
 2218|  20.8k|                        buffer.push_back(*p);
 2219|  20.8k|                        state = numeric_check_state::integer;
 2220|  20.8k|                        break;
 2221|  7.71k|                    default:
  ------------------
  |  Branch (2221:21): [True: 7.71k, False: 403k]
  ------------------
 2222|  7.71k|                        state = numeric_check_state::not_a_number;
 2223|  7.71k|                        break;
 2224|   411k|                    }
 2225|   411k|                    break;
 2226|   411k|                }
 2227|   411k|                case numeric_check_state::fraction1:
  ------------------
  |  Branch (2227:17): [True: 43.7k, False: 14.7M]
  ------------------
 2228|  43.7k|                {
 2229|  43.7k|                    switch (*p)
 2230|  43.7k|                    {
 2231|  42.2k|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2231:21): [True: 2.90k, False: 40.8k]
  |  Branch (2231:30): [True: 538, False: 43.2k]
  |  Branch (2231:39): [True: 845, False: 42.9k]
  |  Branch (2231:48): [True: 117, False: 43.6k]
  |  Branch (2231:57): [True: 116, False: 43.6k]
  |  Branch (2231:66): [True: 420, False: 43.3k]
  |  Branch (2231:75): [True: 707, False: 43.0k]
  |  Branch (2231:84): [True: 2.04k, False: 41.7k]
  |  Branch (2231:93): [True: 33.8k, False: 9.89k]
  |  Branch (2231:102): [True: 671, False: 43.1k]
  ------------------
 2232|       |                        //++precision;
 2233|       |                        //++decimal_places;
 2234|  42.2k|                        buffer.push_back(*p);
 2235|  42.2k|                        state = numeric_check_state::fraction;
 2236|  42.2k|                        break;
 2237|  1.53k|                    default:
  ------------------
  |  Branch (2237:21): [True: 1.53k, False: 42.2k]
  ------------------
 2238|  1.53k|                        state = numeric_check_state::not_a_number;
 2239|  1.53k|                        break;
 2240|  43.7k|                    }
 2241|  43.7k|                    break;
 2242|  43.7k|                }
 2243|  62.7k|                case numeric_check_state::fraction:
  ------------------
  |  Branch (2243:17): [True: 62.7k, False: 14.6M]
  ------------------
 2244|  62.7k|                {
 2245|  62.7k|                    switch (*p)
 2246|  62.7k|                    {
 2247|  60.8k|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2247:21): [True: 41.6k, False: 21.0k]
  |  Branch (2247:30): [True: 1.62k, False: 61.1k]
  |  Branch (2247:39): [True: 1.22k, False: 61.5k]
  |  Branch (2247:48): [True: 4.49k, False: 58.2k]
  |  Branch (2247:57): [True: 335, False: 62.4k]
  |  Branch (2247:66): [True: 4.49k, False: 58.2k]
  |  Branch (2247:75): [True: 348, False: 62.4k]
  |  Branch (2247:84): [True: 2.08k, False: 60.6k]
  |  Branch (2247:93): [True: 3.22k, False: 59.5k]
  |  Branch (2247:102): [True: 1.36k, False: 61.4k]
  ------------------
 2248|       |                        //++precision;
 2249|       |                        //++decimal_places;
 2250|  60.8k|                        buffer.push_back(*p);
 2251|  60.8k|                        break;
 2252|  1.00k|                    case 'e':case 'E':
  ------------------
  |  Branch (2252:21): [True: 197, False: 62.5k]
  |  Branch (2252:30): [True: 808, False: 61.9k]
  ------------------
 2253|  1.00k|                        buffer.push_back(*p);
 2254|  1.00k|                        state = numeric_check_state::exp1;
 2255|  1.00k|                        break;
 2256|    880|                    default:
  ------------------
  |  Branch (2256:21): [True: 880, False: 61.8k]
  ------------------
 2257|    880|                        state = numeric_check_state::not_a_number;
 2258|    880|                        break;
 2259|  62.7k|                    }
 2260|  62.7k|                    break;
 2261|  62.7k|                }
 2262|  62.7k|                case numeric_check_state::exp1:
  ------------------
  |  Branch (2262:17): [True: 13.4k, False: 14.7M]
  ------------------
 2263|  13.4k|                {
 2264|  13.4k|                    switch (*p)
 2265|  13.4k|                    {
 2266|  2.05k|                    case '-':
  ------------------
  |  Branch (2266:21): [True: 2.05k, False: 11.3k]
  ------------------
 2267|  2.05k|                        buffer.push_back(*p);
 2268|  2.05k|                        break;
 2269|    511|                    case '+':
  ------------------
  |  Branch (2269:21): [True: 511, False: 12.9k]
  ------------------
 2270|    511|                        break;
 2271|  10.4k|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2271:21): [True: 375, False: 13.0k]
  |  Branch (2271:30): [True: 593, False: 12.8k]
  |  Branch (2271:39): [True: 2.24k, False: 11.2k]
  |  Branch (2271:48): [True: 561, False: 12.8k]
  |  Branch (2271:57): [True: 963, False: 12.4k]
  |  Branch (2271:66): [True: 634, False: 12.8k]
  |  Branch (2271:75): [True: 854, False: 12.5k]
  |  Branch (2271:84): [True: 878, False: 12.5k]
  |  Branch (2271:93): [True: 1.35k, False: 12.0k]
  |  Branch (2271:102): [True: 1.98k, False: 11.4k]
  ------------------
 2272|  10.4k|                        state = numeric_check_state::exp;
 2273|  10.4k|                        buffer.push_back(*p);
 2274|  10.4k|                        break;
 2275|    440|                    default:
  ------------------
  |  Branch (2275:21): [True: 440, False: 13.0k]
  ------------------
 2276|    440|                        state = numeric_check_state::not_a_number;
 2277|    440|                        break;
 2278|  13.4k|                    }
 2279|  13.4k|                    break;
 2280|  13.4k|                }
 2281|  46.4k|                case numeric_check_state::exp:
  ------------------
  |  Branch (2281:17): [True: 46.4k, False: 14.7M]
  ------------------
 2282|  46.4k|                {
 2283|  46.4k|                    switch (*p)
 2284|  46.4k|                    {
 2285|  43.3k|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2285:21): [True: 4.11k, False: 42.3k]
  |  Branch (2285:30): [True: 3.24k, False: 43.1k]
  |  Branch (2285:39): [True: 1.70k, False: 44.7k]
  |  Branch (2285:48): [True: 6.54k, False: 39.8k]
  |  Branch (2285:57): [True: 805, False: 45.6k]
  |  Branch (2285:66): [True: 6.71k, False: 39.7k]
  |  Branch (2285:75): [True: 549, False: 45.8k]
  |  Branch (2285:84): [True: 460, False: 45.9k]
  |  Branch (2285:93): [True: 4.90k, False: 41.5k]
  |  Branch (2285:102): [True: 14.2k, False: 32.1k]
  ------------------
 2286|  43.3k|                        buffer.push_back(*p);
 2287|  43.3k|                        break;
 2288|  3.11k|                    default:
  ------------------
  |  Branch (2288:21): [True: 3.11k, False: 43.3k]
  ------------------
 2289|  3.11k|                        state = numeric_check_state::not_a_number;
 2290|  3.11k|                        break;
 2291|  46.4k|                    }
 2292|  46.4k|                    break;
 2293|  46.4k|                }
 2294|   987k|                default:
  ------------------
  |  Branch (2294:17): [True: 987k, False: 13.7M]
  ------------------
 2295|   987k|                    break;
 2296|  14.7M|            }
 2297|  14.7M|        }
 2298|       |
 2299|  11.4M|        switch (state)
 2300|  11.4M|        {
 2301|   156k|            case numeric_check_state::null:
  ------------------
  |  Branch (2301:13): [True: 156k, False: 11.3M]
  ------------------
 2302|   156k|                visitor.null_value(semantic_tag::none, *this, ec);
 2303|   156k|                more_ = !cursor_mode_;
 2304|   156k|                break;
 2305|   167k|            case numeric_check_state::boolean_true:
  ------------------
  |  Branch (2305:13): [True: 167k, False: 11.3M]
  ------------------
 2306|   167k|                visitor.bool_value(true, semantic_tag::none, *this, ec);
 2307|   167k|                more_ = !cursor_mode_;
 2308|   167k|                break;
 2309|  3.86k|            case numeric_check_state::boolean_false:
  ------------------
  |  Branch (2309:13): [True: 3.86k, False: 11.4M]
  ------------------
 2310|  3.86k|                visitor.bool_value(false, semantic_tag::none, *this, ec);
 2311|  3.86k|                more_ = !cursor_mode_;
 2312|  3.86k|                break;
 2313|   415k|            case numeric_check_state::zero:
  ------------------
  |  Branch (2313:13): [True: 415k, False: 11.0M]
  ------------------
 2314|   589k|            case numeric_check_state::integer:
  ------------------
  |  Branch (2314:13): [True: 173k, False: 11.3M]
  ------------------
 2315|   589k|            {
 2316|   589k|                if (is_negative)
  ------------------
  |  Branch (2316:21): [True: 390k, False: 198k]
  ------------------
 2317|   390k|                {
 2318|   390k|                    int64_t val{ 0 };
 2319|   390k|                    auto result = jsoncons::dec_to_integer(buffer_.data(), buffer_.length(), val);
 2320|   390k|                    if (result)
  ------------------
  |  Branch (2320:25): [True: 388k, False: 1.72k]
  ------------------
 2321|   388k|                    {
 2322|   388k|                        visitor.int64_value(val, semantic_tag::none, *this, ec);
 2323|   388k|                        more_ = !cursor_mode_;
 2324|   388k|                    }
 2325|  1.72k|                    else // Must be overflow
 2326|  1.72k|                    {
 2327|  1.72k|                        visitor.string_value(buffer_, semantic_tag::bigint, *this, ec);
 2328|  1.72k|                        more_ = !cursor_mode_;
 2329|  1.72k|                    }
 2330|   390k|                }
 2331|   198k|                else
 2332|   198k|                {
 2333|   198k|                    uint64_t val{ 0 };
 2334|   198k|                    auto result = jsoncons::dec_to_integer(buffer_.data(), buffer_.length(), val);
 2335|   198k|                    if (result)
  ------------------
  |  Branch (2335:25): [True: 196k, False: 2.15k]
  ------------------
 2336|   196k|                    {
 2337|   196k|                        visitor.uint64_value(val, semantic_tag::none, *this, ec);
 2338|   196k|                        more_ = !cursor_mode_;
 2339|   196k|                    }
 2340|  2.15k|                    else if (result.ec == std::errc::result_out_of_range)
  ------------------
  |  Branch (2340:30): [True: 2.15k, False: 0]
  ------------------
 2341|  2.15k|                    {
 2342|  2.15k|                        visitor.string_value(buffer_, semantic_tag::bigint, *this, ec);
 2343|  2.15k|                        more_ = !cursor_mode_;
 2344|  2.15k|                    }
 2345|      0|                    else
 2346|      0|                    {
 2347|      0|                        ec = csv_errc::invalid_number; 
 2348|      0|                        more_ = false;
 2349|      0|                        return;
 2350|      0|                    }
 2351|   198k|                }
 2352|   589k|                break;
 2353|   589k|            }
 2354|   589k|            case numeric_check_state::fraction:
  ------------------
  |  Branch (2354:13): [True: 40.3k, False: 11.4M]
  ------------------
 2355|  47.7k|            case numeric_check_state::exp:
  ------------------
  |  Branch (2355:13): [True: 7.33k, False: 11.4M]
  ------------------
 2356|  47.7k|            {
 2357|  47.7k|                if (lossless_number_)
  ------------------
  |  Branch (2357:21): [True: 0, False: 47.7k]
  ------------------
 2358|      0|                {
 2359|      0|                    visitor.string_value(buffer_,semantic_tag::bigdec, *this, ec);
 2360|      0|                    more_ = !cursor_mode_;
 2361|      0|                }
 2362|  47.7k|                else
 2363|  47.7k|                {
 2364|  47.7k|                    double d{0};
 2365|  47.7k|                    auto result = jsoncons::decstr_to_double(buffer.c_str(), buffer.length(), d);
 2366|  47.7k|                    if (result.ec == std::errc::result_out_of_range)
  ------------------
  |  Branch (2366:25): [True: 1.87k, False: 45.8k]
  ------------------
 2367|  1.87k|                    {
 2368|  1.87k|                        d = buffer.front() == '-' ? -HUGE_VAL : HUGE_VAL;
  ------------------
  |  Branch (2368:29): [True: 1.51k, False: 359]
  ------------------
 2369|  1.87k|                    }
 2370|  45.8k|                    else if (result.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (2370:30): [True: 4, False: 45.8k]
  ------------------
 2371|      4|                    {
 2372|      4|                        ec = csv_errc::invalid_number; 
 2373|      4|                        more_ = false;
 2374|      4|                        return;
 2375|      4|                    }
 2376|  47.7k|                    visitor.double_value(d, semantic_tag::none, *this, ec);
 2377|  47.7k|                    more_ = !cursor_mode_;
 2378|  47.7k|                }
 2379|  47.7k|                break;
 2380|  47.7k|            }
 2381|  10.5M|            default:
  ------------------
  |  Branch (2381:13): [True: 10.5M, False: 964k]
  ------------------
 2382|  10.5M|            {
 2383|  10.5M|                visitor.string_value(buffer_, semantic_tag::none, *this, ec);
 2384|  10.5M|                more_ = !cursor_mode_;
 2385|  10.5M|                break;
 2386|  47.7k|            }
 2387|  11.4M|        }
 2388|  11.4M|    } 
_ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE5levelEv:
  753|  3.39k|    {
  754|  3.39k|        return level_;
  755|  3.39k|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE12before_valueERNS_18basic_json_visitorIcEERNS2_10error_codeE:
 1525|  24.0M|    {
 1526|  24.0M|        switch (stack_.back())
 1527|  24.0M|        {
 1528|  12.5M|            case csv_mode::header:
  ------------------
  |  Branch (1528:13): [True: 12.5M, False: 11.4M]
  ------------------
 1529|  12.5M|                if (trim_leading_inside_quotes_ || trim_trailing_inside_quotes_)
  ------------------
  |  Branch (1529:21): [True: 0, False: 12.5M]
  |  Branch (1529:52): [True: 0, False: 12.5M]
  ------------------
 1530|      0|                {
 1531|      0|                    trim_string_buffer(trim_leading_inside_quotes_,trim_trailing_inside_quotes_);
 1532|      0|                }
 1533|  12.5M|                if (line_ == (header_line_+header_line_offset_) && column_index_ >= min_column_names_)
  ------------------
  |  Branch (1533:21): [True: 12.5M, False: 0]
  |  Branch (1533:68): [True: 12.5M, False: 0]
  ------------------
 1534|  12.5M|                {
 1535|  12.5M|                    column_names_.push_back(buffer_);
 1536|  12.5M|                    if (assume_header_ && mapping_kind_ == csv_mapping_kind::n_rows)
  ------------------
  |  Branch (1536:25): [True: 12.5M, False: 0]
  |  Branch (1536:43): [True: 12.5M, False: 0]
  ------------------
 1537|  12.5M|                    {
 1538|  12.5M|                        visitor.string_value(buffer_, semantic_tag::none, *this, ec);
 1539|  12.5M|                        more_ = !cursor_mode_;
 1540|  12.5M|                    }
 1541|  12.5M|                }
 1542|  12.5M|                break;
 1543|  11.4M|            case csv_mode::data:
  ------------------
  |  Branch (1543:13): [True: 11.4M, False: 12.5M]
  ------------------
 1544|  11.4M|                if (mapping_kind_ == csv_mapping_kind::n_objects)
  ------------------
  |  Branch (1544:21): [True: 0, False: 11.4M]
  ------------------
 1545|      0|                {
 1546|      0|                    if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1546:27): [True: 0, False: 0]
  |  Branch (1546:51): [True: 0, False: 0]
  ------------------
 1547|      0|                    {
 1548|      0|                        if (column_index_ < column_names_.size() + offset_)
  ------------------
  |  Branch (1548:29): [True: 0, False: 0]
  ------------------
 1549|      0|                        {
 1550|      0|                            visitor.key(column_names_[column_index_ - offset_], *this, ec);
 1551|      0|                            more_ = !cursor_mode_;
 1552|      0|                        }
 1553|      0|                    }
 1554|      0|                }
 1555|  11.4M|                break;
 1556|      0|            default:
  ------------------
  |  Branch (1556:13): [True: 0, False: 24.0M]
  ------------------
 1557|      0|                break;
 1558|  24.0M|        }
 1559|  24.0M|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE23end_quoted_string_valueERNS_18basic_json_visitorIcEERNS2_10error_codeE:
 1822|  2.94k|    {
 1823|  2.94k|        switch (stack_.back())
 1824|  2.94k|        {
 1825|  2.01k|            case csv_mode::data:
  ------------------
  |  Branch (1825:13): [True: 2.01k, False: 937]
  ------------------
 1826|  2.01k|            case csv_mode::subfields:
  ------------------
  |  Branch (1826:13): [True: 0, False: 2.94k]
  ------------------
 1827|  2.01k|                if (trim_leading_inside_quotes_ || trim_trailing_inside_quotes_)
  ------------------
  |  Branch (1827:21): [True: 0, False: 2.01k]
  |  Branch (1827:52): [True: 0, False: 2.01k]
  ------------------
 1828|      0|                {
 1829|      0|                    trim_string_buffer(trim_leading_inside_quotes_,trim_trailing_inside_quotes_);
 1830|      0|                }
 1831|  2.01k|                switch (mapping_kind_)
  ------------------
  |  Branch (1831:25): [True: 2.01k, False: 0]
  ------------------
 1832|  2.01k|                {
 1833|  2.01k|                case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1833:17): [True: 2.01k, False: 0]
  ------------------
 1834|  2.01k|                    end_value(visitor, false, ec);
 1835|  2.01k|                    break;
 1836|      0|                case csv_mapping_kind::n_objects:
  ------------------
  |  Branch (1836:17): [True: 0, False: 2.01k]
  ------------------
 1837|      0|                    if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1837:27): [True: 0, False: 0]
  |  Branch (1837:51): [True: 0, False: 0]
  ------------------
 1838|      0|                    {
 1839|      0|                        if (column_index_ < column_names_.size() + offset_)
  ------------------
  |  Branch (1839:29): [True: 0, False: 0]
  ------------------
 1840|      0|                        {
 1841|      0|                            if (unquoted_empty_value_is_null_ && buffer_.empty())
  ------------------
  |  Branch (1841:33): [True: 0, False: 0]
  |  Branch (1841:66): [True: 0, False: 0]
  ------------------
 1842|      0|                            {
 1843|      0|                                visitor.null_value(semantic_tag::none, *this, ec);
 1844|      0|                                more_ = !cursor_mode_;
 1845|      0|                            }
 1846|      0|                            else 
 1847|      0|                            {
 1848|      0|                                end_value(visitor, false, ec);
 1849|      0|                            }
 1850|      0|                        }
 1851|      0|                        else if (depth_ > 0)
  ------------------
  |  Branch (1851:34): [True: 0, False: 0]
  ------------------
 1852|      0|                        {
 1853|      0|                            if (unquoted_empty_value_is_null_ && buffer_.empty())
  ------------------
  |  Branch (1853:33): [True: 0, False: 0]
  |  Branch (1853:66): [True: 0, False: 0]
  ------------------
 1854|      0|                            {
 1855|      0|                                visitor.null_value(semantic_tag::none, *this, ec);
 1856|      0|                                more_ = !cursor_mode_;
 1857|      0|                            }
 1858|      0|                            else
 1859|      0|                            {
 1860|      0|                                end_value(visitor, false, ec);
 1861|      0|                            }
 1862|      0|                        }
 1863|      0|                    }
 1864|      0|                    break;
 1865|      0|                case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (1865:17): [True: 0, False: 2.01k]
  ------------------
 1866|      0|                    if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1866:27): [True: 0, False: 0]
  |  Branch (1866:51): [True: 0, False: 0]
  ------------------
 1867|      0|                    {
 1868|      0|                        end_value(visitor, false, ec);
 1869|      0|                    }
 1870|      0|                    else
 1871|      0|                    {
 1872|      0|                        m_columns_filter_.skip_column();
 1873|      0|                    }
 1874|      0|                    break;
 1875|  2.01k|                }
 1876|  2.01k|                break;
 1877|  2.01k|            default:
  ------------------
  |  Branch (1877:13): [True: 937, False: 2.01k]
  ------------------
 1878|    937|                break;
 1879|  2.94k|        }
 1880|  2.94k|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE10end_recordERNS_18basic_json_visitorIcEERNS2_10error_codeE:
 1613|  3.93M|    {
 1614|  3.93M|        if (!column_types_.empty())
  ------------------
  |  Branch (1614:13): [True: 0, False: 3.93M]
  ------------------
 1615|      0|        {
 1616|      0|            switch (mapping_kind_)
 1617|      0|            {
 1618|      0|                case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1618:17): [True: 0, False: 0]
  ------------------
 1619|      0|                case csv_mapping_kind::n_objects:
  ------------------
  |  Branch (1619:17): [True: 0, False: 0]
  ------------------
 1620|      0|                    if (depth_ > 0)
  ------------------
  |  Branch (1620:25): [True: 0, False: 0]
  ------------------
 1621|      0|                    {
 1622|      0|                        visitor.end_array(*this, ec);
 1623|      0|                        more_ = !cursor_mode_;
 1624|      0|                        if (level_ == mark_level_)
  ------------------
  |  Branch (1624:29): [True: 0, False: 0]
  ------------------
 1625|      0|                        {
 1626|      0|                            more_ = false;
 1627|      0|                        }
 1628|      0|                        --level_;
 1629|      0|                        depth_ = 0;
 1630|      0|                    }
 1631|      0|                    break;
 1632|      0|                case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (1632:17): [True: 0, False: 0]
  ------------------
 1633|      0|                    if (depth_ > 0)
  ------------------
  |  Branch (1633:25): [True: 0, False: 0]
  ------------------
 1634|      0|                    {
 1635|      0|                        visitor.end_array(*this, ec);
 1636|      0|                        more_ = !cursor_mode_;
 1637|      0|                        --level_;
 1638|      0|                        depth_ = 0;
 1639|      0|                    }
 1640|      0|                    break;
 1641|      0|                default:
  ------------------
  |  Branch (1641:17): [True: 0, False: 0]
  ------------------
 1642|      0|                    break;
 1643|      0|            }
 1644|      0|        }
 1645|  3.93M|        switch (stack_.back())
 1646|  3.93M|        {
 1647|    760|            case csv_mode::header:
  ------------------
  |  Branch (1647:13): [True: 760, False: 3.93M]
  ------------------
 1648|    760|                if (line_ >= header_lines_)
  ------------------
  |  Branch (1648:21): [True: 760, False: 0]
  ------------------
 1649|    760|                {
 1650|    760|                    stack_.back() = csv_mode::data;
 1651|    760|                }
 1652|    760|                switch (mapping_kind_)
 1653|    760|                {
 1654|    760|                    case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1654:21): [True: 760, False: 0]
  ------------------
 1655|    760|                        if (assume_header_)
  ------------------
  |  Branch (1655:29): [True: 760, False: 0]
  ------------------
 1656|    760|                        {
 1657|    760|                            visitor.end_array(*this, ec);
 1658|    760|                            more_ = !cursor_mode_;
 1659|    760|                            if (level() == mark_level_)
  ------------------
  |  Branch (1659:33): [True: 0, False: 760]
  ------------------
 1660|      0|                            {
 1661|      0|                                more_ = false;
 1662|      0|                            }
 1663|    760|                            --level_;
 1664|    760|                        }
 1665|    760|                        break;
 1666|      0|                    case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (1666:21): [True: 0, False: 760]
  ------------------
 1667|      0|                        m_columns_filter_.initialize(column_names_);
 1668|      0|                        break;
 1669|      0|                    default:
  ------------------
  |  Branch (1669:21): [True: 0, False: 760]
  ------------------
 1670|      0|                        break;
 1671|    760|                }
 1672|    760|                break;
 1673|  3.93M|            case csv_mode::data:
  ------------------
  |  Branch (1673:13): [True: 3.93M, False: 760]
  ------------------
 1674|  3.93M|            case csv_mode::subfields:
  ------------------
  |  Branch (1674:13): [True: 0, False: 3.93M]
  ------------------
 1675|  3.93M|            {
 1676|  3.93M|                switch (mapping_kind_)
  ------------------
  |  Branch (1676:25): [True: 3.93M, False: 0]
  ------------------
 1677|  3.93M|                {
 1678|  3.93M|                    case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1678:21): [True: 3.93M, False: 0]
  ------------------
 1679|  3.93M|                        visitor.end_array(*this, ec);
 1680|  3.93M|                        more_ = !cursor_mode_;
 1681|  3.93M|                        if (level_ == mark_level_)
  ------------------
  |  Branch (1681:29): [True: 0, False: 3.93M]
  ------------------
 1682|      0|                        {
 1683|      0|                            more_ = false;
 1684|      0|                        }
 1685|  3.93M|                        --level_;
 1686|  3.93M|                        break;
 1687|      0|                    case csv_mapping_kind::n_objects:
  ------------------
  |  Branch (1687:21): [True: 0, False: 3.93M]
  ------------------
 1688|      0|                        visitor.end_object(*this, ec);
 1689|      0|                        more_ = !cursor_mode_;
 1690|      0|                        if (level_ == mark_level_)
  ------------------
  |  Branch (1690:29): [True: 0, False: 0]
  ------------------
 1691|      0|                        {
 1692|      0|                            more_ = false;
 1693|      0|                        }
 1694|      0|                        --level_;
 1695|      0|                        break;
 1696|      0|                    case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (1696:21): [True: 0, False: 3.93M]
  ------------------
 1697|      0|                        visitor.end_array(*this, ec);
 1698|      0|                        more_ = !cursor_mode_;
 1699|      0|                        --level_;
 1700|      0|                        break;
 1701|  3.93M|                }
 1702|  3.93M|                break;
 1703|  3.93M|            }
 1704|  3.93M|            default:
  ------------------
  |  Branch (1704:13): [True: 0, False: 3.93M]
  ------------------
 1705|      0|                break;
 1706|  3.93M|        }
 1707|  3.93M|        column_index_ = 0;
 1708|  3.93M|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE9pop_stateEv:
 2396|  5.08M|    {
 2397|  5.08M|        JSONCONS_ASSERT(!state_stack_.empty())
  ------------------
  |  |   49|  5.08M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (49:32): [True: 0, False: 5.08M]
  |  |  ------------------
  |  |   50|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   51|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 2398|  5.08M|        csv_parse_state state = state_stack_.back();
 2399|  5.08M|        state_stack_.pop_back();
 2400|  5.08M|        return state;
 2401|  5.08M|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE10push_stateENS0_15csv_parse_stateE:
 2391|  5.08M|    {
 2392|  5.08M|        state_stack_.push_back(state);
 2393|  5.08M|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE12begin_recordERNS_18basic_json_visitorIcEERNS2_10error_codeE:
 1563|  3.93M|    {
 1564|  3.93M|        offset_ = 0;
 1565|       |
 1566|  3.93M|        if (stack_.back() == csv_mode::header && line_ > (header_lines_+header_line_offset_))
  ------------------
  |  Branch (1566:13): [True: 2.66k, False: 3.93M]
  |  Branch (1566:50): [True: 1.79k, False: 871]
  ------------------
 1567|  1.79k|        {
 1568|  1.79k|            stack_.back() = csv_mode::data;
 1569|  1.79k|        }
 1570|  3.93M|        switch (stack_.back())
 1571|  3.93M|        {
 1572|    871|            case csv_mode::header:
  ------------------
  |  Branch (1572:13): [True: 871, False: 3.93M]
  ------------------
 1573|    871|                switch (mapping_kind_)
 1574|    871|                {
 1575|    871|                    case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1575:21): [True: 871, False: 0]
  ------------------
 1576|    871|                        if (assume_header_ && line_ == (header_line_+header_line_offset_))
  ------------------
  |  Branch (1576:29): [True: 871, False: 0]
  |  Branch (1576:47): [True: 871, False: 0]
  ------------------
 1577|    871|                        {
 1578|    871|                            visitor.begin_array(semantic_tag::none, *this, ec);
 1579|    871|                            more_ = !cursor_mode_;
 1580|    871|                            ++level_;
 1581|    871|                        }
 1582|    871|                        break;
 1583|      0|                    default:
  ------------------
  |  Branch (1583:21): [True: 0, False: 871]
  ------------------
 1584|      0|                        break;
 1585|    871|                }
 1586|    871|                break;
 1587|  3.93M|            case csv_mode::data:
  ------------------
  |  Branch (1587:13): [True: 3.93M, False: 871]
  ------------------
 1588|  3.93M|                switch (mapping_kind_)
 1589|  3.93M|                {
 1590|  3.93M|                    case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1590:21): [True: 3.93M, False: 0]
  ------------------
 1591|  3.93M|                        visitor.begin_array(semantic_tag::none, *this, ec);
 1592|  3.93M|                        more_ = !cursor_mode_;
 1593|  3.93M|                        ++level_;
 1594|  3.93M|                        break;
 1595|      0|                    case csv_mapping_kind::n_objects:
  ------------------
  |  Branch (1595:21): [True: 0, False: 3.93M]
  ------------------
 1596|      0|                        visitor.begin_object(semantic_tag::none, *this, ec);
 1597|      0|                        more_ = !cursor_mode_;
 1598|      0|                        ++level_;
 1599|      0|                        break;
 1600|      0|                    case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (1600:21): [True: 0, False: 3.93M]
  ------------------
 1601|      0|                        break;
 1602|      0|                    default:
  ------------------
  |  Branch (1602:21): [True: 0, False: 3.93M]
  ------------------
 1603|      0|                        break;
 1604|  3.93M|                }
 1605|  3.93M|                break;
 1606|  3.93M|            default:
  ------------------
  |  Branch (1606:13): [True: 0, False: 3.93M]
  ------------------
 1607|      0|                break;
 1608|  3.93M|        }
 1609|  3.93M|    }

_ZN8jsoncons3csv16basic_csv_readerIcNS_13string_sourceIcEENSt3__19allocatorIcEEED2Ev:
  109|  2.74k|        ~basic_csv_reader() noexcept = default;
_ZN8jsoncons3csv16basic_csv_readerIcNS_13string_sourceIcEENSt3__19allocatorIcEEEC2IRNS4_12basic_stringIcNS4_11char_traitsIcEES6_EEEEOT_RNS_18basic_json_visitorIcEERKNS0_24basic_csv_decode_optionsIcEERKS6_:
   62|  2.74k|           : source_(std::forward<Sourceable>(source)),
   63|  2.74k|             visitor_(visitor),
   64|  2.74k|             parser_(options, alloc)
   65|       |
   66|  2.74k|        {
   67|  2.74k|        }
_ZN8jsoncons3csv16basic_csv_readerIcNS_13string_sourceIcEENSt3__19allocatorIcEEE4readEv:
  112|  2.74k|        {
  113|  2.74k|            std::error_code ec;
  114|  2.74k|            read(ec);
  115|  2.74k|            if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   78|  2.74k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 111, False: 2.63k]
  |  |  ------------------
  ------------------
  116|    111|            {
  117|    111|                JSONCONS_THROW(ser_error(ec,parser_.line(),parser_.column()));
  ------------------
  |  |   35|    111|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  118|    111|            }
  119|  2.74k|        }
_ZN8jsoncons3csv16basic_csv_readerIcNS_13string_sourceIcEENSt3__19allocatorIcEEE4readERNS4_10error_codeE:
  122|  2.74k|        {
  123|  2.74k|            read_internal(ec);
  124|  2.74k|        }
_ZN8jsoncons3csv16basic_csv_readerIcNS_13string_sourceIcEENSt3__19allocatorIcEEE13read_internalERNS4_10error_codeE:
  144|  2.74k|        {
  145|  2.74k|            if (source_.is_error())
  ------------------
  |  Branch (145:17): [True: 0, False: 2.74k]
  ------------------
  146|      0|            {
  147|      0|                ec = csv_errc::source_error;
  148|      0|                return;
  149|      0|            }   
  150|  20.5k|            while (!parser_.stopped())
  ------------------
  |  Branch (150:20): [True: 17.8k, False: 2.63k]
  ------------------
  151|  17.8k|            {
  152|  17.8k|                if (parser_.source_exhausted())
  ------------------
  |  Branch (152:21): [True: 17.8k, False: 0]
  ------------------
  153|  17.8k|                {
  154|  17.8k|                    auto s = source_.read_chunk(ec);
  155|  17.8k|                    if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  17.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 12, False: 17.8k]
  |  |  ------------------
  ------------------
  156|  17.8k|                    if (s.size() > 0)
  ------------------
  |  Branch (156:25): [True: 2.73k, False: 15.1k]
  ------------------
  157|  2.73k|                    {
  158|  2.73k|                        parser_.update(s.data(),s.size());
  159|  2.73k|                    }
  160|  17.8k|                }
  161|  17.8k|                parser_.parse_some(visitor_, ec);
  162|  17.8k|                if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   78|  17.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (78:30): [True: 99, False: 17.7k]
  |  |  ------------------
  ------------------
  163|  17.8k|            }
  164|  2.74k|        }