LLVMFuzzerTestOneInput:
    9|  3.49k|{
   10|  3.49k|    std::string s(reinterpret_cast<const char*>(data), size);
   11|  3.49k|    std::istringstream is(s);
   12|       |
   13|  3.49k|    std::string s2;
   14|  3.49k|    csv_string_encoder visitor(s2);
   15|  3.49k|    csv_stream_reader reader(is, visitor);
   16|  3.49k|    std::error_code ec;
   17|  3.49k|    reader.read(ec);
   18|       |
   19|  3.49k|    return 0;
   20|  3.49k|}

_ZN8jsoncons28string_view_constant_of_typeIcEENSt3__117basic_string_viewIT_NS1_11char_traitsIS3_EEEEPKcPKw:
  236|  13.9k|    {
  237|  13.9k|        return jsoncons::string_view(c);
  238|  13.9k|    }

_ZN8jsoncons15make_error_codeENS_9json_errcE:
  147|     10|    {
  148|     10|        return std::error_code(static_cast<int>(result),json_error_category());
  149|     10|    }
_ZN8jsoncons19json_error_categoryEv:
  141|     10|    {
  142|     10|      static json_error_category_impl instance;
  143|     10|      return instance;
  144|     10|    }

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

_ZN8jsoncons6nonstd14integer_limitsIlvE6lowestEv:
  110|  42.6k|        {
  111|  42.6k|            return std::numeric_limits<T>::lowest();
  112|  42.6k|        }

_ZN8jsoncons6nonstd4spanIKcLm18446744073709551615EEC2Ev:
   58|  20.1k|        {
   59|  20.1k|        }
_ZN8jsoncons6nonstd4spanIKcLm18446744073709551615EEC2EPS2_m:
   61|  13.1k|            : data_(data), size_(size)
   62|  13.1k|        {
   63|  13.1k|        }
_ZNK8jsoncons6nonstd4spanIKcLm18446744073709551615EE4sizeEv:
  116|  39.7k|        {
  117|  39.7k|            return size_;
  118|  39.7k|        }
_ZNK8jsoncons6nonstd4spanIKcLm18446744073709551615EE4dataEv:
  111|  13.0k|        {
  112|  13.0k|            return data_;
  113|  13.0k|        }

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

_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2ERS7_:
  256|  3.49k|            : buf_ptr(std::addressof(buf))
  257|  3.49k|        {
  258|  3.49k|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEC2EOS8_:
  251|  3.49k|        {
  252|  3.49k|            std::swap(buf_ptr,other.buf_ptr);
  253|  3.49k|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE9push_backEc:
  287|  11.2M|        {
  288|  11.2M|            buf_ptr->push_back(ch);
  289|  11.2M|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE6appendEPKcm:
  277|  11.6M|        {
  278|  11.6M|            buf_ptr->append(s, length);
  279|  11.6M|        }
_ZN8jsoncons11string_sinkINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE5flushEv:
  273|  6.92k|        {
  274|  6.92k|        }

_ZN8jsoncons13stream_sourceIcNSt3__19allocatorIcEEED2Ev:
  193|  3.49k|    {
  194|  3.49k|        if (chunk_)
  ------------------
  |  Branch (194:13): [True: 3.49k, False: 0]
  ------------------
  195|  3.49k|        {
  196|  3.49k|            std::allocator_traits<char_allocator_type>::deallocate(alloc_, chunk_, chunk_size_);
  197|  3.49k|        }
  198|  3.49k|    }
_ZN8jsoncons13stream_sourceIcNSt3__19allocatorIcEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_:
  176|  3.49k|        : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()),
  177|  3.49k|          chunk_size_(default_max_chunk_size)
  178|  3.49k|    {
  179|  3.49k|        chunk_ = std::allocator_traits<char_allocator_type>::allocate(alloc_, chunk_size_);
  180|  3.49k|        data_end_ = chunk_;
  181|  3.49k|    }
_ZN8jsoncons18basic_null_istreamIcEC1Ev:
   57|  3.49k|      : std::basic_istream<CharT>(&nb_)
   58|  3.49k|    {
   59|  3.49k|    }
_ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev:
   43|  3.49k|        null_buffer() = default;
_ZNK8jsoncons13stream_sourceIcNSt3__19allocatorIcEEE8is_errorEv:
  276|  3.49k|    {
  277|  3.49k|        return stream_ptr_->bad();  
  278|  3.49k|    }
_ZNK8jsoncons13stream_sourceIcNSt3__19allocatorIcEEE3eofEv:
  271|  26.6k|    {
  272|  26.6k|        return remaining_ == 0 && stream_ptr_->eof();
  ------------------
  |  Branch (272:16): [True: 26.6k, False: 0]
  |  Branch (272:35): [True: 20.1k, False: 6.55k]
  ------------------
  273|  26.6k|    }
_ZN8jsoncons13stream_sourceIcNSt3__19allocatorIcEEE10read_chunkEv:
  330|  6.55k|    {
  331|  6.55k|        if (remaining_ == 0)
  ------------------
  |  Branch (331:13): [True: 6.55k, False: 0]
  ------------------
  332|  6.55k|        {
  333|  6.55k|            data_end_ = chunk_;
  334|  6.55k|            remaining_ = fill_buffer(chunk_, chunk_size_);
  335|  6.55k|        }
  336|  6.55k|        const value_type* data = data_end_;
  337|  6.55k|        std::size_t length = remaining_;
  338|  6.55k|        data_end_ += remaining_;
  339|  6.55k|        position_ += remaining_;
  340|  6.55k|        remaining_ = 0;
  341|       |
  342|  6.55k|        return span<const value_type>(data, length);
  343|  6.55k|    }
_ZN8jsoncons13stream_sourceIcNSt3__19allocatorIcEEE11fill_bufferEPcm:
  442|  6.55k|    {
  443|  6.55k|        if (stream_ptr_->eof())
  ------------------
  |  Branch (443:13): [True: 0, False: 6.55k]
  ------------------
  444|      0|        {
  445|      0|            return 0;
  446|      0|        }
  447|       |
  448|  6.55k|        JSONCONS_TRY
  ------------------
  |  |   37|  6.55k|    #define JSONCONS_TRY try
  ------------------
  449|  6.55k|        {
  450|  6.55k|            std::streamsize count = sbuf_->sgetn(reinterpret_cast<char_type*>(chunk), chunk_size);
  451|  6.55k|            std::size_t length = static_cast<std::size_t>(count);
  452|       |
  453|  6.55k|            if (length < chunk_size)
  ------------------
  |  Branch (453:17): [True: 3.49k, False: 3.06k]
  ------------------
  454|  3.49k|            {
  455|  3.49k|                stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit);
  456|  3.49k|            }
  457|  6.55k|            return length;
  458|  6.55k|        }
  459|  6.55k|        JSONCONS_CATCH(const std::exception&)     
  460|  6.55k|        {
  461|      0|            stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit);
  462|      0|            return 0;
  463|      0|        }
  464|  6.55k|    }

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

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

_ZN8jsoncons16decstr_to_doubleEPKcmRd:
  889|   119k|{
  890|   119k|    const char* cur = s+length;
  891|   119k|    char *end = nullptr;
  892|   119k|    val = strtod(s, &end);
  893|   119k|    const char* str_end = end;
  894|   119k|    if (JSONCONS_UNLIKELY(end < cur))
  ------------------
  |  |   79|   119k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 7, False: 119k]
  |  |  ------------------
  ------------------
  895|      7|    {
  896|      7|        if (*end == '.')
  ------------------
  |  Branch (896:13): [True: 0, False: 7]
  ------------------
  897|      0|        {
  898|      0|            std::string buf{s, length};
  899|      0|            char* dot_ptr = &buf[0] + (cur - end - 1);
  900|      0|            *dot_ptr = ',';
  901|      0|            end = nullptr;
  902|      0|            val = strtod(buf.c_str(), &end);
  903|      0|            str_end = s + (end - &buf[0]);
  904|      0|        }
  905|      7|        if (JSONCONS_UNLIKELY(str_end != cur))
  ------------------
  |  |   79|      7|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 7, False: 0]
  |  |  ------------------
  ------------------
  906|      7|        {
  907|      7|            return to_number_result<char>{str_end,std::errc::invalid_argument};
  908|      7|        }
  909|      7|    }
  910|   119k|    if (JSONCONS_UNLIKELY(val <= -HUGE_VAL || val >= HUGE_VAL))
  ------------------
  |  |   79|   234k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 6.94k, False: 112k]
  |  |  |  Branch (79:50): [True: 5.33k, False: 114k]
  |  |  |  Branch (79:50): [True: 1.60k, False: 112k]
  |  |  ------------------
  ------------------
  911|  6.94k|    {
  912|  6.94k|        return to_number_result<char>{str_end, std::errc::result_out_of_range};
  913|  6.94k|    }
  914|   112k|    return to_number_result<char>{str_end};
  915|   119k|}
_ZN8jsoncons16to_number_resultIcEC2EPKcNSt3__14errcE:
  164|   142k|        : ptr(ptr_), ec(ec_)
  165|   142k|    {
  166|   142k|    }
_ZN8jsoncons16to_number_resultIcEC2EPKc:
  160|   112k|        : ptr(ptr_), ec(std::errc{})
  161|   112k|    {
  162|   112k|    }
_ZN8jsoncons14dec_to_integerIlcEENSt3__19enable_ifIXaasr6nonstd14integer_limitsIT_EE14is_specializedsr6nonstd14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  350|  51.9k|{
  351|  51.9k|    if (length == 0)
  ------------------
  |  Branch (351:9): [True: 0, False: 51.9k]
  ------------------
  352|      0|    {
  353|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  354|      0|    }
  355|       |
  356|  51.9k|    bool sign = *s == '-';
  357|  51.9k|    s += sign;
  358|  51.9k|    length -= sign;
  359|       |
  360|  51.9k|    using U = typename nonstd::make_unsigned<T>::type;
  361|       |
  362|  51.9k|    U num;
  363|  51.9k|    auto ru = dec_to_integer(s, length, num);
  364|  51.9k|    if (ru.ec != std::errc{})
  ------------------
  |  Branch (364:9): [True: 9.31k, False: 42.6k]
  ------------------
  365|  9.31k|    {
  366|  9.31k|        return to_number_result<CharT>(ru.ptr, ru.ec);
  367|  9.31k|    }
  368|  42.6k|    if (sign)
  ------------------
  |  Branch (368:9): [True: 42.6k, False: 0]
  ------------------
  369|  42.6k|    {
  370|  42.6k|        if (num > static_cast<U>(-((nonstd::integer_limits<T>::lowest)()+T(1))) + U(1))
  ------------------
  |  Branch (370:13): [True: 1.40k, False: 41.2k]
  ------------------
  371|  1.40k|        {
  372|  1.40k|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  373|  1.40k|        }
  374|  41.2k|        else
  375|  41.2k|        {
  376|  41.2k|            value = static_cast<T>(U(0) - num);
  377|  41.2k|            return to_number_result<CharT>(ru.ptr, std::errc{});
  378|  41.2k|        }
  379|  42.6k|    }
  380|      0|    else
  381|      0|    {
  382|      0|        if (num > static_cast<U>((nonstd::integer_limits<T>::max)()))
  ------------------
  |  Branch (382:13): [True: 0, False: 0]
  ------------------
  383|      0|        {
  384|      0|            return to_number_result<CharT>(ru.ptr, std::errc::result_out_of_range);
  385|      0|        }
  386|      0|        else
  387|      0|        {
  388|      0|            value = static_cast<T>(num);
  389|      0|            return to_number_result<CharT>(ru.ptr, std::errc{});
  390|      0|        }
  391|      0|    }
  392|  42.6k|}
_ZN8jsoncons14dec_to_integerImcEENSt3__19enable_ifIXaasr6nonstd14integer_limitsIT_EE14is_specializedntsr6nonstd14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_:
  288|  83.1k|{
  289|  83.1k|    if (JSONCONS_UNLIKELY(length == 0))
  ------------------
  |  |   79|  83.1k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 83.1k]
  |  |  ------------------
  ------------------
  290|      0|    {
  291|      0|        return to_number_result<CharT>(s, std::errc::invalid_argument);
  292|      0|    }
  293|       |
  294|  83.1k|    static constexpr T max_value = (nonstd::integer_limits<T>::max)();
  295|  83.1k|    static constexpr T max_value_div_10 = max_value / 10;
  296|       |
  297|  83.1k|    T num = 0;
  298|  83.1k|    const CharT* cur = s;
  299|  83.1k|    const CharT* last = s + length;
  300|  83.1k|    static constexpr std::size_t digits10 = static_cast<std::size_t>(nonstd::integer_limits<T>::digits10);
  301|  83.1k|    const std::size_t n = (std::min)(digits10, length);
  302|  83.1k|    const CharT* stop = s + n;
  303|       |     
  304|   501k|    while (cur < stop)
  ------------------
  |  Branch (304:12): [True: 418k, False: 83.1k]
  ------------------
  305|   418k|    {
  306|   418k|        uint8_t d;
  307|   418k|        if (JSONCONS_LIKELY((d = static_cast<uint8_t>(*cur - '0')) <= 9) )
  ------------------
  |  |   78|   418k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (78:28): [True: 418k, False: 0]
  |  |  ------------------
  ------------------
  308|   418k|        {
  309|   418k|            num = static_cast<T>(d) + num*10;
  310|   418k|        }
  311|      0|        else
  312|      0|        {
  313|      0|            return to_number_result<CharT>(cur, std::errc::invalid_argument);
  314|      0|        }
  315|   418k|        ++cur;
  316|   418k|    }
  317|  83.1k|    if (cur == last)
  ------------------
  |  Branch (317:9): [True: 68.5k, False: 14.6k]
  ------------------
  318|  68.5k|    {
  319|  68.5k|        value = num;
  320|  68.5k|        return to_number_result<CharT>(cur, std::errc{});
  321|  68.5k|    }
  322|  14.6k|    if (cur+1 != last)
  ------------------
  |  Branch (322:9): [True: 4.01k, False: 10.6k]
  ------------------
  323|  4.01k|    {
  324|  4.01k|        return to_number_result<CharT>(cur, std::errc::result_out_of_range);
  325|  4.01k|    }
  326|  10.6k|    if (is_char_digit(*cur))
  ------------------
  |  Branch (326:9): [True: 10.6k, False: 0]
  ------------------
  327|  10.6k|    {
  328|  10.6k|        if (num > max_value_div_10)
  ------------------
  |  Branch (328:13): [True: 2.04k, False: 8.57k]
  ------------------
  329|  2.04k|        {
  330|  2.04k|            return to_number_result<CharT>(cur, std::errc::result_out_of_range);
  331|  2.04k|        }
  332|  8.57k|        uint8_t d = static_cast<uint8_t>(*cur - '0');
  333|  8.57k|        num = num*10;
  334|  8.57k|        if (num > max_value - d)
  ------------------
  |  Branch (334:13): [True: 7.52k, False: 1.05k]
  ------------------
  335|  7.52k|        {
  336|  7.52k|            return to_number_result<CharT>(s, std::errc::result_out_of_range);
  337|  7.52k|        }
  338|  1.05k|        num += d;
  339|  1.05k|        ++cur;
  340|  1.05k|        value = num;
  341|  1.05k|        return to_number_result<CharT>(cur, std::errc{});
  342|  8.57k|    }
  343|       |    
  344|      0|    return to_number_result<CharT>(cur, std::errc::invalid_argument);
  345|  10.6k|}
_ZN8jsoncons13is_char_digitEc:
   83|  10.6k|constexpr bool is_char_digit(char d) {
   84|  10.6k|    return is_type(static_cast<uint8_t>(d), (uint8_t)(digit_type_zero | digit_type_nonzero));
   85|  10.6k|}
_ZN8jsoncons7is_typeEhh:
   68|  10.6k|constexpr bool is_type(uint8_t d, uint8_t type) {
   69|  10.6k|    return (digi_table[d] & type) != 0;
   70|  10.6k|}
_ZNK8jsoncons16to_number_resultIcEcvbEv:
  173|  83.1k|    {
  174|  83.1k|        return ec == std::errc{};
  175|  83.1k|    }

_ZN8jsoncons12write_doubleC2ENS_18float_chars_formatEi:
  487|  3.49k|       : float_format_(float_format), precision_(precision), decimal_point_('.')
  488|  3.49k|    {
  489|  3.49k|#if !defined(JSONCONS_NO_LOCALECONV)
  490|  3.49k|        struct lconv *lc = localeconv();
  491|  3.49k|        if (lc != nullptr && lc->decimal_point[0] != 0)
  ------------------
  |  Branch (491:13): [True: 3.49k, False: 0]
  |  Branch (491:30): [True: 3.49k, False: 0]
  ------------------
  492|  3.49k|        {
  493|  3.49k|            decimal_point_ = lc->decimal_point[0];
  494|  3.49k|        }
  495|  3.49k|#endif
  496|  3.49k|    }
_ZN8jsoncons12from_integerImNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr6nonstd10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  26.9k|{
   43|  26.9k|    using char_type = typename Result::value_type;
   44|       |
   45|  26.9k|    char_type buf[255];
   46|  26.9k|    char_type *p = buf;
   47|  26.9k|    const char_type* last = buf+255;
   48|       |
   49|  26.9k|    bool is_negative = value < 0;
   50|       |
   51|  26.9k|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 0, False: 26.9k]
  ------------------
   52|      0|    {
   53|      0|        do
   54|      0|        {
   55|      0|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|      0|        }
   57|      0|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 0, False: 0]
  |  Branch (57:33): [True: 0, False: 0]
  ------------------
   58|      0|    }
   59|  26.9k|    else
   60|  26.9k|    {
   61|       |
   62|  26.9k|        do
   63|  75.1k|        {
   64|  75.1k|            *p++ = static_cast<char_type>(48 + value % 10);
   65|  75.1k|        }
   66|  75.1k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 48.2k, False: 26.9k]
  |  Branch (66:33): [True: 48.2k, False: 0]
  ------------------
   67|  26.9k|    }
   68|  26.9k|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   54|  26.9k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 26.9k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|  26.9k|    std::size_t count = (p - buf);
   71|  26.9k|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 0, False: 26.9k]
  ------------------
   72|      0|    {
   73|      0|        result.push_back('-');
   74|      0|        ++count;
   75|      0|    }
   76|   102k|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 75.1k, False: 26.9k]
  ------------------
   77|  75.1k|    {
   78|  75.1k|        result.push_back(*p);
   79|  75.1k|    }
   80|       |
   81|  26.9k|    return count;
   82|  26.9k|}
_ZN8jsoncons12from_integerIlNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr6nonstd10is_integerIT_EE5valueEmE4typeES9_RT0_:
   42|  41.2k|{
   43|  41.2k|    using char_type = typename Result::value_type;
   44|       |
   45|  41.2k|    char_type buf[255];
   46|  41.2k|    char_type *p = buf;
   47|  41.2k|    const char_type* last = buf+255;
   48|       |
   49|  41.2k|    bool is_negative = value < 0;
   50|       |
   51|  41.2k|    if (value < 0)
  ------------------
  |  Branch (51:9): [True: 40.7k, False: 514]
  ------------------
   52|  40.7k|    {
   53|  40.7k|        do
   54|  58.4k|        {
   55|  58.4k|            *p++ = static_cast<char_type>(48 - (value % 10));
   56|  58.4k|        }
   57|  58.4k|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (57:16): [True: 17.7k, False: 40.7k]
  |  Branch (57:33): [True: 17.7k, False: 0]
  ------------------
   58|  40.7k|    }
   59|    514|    else
   60|    514|    {
   61|       |
   62|    514|        do
   63|    514|        {
   64|    514|            *p++ = static_cast<char_type>(48 + value % 10);
   65|    514|        }
   66|    514|        while ((value /= 10) && (p < last));
  ------------------
  |  Branch (66:16): [True: 0, False: 514]
  |  Branch (66:33): [True: 0, False: 0]
  ------------------
   67|    514|    }
   68|  41.2k|    JSONCONS_ASSERT(p != last);
  ------------------
  |  |   54|  41.2k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 41.2k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
   69|       |
   70|  41.2k|    std::size_t count = (p - buf);
   71|  41.2k|    if (is_negative)
  ------------------
  |  Branch (71:9): [True: 40.7k, False: 514]
  ------------------
   72|  40.7k|    {
   73|  40.7k|        result.push_back('-');
   74|  40.7k|        ++count;
   75|  40.7k|    }
   76|   100k|    while (--p >= buf)
  ------------------
  |  Branch (76:12): [True: 58.9k, False: 41.2k]
  ------------------
   77|  58.9k|    {
   78|  58.9k|        result.push_back(*p);
   79|  58.9k|    }
   80|       |
   81|  41.2k|    return count;
   82|  41.2k|}
_ZN8jsoncons12write_doubleclINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEmdRT_:
  503|   102k|    {
  504|   102k|        std::size_t count = 0;
  505|       |
  506|   102k|        char number_buffer[200];
  507|   102k|        int length = 0;
  508|       |
  509|   102k|        switch (float_format_)
  510|   102k|        {
  511|      0|        case float_chars_format::fixed:
  ------------------
  |  Branch (511:9): [True: 0, False: 102k]
  ------------------
  512|      0|            {
  513|      0|                if (precision_ > 0)
  ------------------
  |  Branch (513:21): [True: 0, False: 0]
  ------------------
  514|      0|                {
  515|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*f", precision_, val);
  516|      0|                    if (length < 0)
  ------------------
  |  Branch (516:25): [True: 0, False: 0]
  ------------------
  517|      0|                    {
  518|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  519|      0|                    }
  520|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  521|      0|                }
  522|      0|                else
  523|      0|                {
  524|      0|                    if (!dtoa_fixed(val, decimal_point_, result))
  ------------------
  |  Branch (524:25): [True: 0, False: 0]
  ------------------
  525|      0|                    {
  526|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  527|      0|                    }
  528|      0|                }
  529|      0|            }
  530|      0|            break;
  531|      0|        case float_chars_format::scientific:
  ------------------
  |  Branch (531:9): [True: 0, False: 102k]
  ------------------
  532|      0|            {
  533|      0|                if (precision_ > 0)
  ------------------
  |  Branch (533:21): [True: 0, False: 0]
  ------------------
  534|      0|                {
  535|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*e", precision_, val);
  536|      0|                    if (length < 0)
  ------------------
  |  Branch (536:25): [True: 0, False: 0]
  ------------------
  537|      0|                    {
  538|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  539|      0|                    }
  540|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  541|      0|                }
  542|      0|                else
  543|      0|                {
  544|      0|                    if (!dtoa_scientific(val, decimal_point_, result))
  ------------------
  |  Branch (544:25): [True: 0, False: 0]
  ------------------
  545|      0|                    {
  546|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  547|      0|                    }
  548|      0|                }
  549|      0|            }
  550|      0|            break;
  551|   102k|        case float_chars_format::general:
  ------------------
  |  Branch (551:9): [True: 102k, False: 0]
  ------------------
  552|   102k|            {
  553|   102k|                if (precision_ > 0)
  ------------------
  |  Branch (553:21): [True: 0, False: 102k]
  ------------------
  554|      0|                {
  555|      0|                    length = snprintf(number_buffer, sizeof(number_buffer), "%1.*g", precision_, val);
  556|      0|                    if (length < 0)
  ------------------
  |  Branch (556:25): [True: 0, False: 0]
  ------------------
  557|      0|                    {
  558|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  559|      0|                    }
  560|      0|                    dump_buffer(number_buffer, length, decimal_point_, result);
  561|      0|                }
  562|   102k|                else
  563|   102k|                {
  564|   102k|                    if (!dtoa_general(val, decimal_point_, result))
  ------------------
  |  Branch (564:25): [True: 0, False: 102k]
  ------------------
  565|      0|                    {
  566|      0|                        JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  567|      0|                    }
  568|   102k|                }             
  569|   102k|                break;
  570|   102k|            }
  571|   102k|            default:
  ------------------
  |  Branch (571:13): [True: 0, False: 102k]
  ------------------
  572|      0|                JSONCONS_THROW(json_runtime_error<std::invalid_argument>("write_double failed."));
  ------------------
  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  ------------------
  573|      0|                break;
  574|   102k|        }
  575|   102k|        return count;
  576|   102k|    }
_ZN8jsoncons11dump_bufferINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKcmcRT_:
  243|  10.2k|{
  244|  10.2k|    const char *sbeg = buffer;
  245|  10.2k|    const char *send = sbeg + length;
  246|       |
  247|  10.2k|    if (sbeg != send)
  ------------------
  |  Branch (247:9): [True: 10.2k, False: 0]
  ------------------
  248|  10.2k|    {
  249|  10.2k|        bool needs_dot = true;
  250|  88.2k|        for (const char* q = sbeg; q < send; ++q)
  ------------------
  |  Branch (250:36): [True: 78.0k, False: 10.2k]
  ------------------
  251|  78.0k|        {
  252|  78.0k|            switch (*q)
  253|  78.0k|            {
  254|    899|            case '-':
  ------------------
  |  Branch (254:13): [True: 899, False: 77.1k]
  ------------------
  255|  2.71k|            case '0':
  ------------------
  |  Branch (255:13): [True: 1.81k, False: 76.2k]
  ------------------
  256|  10.7k|            case '1':
  ------------------
  |  Branch (256:13): [True: 8.00k, False: 70.0k]
  ------------------
  257|  26.2k|            case '2':
  ------------------
  |  Branch (257:13): [True: 15.5k, False: 62.5k]
  ------------------
  258|  36.7k|            case '3':
  ------------------
  |  Branch (258:13): [True: 10.5k, False: 67.5k]
  ------------------
  259|  39.1k|            case '4':
  ------------------
  |  Branch (259:13): [True: 2.41k, False: 75.6k]
  ------------------
  260|  40.5k|            case '5':
  ------------------
  |  Branch (260:13): [True: 1.32k, False: 76.7k]
  ------------------
  261|  42.2k|            case '6':
  ------------------
  |  Branch (261:13): [True: 1.73k, False: 76.3k]
  ------------------
  262|  49.7k|            case '7':
  ------------------
  |  Branch (262:13): [True: 7.48k, False: 70.5k]
  ------------------
  263|  53.7k|            case '8':
  ------------------
  |  Branch (263:13): [True: 4.00k, False: 74.0k]
  ------------------
  264|  57.4k|            case '9':
  ------------------
  |  Branch (264:13): [True: 3.74k, False: 74.3k]
  ------------------
  265|  66.0k|            case '+':
  ------------------
  |  Branch (265:13): [True: 8.58k, False: 69.4k]
  ------------------
  266|  66.0k|                result.push_back(*q);
  267|  66.0k|                break;
  268|  8.74k|            case 'e':
  ------------------
  |  Branch (268:13): [True: 8.74k, False: 69.3k]
  ------------------
  269|  8.74k|            case 'E':
  ------------------
  |  Branch (269:13): [True: 0, False: 78.0k]
  ------------------
  270|  8.74k|                result.push_back('e');
  271|  8.74k|                needs_dot = false;
  272|  8.74k|                break;
  273|  3.27k|            default:
  ------------------
  |  Branch (273:13): [True: 3.27k, False: 74.8k]
  ------------------
  274|  3.27k|                if (*q == decimal_point)
  ------------------
  |  Branch (274:21): [True: 3.27k, False: 0]
  ------------------
  275|  3.27k|                {
  276|  3.27k|                    needs_dot = false;
  277|  3.27k|                    result.push_back('.');
  278|  3.27k|                }
  279|  3.27k|                break;
  280|  78.0k|            }
  281|  78.0k|        }
  282|  10.2k|        if (needs_dot)
  ------------------
  |  Branch (282:13): [True: 485, False: 9.73k]
  ------------------
  283|    485|        {
  284|    485|            result.push_back('.');
  285|    485|            result.push_back('0');
  286|    485|        }
  287|  10.2k|    }
  288|  10.2k|}
_ZN8jsoncons15prettify_stringINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvPKciiiiRT_:
  171|  90.7k|{
  172|  90.7k|    int nb_digits = length;
  173|  90.7k|    int offset;
  174|       |    /* v = buffer * 10^k
  175|       |       kk is such that 10^(kk-1) <= v < 10^kk
  176|       |       this way kk gives the position of the decimal point.
  177|       |    */
  178|  90.7k|    int kk = nb_digits + k;
  179|       |
  180|  90.7k|    if (nb_digits <= kk && kk <= max_exp)
  ------------------
  |  Branch (180:9): [True: 77.5k, False: 13.2k]
  |  Branch (180:28): [True: 72.0k, False: 5.40k]
  ------------------
  181|  72.0k|    {
  182|       |        /* the first digits are already in. Add some 0s and call it a day. */
  183|       |        /* the max_exp is a personal choice. Only 16 digits could possibly be relevant.
  184|       |         * Basically we want to print 12340000000 rather than 1234.0e7 or 1.234e10 */
  185|   154k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (185:25): [True: 82.8k, False: 72.0k]
  ------------------
  186|  82.8k|        {
  187|  82.8k|            result.push_back(buffer[i]);
  188|  82.8k|        }
  189|  1.09M|        for (int i = nb_digits; i < kk; ++i)
  ------------------
  |  Branch (189:33): [True: 1.02M, False: 72.0k]
  ------------------
  190|  1.02M|        {
  191|  1.02M|            result.push_back('0');
  192|  1.02M|        }
  193|  72.0k|        result.push_back('.');
  194|  72.0k|        result.push_back('0');
  195|  72.0k|    } 
  196|  18.6k|    else if (0 < kk && kk <= max_exp)
  ------------------
  |  Branch (196:14): [True: 12.1k, False: 6.48k]
  |  Branch (196:24): [True: 6.77k, False: 5.40k]
  ------------------
  197|  6.77k|    {
  198|       |        /* comma number. Just insert a '.' at the correct location. */
  199|  43.6k|        for (int i = 0; i < kk; ++i)
  ------------------
  |  Branch (199:25): [True: 36.8k, False: 6.77k]
  ------------------
  200|  36.8k|        {
  201|  36.8k|            result.push_back(buffer[i]);
  202|  36.8k|        }
  203|  6.77k|        result.push_back('.');
  204|  51.8k|        for (int i = kk; i < nb_digits; ++i)
  ------------------
  |  Branch (204:26): [True: 45.0k, False: 6.77k]
  ------------------
  205|  45.0k|        {
  206|  45.0k|            result.push_back(buffer[i]);
  207|  45.0k|        }
  208|  6.77k|    } 
  209|  11.8k|    else if (min_exp < kk && kk <= 0)
  ------------------
  |  Branch (209:14): [True: 7.26k, False: 4.63k]
  |  Branch (209:30): [True: 1.85k, False: 5.40k]
  ------------------
  210|  1.85k|    {
  211|  1.85k|        offset = 2 - kk;
  212|       |
  213|  1.85k|        result.push_back('0');
  214|  1.85k|        result.push_back('.');
  215|  3.36k|        for (int i = 2; i < offset; ++i) 
  ------------------
  |  Branch (215:25): [True: 1.50k, False: 1.85k]
  ------------------
  216|  1.50k|            result.push_back('0');
  217|  6.89k|        for (int i = 0; i < nb_digits; ++i)
  ------------------
  |  Branch (217:25): [True: 5.04k, False: 1.85k]
  ------------------
  218|  5.04k|        {
  219|  5.04k|            result.push_back(buffer[i]);
  220|  5.04k|        }
  221|  1.85k|    } 
  222|  10.0k|    else if (nb_digits == 1)
  ------------------
  |  Branch (222:14): [True: 1.97k, False: 8.06k]
  ------------------
  223|  1.97k|    {
  224|  1.97k|        result.push_back(buffer[0]);
  225|  1.97k|        result.push_back('e');
  226|  1.97k|        fill_exponent(kk - 1, result);
  227|  1.97k|    } 
  228|  8.06k|    else
  229|  8.06k|    {
  230|  8.06k|        result.push_back(buffer[0]);
  231|  8.06k|        result.push_back('.');
  232|  77.1k|        for (int i = 1; i < nb_digits; ++i)
  ------------------
  |  Branch (232:25): [True: 69.0k, False: 8.06k]
  ------------------
  233|  69.0k|        {
  234|  69.0k|            result.push_back(buffer[i]);
  235|  69.0k|        }
  236|  8.06k|        result.push_back('e');
  237|  8.06k|        fill_exponent(kk - 1, result);
  238|  8.06k|    }
  239|  90.7k|}
_ZN8jsoncons13fill_exponentINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEviRT_:
  136|  10.0k|{
  137|  10.0k|    if (K < 0)
  ------------------
  |  Branch (137:9): [True: 4.63k, False: 5.40k]
  ------------------
  138|  4.63k|    {
  139|  4.63k|        result.push_back('-');
  140|  4.63k|        K = -K;
  141|  4.63k|    }
  142|  5.40k|    else
  143|  5.40k|    {
  144|  5.40k|        result.push_back('+'); // compatibility with sprintf
  145|  5.40k|    }
  146|       |
  147|  10.0k|    if (K < 10)
  ------------------
  |  Branch (147:9): [True: 2.27k, False: 7.75k]
  ------------------
  148|  2.27k|    {
  149|  2.27k|        result.push_back('0'); // compatibility with sprintf
  150|  2.27k|        result.push_back((char)('0' + K));
  151|  2.27k|    }
  152|  7.75k|    else if (K < 100)
  ------------------
  |  Branch (152:14): [True: 4.94k, False: 2.81k]
  ------------------
  153|  4.94k|    {
  154|  4.94k|        result.push_back((char)('0' + K / 10)); K %= 10;
  155|  4.94k|        result.push_back((char)('0' + K));
  156|  4.94k|    }
  157|  2.81k|    else if (K < 1000)
  ------------------
  |  Branch (157:14): [True: 2.81k, False: 0]
  ------------------
  158|  2.81k|    {
  159|  2.81k|        result.push_back((char)('0' + K / 100)); K %= 100;
  160|  2.81k|        result.push_back((char)('0' + K / 10)); K %= 10;
  161|  2.81k|        result.push_back((char)('0' + K));
  162|  2.81k|    }
  163|      0|    else
  164|      0|    {
  165|      0|        jsoncons::from_integer(K, result);
  166|      0|    }
  167|  10.0k|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_:
  475|   102k|{
  476|   102k|    return dtoa_general(v, decimal_point, result, std::integral_constant<bool, std::numeric_limits<double>::is_iec559>());
  477|   102k|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_NS1_17integral_constantIbLb1EEE:
  366|   102k|{
  367|   102k|    if (v == 0)
  ------------------
  |  Branch (367:9): [True: 1.56k, False: 100k]
  ------------------
  368|  1.56k|    {
  369|  1.56k|        result.push_back('0');
  370|  1.56k|        result.push_back('.');
  371|  1.56k|        result.push_back('0');
  372|  1.56k|        return true;
  373|  1.56k|    }
  374|       |
  375|   100k|    int length = 0;
  376|   100k|    int k;
  377|       |
  378|   100k|    char buffer[100];
  379|       |
  380|   100k|    double u = std::signbit(v) ? -v : v;
  ------------------
  |  Branch (380:16): [True: 2.74k, False: 98.2k]
  ------------------
  381|   100k|    if (jsoncons::detail::grisu3(u, buffer, &length, &k))
  ------------------
  |  Branch (381:9): [True: 90.7k, False: 10.2k]
  ------------------
  382|  90.7k|    {
  383|  90.7k|        if (std::signbit(v))
  ------------------
  |  Branch (383:13): [True: 2.01k, False: 88.7k]
  ------------------
  384|  2.01k|        {
  385|  2.01k|            result.push_back('-');
  386|  2.01k|        }
  387|       |        // min exp: -4 is consistent with sprintf
  388|       |        // max exp: std::numeric_limits<double>::max_digits10
  389|  90.7k|        jsoncons::prettify_string(buffer, length, k, -4, std::numeric_limits<double>::max_digits10, result);
  390|  90.7k|        return true;
  391|  90.7k|    }
  392|  10.2k|    else
  393|  10.2k|    {
  394|  10.2k|        return dtoa_general(v, decimal_point, result, std::false_type());
  395|  10.2k|    }
  396|   100k|}
_ZN8jsoncons12dtoa_generalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbdcRT_NS1_17integral_constantIbLb0EEE:
  329|  10.2k|{
  330|  10.2k|    if (val == 0)
  ------------------
  |  Branch (330:9): [True: 0, False: 10.2k]
  ------------------
  331|      0|    {
  332|      0|        result.push_back('0');
  333|      0|        result.push_back('.');
  334|      0|        result.push_back('0');
  335|      0|        return true;
  336|      0|    }
  337|       |
  338|  10.2k|    char buffer[100];
  339|  10.2k|    int precision = std::numeric_limits<double>::digits10;
  340|  10.2k|    int length = snprintf(buffer, sizeof(buffer), "%1.*g", precision, val);
  341|  10.2k|    if (length < 0)
  ------------------
  |  Branch (341:9): [True: 0, False: 10.2k]
  ------------------
  342|      0|    {
  343|      0|        return false;
  344|      0|    }
  345|  10.2k|    double x{0};
  346|  10.2k|    auto res = decstr_to_double(buffer, length, x);
  347|  10.2k|    if (res.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (347:9): [True: 0, False: 10.2k]
  ------------------
  348|      0|    {
  349|      0|        return false;
  350|      0|    }
  351|  10.2k|    if (x != val)
  ------------------
  |  Branch (351:9): [True: 1.54k, False: 8.67k]
  ------------------
  352|  1.54k|    {
  353|  1.54k|        const int precision2 = std::numeric_limits<double>::max_digits10;
  354|  1.54k|        length = snprintf(buffer, sizeof(buffer), "%1.*g", precision2, val);
  355|  1.54k|        if (length < 0)
  ------------------
  |  Branch (355:13): [True: 0, False: 1.54k]
  ------------------
  356|      0|        {
  357|      0|            return false;
  358|      0|        }
  359|  1.54k|    }
  360|  10.2k|    dump_buffer(buffer, length, decimal_point, result);
  361|  10.2k|    return true;
  362|  10.2k|}

_ZN8jsoncons14unicode_traits24detect_encoding_from_bomIcEENSt3__19enable_ifIXsr6nonstd8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m:
   66|  3.49k|    {
   67|  3.49k|        static constexpr uint8_t bom_utf8[] = {0xef,0xbb,0xbf}; 
   68|  3.49k|        static constexpr uint8_t bom_utf16le[] = {0xff,0xfe}; 
   69|  3.49k|        static constexpr uint8_t bom_utf16be[] = {0xfe,0xff}; 
   70|  3.49k|        static constexpr uint8_t bom_utf32le[] = {0xff,0xfe,0x00,0x00}; 
   71|  3.49k|        static constexpr uint8_t bom_utf32be[] = {0x00,0x00,0xfe,0xff}; 
   72|       |
   73|  3.49k|        if (length >= 4 && !memcmp(data,bom_utf32le,4))
  ------------------
  |  Branch (73:13): [True: 3.16k, False: 322]
  |  Branch (73:28): [True: 1, False: 3.16k]
  ------------------
   74|      1|        {
   75|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32le};
   76|      1|        }
   77|  3.49k|        else if (length >= 4 && !memcmp(data,bom_utf32be,4))
  ------------------
  |  Branch (77:18): [True: 3.16k, False: 322]
  |  Branch (77:33): [True: 1, False: 3.16k]
  ------------------
   78|      1|        {
   79|      1|            return detect_encoding_result<CharT>{data+4,encoding_kind::utf32be};
   80|      1|        }
   81|  3.48k|        else if (length >= 2 && !memcmp(data,bom_utf16le,2))
  ------------------
  |  Branch (81:18): [True: 3.45k, False: 39]
  |  Branch (81:33): [True: 7, False: 3.44k]
  ------------------
   82|      7|        {
   83|      7|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16le};
   84|      7|        }
   85|  3.48k|        else if (length >= 2 && !memcmp(data,bom_utf16be,2))
  ------------------
  |  Branch (85:18): [True: 3.44k, False: 39]
  |  Branch (85:33): [True: 1, False: 3.44k]
  ------------------
   86|      1|        {
   87|      1|            return detect_encoding_result<CharT>{data+2,encoding_kind::utf16be};
   88|      1|        }
   89|  3.48k|        else if (length >= 3 && !memcmp(data,bom_utf8,3))
  ------------------
  |  Branch (89:18): [True: 3.34k, False: 141]
  |  Branch (89:33): [True: 2, False: 3.33k]
  ------------------
   90|      2|        {
   91|      2|            return detect_encoding_result<CharT>{data+3,encoding_kind::utf8};
   92|      2|        }
   93|  3.47k|        else
   94|  3.47k|        {
   95|  3.47k|            return detect_encoding_result<CharT>{data,encoding_kind::undetected};
   96|  3.47k|        }
   97|  3.49k|    }

_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_EC2EOSA_RKS8_:
  147|  3.49k|       : basic_csv_encoder(std::forward<Sink>(sink), basic_csv_encode_options<CharT>(), alloc)
  148|  3.49k|    {
  149|  3.49k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_EC2EOSA_RKNS0_24basic_csv_encode_optionsIcEERKS8_:
  154|  3.49k|      : sink_(std::forward<Sink>(sink)),
  155|  3.49k|        flat_(options.flat()),
  156|  3.49k|        max_nesting_depth_(options.max_nesting_depth()),
  157|  3.49k|        has_column_mapping_(!options.column_mapping().empty()),
  158|  3.49k|        has_column_names_(!options.column_names().empty()),
  159|  3.49k|        field_delimiter_(options.field_delimiter()),
  160|  3.49k|        subfield_delimiter_(options.subfield_delimiter()),
  161|  3.49k|        line_delimiter_(options.line_delimiter()),
  162|  3.49k|        quote_style_(options.quote_style()),
  163|  3.49k|        quote_char_(options.quote_char()),
  164|  3.49k|        quote_escape_char_(options.quote_escape_char()),
  165|  3.49k|        enable_nan_to_num_(options.enable_nan_to_num()),
  166|  3.49k|        nan_to_num_(options.nan_to_num()),
  167|  3.49k|        enable_nan_to_str_(options.enable_nan_to_str()),
  168|  3.49k|        nan_to_str_(options.nan_to_str()),
  169|  3.49k|        enable_inf_to_num_(options.enable_inf_to_num()),
  170|  3.49k|        inf_to_num_(options.inf_to_num()),
  171|  3.49k|        enable_inf_to_str_(options.enable_inf_to_str()),
  172|  3.49k|        inf_to_str_(options.inf_to_str()),
  173|  3.49k|        enable_neginf_to_num_(options.enable_neginf_to_num()),
  174|  3.49k|        neginf_to_num_(options.neginf_to_num()),
  175|  3.49k|        enable_neginf_to_str_(options.enable_neginf_to_str()),
  176|  3.49k|        neginf_to_str_(options.neginf_to_str()),
  177|  3.49k|        alloc_(alloc),
  178|  3.49k|        stack_(alloc),
  179|  3.49k|        fp_(options.float_format(), options.precision()),
  180|  3.49k|        column_names_(alloc),
  181|  3.49k|        column_paths_(alloc),
  182|  3.49k|        column_path_name_map_(alloc),
  183|  3.49k|        column_path_value_map_(alloc),
  184|  3.49k|        column_path_column_map_(alloc),
  185|  3.49k|        value_buffer_(alloc),
  186|  3.49k|        column_it_(column_path_column_map_.end())
  187|  3.49k|    {
  188|  3.49k|        if (has_column_mapping_)
  ------------------
  |  Branch (188:13): [True: 0, False: 3.49k]
  ------------------
  189|      0|        {
  190|      0|            for (const auto& item : options.column_mapping())
  ------------------
  |  Branch (190:35): [True: 0, False: 0]
  ------------------
  191|      0|            {
  192|      0|                column_paths_.emplace_back(item.first);
  193|      0|                column_path_name_map_.emplace(item.first, item.second);
  194|      0|                column_path_value_map_.emplace(item.first, string_type{alloc_});
  195|      0|            }
  196|      0|        }
  197|  3.49k|        if (has_column_names_)
  ------------------
  |  Branch (197:13): [True: 0, False: 3.49k]
  ------------------
  198|      0|        {
  199|      0|            jsoncons::csv::detail::parse_column_names(options.column_names(), column_names_);
  200|      0|        }
  201|  3.49k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E15visit_end_arrayERKNS_11ser_contextERNS3_10error_codeE:
  622|   172k|    {
  623|   172k|        JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   54|   172k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 172k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  624|       |        
  625|   172k|        switch (stack_.back().item_kind_)
  626|   172k|        {
  627|      0|            case stack_item_kind::row_mapping:
  ------------------
  |  Branch (627:13): [True: 0, False: 172k]
  ------------------
  628|  3.37k|            case stack_item_kind::flat_row_mapping:
  ------------------
  |  Branch (628:13): [True: 3.37k, False: 168k]
  ------------------
  629|  3.37k|                break;
  630|      0|            case stack_item_kind::flat_row:
  ------------------
  |  Branch (630:13): [True: 0, False: 172k]
  ------------------
  631|      0|                if (parent(stack_).item_kind_ == stack_item_kind::flat_row_mapping)
  ------------------
  |  Branch (631:21): [True: 0, False: 0]
  ------------------
  632|      0|                {
  633|      0|                    if (stack_[0].count_ == 0 && !column_path_name_map_.empty())
  ------------------
  |  Branch (633:25): [True: 0, False: 0]
  |  Branch (633:50): [True: 0, False: 0]
  ------------------
  634|      0|                    {
  635|      0|                        std::size_t col = 0;
  636|      0|                        for (std::size_t i = 0; i < column_paths_.size(); ++i)
  ------------------
  |  Branch (636:49): [True: 0, False: 0]
  ------------------
  637|      0|                        {
  638|      0|                            auto it = column_path_name_map_.find(column_paths_[i]);
  639|      0|                            if (it != column_path_name_map_.end())
  ------------------
  |  Branch (639:33): [True: 0, False: 0]
  ------------------
  640|      0|                            {
  641|      0|                                if (col > 0)
  ------------------
  |  Branch (641:37): [True: 0, False: 0]
  ------------------
  642|      0|                                {
  643|      0|                                    sink_.push_back(field_delimiter_);
  644|      0|                                }
  645|      0|                                sink_.append(it->second.data(), it->second.length());
  646|      0|                                ++col;
  647|      0|                            }
  648|      0|                        }
  649|      0|                        sink_.append(line_delimiter_.data(), line_delimiter_.length());
  650|      0|                    }
  651|       |
  652|      0|                    for (std::size_t i = 0; i < column_paths_.size(); ++i)
  ------------------
  |  Branch (652:45): [True: 0, False: 0]
  ------------------
  653|      0|                    {
  654|      0|                        if (i > 0)
  ------------------
  |  Branch (654:29): [True: 0, False: 0]
  ------------------
  655|      0|                        {
  656|      0|                            sink_.push_back(field_delimiter_);
  657|      0|                        }
  658|      0|                        auto it = column_path_value_map_.find(column_paths_[i]);
  659|      0|                        if (it != column_path_value_map_.end())
  ------------------
  |  Branch (659:29): [True: 0, False: 0]
  ------------------
  660|      0|                        {
  661|      0|                            sink_.append(it->second.data(), it->second.length());
  662|      0|                            it->second.clear();
  663|      0|                        }
  664|      0|                    }
  665|      0|                    sink_.append(line_delimiter_.data(), line_delimiter_.length());
  666|      0|                }
  667|      0|                break;
  668|   168k|            case stack_item_kind::stream_flat_row:
  ------------------
  |  Branch (668:13): [True: 168k, False: 3.37k]
  ------------------
  669|   168k|                if (parent(stack_).item_kind_ == stack_item_kind::flat_row_mapping)
  ------------------
  |  Branch (669:21): [True: 168k, False: 0]
  ------------------
  670|   168k|                {
  671|   168k|                    sink_.append(line_delimiter_.data(), line_delimiter_.length());
  672|   168k|                }
  673|   168k|                break;
  674|      0|            case stack_item_kind::multivalued_field:
  ------------------
  |  Branch (674:13): [True: 0, False: 172k]
  ------------------
  675|      0|            {
  676|      0|                auto it = column_path_value_map_.find(parent(stack_).column_path_);
  677|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (677:21): [True: 0, False: 0]
  ------------------
  678|      0|                {
  679|      0|                    it->second = value_buffer_;
  680|      0|                }
  681|      0|                break;
  682|      0|            }
  683|      0|            case stack_item_kind::stream_multivalued_field:
  ------------------
  |  Branch (683:13): [True: 0, False: 172k]
  ------------------
  684|      0|            {
  685|      0|                if (parent(stack_).count_ > 0)
  ------------------
  |  Branch (685:21): [True: 0, False: 0]
  ------------------
  686|      0|                {
  687|      0|                    sink_.push_back(field_delimiter_);
  688|      0|                }
  689|      0|                sink_.append(value_buffer_.data(), value_buffer_.size());
  690|      0|                break;
  691|      0|            }
  692|      0|            case stack_item_kind::row:
  ------------------
  |  Branch (692:13): [True: 0, False: 172k]
  ------------------
  693|      0|                if (parent(stack_).item_kind_ == stack_item_kind::row_mapping)
  ------------------
  |  Branch (693:21): [True: 0, False: 0]
  ------------------
  694|      0|                {
  695|      0|                    if (stack_[0].count_ == 0)
  ------------------
  |  Branch (695:25): [True: 0, False: 0]
  ------------------
  696|      0|                    {
  697|      0|                        std::size_t col = 0;
  698|      0|                        for (std::size_t i = 0; i < column_paths_.size(); ++i)
  ------------------
  |  Branch (698:49): [True: 0, False: 0]
  ------------------
  699|      0|                        {
  700|      0|                            auto it = column_path_name_map_.find(column_paths_[i]);
  701|      0|                            if (it != column_path_name_map_.end())
  ------------------
  |  Branch (701:33): [True: 0, False: 0]
  ------------------
  702|      0|                            {
  703|      0|                                if (col > 0)
  ------------------
  |  Branch (703:37): [True: 0, False: 0]
  ------------------
  704|      0|                                {
  705|      0|                                    sink_.push_back(field_delimiter_);
  706|      0|                                }
  707|      0|                                sink_.append(it->second.data(), it->second.length());
  708|      0|                                ++col;
  709|      0|                            }
  710|      0|                        }
  711|      0|                        sink_.append(line_delimiter_.data(), 
  712|      0|                            line_delimiter_.length());
  713|      0|                    }
  714|       |                    
  715|      0|                    for (std::size_t i = 0; i < column_paths_.size(); ++i)
  ------------------
  |  Branch (715:45): [True: 0, False: 0]
  ------------------
  716|      0|                    {
  717|      0|                        if (i > 0)
  ------------------
  |  Branch (717:29): [True: 0, False: 0]
  ------------------
  718|      0|                        {
  719|      0|                            sink_.push_back(field_delimiter_);
  720|      0|                        }
  721|      0|                        auto it = column_path_value_map_.find(column_paths_[i]);
  722|      0|                        if (it != column_path_value_map_.end())
  ------------------
  |  Branch (722:29): [True: 0, False: 0]
  ------------------
  723|      0|                        {
  724|      0|                            sink_.append(it->second.data(), it->second.length());
  725|      0|                            it->second.clear();
  726|      0|                        }
  727|      0|                    }
  728|      0|                    sink_.append(line_delimiter_.data(), line_delimiter_.length());
  729|      0|                }
  730|      0|                break;
  731|      0|            case stack_item_kind::column:
  ------------------
  |  Branch (731:13): [True: 0, False: 172k]
  ------------------
  732|      0|                ++column_index_;
  733|      0|                break;
  734|      0|            case stack_item_kind::column_multivalued_field:
  ------------------
  |  Branch (734:13): [True: 0, False: 172k]
  ------------------
  735|      0|                column_it_->second.emplace_back(value_buffer_.data(),value_buffer_.length());
  736|      0|                break;
  737|      0|            case stack_item_kind::unmapped:
  ------------------
  |  Branch (737:13): [True: 0, False: 172k]
  ------------------
  738|      0|                break;
  739|      0|            default:
  ------------------
  |  Branch (739:13): [True: 0, False: 172k]
  ------------------
  740|       |                //std::cout << "visit_end_array " << (int)stack_.back().item_kind_ << "\n"; 
  741|      0|                ec = csv_errc::source_error;
  742|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  743|   172k|        }
  744|   172k|        stack_.pop_back();
  745|       |
  746|   172k|        if (!stack_.empty())
  ------------------
  |  Branch (746:13): [True: 168k, False: 3.37k]
  ------------------
  747|   168k|        {
  748|   168k|            ++stack_.back().count_;
  749|   168k|        }
  750|   172k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   172k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  751|   172k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E6parentERKNS3_6vectorINSB_10stack_itemENS7_ISD_EEEE:
   99|   168k|    {
  100|   168k|        JSONCONS_ASSERT(stack.size() >= 2);
  ------------------
  |  |   54|   168k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 168k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  101|   168k|        return stack[stack.size() - 2];
  102|   168k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1171|  26.9k|    {
 1172|  26.9k|        JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   54|  26.9k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 26.9k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1173|  26.9k|        switch (stack_.back().item_kind_)
 1174|  26.9k|        {
 1175|      0|            case stack_item_kind::flat_object:
  ------------------
  |  Branch (1175:13): [True: 0, False: 26.9k]
  ------------------
 1176|      0|            case stack_item_kind::object:
  ------------------
  |  Branch (1176:13): [True: 0, False: 26.9k]
  ------------------
 1177|      0|            {
 1178|      0|                if (stack_[0].count_ == 0)
  ------------------
  |  Branch (1178:21): [True: 0, False: 0]
  ------------------
 1179|      0|                {
 1180|      0|                    if (!has_column_mapping_)
  ------------------
  |  Branch (1180:25): [True: 0, False: 0]
  ------------------
 1181|      0|                    {
 1182|      0|                        string_type str = stack_.back().column_path_;
 1183|      0|                        column_paths_.emplace_back(str);
 1184|      0|                        column_path_value_map_.emplace(std::move(str), string_type{alloc_});
 1185|      0|                    }
 1186|      0|                }
 1187|      0|                auto it = column_path_value_map_.find(stack_.back().column_path_);
 1188|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (1188:21): [True: 0, False: 0]
  ------------------
 1189|      0|                {
 1190|      0|                    write_uint64_value(val, it->second);
 1191|      0|                }
 1192|      0|                break;
 1193|      0|            }
 1194|      0|            case stack_item_kind::flat_row:
  ------------------
  |  Branch (1194:13): [True: 0, False: 26.9k]
  ------------------
 1195|      0|            case stack_item_kind::row:
  ------------------
  |  Branch (1195:13): [True: 0, False: 26.9k]
  ------------------
 1196|      0|            {
 1197|      0|                append_array_path_component();
 1198|      0|                auto it = column_path_value_map_.find(stack_.back().column_path_);
 1199|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (1199:21): [True: 0, False: 0]
  ------------------
 1200|      0|                {
 1201|      0|                    write_uint64_value(val, it->second);
 1202|      0|                }
 1203|      0|                break;
 1204|      0|            }
 1205|  26.9k|            case stack_item_kind::stream_flat_row:
  ------------------
  |  Branch (1205:13): [True: 26.9k, False: 0]
  ------------------
 1206|  26.9k|            {
 1207|  26.9k|                if (stack_.back().count_ > 0)
  ------------------
  |  Branch (1207:21): [True: 12.1k, False: 14.7k]
  ------------------
 1208|  12.1k|                {
 1209|  12.1k|                    sink_.push_back(field_delimiter_);
 1210|  12.1k|                }
 1211|  26.9k|                value_buffer_.clear();
 1212|  26.9k|                write_uint64_value(val, value_buffer_);
 1213|  26.9k|                sink_.append(value_buffer_.data(), value_buffer_.size());
 1214|  26.9k|                break;
 1215|      0|            }
 1216|      0|            case stack_item_kind::multivalued_field:
  ------------------
  |  Branch (1216:13): [True: 0, False: 26.9k]
  ------------------
 1217|      0|            case stack_item_kind::column_multivalued_field:
  ------------------
  |  Branch (1217:13): [True: 0, False: 26.9k]
  ------------------
 1218|      0|            case stack_item_kind::stream_multivalued_field:
  ------------------
  |  Branch (1218:13): [True: 0, False: 26.9k]
  ------------------
 1219|      0|            {
 1220|      0|                if (!value_buffer_.empty())
  ------------------
  |  Branch (1220:21): [True: 0, False: 0]
  ------------------
 1221|      0|                {
 1222|      0|                    value_buffer_.push_back(subfield_delimiter_);
 1223|      0|                }
 1224|      0|                write_uint64_value(val, value_buffer_);
 1225|      0|                break;
 1226|      0|            }
 1227|      0|            case stack_item_kind::column:
  ------------------
  |  Branch (1227:13): [True: 0, False: 26.9k]
  ------------------
 1228|      0|            {
 1229|      0|                (*column_it_).second.emplace_back();
 1230|      0|                write_uint64_value(val, (*column_it_).second.back());
 1231|      0|                break;
 1232|      0|            }
 1233|      0|            default:
  ------------------
  |  Branch (1233:13): [True: 0, False: 26.9k]
  ------------------
 1234|      0|                break;
 1235|  26.9k|        }
 1236|  26.9k|        ++stack_.back().count_;
 1237|  26.9k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  26.9k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1238|  26.9k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E18write_uint64_valueEmRS9_:
 1392|  26.9k|    {
 1393|  26.9k|        jsoncons::from_integer(val,str);
 1394|  26.9k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1098|  41.2k|    {
 1099|  41.2k|        JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   54|  41.2k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 41.2k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1100|  41.2k|        switch (stack_.back().item_kind_)
 1101|  41.2k|        {
 1102|      0|            case stack_item_kind::flat_object:
  ------------------
  |  Branch (1102:13): [True: 0, False: 41.2k]
  ------------------
 1103|      0|            case stack_item_kind::object:
  ------------------
  |  Branch (1103:13): [True: 0, False: 41.2k]
  ------------------
 1104|      0|            {
 1105|      0|                if (stack_[0].count_ == 0)
  ------------------
  |  Branch (1105:21): [True: 0, False: 0]
  ------------------
 1106|      0|                {
 1107|      0|                    if (!has_column_mapping_)
  ------------------
  |  Branch (1107:25): [True: 0, False: 0]
  ------------------
 1108|      0|                    {
 1109|      0|                        string_type str = stack_.back().column_path_;
 1110|      0|                        column_paths_.emplace_back(str);
 1111|      0|                        column_path_value_map_.emplace(std::move(str), string_type{alloc_});
 1112|      0|                    }
 1113|      0|                }
 1114|      0|                auto it = column_path_value_map_.find(stack_.back().column_path_);
 1115|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (1115:21): [True: 0, False: 0]
  ------------------
 1116|      0|                {
 1117|      0|                    write_int64_value(val, it->second);
 1118|      0|                }
 1119|      0|                break;
 1120|      0|            }
 1121|      0|            case stack_item_kind::flat_row:
  ------------------
  |  Branch (1121:13): [True: 0, False: 41.2k]
  ------------------
 1122|      0|            case stack_item_kind::row:
  ------------------
  |  Branch (1122:13): [True: 0, False: 41.2k]
  ------------------
 1123|      0|            {
 1124|      0|                append_array_path_component();
 1125|      0|                auto it = column_path_value_map_.find(stack_.back().column_path_);
 1126|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (1126:21): [True: 0, False: 0]
  ------------------
 1127|      0|                {
 1128|      0|                    write_int64_value(val, it->second);
 1129|      0|                }
 1130|      0|                break;
 1131|      0|            }
 1132|  41.2k|            case stack_item_kind::stream_flat_row:
  ------------------
  |  Branch (1132:13): [True: 41.2k, False: 0]
  ------------------
 1133|  41.2k|            {
 1134|  41.2k|                if (stack_.back().count_ > 0)
  ------------------
  |  Branch (1134:21): [True: 38.6k, False: 2.65k]
  ------------------
 1135|  38.6k|                {
 1136|  38.6k|                    sink_.push_back(field_delimiter_);
 1137|  38.6k|                }
 1138|  41.2k|                value_buffer_.clear();
 1139|  41.2k|                write_int64_value(val, value_buffer_);
 1140|  41.2k|                sink_.append(value_buffer_.data(), value_buffer_.size());
 1141|  41.2k|                break;
 1142|      0|            }
 1143|      0|            case stack_item_kind::column_multivalued_field:
  ------------------
  |  Branch (1143:13): [True: 0, False: 41.2k]
  ------------------
 1144|      0|            case stack_item_kind::multivalued_field:
  ------------------
  |  Branch (1144:13): [True: 0, False: 41.2k]
  ------------------
 1145|      0|            case stack_item_kind::stream_multivalued_field:
  ------------------
  |  Branch (1145:13): [True: 0, False: 41.2k]
  ------------------
 1146|      0|            {
 1147|      0|                if (!value_buffer_.empty())
  ------------------
  |  Branch (1147:21): [True: 0, False: 0]
  ------------------
 1148|      0|                {
 1149|      0|                    value_buffer_.push_back(subfield_delimiter_);
 1150|      0|                }
 1151|      0|                write_int64_value(val, value_buffer_);
 1152|      0|                break;
 1153|      0|            }
 1154|      0|            case stack_item_kind::column:
  ------------------
  |  Branch (1154:13): [True: 0, False: 41.2k]
  ------------------
 1155|      0|            {
 1156|      0|                (*column_it_).second.emplace_back();
 1157|      0|                write_int64_value(val, (*column_it_).second.back());
 1158|      0|                break;
 1159|      0|            }
 1160|      0|            default:
  ------------------
  |  Branch (1160:13): [True: 0, False: 41.2k]
  ------------------
 1161|      0|                break;
 1162|  41.2k|        }
 1163|  41.2k|        ++stack_.back().count_;
 1164|  41.2k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  41.2k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1165|  41.2k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E17write_int64_valueElRS9_:
 1387|  41.2k|    {
 1388|  41.2k|        jsoncons::from_integer(val,str);
 1389|  41.2k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1021|   109k|    {
 1022|   109k|        JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   54|   109k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 109k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1023|   109k|        switch (stack_.back().item_kind_)
 1024|   109k|        {
 1025|      0|            case stack_item_kind::flat_object:
  ------------------
  |  Branch (1025:13): [True: 0, False: 109k]
  ------------------
 1026|      0|            case stack_item_kind::object:
  ------------------
  |  Branch (1026:13): [True: 0, False: 109k]
  ------------------
 1027|      0|            {
 1028|      0|                if (stack_[0].count_ == 0)
  ------------------
  |  Branch (1028:21): [True: 0, False: 0]
  ------------------
 1029|      0|                {
 1030|      0|                    if (!has_column_mapping_)
  ------------------
  |  Branch (1030:25): [True: 0, False: 0]
  ------------------
 1031|      0|                    {
 1032|      0|                        string_type str = stack_.back().column_path_;
 1033|      0|                        column_paths_.emplace_back(str);
 1034|      0|                        column_path_value_map_.emplace(std::move(str), string_type{alloc_});
 1035|      0|                    }
 1036|      0|                }
 1037|      0|                auto it = column_path_value_map_.find(stack_.back().column_path_);
 1038|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (1038:21): [True: 0, False: 0]
  ------------------
 1039|      0|                {
 1040|      0|                    write_double_value(val, context, it->second, ec);
 1041|      0|                }
 1042|      0|                break;
 1043|      0|            }
 1044|      0|            case stack_item_kind::flat_row:
  ------------------
  |  Branch (1044:13): [True: 0, False: 109k]
  ------------------
 1045|      0|            case stack_item_kind::row:
  ------------------
  |  Branch (1045:13): [True: 0, False: 109k]
  ------------------
 1046|      0|            {
 1047|      0|                append_array_path_component();
 1048|      0|                auto it = column_path_value_map_.find(stack_.back().column_path_);
 1049|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (1049:21): [True: 0, False: 0]
  ------------------
 1050|      0|                {
 1051|      0|                    write_double_value(val, context, it->second, ec);
 1052|      0|                }
 1053|      0|                break;
 1054|      0|            }
 1055|   109k|            case stack_item_kind::stream_flat_row:
  ------------------
  |  Branch (1055:13): [True: 109k, False: 0]
  ------------------
 1056|   109k|            {
 1057|   109k|                if (stack_.back().count_ > 0)
  ------------------
  |  Branch (1057:21): [True: 29.8k, False: 79.6k]
  ------------------
 1058|  29.8k|                {
 1059|  29.8k|                    sink_.push_back(field_delimiter_);
 1060|  29.8k|                }
 1061|   109k|                value_buffer_.clear();
 1062|   109k|                write_double_value(val, context, value_buffer_, ec);
 1063|   109k|                if (JSONCONS_UNLIKELY(ec))
  ------------------
  |  |   79|   109k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 109k]
  |  |  ------------------
  ------------------
 1064|      0|                {
 1065|      0|                    JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1066|      0|                }
 1067|   109k|                sink_.append(value_buffer_.data(), value_buffer_.size());
 1068|   109k|                break;
 1069|   109k|            }
 1070|      0|            case stack_item_kind::multivalued_field:
  ------------------
  |  Branch (1070:13): [True: 0, False: 109k]
  ------------------
 1071|      0|            case stack_item_kind::column_multivalued_field:
  ------------------
  |  Branch (1071:13): [True: 0, False: 109k]
  ------------------
 1072|      0|            case stack_item_kind::stream_multivalued_field:
  ------------------
  |  Branch (1072:13): [True: 0, False: 109k]
  ------------------
 1073|      0|            {
 1074|      0|                if (!value_buffer_.empty())
  ------------------
  |  Branch (1074:21): [True: 0, False: 0]
  ------------------
 1075|      0|                {
 1076|      0|                    value_buffer_.push_back(subfield_delimiter_);
 1077|      0|                }
 1078|      0|                write_double_value(val, context, value_buffer_, ec);
 1079|      0|                break;
 1080|      0|            }
 1081|      0|            case stack_item_kind::column:
  ------------------
  |  Branch (1081:13): [True: 0, False: 109k]
  ------------------
 1082|      0|            {
 1083|      0|                (*column_it_).second.emplace_back();
 1084|      0|                write_double_value(val, context, (*column_it_).second.back(), ec);
 1085|      0|                break;
 1086|      0|            }
 1087|      0|            default:
  ------------------
  |  Branch (1087:13): [True: 0, False: 109k]
  ------------------
 1088|      0|                break;
 1089|   109k|        }
 1090|   109k|        ++stack_.back().count_;
 1091|   109k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   109k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1092|   109k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E18write_double_valueEdRKNS_11ser_contextERS9_RNS3_10error_codeE:
 1331|   109k|    {
 1332|   109k|        if (!std::isfinite(val))
  ------------------
  |  Branch (1332:13): [True: 6.94k, False: 102k]
  ------------------
 1333|  6.94k|        {
 1334|  6.94k|            if ((std::isnan)(val))
  ------------------
  |  Branch (1334:17): [True: 0, False: 6.94k]
  ------------------
 1335|      0|            {
 1336|      0|                if (enable_nan_to_num_)
  ------------------
  |  Branch (1336:21): [True: 0, False: 0]
  ------------------
 1337|      0|                {
 1338|      0|                    str.append(nan_to_num_.data(), nan_to_num_.length());
 1339|      0|                }
 1340|      0|                else if (enable_nan_to_str_)
  ------------------
  |  Branch (1340:26): [True: 0, False: 0]
  ------------------
 1341|      0|                {
 1342|      0|                    visit_string(nan_to_str_, semantic_tag::none, context, ec);
 1343|      0|                }
 1344|      0|                else
 1345|      0|                {
 1346|      0|                    str.append(null_literal().data(), null_literal().size());
 1347|      0|                }
 1348|      0|            }
 1349|  6.94k|            else if (val == std::numeric_limits<double>::infinity())
  ------------------
  |  Branch (1349:22): [True: 1.60k, False: 5.33k]
  ------------------
 1350|  1.60k|            {
 1351|  1.60k|                if (enable_inf_to_num_)
  ------------------
  |  Branch (1351:21): [True: 0, False: 1.60k]
  ------------------
 1352|      0|                {
 1353|      0|                    str.append(inf_to_num_.data(), inf_to_num_.length());
 1354|      0|                }
 1355|  1.60k|                else if (enable_inf_to_str_)
  ------------------
  |  Branch (1355:26): [True: 0, False: 1.60k]
  ------------------
 1356|      0|                {
 1357|      0|                    visit_string(inf_to_str_, semantic_tag::none, context, ec);
 1358|      0|                }
 1359|  1.60k|                else
 1360|  1.60k|                {
 1361|  1.60k|                    str.append(null_literal().data(), null_literal().size());
 1362|  1.60k|                }
 1363|  1.60k|            }
 1364|  5.33k|            else
 1365|  5.33k|            {
 1366|  5.33k|                if (enable_neginf_to_num_)
  ------------------
  |  Branch (1366:21): [True: 0, False: 5.33k]
  ------------------
 1367|      0|                {
 1368|      0|                    str.append(neginf_to_num_.data(), neginf_to_num_.length());
 1369|      0|                }
 1370|  5.33k|                else if (enable_neginf_to_str_)
  ------------------
  |  Branch (1370:26): [True: 0, False: 5.33k]
  ------------------
 1371|      0|                {
 1372|      0|                    visit_string(neginf_to_str_, semantic_tag::none, context, ec);
 1373|      0|                }
 1374|  5.33k|                else
 1375|  5.33k|                {
 1376|  5.33k|                    str.append(null_literal().data(), null_literal().size());
 1377|  5.33k|                }
 1378|  5.33k|            }
 1379|  6.94k|        }
 1380|   102k|        else
 1381|   102k|        {
 1382|   102k|            fp_(val, str);
 1383|   102k|        }
 1384|   109k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E12null_literalEv:
   47|  18.0k|    {
   48|  18.0k|        static jsoncons::basic_string_view<CharT> k = JSONCONS_STRING_VIEW_CONSTANT(CharT,"null");
  ------------------
  |  |  309|  18.0k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  305|  18.0k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  302|  18.0k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   49|  18.0k|        return k;
   50|  18.0k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E11visit_flushEv:
  256|  3.43k|    {
  257|  3.43k|        sink_.flush();
  258|  3.43k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E10stack_itemC2ENSB_15stack_item_kindE:
   86|   172k|           : item_kind_(item_kind)
   87|   172k|        {
   88|   172k|        }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  491|   172k|    {
  492|   172k|        if (stack_.empty())
  ------------------
  |  Branch (492:13): [True: 3.48k, False: 168k]
  ------------------
  493|  3.48k|        {
  494|  3.48k|            if (flat_)
  ------------------
  |  Branch (494:17): [True: 3.48k, False: 0]
  ------------------
  495|  3.48k|            {
  496|  3.48k|                stack_.emplace_back(stack_item_kind::flat_row_mapping);
  497|  3.48k|            }
  498|      0|            else
  499|      0|            {
  500|      0|                stack_.emplace_back(stack_item_kind::row_mapping);
  501|      0|            }
  502|  3.48k|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  3.48k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  503|  3.48k|        }
  504|   168k|        if (JSONCONS_UNLIKELY(stack_.size() >= max_nesting_depth_))
  ------------------
  |  |   79|   168k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 0, False: 168k]
  |  |  ------------------
  ------------------
  505|      0|        {
  506|      0|            ec = csv_errc::max_nesting_depth_exceeded;
  507|      0|            JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  508|      0|        }
  509|       |        // legacy        
  510|   168k|        if (has_column_names_ && stack_.back().count_ == 0)
  ------------------
  |  Branch (510:13): [True: 0, False: 168k]
  |  Branch (510:34): [True: 0, False: 0]
  ------------------
  511|      0|        {
  512|      0|            if (stack_.back().item_kind_ == stack_item_kind::flat_row_mapping || stack_.back().item_kind_ == stack_item_kind::row_mapping)
  ------------------
  |  Branch (512:17): [True: 0, False: 0]
  |  Branch (512:82): [True: 0, False: 0]
  ------------------
  513|      0|            {
  514|      0|                std::size_t index = 0;
  515|      0|                for (const auto& item : column_names_)
  ------------------
  |  Branch (515:39): [True: 0, False: 0]
  ------------------
  516|      0|                {
  517|      0|                    string_type str{alloc_};
  518|      0|                    str.push_back('/');
  519|      0|                    jsoncons::from_integer(index, str);
  520|      0|                    column_paths_.emplace_back(str);
  521|      0|                    column_path_value_map_.emplace(str, string_type{alloc_});
  522|      0|                    column_path_name_map_.emplace(std::move(str), item);
  523|      0|                    ++index;
  524|      0|                }
  525|      0|                has_column_mapping_ = true;
  526|      0|            }
  527|      0|        }
  528|       |        
  529|   168k|        switch (stack_.back().item_kind_)
  530|   168k|        {
  531|   168k|            case stack_item_kind::flat_row_mapping:
  ------------------
  |  Branch (531:13): [True: 168k, False: 0]
  ------------------
  532|   168k|                if (has_column_mapping_)
  ------------------
  |  Branch (532:21): [True: 0, False: 168k]
  ------------------
  533|      0|                {
  534|      0|                    stack_.emplace_back(stack_item_kind::flat_row);
  535|      0|                }
  536|   168k|                else
  537|   168k|                {
  538|   168k|                    stack_.emplace_back(stack_item_kind::stream_flat_row);
  539|   168k|                }
  540|   168k|                break;
  541|      0|            case stack_item_kind::row_mapping:
  ------------------
  |  Branch (541:13): [True: 0, False: 168k]
  ------------------
  542|      0|                stack_.emplace_back(stack_item_kind::row);
  543|      0|                break;
  544|      0|            case stack_item_kind::object:
  ------------------
  |  Branch (544:13): [True: 0, False: 168k]
  ------------------
  545|      0|                stack_.emplace_back(stack_item_kind::object);
  546|      0|                break;
  547|      0|            case stack_item_kind::row:
  ------------------
  |  Branch (547:13): [True: 0, False: 168k]
  ------------------
  548|      0|                stack_.emplace_back(stack_item_kind::row);
  549|      0|                break;
  550|      0|            case stack_item_kind::flat_row:
  ------------------
  |  Branch (550:13): [True: 0, False: 168k]
  ------------------
  551|      0|                if (subfield_delimiter_ == char_type())
  ------------------
  |  Branch (551:21): [True: 0, False: 0]
  ------------------
  552|      0|                {
  553|      0|                    stack_.emplace_back(stack_item_kind::unmapped);
  554|      0|                }
  555|      0|                else
  556|      0|                {
  557|      0|                    append_array_path_component();
  558|      0|                    value_buffer_.clear();
  559|      0|                    stack_.emplace_back(stack_item_kind::multivalued_field);
  560|      0|                }
  561|      0|                break;
  562|      0|            case stack_item_kind::stream_flat_row:
  ------------------
  |  Branch (562:13): [True: 0, False: 168k]
  ------------------
  563|      0|                if (subfield_delimiter_ == char_type())
  ------------------
  |  Branch (563:21): [True: 0, False: 0]
  ------------------
  564|      0|                {
  565|      0|                    stack_.emplace_back(stack_item_kind::unmapped);
  566|      0|                }
  567|      0|                else
  568|      0|                {
  569|      0|                    value_buffer_.clear();
  570|      0|                    stack_.emplace_back(stack_item_kind::stream_multivalued_field);
  571|      0|                }
  572|      0|                break;
  573|      0|            case stack_item_kind::flat_object:
  ------------------
  |  Branch (573:13): [True: 0, False: 168k]
  ------------------
  574|      0|                if (subfield_delimiter_ == char_type())
  ------------------
  |  Branch (574:21): [True: 0, False: 0]
  ------------------
  575|      0|                {
  576|      0|                    stack_.emplace_back(stack_item_kind::unmapped);
  577|      0|                }
  578|      0|                else
  579|      0|                {
  580|      0|                    if (stack_[0].count_ == 0)
  ------------------
  |  Branch (580:25): [True: 0, False: 0]
  ------------------
  581|      0|                    {
  582|      0|                        if (!has_column_mapping_)
  ------------------
  |  Branch (582:29): [True: 0, False: 0]
  ------------------
  583|      0|                        {
  584|      0|                            string_type str = stack_.back().column_path_;
  585|      0|                            column_paths_.emplace_back(str);
  586|      0|                            column_path_value_map_.emplace(std::move(str), string_type{alloc_});
  587|      0|                        }
  588|      0|                    }
  589|       |                    
  590|      0|                    value_buffer_.clear();
  591|      0|                    stack_.emplace_back(stack_item_kind::multivalued_field);
  592|      0|                }
  593|      0|                break;
  594|      0|            case stack_item_kind::multivalued_field:
  ------------------
  |  Branch (594:13): [True: 0, False: 168k]
  ------------------
  595|      0|            case stack_item_kind::stream_multivalued_field:
  ------------------
  |  Branch (595:13): [True: 0, False: 168k]
  ------------------
  596|      0|                stack_.emplace_back(stack_item_kind::unmapped);
  597|      0|                break;
  598|      0|            case stack_item_kind::column_mapping:
  ------------------
  |  Branch (598:13): [True: 0, False: 168k]
  ------------------
  599|      0|                stack_.emplace_back(stack_item_kind::column);
  600|      0|                break;
  601|      0|            case stack_item_kind::column:
  ------------------
  |  Branch (601:13): [True: 0, False: 168k]
  ------------------
  602|      0|            {
  603|      0|                value_buffer_.clear();
  604|      0|                stack_.emplace_back(stack_item_kind::column_multivalued_field);
  605|      0|                break;
  606|      0|            }
  607|      0|            case stack_item_kind::column_multivalued_field:
  ------------------
  |  Branch (607:13): [True: 0, False: 168k]
  ------------------
  608|      0|                stack_.emplace_back(stack_item_kind::unmapped);
  609|      0|                break;
  610|      0|            case stack_item_kind::unmapped:
  ------------------
  |  Branch (610:13): [True: 0, False: 168k]
  ------------------
  611|      0|                stack_.emplace_back(stack_item_kind::unmapped);
  612|      0|                break;
  613|      0|            default: // error
  ------------------
  |  Branch (613:13): [True: 0, False: 168k]
  ------------------
  614|       |                //std::cout << "visit_begin_array " << (int)stack_.back().item_kind_ << "\n"; 
  615|      0|                ec = csv_errc::source_error;
  616|      0|                JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|      0|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  617|   168k|        }
  618|   168k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|   168k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  619|   168k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  822|  2.08k|    {
  823|  2.08k|        JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   54|  2.08k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 2.08k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  824|  2.08k|        switch (stack_.back().item_kind_)
  825|  2.08k|        {
  826|      0|            case stack_item_kind::flat_object:
  ------------------
  |  Branch (826:13): [True: 0, False: 2.08k]
  ------------------
  827|      0|            case stack_item_kind::object:
  ------------------
  |  Branch (827:13): [True: 0, False: 2.08k]
  ------------------
  828|      0|            {
  829|      0|                if (stack_[0].count_ == 0)
  ------------------
  |  Branch (829:21): [True: 0, False: 0]
  ------------------
  830|      0|                {
  831|      0|                    if (!has_column_mapping_)
  ------------------
  |  Branch (831:25): [True: 0, False: 0]
  ------------------
  832|      0|                    {
  833|      0|                        string_type str = stack_.back().column_path_;
  834|      0|                        column_paths_.emplace_back(str);
  835|      0|                        column_path_value_map_.emplace(std::move(str), string_type{alloc_});
  836|      0|                    }
  837|      0|                }
  838|      0|                auto it = column_path_value_map_.find(stack_.back().column_path_);
  839|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (839:21): [True: 0, False: 0]
  ------------------
  840|      0|                {
  841|      0|                    write_null_value(it->second);
  842|      0|                }
  843|      0|                break;
  844|      0|            }
  845|      0|            case stack_item_kind::flat_row:
  ------------------
  |  Branch (845:13): [True: 0, False: 2.08k]
  ------------------
  846|      0|            case stack_item_kind::row:
  ------------------
  |  Branch (846:13): [True: 0, False: 2.08k]
  ------------------
  847|      0|            {
  848|      0|                append_array_path_component();
  849|      0|                auto it = column_path_value_map_.find(stack_.back().column_path_);
  850|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (850:21): [True: 0, False: 0]
  ------------------
  851|      0|                {
  852|      0|                    write_null_value(it->second);
  853|      0|                }
  854|      0|                break;
  855|      0|            }
  856|  2.08k|            case stack_item_kind::stream_flat_row:
  ------------------
  |  Branch (856:13): [True: 2.08k, False: 0]
  ------------------
  857|  2.08k|            {
  858|  2.08k|                if (stack_.back().count_ > 0)
  ------------------
  |  Branch (858:21): [True: 1.57k, False: 513]
  ------------------
  859|  1.57k|                {
  860|  1.57k|                    sink_.push_back(field_delimiter_);
  861|  1.57k|                }
  862|  2.08k|                value_buffer_.clear();
  863|  2.08k|                write_null_value(value_buffer_);
  864|  2.08k|                sink_.append(value_buffer_.data(), value_buffer_.size());
  865|  2.08k|                break;
  866|      0|            }
  867|      0|            case stack_item_kind::column_multivalued_field:
  ------------------
  |  Branch (867:13): [True: 0, False: 2.08k]
  ------------------
  868|      0|            case stack_item_kind::multivalued_field:
  ------------------
  |  Branch (868:13): [True: 0, False: 2.08k]
  ------------------
  869|      0|            case stack_item_kind::stream_multivalued_field:
  ------------------
  |  Branch (869:13): [True: 0, False: 2.08k]
  ------------------
  870|      0|            {
  871|      0|                if (!value_buffer_.empty())
  ------------------
  |  Branch (871:21): [True: 0, False: 0]
  ------------------
  872|      0|                {
  873|      0|                    value_buffer_.push_back(subfield_delimiter_);
  874|      0|                }
  875|      0|                write_null_value(value_buffer_);
  876|      0|                break;
  877|      0|            }
  878|      0|            case stack_item_kind::column:
  ------------------
  |  Branch (878:13): [True: 0, False: 2.08k]
  ------------------
  879|      0|            {
  880|      0|                (*column_it_).second.emplace_back();
  881|      0|                write_null_value((*column_it_).second.back());
  882|      0|                break;
  883|      0|            }
  884|      0|            default:
  ------------------
  |  Branch (884:13): [True: 0, False: 2.08k]
  ------------------
  885|      0|                break;
  886|  2.08k|        }
  887|  2.08k|        ++stack_.back().count_;
  888|  2.08k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  2.08k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  889|  2.08k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E16write_null_valueERS9_:
 1409|  2.08k|    {
 1410|  2.08k|        str.append(null_literal().data(), null_literal().size());
 1411|  2.08k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
 1241|  7.21k|    {
 1242|  7.21k|        JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   54|  7.21k|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 7.21k]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 1243|  7.21k|        switch (stack_.back().item_kind_)
 1244|  7.21k|        {
 1245|      0|            case stack_item_kind::flat_object:
  ------------------
  |  Branch (1245:13): [True: 0, False: 7.21k]
  ------------------
 1246|      0|            case stack_item_kind::object:
  ------------------
  |  Branch (1246:13): [True: 0, False: 7.21k]
  ------------------
 1247|      0|            {
 1248|      0|                if (stack_[0].count_ == 0)
  ------------------
  |  Branch (1248:21): [True: 0, False: 0]
  ------------------
 1249|      0|                {
 1250|      0|                    if (!has_column_mapping_)
  ------------------
  |  Branch (1250:25): [True: 0, False: 0]
  ------------------
 1251|      0|                    {
 1252|      0|                        string_type str = stack_.back().column_path_;
 1253|      0|                        column_paths_.emplace_back(str);
 1254|      0|                        column_path_value_map_.emplace(std::move(str), string_type{alloc_});
 1255|      0|                    }
 1256|      0|                }
 1257|      0|                auto it = column_path_value_map_.find(stack_.back().column_path_);
 1258|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (1258:21): [True: 0, False: 0]
  ------------------
 1259|      0|                {
 1260|      0|                    write_bool_value(val, it->second);
 1261|      0|                }
 1262|      0|                break;
 1263|      0|            }
 1264|      0|            case stack_item_kind::flat_row:
  ------------------
  |  Branch (1264:13): [True: 0, False: 7.21k]
  ------------------
 1265|      0|            case stack_item_kind::row:
  ------------------
  |  Branch (1265:13): [True: 0, False: 7.21k]
  ------------------
 1266|      0|            {
 1267|      0|                append_array_path_component();
 1268|      0|                auto it = column_path_value_map_.find(stack_.back().column_path_);
 1269|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (1269:21): [True: 0, False: 0]
  ------------------
 1270|      0|                {
 1271|      0|                    write_bool_value(val, it->second);
 1272|      0|                }
 1273|      0|                break;
 1274|      0|            }
 1275|  7.21k|            case stack_item_kind::stream_flat_row:
  ------------------
  |  Branch (1275:13): [True: 7.21k, False: 0]
  ------------------
 1276|  7.21k|            {
 1277|  7.21k|                if (stack_.back().count_ > 0)
  ------------------
  |  Branch (1277:21): [True: 6.36k, False: 845]
  ------------------
 1278|  6.36k|                {
 1279|  6.36k|                    sink_.push_back(field_delimiter_);
 1280|  6.36k|                }
 1281|  7.21k|                value_buffer_.clear();
 1282|  7.21k|                write_bool_value(val, value_buffer_);
 1283|  7.21k|                sink_.append(value_buffer_.data(), value_buffer_.size());
 1284|  7.21k|                break;
 1285|      0|            }
 1286|      0|            case stack_item_kind::multivalued_field:
  ------------------
  |  Branch (1286:13): [True: 0, False: 7.21k]
  ------------------
 1287|      0|            case stack_item_kind::column_multivalued_field:
  ------------------
  |  Branch (1287:13): [True: 0, False: 7.21k]
  ------------------
 1288|      0|            case stack_item_kind::stream_multivalued_field:
  ------------------
  |  Branch (1288:13): [True: 0, False: 7.21k]
  ------------------
 1289|      0|            {
 1290|      0|                if (!value_buffer_.empty())
  ------------------
  |  Branch (1290:21): [True: 0, False: 0]
  ------------------
 1291|      0|                {
 1292|      0|                    value_buffer_.push_back(subfield_delimiter_);
 1293|      0|                }
 1294|      0|                write_bool_value(val, value_buffer_);
 1295|      0|                break;
 1296|      0|            }
 1297|      0|            case stack_item_kind::column:
  ------------------
  |  Branch (1297:13): [True: 0, False: 7.21k]
  ------------------
 1298|      0|            {
 1299|      0|                (*column_it_).second.emplace_back();
 1300|      0|                write_bool_value(val, (*column_it_).second.back());
 1301|      0|                break;
 1302|      0|            }
 1303|      0|            default:
  ------------------
  |  Branch (1303:13): [True: 0, False: 7.21k]
  ------------------
 1304|      0|                break;
 1305|  7.21k|        }
 1306|  7.21k|        ++stack_.back().count_;
 1307|  7.21k|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  7.21k|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
 1308|  7.21k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E16write_bool_valueEbRS9_:
 1397|  7.21k|    {
 1398|  7.21k|        if (val)
  ------------------
  |  Branch (1398:13): [True: 3.73k, False: 3.47k]
  ------------------
 1399|  3.73k|        {
 1400|  3.73k|            str.append(true_literal().data(), true_literal().size());
 1401|  3.73k|        }
 1402|  3.47k|        else
 1403|  3.47k|        {
 1404|  3.47k|            str.append(false_literal().data(), false_literal().size());
 1405|  3.47k|        }
 1406|  7.21k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E12true_literalEv:
   52|  7.47k|    {
   53|  7.47k|        static jsoncons::basic_string_view<CharT> k = JSONCONS_STRING_VIEW_CONSTANT(CharT,"true");
  ------------------
  |  |  309|  7.47k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  305|  7.47k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  302|  7.47k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   54|  7.47k|        return k;
   55|  7.47k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E13false_literalEv:
   57|  6.94k|    {
   58|  6.94k|        static jsoncons::basic_string_view<CharT> k = JSONCONS_STRING_VIEW_CONSTANT(CharT,"false");
  ------------------
  |  |  309|  6.94k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  305|  6.94k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  302|  6.94k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   59|  6.94k|        return k;
   60|  6.94k|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E12visit_stringERKNS3_17basic_string_viewIcS6_EENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE:
  892|  11.2M|    {
  893|  11.2M|        JSONCONS_ASSERT(!stack_.empty());
  ------------------
  |  |   54|  11.2M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 11.2M]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  894|  11.2M|        switch (stack_.back().item_kind_)
  895|  11.2M|        {
  896|      0|            case stack_item_kind::flat_object:
  ------------------
  |  Branch (896:13): [True: 0, False: 11.2M]
  ------------------
  897|      0|            case stack_item_kind::object:
  ------------------
  |  Branch (897:13): [True: 0, False: 11.2M]
  ------------------
  898|      0|            {
  899|      0|                if (stack_[0].count_ == 0)
  ------------------
  |  Branch (899:21): [True: 0, False: 0]
  ------------------
  900|      0|                {
  901|      0|                    if (!has_column_mapping_)
  ------------------
  |  Branch (901:25): [True: 0, False: 0]
  ------------------
  902|      0|                    {
  903|      0|                        string_type str = stack_.back().column_path_;
  904|      0|                        column_paths_.emplace_back(str);
  905|      0|                        column_path_value_map_.emplace(std::move(str), string_type{alloc_});
  906|      0|                    }
  907|      0|                }
  908|       |
  909|      0|                auto it = column_path_value_map_.find(stack_.back().column_path_);
  910|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (910:21): [True: 0, False: 0]
  ------------------
  911|      0|                {
  912|      0|                    write_string_value(sv, it->second);
  913|      0|                }
  914|      0|                break;
  915|      0|            }
  916|      0|            case stack_item_kind::flat_row:
  ------------------
  |  Branch (916:13): [True: 0, False: 11.2M]
  ------------------
  917|      0|            case stack_item_kind::row:
  ------------------
  |  Branch (917:13): [True: 0, False: 11.2M]
  ------------------
  918|      0|            {
  919|      0|                append_array_path_component();
  920|      0|                auto it = column_path_value_map_.find(stack_.back().column_path_);
  921|      0|                if (it != column_path_value_map_.end())
  ------------------
  |  Branch (921:21): [True: 0, False: 0]
  ------------------
  922|      0|                {
  923|      0|                    write_string_value(sv, it->second);
  924|      0|                }
  925|      0|                break;
  926|      0|            }
  927|  11.2M|            case stack_item_kind::stream_flat_row:
  ------------------
  |  Branch (927:13): [True: 11.2M, False: 0]
  ------------------
  928|  11.2M|            {
  929|  11.2M|                if (stack_.back().count_ > 0)
  ------------------
  |  Branch (929:21): [True: 11.1M, False: 70.2k]
  ------------------
  930|  11.1M|                {
  931|  11.1M|                    sink_.push_back(field_delimiter_);
  932|  11.1M|                }
  933|  11.2M|                value_buffer_.clear();
  934|  11.2M|                write_string_value(sv, value_buffer_);
  935|  11.2M|                sink_.append(value_buffer_.data(), value_buffer_.size());
  936|  11.2M|                break;
  937|      0|            }
  938|      0|            case stack_item_kind::column_multivalued_field:
  ------------------
  |  Branch (938:13): [True: 0, False: 11.2M]
  ------------------
  939|      0|            case stack_item_kind::multivalued_field:
  ------------------
  |  Branch (939:13): [True: 0, False: 11.2M]
  ------------------
  940|      0|            case stack_item_kind::stream_multivalued_field:
  ------------------
  |  Branch (940:13): [True: 0, False: 11.2M]
  ------------------
  941|      0|            {
  942|      0|                if (!value_buffer_.empty())
  ------------------
  |  Branch (942:21): [True: 0, False: 0]
  ------------------
  943|      0|                {
  944|      0|                    value_buffer_.push_back(subfield_delimiter_);
  945|      0|                }
  946|      0|                write_string_value(sv, value_buffer_);
  947|      0|                break;
  948|      0|            }
  949|      0|            case stack_item_kind::column:
  ------------------
  |  Branch (949:13): [True: 0, False: 11.2M]
  ------------------
  950|      0|            {
  951|      0|                (*column_it_).second.emplace_back();
  952|      0|                write_string_value(sv, (*column_it_).second.back());
  953|      0|                break;
  954|      0|            }
  955|      0|            default:
  ------------------
  |  Branch (955:13): [True: 0, False: 11.2M]
  ------------------
  956|      0|                break;
  957|  11.2M|        }
  958|  11.2M|        ++stack_.back().count_;
  959|  11.2M|        JSONCONS_VISITOR_RETURN;
  ------------------
  |  |  321|  11.2M|#define JSONCONS_VISITOR_RETURN return true 
  ------------------
  960|  11.2M|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E18write_string_valueERKNS3_17basic_string_viewIcS6_EERS9_:
 1311|  11.2M|    {
 1312|  11.2M|        const char* s = value.data();
 1313|  11.2M|        const std::size_t length = value.length();
 1314|       |        
 1315|  11.2M|        bool quote = false;
 1316|  11.2M|        if (quote_style_ == quote_style_kind::all || quote_style_ == quote_style_kind::nonnumeric ||
  ------------------
  |  Branch (1316:13): [True: 0, False: 11.2M]
  |  Branch (1316:54): [True: 0, False: 11.2M]
  ------------------
 1317|  11.2M|            (quote_style_ == quote_style_kind::minimal &&
  ------------------
  |  Branch (1317:14): [True: 11.2M, False: 0]
  ------------------
 1318|  11.2M|            (std::char_traits<CharT>::find(s, length, field_delimiter_) != nullptr || std::char_traits<CharT>::find(s, length, quote_char_) != nullptr)))
  ------------------
  |  Branch (1318:14): [True: 263, False: 11.2M]
  |  Branch (1318:87): [True: 343, False: 11.2M]
  ------------------
 1319|    606|        {
 1320|    606|            quote = true;
 1321|    606|            str.push_back(quote_char_);
 1322|    606|        }
 1323|  11.2M|        escape_string(s, length, quote_char_, quote_escape_char_, str);
 1324|  11.2M|        if (quote)
  ------------------
  |  Branch (1324:13): [True: 606, False: 11.2M]
  ------------------
 1325|    606|        {
 1326|    606|            str.push_back(quote_char_);
 1327|    606|        }
 1328|  11.2M|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_E13escape_stringEPKcmccRS9_:
  237|  11.2M|    {
  238|  11.2M|        const CharT* begin = s;
  239|  11.2M|        const CharT* end = s + length;
  240|  40.2M|        for (const CharT* it = begin; it != end; ++it)
  ------------------
  |  Branch (240:39): [True: 29.0M, False: 11.2M]
  ------------------
  241|  29.0M|        {
  242|  29.0M|            CharT c = *it;
  243|  29.0M|            if (c == quote_char)
  ------------------
  |  Branch (243:17): [True: 873, False: 29.0M]
  ------------------
  244|    873|            {
  245|    873|                sink.push_back(quote_escape_char); 
  246|    873|                sink.push_back(quote_char);
  247|    873|            }
  248|  29.0M|            else
  249|  29.0M|            {
  250|  29.0M|                sink.push_back(c);
  251|  29.0M|            }
  252|  29.0M|        }
  253|  11.2M|    }
_ZN8jsoncons3csv17basic_csv_encoderIcNS_11string_sinkINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEES8_ED2Ev:
  204|  3.49k|    {
  205|  3.49k|        JSONCONS_TRY
  ------------------
  |  |   37|  3.49k|    #define JSONCONS_TRY try
  ------------------
  206|  3.49k|        {
  207|  3.49k|            sink_.flush();
  208|  3.49k|        }
  209|  3.49k|        JSONCONS_CATCH(...)
  210|  3.49k|        {
  211|      0|        }
  212|  3.49k|    }

_ZN8jsoncons3csv15make_error_codeENS0_8csv_errcE:
   82|     43|{
   83|     43|    return std::error_code(static_cast<int>(result),csv_error_category());
   84|     43|}
_ZN8jsoncons3csv18csv_error_categoryEv:
   75|     43|{
   76|     43|  static csv_error_category_impl instance;
   77|     43|  return instance;
   78|     43|}

_ZN8jsoncons3csv24basic_csv_options_commonIcED2Ev:
  320|  6.98k|    virtual ~basic_csv_options_common() = default;
_ZN8jsoncons3csv24basic_csv_encode_optionsIcEC1Ev:
  640|  3.49k|    {
  641|  3.49k|        line_delimiter_.push_back('\n');
  642|  3.49k|    }
_ZN8jsoncons3csv24basic_csv_options_commonIcEC2Ev:
  303|  6.98k|      : flat_{true},                  
  304|  6.98k|        enable_nan_to_num_{false},    
  305|  6.98k|        enable_inf_to_num_{false},    
  306|  6.98k|        enable_neginf_to_num_{false}, 
  307|  6.98k|        enable_nan_to_str_{false},    
  308|  6.98k|        enable_inf_to_str_{false},    
  309|  6.98k|        enable_neginf_to_str_{false}, 
  310|  6.98k|        enable_str_to_nan_{false},    
  311|  6.98k|        enable_str_to_inf_{false},    
  312|  6.98k|        enable_str_to_neginf_{false}
  313|  6.98k|    {
  314|  6.98k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE4flatEv:
  324|  3.49k|    {
  325|  3.49k|        return flat_;
  326|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE17max_nesting_depthEv:
  329|  3.49k|    {
  330|  3.49k|        return max_nesting_depth_;
  331|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE14column_mappingEv:
  359|  3.49k|    {
  360|  3.49k|        return column_mapping_;
  361|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE12column_namesEv:
  354|  10.4k|    {
  355|  10.4k|        return column_names_;
  356|  10.4k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE15field_delimiterEv:
  334|  6.98k|    {
  335|  6.98k|        return field_delimiter_;
  336|  6.98k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE18subfield_delimiterEv:
  339|  6.98k|    {
  340|  6.98k|        return subfield_delimiter_;
  341|  6.98k|    }
_ZNK8jsoncons3csv24basic_csv_encode_optionsIcE14line_delimiterEv:
  676|  3.49k|    {
  677|  3.49k|        return line_delimiter_;
  678|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_encode_optionsIcE11quote_styleEv:
  661|  3.49k|    {
  662|  3.49k|        return quote_style_;
  663|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE10quote_charEv:
  344|  6.98k|    {
  345|  6.98k|        return quote_char_;
  346|  6.98k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE17quote_escape_charEv:
  349|  6.98k|    {
  350|  6.98k|        return quote_escape_char_;
  351|  6.98k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE17enable_nan_to_numEv:
  364|  3.49k|    {
  365|  3.49k|        return enable_nan_to_num_;
  366|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE10nan_to_numEv:
  409|  3.49k|    {
  410|  3.49k|        return nan_to_num_; 
  411|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE17enable_nan_to_strEv:
  379|  3.49k|    {
  380|  3.49k|        return enable_nan_to_str_;
  381|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE10nan_to_strEv:
  438|  6.98k|    {
  439|  6.98k|        return nan_to_str_;
  440|  6.98k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE17enable_inf_to_numEv:
  369|  3.49k|    {
  370|  3.49k|        return enable_inf_to_num_;
  371|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE10inf_to_numEv:
  414|  3.49k|    {
  415|  3.49k|        return inf_to_num_; 
  416|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE17enable_inf_to_strEv:
  389|  3.49k|    {
  390|  3.49k|        return enable_inf_to_str_;
  391|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE10inf_to_strEv:
  443|  6.98k|    {
  444|  6.98k|        return inf_to_str_; 
  445|  6.98k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE20enable_neginf_to_numEv:
  374|  3.49k|    {
  375|  3.49k|        return enable_neginf_to_num_ || enable_inf_to_num_;
  ------------------
  |  Branch (375:16): [True: 0, False: 3.49k]
  |  Branch (375:41): [True: 0, False: 3.49k]
  ------------------
  376|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE13neginf_to_numEv:
  419|  3.49k|    {
  420|  3.49k|        if (enable_neginf_to_num_)
  ------------------
  |  Branch (420:13): [True: 0, False: 3.49k]
  ------------------
  421|      0|        {
  422|      0|            return neginf_to_num_;
  423|      0|        }
  424|  3.49k|        else if (enable_inf_to_num_)
  ------------------
  |  Branch (424:18): [True: 0, False: 3.49k]
  ------------------
  425|      0|        {
  426|      0|            string_type s;
  427|      0|            s.push_back('-');
  428|      0|            s.append(inf_to_num_);
  429|      0|            return s;
  430|      0|        }
  431|  3.49k|        else
  432|  3.49k|        {
  433|  3.49k|            return neginf_to_num_; 
  434|  3.49k|        }
  435|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE20enable_neginf_to_strEv:
  399|  3.49k|    {
  400|  3.49k|        return enable_neginf_to_str_ || enable_inf_to_str_;
  ------------------
  |  Branch (400:16): [True: 0, False: 3.49k]
  |  Branch (400:41): [True: 0, False: 3.49k]
  ------------------
  401|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE13neginf_to_strEv:
  448|  6.98k|    {
  449|  6.98k|        if (enable_neginf_to_str_)
  ------------------
  |  Branch (449:13): [True: 0, False: 6.98k]
  ------------------
  450|      0|        {
  451|      0|            return neginf_to_str_;
  452|      0|        }
  453|  6.98k|        else if (enable_inf_to_str_)
  ------------------
  |  Branch (453:18): [True: 0, False: 6.98k]
  ------------------
  454|      0|        {
  455|      0|            string_type s;
  456|      0|            s.push_back('-');
  457|      0|            s.append(inf_to_str_);
  458|      0|            return s;
  459|      0|        }
  460|  6.98k|        else
  461|  6.98k|        {
  462|  6.98k|            return neginf_to_str_; // empty string
  463|  6.98k|        }
  464|  6.98k|    }
_ZNK8jsoncons3csv24basic_csv_encode_optionsIcE12float_formatEv:
  666|  3.49k|    {
  667|  3.49k|        return float_format_;
  668|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_encode_optionsIcE9precisionEv:
  671|  3.49k|    {
  672|  3.49k|        return precision_;
  673|  3.49k|    }
_ZN8jsoncons3csv6detail18parse_column_namesIcNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEEEvRKNS5_IT_NS6_ISD_EENS8_ISD_EEEERT0_:
   66|  6.98k|{
   67|  6.98k|    column_state state = column_state::sequence;
   68|  6.98k|    typename Container::value_type buffer(cont.get_allocator());
   69|       |
   70|  6.98k|    auto p = names.begin();
   71|  6.98k|    while (p != names.end())
  ------------------
  |  Branch (71:12): [True: 0, False: 6.98k]
  ------------------
   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|  6.98k|    if (state == column_state::label)
  ------------------
  |  Branch (108:9): [True: 0, False: 6.98k]
  ------------------
  109|      0|    {
  110|      0|        cont.push_back(buffer);
  111|      0|        buffer.clear();
  112|      0|    }
  113|       |
  114|  6.98k|} // namespace detail
_ZN8jsoncons3csv24basic_csv_decode_optionsIcEC1Ev:
  495|  3.49k|        : assume_header_(false),
  496|  3.49k|          ignore_empty_values_(false),
  497|  3.49k|          ignore_empty_lines_(true),
  498|  3.49k|          trim_leading_(false),
  499|  3.49k|          trim_trailing_(false),
  500|  3.49k|          trim_leading_inside_quotes_(false),
  501|  3.49k|          trim_trailing_inside_quotes_(false),
  502|  3.49k|          unquoted_empty_value_is_null_(false),
  503|  3.49k|          infer_types_(true),
  504|  3.49k|          lossless_number_(false)
  505|  3.49k|    {}
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE13assume_headerEv:
  540|  6.98k|    {
  541|  6.98k|        return assume_header_;
  542|  6.98k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE15comment_starterEv:
  600|  3.49k|    {
  601|  3.49k|        return comment_starter_;
  602|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE12header_linesEv:
  535|  3.49k|    {
  536|  3.49k|        return (assume_header_ && header_lines_ <= 1) ? 1 : header_lines_;
  ------------------
  |  Branch (536:17): [True: 0, False: 3.49k]
  |  Branch (536:35): [True: 0, False: 0]
  ------------------
  537|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE19ignore_empty_valuesEv:
  545|  3.49k|    {
  546|  3.49k|        return ignore_empty_values_;
  547|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE18ignore_empty_linesEv:
  550|  3.49k|    {
  551|  3.49k|        return ignore_empty_lines_;
  552|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE11infer_typesEv:
  590|  3.49k|    {
  591|  3.49k|        return infer_types_;
  592|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE15lossless_numberEv:
  595|  3.49k|    {
  596|  3.49k|        return lossless_number_;
  597|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE12mapping_kindEv:
  605|  3.49k|    {
  606|  3.49k|        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: 0, False: 3.49k]
  |  Branch (606:71): [True: 0, False: 3.49k]
  |  Branch (606:90): [True: 0, False: 3.49k]
  ------------------
  607|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE9max_linesEv:
  610|  3.49k|    {
  611|  3.49k|        return max_lines_;
  612|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE12trim_leadingEv:
  555|  3.49k|    {
  556|  3.49k|        return trim_leading_;
  557|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE26trim_leading_inside_quotesEv:
  565|  3.49k|    {
  566|  3.49k|        return trim_leading_inside_quotes_;
  567|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE13trim_trailingEv:
  560|  3.49k|    {
  561|  3.49k|        return trim_trailing_;
  562|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE27trim_trailing_inside_quotesEv:
  570|  3.49k|    {
  571|  3.49k|        return trim_trailing_inside_quotes_;
  572|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE28unquoted_empty_value_is_nullEv:
  585|  3.49k|    {
  586|  3.49k|        return unquoted_empty_value_is_null_;
  587|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE17enable_str_to_infEv:
  394|  3.49k|    {
  395|  3.49k|        return enable_str_to_inf_;
  396|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE20enable_str_to_neginfEv:
  404|  3.49k|    {
  405|  3.49k|        return enable_str_to_neginf_ || enable_str_to_inf_;
  ------------------
  |  Branch (405:16): [True: 0, False: 3.49k]
  |  Branch (405:41): [True: 0, False: 3.49k]
  ------------------
  406|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_options_commonIcE17enable_str_to_nanEv:
  384|  3.49k|    {
  385|  3.49k|        return enable_str_to_nan_;
  386|  3.49k|    }
_ZN8jsoncons3csv6detail18parse_column_typesIcNSt3__16vectorINS0_13csv_type_infoENS3_9allocatorIS5_EEEEEEvRKNS3_12basic_stringIT_NS3_11char_traitsISA_EENS6_ISA_EEEERT0_:
  119|  3.49k|{
  120|  3.49k|    const std::map<jsoncons::basic_string_view<CharT>,csv_column_type> type_dictionary =
  121|  3.49k|    {
  122|       |
  123|  3.49k|        {JSONCONS_STRING_VIEW_CONSTANT(CharT,"string"),csv_column_type::string_t},
  ------------------
  |  |  309|  3.49k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  305|  3.49k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  302|  3.49k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  124|  3.49k|        {JSONCONS_STRING_VIEW_CONSTANT(CharT,"integer"),csv_column_type::integer_t},
  ------------------
  |  |  309|  3.49k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  305|  3.49k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  302|  3.49k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  125|  3.49k|        {JSONCONS_STRING_VIEW_CONSTANT(CharT,"float"),csv_column_type::float_t},
  ------------------
  |  |  309|  3.49k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  305|  3.49k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  302|  3.49k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  126|  3.49k|        {JSONCONS_STRING_VIEW_CONSTANT(CharT,"boolean"),csv_column_type::boolean_t}
  ------------------
  |  |  309|  3.49k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) jsoncons::string_view_constant_of_type<CharT>(Str, JSONCONS_PP_WIDEN(Str))
  |  |  ------------------
  |  |  |  |  305|  3.49k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A)
  |  |  |  |  ------------------
  |  |  |  |  |  |  302|  3.49k|#define JSONCONS_PP_EXPAND(X) X    
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  127|  3.49k|    };
  128|       |
  129|  3.49k|    column_state state = column_state::sequence;
  130|  3.49k|    int depth = 0;
  131|  3.49k|    std::basic_string<CharT> buffer;
  132|       |
  133|  3.49k|    auto p = types.begin();
  134|  3.49k|    while (p != types.end())
  ------------------
  |  Branch (134:12): [True: 0, False: 3.49k]
  ------------------
  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);
  ------------------
  |  |   54|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  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);
  ------------------
  |  |   54|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  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);
  ------------------
  |  |   54|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, Folded]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      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);
  ------------------
  |  |   54|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, Folded]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      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);
  ------------------
  |  |   54|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 0]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  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);
  ------------------
  |  |   54|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, Folded]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      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|  3.49k|    if (state == column_state::label)
  ------------------
  |  Branch (247:9): [True: 0, False: 3.49k]
  ------------------
  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);
  ------------------
  |  |   54|      0|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, Folded]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
  258|      0|        }
  259|      0|    }
  260|  3.49k|}
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE12column_typesEv:
  615|  3.49k|    {
  616|  3.49k|        return column_types_;
  617|  3.49k|    }
_ZNK8jsoncons3csv24basic_csv_decode_optionsIcE15column_defaultsEv:
  620|  3.49k|    {
  621|  3.49k|        return column_defaults_;
  622|  3.49k|    }

_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEED2Ev:
  734|  3.49k|    {
  735|  3.49k|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEEC2ERKNS0_24basic_csv_decode_optionsIcEERKS4_:
  636|  3.49k|       : alloc_(alloc),
  637|  3.49k|         state_(csv_parse_state::start),
  638|  3.49k|         err_handler_(default_csv_parsing()),
  639|  3.49k|         assume_header_(options.assume_header()),                  
  640|  3.49k|         comment_starter_(options.comment_starter()),
  641|  3.49k|         field_delimiter_(options.field_delimiter()),
  642|  3.49k|         header_lines_(options.header_lines()),
  643|  3.49k|         ignore_empty_values_(options.ignore_empty_values()),
  644|  3.49k|         ignore_empty_lines_(options.ignore_empty_lines()),
  645|  3.49k|         infer_types_(options.infer_types()),
  646|  3.49k|         lossless_number_(options.lossless_number()), 
  647|  3.49k|         mapping_kind_(options.mapping_kind()),
  648|  3.49k|         max_lines_(options.max_lines()),
  649|  3.49k|         quote_char_(options.quote_char()),
  650|  3.49k|         quote_escape_char_(options.quote_escape_char()),
  651|  3.49k|         subfield_delimiter_(options.subfield_delimiter()),
  652|  3.49k|         trim_leading_(options.trim_leading()),
  653|  3.49k|         trim_leading_inside_quotes_(options.trim_leading_inside_quotes()),
  654|  3.49k|         trim_trailing_(options.trim_trailing()),
  655|  3.49k|         trim_trailing_inside_quotes_(options.trim_trailing_inside_quotes()),
  656|  3.49k|         unquoted_empty_value_is_null_(options.unquoted_empty_value_is_null()),
  657|  3.49k|         enable_str_to_inf_(options.enable_str_to_inf()),
  658|  3.49k|         enable_str_to_neginf_(options.enable_str_to_neginf()),
  659|  3.49k|         enable_str_to_nan_(options.enable_str_to_nan()),
  660|  3.49k|         inf_to_str_(options.inf_to_str()),
  661|  3.49k|         neginf_to_str_(options.neginf_to_str()),
  662|  3.49k|         nan_to_str_(options.nan_to_str()),
  663|  3.49k|         m_columns_filter_(alloc),
  664|  3.49k|         stack_(alloc),
  665|  3.49k|         column_names_(alloc),
  666|  3.49k|         column_types_(alloc),
  667|  3.49k|         column_defaults_(alloc),
  668|  3.49k|         state_stack_(alloc),
  669|  3.49k|         buffer_(alloc)
  670|  3.49k|    {
  671|  3.49k|        jsoncons::csv::detail::parse_column_types(options.column_types(), column_types_);
  672|  3.49k|        jsoncons::csv::detail::parse_column_names(options.column_defaults(), column_defaults_);
  673|  3.49k|        jsoncons::csv::detail::parse_column_names(options.column_names(), column_names_);
  674|  3.49k|        min_column_names_ = column_names_.size();
  675|  3.49k|        initialize();
  676|  3.49k|    }
_ZN8jsoncons3csv6detail16m_columns_filterIcNSt3__19allocatorIcEEEC2ERKS5_:
  258|  3.49k|            : alloc_(alloc),
  259|  3.49k|              column_names_(alloc),
  260|  3.49k|              cached_events_(alloc)
  261|  3.49k|        {
  262|  3.49k|        }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE10initializeEv:
 1507|  3.49k|    {
 1508|  3.49k|        stack_.reserve(default_depth);
 1509|  3.49k|        stack_.push_back(csv_mode::initial);
 1510|  3.49k|        stack_.push_back((header_lines_ > 0) ? csv_mode::header : csv_mode::data);
  ------------------
  |  Branch (1510:26): [True: 0, False: 3.49k]
  ------------------
 1511|  3.49k|    }
_ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE7stoppedEv:
  769|  30.0k|    {
  770|  30.0k|        return !more_;
  771|  30.0k|    }
_ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE16source_exhaustedEv:
  774|  26.6k|    {
  775|  26.6k|        return input_ptr_ == input_end_;
  776|  26.6k|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE6updateEPKcm:
 1489|  6.51k|    {
 1490|  6.51k|        begin_input_ = data;
 1491|  6.51k|        input_end_ = data + length;
 1492|  6.51k|        input_ptr_ = begin_input_;
 1493|  6.51k|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE10parse_someERNS_18basic_json_visitorIcEERNS2_10error_codeE:
  823|  26.6k|    {
  824|  26.6k|        basic_json_visitor<CharT>& local_visitor = (mapping_kind_ == csv_mapping_kind::m_columns) 
  ------------------
  |  Branch (824:52): [True: 0, False: 26.6k]
  ------------------
  825|  26.6k|            ? m_columns_filter_ : visitor;
  826|       |
  827|  26.6k|        switch (mapping_kind_)
  828|  26.6k|        {
  829|      0|            case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (829:13): [True: 0, False: 26.6k]
  ------------------
  830|      0|                cursor_mode_ = false;
  831|      0|                break;
  832|  26.6k|            default:
  ------------------
  |  Branch (832:13): [True: 26.6k, False: 0]
  ------------------
  833|  26.6k|                break;
  834|  26.6k|        } 
  835|       |
  836|  26.6k|        const CharT* local_input_end = input_end_;
  837|       |
  838|  26.6k|        if (input_ptr_ == local_input_end && more_)
  ------------------
  |  Branch (838:13): [True: 20.1k, False: 6.51k]
  |  Branch (838:46): [True: 20.1k, False: 0]
  ------------------
  839|  20.1k|        {
  840|  20.1k|            switch (state_)
  841|  20.1k|            {
  842|      1|                case csv_parse_state::start:
  ------------------
  |  Branch (842:17): [True: 1, False: 20.1k]
  ------------------
  843|      1|                    ec = csv_errc::source_error;
  844|      1|                    more_ = false;
  845|      1|                    return;
  846|  3.17k|                case csv_parse_state::before_unquoted_field:
  ------------------
  |  Branch (846:17): [True: 3.17k, False: 16.9k]
  ------------------
  847|  3.17k|                case csv_parse_state::before_last_unquoted_field:
  ------------------
  |  Branch (847:17): [True: 0, False: 20.1k]
  ------------------
  848|  3.17k|                    end_unquoted_string_value(local_visitor, ec);
  849|  3.17k|                    state_ = csv_parse_state::before_last_unquoted_field_tail;
  850|  3.17k|                    break;
  851|  3.16k|                case csv_parse_state::before_last_unquoted_field_tail:
  ------------------
  |  Branch (851:17): [True: 3.16k, False: 16.9k]
  ------------------
  852|  3.16k|                    if (stack_.back() == csv_mode::subfields)
  ------------------
  |  Branch (852:25): [True: 0, False: 3.16k]
  ------------------
  853|      0|                    {
  854|      0|                        stack_.pop_back();
  855|      0|                        local_visitor.end_array(*this, ec);
  856|      0|                        more_ = !cursor_mode_;
  857|      0|                        if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (857:29): [True: 0, False: 0]
  ------------------
  858|      0|                        {
  859|      0|                            if (level() == mark_level_)
  ------------------
  |  Branch (859:33): [True: 0, False: 0]
  ------------------
  860|      0|                            {
  861|      0|                                more_ = false;
  862|      0|                            }
  863|      0|                        }
  864|      0|                        --level_;
  865|      0|                    }
  866|  3.16k|                    ++column_index_;
  867|  3.16k|                    state_ = csv_parse_state::end_record;
  868|  3.16k|                    break;
  869|    119|                case csv_parse_state::before_unquoted_string: 
  ------------------
  |  Branch (869:17): [True: 119, False: 20.0k]
  ------------------
  870|    119|                    buffer_.clear();
  871|    119|                    JSONCONS_FALLTHROUGH;
  ------------------
  |  |  565|    119|#  define JSONCONS_FALLTHROUGH [[fallthrough]]
  ------------------
  872|  3.17k|                case csv_parse_state::unquoted_string: 
  ------------------
  |  Branch (872:17): [True: 3.05k, False: 17.0k]
  ------------------
  873|  3.17k|                    if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (873:25): [True: 0, False: 3.17k]
  |  Branch (873:42): [True: 0, False: 3.17k]
  ------------------
  874|      0|                    {
  875|      0|                        trim_string_buffer(trim_leading_,trim_trailing_);
  876|      0|                    }
  877|  3.17k|                    if (ignore_empty_values_ && buffer_.empty())
  ------------------
  |  Branch (877:25): [True: 0, False: 3.17k]
  |  Branch (877:49): [True: 0, False: 0]
  ------------------
  878|      0|                    {
  879|      0|                        state_ = csv_parse_state::end_record;
  880|      0|                    }
  881|  3.17k|                    else
  882|  3.17k|                    {
  883|  3.17k|                        before_value(local_visitor, ec);
  884|  3.17k|                        state_ = csv_parse_state::before_unquoted_field;
  885|  3.17k|                    }
  886|  3.17k|                    break;
  887|     44|                case csv_parse_state::before_last_quoted_field:
  ------------------
  |  Branch (887:17): [True: 44, False: 20.0k]
  ------------------
  888|     44|                    end_quoted_string_value(local_visitor, ec);
  889|     44|                    ++column_index_;
  890|     44|                    state_ = csv_parse_state::end_record;
  891|     44|                    break;
  892|     44|                case csv_parse_state::escaped_value:
  ------------------
  |  Branch (892:17): [True: 44, False: 20.0k]
  ------------------
  893|     44|                    if (quote_escape_char_ == quote_char_)
  ------------------
  |  Branch (893:25): [True: 44, False: 0]
  ------------------
  894|     44|                    {
  895|     44|                        if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (895:31): [True: 0, False: 44]
  |  Branch (895:55): [True: 0, False: 0]
  ------------------
  896|     44|                        {
  897|     44|                            before_value(local_visitor, ec);
  898|     44|                            ++column_;
  899|     44|                            state_ = csv_parse_state::before_last_quoted_field;
  900|     44|                        }
  901|      0|                        else
  902|      0|                        {
  903|      0|                            state_ = csv_parse_state::end_record;
  904|      0|                        }
  905|     44|                    }
  906|      0|                    else
  907|      0|                    {
  908|      0|                        ec = csv_errc::invalid_escaped_char;
  909|      0|                        more_ = false;
  910|      0|                        return;
  911|      0|                    }
  912|     44|                    break;
  913|  3.43k|                case csv_parse_state::end_record:
  ------------------
  |  Branch (913:17): [True: 3.43k, False: 16.7k]
  ------------------
  914|  3.43k|                    if (column_index_ > 0)
  ------------------
  |  Branch (914:25): [True: 3.23k, False: 208]
  ------------------
  915|  3.23k|                    {
  916|  3.23k|                        end_record(local_visitor, ec);
  917|  3.23k|                    }
  918|  3.43k|                    state_ = csv_parse_state::no_more_records;
  919|  3.43k|                    break;
  920|  3.43k|                case csv_parse_state::no_more_records: 
  ------------------
  |  Branch (920:17): [True: 3.43k, False: 16.7k]
  ------------------
  921|  3.43k|                    switch (stack_.back()) 
  922|  3.43k|                    {
  923|      0|                        case csv_mode::header:
  ------------------
  |  Branch (923:25): [True: 0, False: 3.43k]
  ------------------
  924|      0|                            stack_.pop_back();
  925|      0|                            break;
  926|  3.43k|                        case csv_mode::data:
  ------------------
  |  Branch (926:25): [True: 3.43k, False: 0]
  ------------------
  927|  3.43k|                            stack_.pop_back();
  928|  3.43k|                            break;
  929|      0|                        default:
  ------------------
  |  Branch (929:25): [True: 0, False: 3.43k]
  ------------------
  930|      0|                            break;
  931|  3.43k|                    }
  932|  3.43k|                    local_visitor.end_array(*this, ec);
  933|  3.43k|                    more_ = !cursor_mode_;
  934|  3.43k|                    if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (934:25): [True: 3.43k, False: 0]
  ------------------
  935|  3.43k|                    {
  936|  3.43k|                        if (level() == mark_level_)
  ------------------
  |  Branch (936:29): [True: 0, False: 3.43k]
  ------------------
  937|      0|                        {
  938|      0|                            more_ = false;
  939|      0|                        }
  940|  3.43k|                    }
  941|  3.43k|                    --level_;
  942|       |                    
  943|  3.43k|                    if (mapping_kind_ == csv_mapping_kind::m_columns)
  ------------------
  |  Branch (943:25): [True: 0, False: 3.43k]
  ------------------
  944|      0|                    {
  945|      0|                        if (!m_columns_filter_.done())
  ------------------
  |  Branch (945:29): [True: 0, False: 0]
  ------------------
  946|      0|                        {
  947|      0|                            more_ = m_columns_filter_.replay_parse_events(visitor, actual_cursor_mode_, mark_level_);
  948|      0|                        }
  949|      0|                        else
  950|      0|                        {
  951|      0|                            state_ = csv_parse_state::accept;
  952|      0|                        }
  953|      0|                    }
  954|  3.43k|                    else
  955|  3.43k|                    {
  956|  3.43k|                        state_ = csv_parse_state::accept;
  957|  3.43k|                    }
  958|  3.43k|                    break;
  959|  3.43k|                case csv_parse_state::accept:
  ------------------
  |  Branch (959:17): [True: 3.43k, False: 16.7k]
  ------------------
  960|  3.43k|                    if (!(stack_.size() == 1 && stack_.back() == csv_mode::initial))
  ------------------
  |  Branch (960:27): [True: 3.43k, False: 0]
  |  Branch (960:49): [True: 3.43k, False: 0]
  ------------------
  961|      0|                    {
  962|      0|                        err_handler_(csv_errc::unexpected_eof, *this);
  963|      0|                        ec = csv_errc::unexpected_eof;
  964|      0|                        more_ = false;
  965|      0|                        return;
  966|      0|                    }
  967|  3.43k|                    stack_.pop_back();
  968|  3.43k|                    local_visitor.flush();
  969|  3.43k|                    state_ = csv_parse_state::done;
  970|  3.43k|                    more_ = false;
  971|  3.43k|                    return;
  972|    227|                default:
  ------------------
  |  Branch (972:17): [True: 227, False: 19.9k]
  ------------------
  973|    227|                    state_ = csv_parse_state::end_record;
  974|    227|                    break;
  975|  20.1k|            }
  976|  20.1k|        }
  977|       |
  978|  94.2M|        for (; (input_ptr_ < local_input_end) && more_;)
  ------------------
  |  Branch (978:16): [True: 94.2M, False: 23.1k]
  |  Branch (978:50): [True: 94.2M, False: 3]
  ------------------
  979|  94.2M|        {
  980|  94.2M|            CharT curr_char = *input_ptr_;
  981|       |
  982|  94.2M|            switch (state_) 
  983|  94.2M|            {
  984|  6.44M|                case csv_parse_state::cr:
  ------------------
  |  Branch (984:17): [True: 6.44M, False: 87.7M]
  ------------------
  985|  6.44M|                    ++line_;
  986|  6.44M|                    column_ = 1;
  987|  6.44M|                    switch (*input_ptr_)
  988|  6.44M|                    {
  989|  15.2k|                        case '\n':
  ------------------
  |  Branch (989:25): [True: 15.2k, False: 6.43M]
  ------------------
  990|  15.2k|                            ++input_ptr_;
  991|  15.2k|                            state_ = pop_state();
  992|  15.2k|                            break;
  993|  6.43M|                        default:
  ------------------
  |  Branch (993:25): [True: 6.43M, False: 15.2k]
  ------------------
  994|  6.43M|                            state_ = pop_state();
  995|  6.43M|                            break;
  996|  6.44M|                    }
  997|  6.44M|                    break;
  998|  6.44M|                case csv_parse_state::start:
  ------------------
  |  Branch (998:17): [True: 3.48k, False: 94.2M]
  ------------------
  999|  3.48k|                    if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (999:25): [True: 3.48k, False: 0]
  ------------------
 1000|  3.48k|                    {
 1001|  3.48k|                        local_visitor.begin_array(semantic_tag::none, *this, ec);
 1002|  3.48k|                        more_ = !cursor_mode_;
 1003|  3.48k|                        ++level_;
 1004|  3.48k|                    }
 1005|  3.48k|                    if (assume_header_ && mapping_kind_ == csv_mapping_kind::n_rows && !column_names_.empty())
  ------------------
  |  Branch (1005:25): [True: 0, False: 3.48k]
  |  Branch (1005:43): [True: 0, False: 0]
  |  Branch (1005:88): [True: 0, False: 0]
  ------------------
 1006|      0|                    {
 1007|      0|                        column_index_ = 0; 
 1008|      0|                        local_visitor.begin_array(semantic_tag::none, *this, ec);
 1009|      0|                        ++level_;
 1010|      0|                        more_ = !cursor_mode_;
 1011|      0|                        state_ = csv_parse_state::expect_comment_or_record;
 1012|      0|                    }
 1013|  3.48k|                    else
 1014|  3.48k|                    {
 1015|  3.48k|                        state_ = csv_parse_state::expect_comment_or_record;
 1016|  3.48k|                    }
 1017|  3.48k|                    break;
 1018|  3.13M|                case csv_parse_state::comment: 
  ------------------
  |  Branch (1018:17): [True: 3.13M, False: 91.0M]
  ------------------
 1019|  3.13M|                    switch (curr_char)
 1020|  3.13M|                    {
 1021|  94.6k|                        case '\n':
  ------------------
  |  Branch (1021:25): [True: 94.6k, False: 3.03M]
  ------------------
 1022|  94.6k|                        {
 1023|  94.6k|                            ++line_;
 1024|  94.6k|                            if (stack_.back() == csv_mode::header)
  ------------------
  |  Branch (1024:33): [True: 0, False: 94.6k]
  ------------------
 1025|      0|                            {
 1026|      0|                                ++header_line_offset_;
 1027|      0|                            }
 1028|  94.6k|                            column_ = 1;
 1029|  94.6k|                            state_ = csv_parse_state::expect_comment_or_record;
 1030|  94.6k|                            break;
 1031|      0|                        }
 1032|  1.54k|                        case '\r':
  ------------------
  |  Branch (1032:25): [True: 1.54k, False: 3.12M]
  ------------------
 1033|  1.54k|                            ++line_;
 1034|  1.54k|                            if (stack_.back() == csv_mode::header)
  ------------------
  |  Branch (1034:33): [True: 0, False: 1.54k]
  ------------------
 1035|      0|                            {
 1036|      0|                                ++header_line_offset_;
 1037|      0|                            }
 1038|  1.54k|                            column_ = 1;
 1039|  1.54k|                            state_ = csv_parse_state::expect_comment_or_record;
 1040|  1.54k|                            push_state(state_);
 1041|  1.54k|                            state_ = csv_parse_state::cr;
 1042|  1.54k|                            break;
 1043|  3.03M|                        default:
  ------------------
  |  Branch (1043:25): [True: 3.03M, False: 96.2k]
  ------------------
 1044|  3.03M|                            ++column_;
 1045|  3.03M|                            break;
 1046|  3.13M|                    }
 1047|  3.13M|                    ++input_ptr_;
 1048|  3.13M|                    break;
 1049|       |                
 1050|  1.24M|                case csv_parse_state::expect_comment_or_record:
  ------------------
  |  Branch (1050:17): [True: 1.24M, False: 92.9M]
  ------------------
 1051|  1.24M|                    buffer_.clear();
 1052|  1.24M|                    if (curr_char == comment_starter_)
  ------------------
  |  Branch (1052:25): [True: 96.2k, False: 1.15M]
  ------------------
 1053|  96.2k|                    {
 1054|  96.2k|                        state_ = csv_parse_state::comment;
 1055|  96.2k|                        ++column_;
 1056|  96.2k|                        ++input_ptr_;
 1057|  96.2k|                    }
 1058|  1.15M|                    else
 1059|  1.15M|                    {
 1060|  1.15M|                        state_ = csv_parse_state::expect_record;
 1061|  1.15M|                    }
 1062|  1.24M|                    break;
 1063|   179k|                case csv_parse_state::quoted_string: 
  ------------------
  |  Branch (1063:17): [True: 179k, False: 94.0M]
  ------------------
 1064|   179k|                    {
 1065|   179k|                        if (curr_char == quote_escape_char_)
  ------------------
  |  Branch (1065:29): [True: 3.86k, False: 176k]
  ------------------
 1066|  3.86k|                        {
 1067|  3.86k|                            state_ = csv_parse_state::escaped_value;
 1068|  3.86k|                        }
 1069|   176k|                        else if (curr_char == quote_char_)
  ------------------
  |  Branch (1069:34): [True: 0, False: 176k]
  ------------------
 1070|      0|                        {
 1071|      0|                            state_ = csv_parse_state::between_values;
 1072|      0|                        }
 1073|   176k|                        else
 1074|   176k|                        {
 1075|   176k|                            buffer_.push_back(static_cast<CharT>(curr_char));
 1076|   176k|                        }
 1077|   179k|                    }
 1078|   179k|                    ++column_;
 1079|   179k|                    ++input_ptr_;
 1080|   179k|                    break;
 1081|  3.82k|                case csv_parse_state::escaped_value: 
  ------------------
  |  Branch (1081:17): [True: 3.82k, False: 94.2M]
  ------------------
 1082|  3.82k|                    {
 1083|  3.82k|                        if (curr_char == quote_char_)
  ------------------
  |  Branch (1083:29): [True: 1.08k, False: 2.73k]
  ------------------
 1084|  1.08k|                        {
 1085|  1.08k|                            buffer_.push_back(static_cast<CharT>(curr_char));
 1086|  1.08k|                            state_ = csv_parse_state::quoted_string;
 1087|  1.08k|                            ++column_;
 1088|  1.08k|                            ++input_ptr_;
 1089|  1.08k|                        }
 1090|  2.73k|                        else if (quote_escape_char_ == quote_char_)
  ------------------
  |  Branch (1090:34): [True: 2.73k, False: 0]
  ------------------
 1091|  2.73k|                        {
 1092|  2.73k|                            state_ = csv_parse_state::between_values;
 1093|  2.73k|                        }
 1094|      0|                        else
 1095|      0|                        {
 1096|      0|                            ec = csv_errc::invalid_escaped_char;
 1097|      0|                            more_ = false;
 1098|      0|                            return;
 1099|      0|                        }
 1100|  3.82k|                    }
 1101|  3.82k|                    break;
 1102|  3.82k|                case csv_parse_state::between_values:
  ------------------
  |  Branch (1102:17): [True: 3.10k, False: 94.2M]
  ------------------
 1103|  3.10k|                    switch (curr_char)
 1104|  3.10k|                    {
 1105|    777|                        case '\r':
  ------------------
  |  Branch (1105:25): [True: 777, False: 2.33k]
  ------------------
 1106|  1.62k|                        case '\n':
  ------------------
  |  Branch (1106:25): [True: 852, False: 2.25k]
  ------------------
 1107|  1.62k|                        {
 1108|  1.62k|                            if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (1108:33): [True: 0, False: 1.62k]
  |  Branch (1108:50): [True: 0, False: 1.62k]
  ------------------
 1109|      0|                            {
 1110|      0|                                trim_string_buffer(trim_leading_,trim_trailing_);
 1111|      0|                            }
 1112|  1.62k|                            if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1112:35): [True: 0, False: 1.62k]
  |  Branch (1112:59): [True: 0, False: 0]
  ------------------
 1113|  1.62k|                            {
 1114|  1.62k|                                before_value(local_visitor, ec);
 1115|  1.62k|                                state_ = csv_parse_state::before_last_quoted_field;
 1116|  1.62k|                            }
 1117|      0|                            else
 1118|      0|                            {
 1119|      0|                                state_ = csv_parse_state::end_record;
 1120|      0|                            }
 1121|  1.62k|                            break;
 1122|    777|                        }
 1123|  1.48k|                        default:
  ------------------
  |  Branch (1123:25): [True: 1.48k, False: 1.62k]
  ------------------
 1124|  1.48k|                            if (curr_char == field_delimiter_)
  ------------------
  |  Branch (1124:33): [True: 1.05k, False: 426]
  ------------------
 1125|  1.05k|                            {
 1126|  1.05k|                                if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (1126:37): [True: 0, False: 1.05k]
  |  Branch (1126:54): [True: 0, False: 1.05k]
  ------------------
 1127|      0|                                {
 1128|      0|                                    trim_string_buffer(trim_leading_,trim_trailing_);
 1129|      0|                                }
 1130|  1.05k|                                before_value(local_visitor, ec);
 1131|  1.05k|                                state_ = csv_parse_state::before_quoted_field;
 1132|  1.05k|                            }
 1133|    426|                            else if (subfield_delimiter_ != char_type() && curr_char == subfield_delimiter_)
  ------------------
  |  Branch (1133:38): [True: 0, False: 426]
  |  Branch (1133:76): [True: 0, False: 0]
  ------------------
 1134|      0|                            {
 1135|      0|                                if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (1135:37): [True: 0, False: 0]
  |  Branch (1135:54): [True: 0, False: 0]
  ------------------
 1136|      0|                                {
 1137|      0|                                    trim_string_buffer(trim_leading_,trim_trailing_);
 1138|      0|                                }
 1139|      0|                                before_value(local_visitor, ec);
 1140|      0|                                state_ = csv_parse_state::before_quoted_subfield;
 1141|      0|                            }
 1142|    426|                            else if (curr_char == ' ' || curr_char == '\t')
  ------------------
  |  Branch (1142:38): [True: 197, False: 229]
  |  Branch (1142:58): [True: 194, False: 35]
  ------------------
 1143|    391|                            {
 1144|    391|                                ++column_;
 1145|    391|                                ++input_ptr_;
 1146|    391|                            }
 1147|     35|                            else
 1148|     35|                            {
 1149|     35|                                ec = csv_errc::unexpected_char_between_fields;
 1150|     35|                                more_ = false;
 1151|     35|                                return;
 1152|     35|                            }
 1153|  1.44k|                            break;
 1154|  3.10k|                    }
 1155|  3.07k|                    break;
 1156|  11.2M|                case csv_parse_state::before_unquoted_string: 
  ------------------
  |  Branch (1156:17): [True: 11.2M, False: 82.9M]
  ------------------
 1157|  11.2M|                {
 1158|  11.2M|                    buffer_.clear();
 1159|  11.2M|                    state_ = csv_parse_state::unquoted_string;
 1160|  11.2M|                    break;
 1161|  3.10k|                }
 1162|  11.2M|                case csv_parse_state::before_unquoted_field:
  ------------------
  |  Branch (1162:17): [True: 11.2M, False: 82.9M]
  ------------------
 1163|  11.2M|                    end_unquoted_string_value(local_visitor, ec);
 1164|  11.2M|                    state_ = csv_parse_state::before_unquoted_field_tail;
 1165|  11.2M|                    break;
 1166|  11.2M|                case csv_parse_state::before_unquoted_field_tail:
  ------------------
  |  Branch (1166:17): [True: 11.2M, False: 82.9M]
  ------------------
 1167|  11.2M|                {
 1168|  11.2M|                    if (stack_.back() == csv_mode::subfields)
  ------------------
  |  Branch (1168:25): [True: 0, False: 11.2M]
  ------------------
 1169|      0|                    {
 1170|      0|                        stack_.pop_back();
 1171|      0|                        local_visitor.end_array(*this, ec);
 1172|      0|                        more_ = !cursor_mode_;
 1173|      0|                        if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (1173:29): [True: 0, False: 0]
  ------------------
 1174|      0|                        {
 1175|      0|                            if (level() == mark_level_)
  ------------------
  |  Branch (1175:33): [True: 0, False: 0]
  ------------------
 1176|      0|                            {
 1177|      0|                                more_ = false;
 1178|      0|                            }
 1179|      0|                        }
 1180|      0|                        --level_;
 1181|      0|                    }
 1182|  11.2M|                    ++column_index_;
 1183|  11.2M|                    state_ = csv_parse_state::before_unquoted_string;
 1184|  11.2M|                    ++column_;
 1185|  11.2M|                    ++input_ptr_;
 1186|  11.2M|                    break;
 1187|  3.10k|                }
 1188|      0|                case csv_parse_state::before_unquoted_field_tail1:
  ------------------
  |  Branch (1188:17): [True: 0, False: 94.2M]
  ------------------
 1189|      0|                {
 1190|      0|                    if (stack_.back() == csv_mode::subfields)
  ------------------
  |  Branch (1190:25): [True: 0, False: 0]
  ------------------
 1191|      0|                    {
 1192|      0|                        stack_.pop_back();
 1193|      0|                        local_visitor.end_array(*this, ec);
 1194|      0|                        more_ = !cursor_mode_;
 1195|      0|                        if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (1195:29): [True: 0, False: 0]
  ------------------
 1196|      0|                        {
 1197|      0|                            if (level() == mark_level_)
  ------------------
  |  Branch (1197:33): [True: 0, False: 0]
  ------------------
 1198|      0|                            {
 1199|      0|                                more_ = false;
 1200|      0|                            }
 1201|      0|                        }
 1202|      0|                        --level_;
 1203|      0|                    }
 1204|      0|                    state_ = csv_parse_state::end_record;
 1205|      0|                    ++column_;
 1206|      0|                    ++input_ptr_;
 1207|      0|                    break;
 1208|  3.10k|                }
 1209|       |
 1210|   163k|                case csv_parse_state::before_last_unquoted_field:
  ------------------
  |  Branch (1210:17): [True: 163k, False: 94.0M]
  ------------------
 1211|   163k|                    end_unquoted_string_value(local_visitor, ec);
 1212|   163k|                    state_ = csv_parse_state::before_last_unquoted_field_tail;
 1213|   163k|                    break;
 1214|       |
 1215|   163k|                case csv_parse_state::before_last_unquoted_field_tail:
  ------------------
  |  Branch (1215:17): [True: 163k, False: 94.0M]
  ------------------
 1216|   163k|                    if (stack_.back() == csv_mode::subfields)
  ------------------
  |  Branch (1216:25): [True: 0, False: 163k]
  ------------------
 1217|      0|                    {
 1218|      0|                        stack_.pop_back();
 1219|      0|                        local_visitor.end_array(*this, ec);
 1220|      0|                        more_ = !cursor_mode_;
 1221|      0|                        if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (1221:29): [True: 0, False: 0]
  ------------------
 1222|      0|                        {
 1223|      0|                            if (level() == mark_level_)
  ------------------
  |  Branch (1223:33): [True: 0, False: 0]
  ------------------
 1224|      0|                            {
 1225|      0|                                more_ = false;
 1226|      0|                            }
 1227|      0|                        }
 1228|      0|                        --level_;
 1229|      0|                    }
 1230|   163k|                    ++column_index_;
 1231|   163k|                    state_ = csv_parse_state::end_record;
 1232|   163k|                    break;
 1233|       |
 1234|      0|                case csv_parse_state::before_unquoted_subfield:
  ------------------
  |  Branch (1234:17): [True: 0, False: 94.2M]
  ------------------
 1235|      0|                    if (stack_.back() == csv_mode::data)
  ------------------
  |  Branch (1235:25): [True: 0, False: 0]
  ------------------
 1236|      0|                    {
 1237|      0|                        stack_.push_back(csv_mode::subfields);
 1238|      0|                        local_visitor.begin_array(semantic_tag::none, *this, ec);
 1239|      0|                        more_ = !cursor_mode_;
 1240|      0|                        ++level_;
 1241|      0|                    }
 1242|      0|                    state_ = csv_parse_state::before_unquoted_subfield_tail;
 1243|      0|                    break; 
 1244|      0|                case csv_parse_state::before_unquoted_subfield_tail:
  ------------------
  |  Branch (1244:17): [True: 0, False: 94.2M]
  ------------------
 1245|      0|                    end_unquoted_string_value(local_visitor, ec);
 1246|      0|                    state_ = csv_parse_state::before_unquoted_string;
 1247|      0|                    ++column_;
 1248|      0|                    ++input_ptr_;
 1249|      0|                    break;
 1250|  1.05k|                case csv_parse_state::before_quoted_field:
  ------------------
  |  Branch (1250:17): [True: 1.05k, False: 94.2M]
  ------------------
 1251|  1.05k|                    end_quoted_string_value(local_visitor, ec);
 1252|  1.05k|                    state_ = csv_parse_state::before_unquoted_field_tail; // return to unquoted
 1253|  1.05k|                    break;
 1254|      0|                case csv_parse_state::before_quoted_subfield:
  ------------------
  |  Branch (1254:17): [True: 0, False: 94.2M]
  ------------------
 1255|      0|                    if (stack_.back() == csv_mode::data)
  ------------------
  |  Branch (1255:25): [True: 0, False: 0]
  ------------------
 1256|      0|                    {
 1257|      0|                        stack_.push_back(csv_mode::subfields);
 1258|      0|                        local_visitor.begin_array(semantic_tag::none, *this, ec);
 1259|      0|                        more_ = !cursor_mode_;
 1260|      0|                        ++level_;
 1261|      0|                    }
 1262|      0|                    state_ = csv_parse_state::before_quoted_subfield_tail;
 1263|      0|                    break; 
 1264|      0|                case csv_parse_state::before_quoted_subfield_tail:
  ------------------
  |  Branch (1264:17): [True: 0, False: 94.2M]
  ------------------
 1265|      0|                    end_quoted_string_value(local_visitor, ec);
 1266|      0|                    state_ = csv_parse_state::before_unquoted_string;
 1267|      0|                    ++column_;
 1268|      0|                    ++input_ptr_;
 1269|      0|                    break;
 1270|  1.62k|                case csv_parse_state::before_last_quoted_field:
  ------------------
  |  Branch (1270:17): [True: 1.62k, False: 94.2M]
  ------------------
 1271|  1.62k|                    end_quoted_string_value(local_visitor, ec);
 1272|  1.62k|                    state_ = csv_parse_state::before_last_quoted_field_tail;
 1273|  1.62k|                    break;
 1274|  1.62k|                case csv_parse_state::before_last_quoted_field_tail:
  ------------------
  |  Branch (1274:17): [True: 1.62k, False: 94.2M]
  ------------------
 1275|  1.62k|                    if (stack_.back() == csv_mode::subfields)
  ------------------
  |  Branch (1275:25): [True: 0, False: 1.62k]
  ------------------
 1276|      0|                    {
 1277|      0|                        stack_.pop_back();
 1278|      0|                        local_visitor.end_array(*this, ec);
 1279|      0|                        more_ = !cursor_mode_;
 1280|      0|                        if (mapping_kind_ != csv_mapping_kind::m_columns)
  ------------------
  |  Branch (1280:29): [True: 0, False: 0]
  ------------------
 1281|      0|                        {
 1282|      0|                            if (level() == mark_level_)
  ------------------
  |  Branch (1282:33): [True: 0, False: 0]
  ------------------
 1283|      0|                            {
 1284|      0|                                more_ = false;
 1285|      0|                            }
 1286|      0|                        }
 1287|      0|                        --level_;
 1288|      0|                    }
 1289|  1.62k|                    ++column_index_;
 1290|  1.62k|                    state_ = csv_parse_state::end_record;
 1291|  1.62k|                    break;
 1292|  41.3M|                case csv_parse_state::unquoted_string: 
  ------------------
  |  Branch (1292:17): [True: 41.3M, False: 52.8M]
  ------------------
 1293|  41.3M|                {
 1294|  41.3M|                    switch (curr_char)
 1295|  41.3M|                    {
 1296|   112k|                        case '\n':
  ------------------
  |  Branch (1296:25): [True: 112k, False: 41.2M]
  ------------------
 1297|   163k|                        case '\r':
  ------------------
  |  Branch (1297:25): [True: 51.8k, False: 41.2M]
  ------------------
 1298|   163k|                        {
 1299|   163k|                            if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (1299:33): [True: 0, False: 163k]
  |  Branch (1299:50): [True: 0, False: 163k]
  ------------------
 1300|      0|                            {
 1301|      0|                                trim_string_buffer(trim_leading_,trim_trailing_);
 1302|      0|                            }
 1303|   163k|                            if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1303:35): [True: 0, False: 163k]
  |  Branch (1303:59): [True: 0, False: 0]
  ------------------
 1304|   163k|                            {
 1305|   163k|                                before_value(local_visitor, ec);
 1306|   163k|                                state_ = csv_parse_state::before_last_unquoted_field;
 1307|   163k|                            }
 1308|      0|                            else
 1309|      0|                            {
 1310|      0|                                state_ = csv_parse_state::end_record;
 1311|      0|                            }
 1312|   163k|                            break;
 1313|   112k|                        }
 1314|  41.1M|                        default:
  ------------------
  |  Branch (1314:25): [True: 41.1M, False: 163k]
  ------------------
 1315|  41.1M|                            if (curr_char == field_delimiter_)
  ------------------
  |  Branch (1315:33): [True: 11.2M, False: 29.9M]
  ------------------
 1316|  11.2M|                            {
 1317|  11.2M|                                if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (1317:37): [True: 0, False: 11.2M]
  |  Branch (1317:54): [True: 0, False: 11.2M]
  ------------------
 1318|      0|                                {
 1319|      0|                                    trim_string_buffer(trim_leading_,trim_trailing_);
 1320|      0|                                }
 1321|  11.2M|                                before_value(local_visitor, ec);
 1322|  11.2M|                                state_ = csv_parse_state::before_unquoted_field;
 1323|  11.2M|                            }
 1324|  29.9M|                            else if (subfield_delimiter_ != char_type() && curr_char == subfield_delimiter_)
  ------------------
  |  Branch (1324:38): [True: 0, False: 29.9M]
  |  Branch (1324:76): [True: 0, False: 0]
  ------------------
 1325|      0|                            {
 1326|      0|                                if (trim_leading_ || trim_trailing_)
  ------------------
  |  Branch (1326:37): [True: 0, False: 0]
  |  Branch (1326:54): [True: 0, False: 0]
  ------------------
 1327|      0|                                {
 1328|      0|                                    trim_string_buffer(trim_leading_,trim_trailing_);
 1329|      0|                                }
 1330|      0|                                before_value(local_visitor, ec);
 1331|      0|                                state_ = csv_parse_state::before_unquoted_subfield;
 1332|      0|                            }
 1333|  29.9M|                            else if (curr_char == quote_char_)
  ------------------
  |  Branch (1333:38): [True: 1.25k, False: 29.9M]
  ------------------
 1334|  1.25k|                            {
 1335|  1.25k|                                buffer_.clear();
 1336|  1.25k|                                state_ = csv_parse_state::quoted_string;
 1337|  1.25k|                                ++column_;
 1338|  1.25k|                                ++input_ptr_;
 1339|  1.25k|                            }
 1340|  29.9M|                            else
 1341|  29.9M|                            {
 1342|  29.9M|                                buffer_.push_back(static_cast<CharT>(curr_char));
 1343|  29.9M|                                ++column_;
 1344|  29.9M|                                ++input_ptr_;
 1345|  29.9M|                            }
 1346|  41.1M|                            break;
 1347|  41.3M|                    }
 1348|  41.3M|                    break;
 1349|  41.3M|                }
 1350|  41.3M|                case csv_parse_state::expect_record: 
  ------------------
  |  Branch (1350:17): [True: 7.54M, False: 86.6M]
  ------------------
 1351|  7.54M|                {
 1352|  7.54M|                    switch (curr_char)
 1353|  7.54M|                    {
 1354|   983k|                        case '\n':
  ------------------
  |  Branch (1354:25): [True: 983k, False: 6.56M]
  ------------------
 1355|   983k|                        {
 1356|   983k|                            if (!ignore_empty_lines_)
  ------------------
  |  Branch (1356:33): [True: 0, False: 983k]
  ------------------
 1357|      0|                            {
 1358|      0|                                begin_record(local_visitor, ec);
 1359|      0|                                state_ = csv_parse_state::end_record;
 1360|      0|                            }
 1361|   983k|                            else
 1362|   983k|                            {
 1363|   983k|                                ++line_;
 1364|   983k|                                column_ = 1;
 1365|   983k|                                state_ = csv_parse_state::expect_comment_or_record;
 1366|   983k|                                ++input_ptr_;
 1367|   983k|                            }
 1368|   983k|                            break;
 1369|      0|                        }
 1370|  6.39M|                        case '\r':
  ------------------
  |  Branch (1370:25): [True: 6.39M, False: 1.15M]
  ------------------
 1371|  6.39M|                            if (!ignore_empty_lines_)
  ------------------
  |  Branch (1371:33): [True: 0, False: 6.39M]
  ------------------
 1372|      0|                            {
 1373|      0|                                begin_record(local_visitor, ec);
 1374|      0|                                state_ = csv_parse_state::end_record;
 1375|      0|                            }
 1376|  6.39M|                            else
 1377|  6.39M|                            {
 1378|  6.39M|                                ++input_ptr_;
 1379|  6.39M|                                push_state(state_);
 1380|  6.39M|                                state_ = csv_parse_state::cr;
 1381|  6.39M|                            }
 1382|  6.39M|                            break;
 1383|  2.57k|                        case ' ':
  ------------------
  |  Branch (1383:25): [True: 2.57k, False: 7.54M]
  ------------------
 1384|  3.38k|                        case '\t':
  ------------------
  |  Branch (1384:25): [True: 810, False: 7.54M]
  ------------------
 1385|  3.38k|                            if (!trim_leading_)
  ------------------
  |  Branch (1385:33): [True: 3.38k, False: 0]
  ------------------
 1386|  3.38k|                            {
 1387|  3.38k|                                buffer_.push_back(static_cast<CharT>(curr_char));
 1388|  3.38k|                                begin_record(local_visitor, ec);
 1389|  3.38k|                                state_ = csv_parse_state::unquoted_string;
 1390|  3.38k|                            }
 1391|  3.38k|                            ++column_;
 1392|  3.38k|                            ++input_ptr_;
 1393|  3.38k|                            break;
 1394|   165k|                        default:
  ------------------
  |  Branch (1394:25): [True: 165k, False: 7.37M]
  ------------------
 1395|   165k|                            begin_record(local_visitor, ec);
 1396|   165k|                            if (curr_char == quote_char_)
  ------------------
  |  Branch (1396:33): [True: 1.58k, False: 163k]
  ------------------
 1397|  1.58k|                            {
 1398|  1.58k|                                buffer_.clear();
 1399|  1.58k|                                state_ = csv_parse_state::quoted_string;
 1400|  1.58k|                                ++column_;
 1401|  1.58k|                                ++input_ptr_;
 1402|  1.58k|                            }
 1403|   163k|                            else
 1404|   163k|                            {
 1405|   163k|                                state_ = csv_parse_state::unquoted_string;
 1406|   163k|                            }
 1407|   165k|                            break;
 1408|  7.54M|                        }
 1409|  7.54M|                    break;
 1410|  7.54M|                    }
 1411|  7.54M|                case csv_parse_state::end_record: 
  ------------------
  |  Branch (1411:17): [True: 165k, False: 94.0M]
  ------------------
 1412|   165k|                {
 1413|   165k|                    switch (curr_char)
 1414|   165k|                    {
 1415|   112k|                        case '\n':
  ------------------
  |  Branch (1415:25): [True: 112k, False: 52.5k]
  ------------------
 1416|   112k|                        {
 1417|   112k|                            ++line_;
 1418|   112k|                            column_ = 1;
 1419|   112k|                            state_ = csv_parse_state::expect_comment_or_record;
 1420|   112k|                            end_record(local_visitor, ec);
 1421|   112k|                            ++input_ptr_;
 1422|   112k|                            break;
 1423|      0|                        }
 1424|  52.5k|                        case '\r':
  ------------------
  |  Branch (1424:25): [True: 52.5k, False: 112k]
  ------------------
 1425|  52.5k|                            ++line_;
 1426|  52.5k|                            column_ = 1;
 1427|  52.5k|                            state_ = csv_parse_state::expect_comment_or_record;
 1428|  52.5k|                            end_record(local_visitor, ec);
 1429|  52.5k|                            push_state(state_);
 1430|  52.5k|                            state_ = csv_parse_state::cr;
 1431|  52.5k|                            ++input_ptr_;
 1432|  52.5k|                            break;
 1433|      0|                        case ' ':
  ------------------
  |  Branch (1433:25): [True: 0, False: 165k]
  ------------------
 1434|      0|                        case '\t':
  ------------------
  |  Branch (1434:25): [True: 0, False: 165k]
  ------------------
 1435|      0|                            ++column_;
 1436|      0|                            ++input_ptr_;
 1437|      0|                            break;
 1438|      0|                        default:
  ------------------
  |  Branch (1438:25): [True: 0, False: 165k]
  ------------------
 1439|      0|                            err_handler_(csv_errc::syntax_error, *this);
 1440|      0|                            ec = csv_errc::syntax_error;
 1441|      0|                            more_ = false;
 1442|      0|                            return;
 1443|   165k|                        }
 1444|   165k|                    break;
 1445|   165k|                }
 1446|   165k|                default:
  ------------------
  |  Branch (1446:17): [True: 0, False: 94.2M]
  ------------------
 1447|      0|                    err_handler_(csv_errc::invalid_parse_state, *this);
 1448|      0|                    ec = csv_errc::invalid_parse_state;
 1449|      0|                    more_ = false;
 1450|      0|                    return;
 1451|  94.2M|            }
 1452|  94.2M|            if (line_ > max_lines_)
  ------------------
  |  Branch (1452:17): [True: 0, False: 94.2M]
  ------------------
 1453|      0|            {
 1454|      0|                state_ = csv_parse_state::done;
 1455|      0|                more_ = false;
 1456|      0|            }
 1457|  94.2M|        }
 1458|  23.2k|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE25end_unquoted_string_valueERNS_18basic_json_visitorIcEERNS2_10error_codeE:
 1747|  11.4M|    {
 1748|  11.4M|        switch (stack_.back())
 1749|  11.4M|        {
 1750|  11.4M|            case csv_mode::data:
  ------------------
  |  Branch (1750:13): [True: 11.4M, False: 0]
  ------------------
 1751|  11.4M|            case csv_mode::subfields:
  ------------------
  |  Branch (1751:13): [True: 0, False: 11.4M]
  ------------------
 1752|  11.4M|                switch (mapping_kind_)
  ------------------
  |  Branch (1752:25): [True: 11.4M, False: 0]
  ------------------
 1753|  11.4M|                {
 1754|  11.4M|                case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1754:17): [True: 11.4M, False: 0]
  ------------------
 1755|  11.4M|                    if (unquoted_empty_value_is_null_ && buffer_.empty())
  ------------------
  |  Branch (1755:25): [True: 0, False: 11.4M]
  |  Branch (1755:58): [True: 0, False: 0]
  ------------------
 1756|      0|                    {
 1757|      0|                        visitor.null_value(semantic_tag::none, *this, ec);
 1758|      0|                        more_ = !cursor_mode_;
 1759|      0|                    }
 1760|  11.4M|                    else
 1761|  11.4M|                    {
 1762|  11.4M|                        end_value(visitor, infer_types_, ec);
 1763|  11.4M|                    }
 1764|  11.4M|                    break;
 1765|      0|                case csv_mapping_kind::n_objects:
  ------------------
  |  Branch (1765:17): [True: 0, False: 11.4M]
  ------------------
 1766|      0|                    if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1766:27): [True: 0, False: 0]
  |  Branch (1766:51): [True: 0, False: 0]
  ------------------
 1767|      0|                    {
 1768|      0|                        if (column_index_ < column_names_.size() + offset_)
  ------------------
  |  Branch (1768:29): [True: 0, False: 0]
  ------------------
 1769|      0|                        {
 1770|      0|                            if (unquoted_empty_value_is_null_ && buffer_.empty())
  ------------------
  |  Branch (1770:33): [True: 0, False: 0]
  |  Branch (1770:66): [True: 0, False: 0]
  ------------------
 1771|      0|                            {
 1772|      0|                                visitor.null_value(semantic_tag::none, *this, ec);
 1773|      0|                                more_ = !cursor_mode_;
 1774|      0|                            }
 1775|      0|                            else
 1776|      0|                            {
 1777|      0|                                end_value(visitor, infer_types_, ec);
 1778|      0|                            }
 1779|      0|                        }
 1780|      0|                        else if (depth_ > 0)
  ------------------
  |  Branch (1780:34): [True: 0, False: 0]
  ------------------
 1781|      0|                        {
 1782|      0|                            if (unquoted_empty_value_is_null_ && buffer_.empty())
  ------------------
  |  Branch (1782:33): [True: 0, False: 0]
  |  Branch (1782:66): [True: 0, False: 0]
  ------------------
 1783|      0|                            {
 1784|      0|                                visitor.null_value(semantic_tag::none, *this, ec);
 1785|      0|                                more_ = !cursor_mode_;
 1786|      0|                            }
 1787|      0|                            else
 1788|      0|                            {
 1789|      0|                                end_value(visitor, infer_types_, ec);
 1790|      0|                            }
 1791|      0|                        }
 1792|      0|                    }
 1793|      0|                    break;
 1794|      0|                case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (1794:17): [True: 0, False: 11.4M]
  ------------------
 1795|      0|                    if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1795:27): [True: 0, False: 0]
  |  Branch (1795:51): [True: 0, False: 0]
  ------------------
 1796|      0|                    {
 1797|      0|                        end_value(visitor, infer_types_, ec);
 1798|      0|                    }
 1799|      0|                    else
 1800|      0|                    {
 1801|      0|                        m_columns_filter_.skip_column();
 1802|      0|                    }
 1803|      0|                    break;
 1804|  11.4M|                }
 1805|  11.4M|                break;
 1806|  11.4M|            default:
  ------------------
  |  Branch (1806:13): [True: 0, False: 11.4M]
  ------------------
 1807|      0|                break;
 1808|  11.4M|        }
 1809|  11.4M|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE9end_valueERNS_18basic_json_visitorIcEEbRNS2_10error_codeE:
 1875|  11.4M|    {
 1876|  11.4M|        if (enable_str_to_inf_ && buffer_ == inf_to_str_)
  ------------------
  |  Branch (1876:13): [True: 0, False: 11.4M]
  |  Branch (1876:35): [True: 0, False: 0]
  ------------------
 1877|      0|        {
 1878|      0|            visitor.double_value(std::numeric_limits<double>::infinity(), semantic_tag::none, *this, ec);
 1879|      0|            more_ = !cursor_mode_;
 1880|      0|        }
 1881|  11.4M|        else if (enable_str_to_neginf_ && buffer_ == neginf_to_str_)
  ------------------
  |  Branch (1881:18): [True: 0, False: 11.4M]
  |  Branch (1881:43): [True: 0, False: 0]
  ------------------
 1882|      0|        {
 1883|      0|            visitor.double_value(-std::numeric_limits<double>::infinity(), semantic_tag::none, *this, ec);
 1884|      0|            more_ = !cursor_mode_;
 1885|      0|        }
 1886|  11.4M|        else if (enable_str_to_nan_ && buffer_ == nan_to_str_)
  ------------------
  |  Branch (1886:18): [True: 0, False: 11.4M]
  |  Branch (1886:40): [True: 0, False: 0]
  ------------------
 1887|      0|        {
 1888|      0|            visitor.double_value(std::numeric_limits<double>::quiet_NaN(), 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.72k]
  ------------------
 2065|  11.4M|            {
 2066|  11.4M|                end_value_with_numeric_check(visitor, ec);
 2067|  11.4M|            }
 2068|  2.72k|            else
 2069|  2.72k|            {
 2070|  2.72k|                visitor.string_value(buffer_, semantic_tag::none, *this, ec);
 2071|  2.72k|                more_ = !cursor_mode_;
 2072|  2.72k|            }
 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|  29.5M|        for (auto p = buffer_.begin(); state != numeric_check_state::not_a_number && p != last; ++p)
  ------------------
  |  Branch (2106:40): [True: 29.4M, False: 95.8k]
  |  Branch (2106:86): [True: 18.0M, False: 11.3M]
  ------------------
 2107|  18.0M|        {
 2108|  18.0M|            switch (state)
 2109|  18.0M|            {
 2110|   302k|                case numeric_check_state::initial:
  ------------------
  |  Branch (2110:17): [True: 302k, False: 17.7M]
  ------------------
 2111|   302k|                {
 2112|   302k|                    switch (*p)
 2113|   302k|                    {
 2114|  5.76k|                    case 'n':case 'N':
  ------------------
  |  Branch (2114:21): [True: 3.75k, False: 298k]
  |  Branch (2114:30): [True: 2.00k, False: 300k]
  ------------------
 2115|  5.76k|                        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: 4.33k, False: 1.42k]
  |  Branch (2115:47): [True: 2.09k, False: 2.24k]
  |  Branch (2115:62): [True: 1.40k, False: 841]
  |  Branch (2115:79): [True: 1.09k, False: 2.40k]
  |  Branch (2115:94): [True: 1.55k, False: 841]
  |  Branch (2115:111): [True: 747, False: 1.90k]
  |  Branch (2115:126): [True: 1.33k, False: 568]
  ------------------
 2116|  2.08k|                        {
 2117|  2.08k|                            state = numeric_check_state::null;
 2118|  2.08k|                        }
 2119|  3.67k|                        else
 2120|  3.67k|                        {
 2121|  3.67k|                            state = numeric_check_state::not_a_number;
 2122|  3.67k|                        }
 2123|  5.76k|                        break;
 2124|  8.48k|                    case 't':case 'T':
  ------------------
  |  Branch (2124:21): [True: 5.77k, False: 296k]
  |  Branch (2124:30): [True: 2.71k, False: 299k]
  ------------------
 2125|  8.48k|                        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: 6.66k, False: 1.81k]
  |  Branch (2125:47): [True: 3.97k, False: 2.69k]
  |  Branch (2125:62): [True: 2.32k, False: 370]
  |  Branch (2125:79): [True: 1.53k, False: 4.76k]
  |  Branch (2125:94): [True: 4.49k, False: 275]
  |  Branch (2125:111): [True: 373, False: 5.65k]
  |  Branch (2125:126): [True: 3.36k, False: 2.28k]
  ------------------
 2126|  3.73k|                        {
 2127|  3.73k|                            state = numeric_check_state::boolean_true;
 2128|  3.73k|                        }
 2129|  4.75k|                        else
 2130|  4.75k|                        {
 2131|  4.75k|                            state = numeric_check_state::not_a_number;
 2132|  4.75k|                        }
 2133|  8.48k|                        break;
 2134|  20.3k|                    case 'f':case 'F':
  ------------------
  |  Branch (2134:21): [True: 8.22k, False: 293k]
  |  Branch (2134:30): [True: 12.0k, False: 290k]
  ------------------
 2135|  20.3k|                        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: 16.4k, False: 3.89k]
  |  Branch (2135:47): [True: 7.36k, False: 9.05k]
  |  Branch (2135:62): [True: 8.74k, False: 309]
  |  Branch (2135:79): [True: 6.06k, False: 10.0k]
  |  Branch (2135:94): [True: 9.09k, False: 951]
  |  Branch (2135:111): [True: 668, False: 14.4k]
  |  Branch (2135:126): [True: 10.8k, False: 3.61k]
  |  Branch (2135:143): [True: 562, False: 10.9k]
  |  Branch (2135:158): [True: 2.91k, False: 8.07k]
  ------------------
 2136|  3.47k|                        {
 2137|  3.47k|                            state = numeric_check_state::boolean_false;
 2138|  3.47k|                        }
 2139|  16.8k|                        else
 2140|  16.8k|                        {
 2141|  16.8k|                            state = numeric_check_state::not_a_number;
 2142|  16.8k|                        }
 2143|  20.3k|                        break;
 2144|  74.8k|                    case '-':
  ------------------
  |  Branch (2144:21): [True: 74.8k, False: 227k]
  ------------------
 2145|  74.8k|                        is_negative = true;
 2146|  74.8k|                        buffer.push_back(*p);
 2147|  74.8k|                        state = numeric_check_state::minus;
 2148|  74.8k|                        break;
 2149|  8.54k|                    case '0':
  ------------------
  |  Branch (2149:21): [True: 8.54k, False: 293k]
  ------------------
 2150|       |                        //++precision;
 2151|  8.54k|                        buffer.push_back(*p);
 2152|  8.54k|                        state = numeric_check_state::zero;
 2153|  8.54k|                        break;
 2154|   150k|                    case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2154:21): [True: 94.9k, False: 207k]
  |  Branch (2154:30): [True: 12.9k, False: 289k]
  |  Branch (2154:39): [True: 5.61k, False: 296k]
  |  Branch (2154:48): [True: 3.61k, False: 298k]
  |  Branch (2154:57): [True: 10.1k, False: 292k]
  |  Branch (2154:66): [True: 7.30k, False: 294k]
  |  Branch (2154:75): [True: 3.06k, False: 299k]
  |  Branch (2154:84): [True: 5.79k, False: 296k]
  |  Branch (2154:93): [True: 7.15k, False: 295k]
  ------------------
 2155|       |                        //++precision;
 2156|   150k|                        buffer.push_back(*p);
 2157|   150k|                        state = numeric_check_state::integer;
 2158|   150k|                        break;
 2159|  33.6k|                    default:
  ------------------
  |  Branch (2159:21): [True: 33.6k, False: 268k]
  ------------------
 2160|  33.6k|                        state = numeric_check_state::not_a_number;
 2161|  33.6k|                        break;
 2162|   302k|                    }
 2163|   302k|                    break;
 2164|   302k|                }
 2165|   302k|                case numeric_check_state::zero:
  ------------------
  |  Branch (2165:17): [True: 7.43k, False: 18.0M]
  ------------------
 2166|  7.43k|                {
 2167|  7.43k|                    switch (*p)
 2168|  7.43k|                    {
 2169|  2.84k|                        case '.':
  ------------------
  |  Branch (2169:25): [True: 2.84k, False: 4.58k]
  ------------------
 2170|  2.84k|                        {
 2171|  2.84k|                            buffer.push_back('.');
 2172|  2.84k|                            state = numeric_check_state::fraction1;
 2173|  2.84k|                        }
 2174|  2.84k|                        break;
 2175|  2.56k|                    case 'e':case 'E':
  ------------------
  |  Branch (2175:21): [True: 985, False: 6.44k]
  |  Branch (2175:30): [True: 1.58k, False: 5.85k]
  ------------------
 2176|  2.56k|                        buffer.push_back(*p);
 2177|  2.56k|                        state = numeric_check_state::exp1;
 2178|  2.56k|                        break;
 2179|  2.01k|                    default:
  ------------------
  |  Branch (2179:21): [True: 2.01k, False: 5.41k]
  ------------------
 2180|  2.01k|                        state = numeric_check_state::not_a_number;
 2181|  2.01k|                        break;
 2182|  7.43k|                    }
 2183|  7.43k|                    break;
 2184|  7.43k|                }
 2185|  17.2M|                case numeric_check_state::integer:
  ------------------
  |  Branch (2185:17): [True: 17.2M, False: 804k]
  ------------------
 2186|  17.2M|                {
 2187|  17.2M|                    switch (*p)
 2188|  17.2M|                    {
 2189|  17.1M|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2189:21): [True: 15.9M, False: 1.34M]
  |  Branch (2189:30): [True: 366k, False: 16.9M]
  |  Branch (2189:39): [True: 46.4k, False: 17.2M]
  |  Branch (2189:48): [True: 56.6k, False: 17.2M]
  |  Branch (2189:57): [True: 96.9k, False: 17.1M]
  |  Branch (2189:66): [True: 54.6k, False: 17.2M]
  |  Branch (2189:75): [True: 87.8k, False: 17.1M]
  |  Branch (2189:84): [True: 371k, False: 16.9M]
  |  Branch (2189:93): [True: 75.0k, False: 17.2M]
  |  Branch (2189:102): [True: 53.7k, False: 17.2M]
  ------------------
 2190|       |                        //++precision;
 2191|  17.1M|                        buffer.push_back(*p);
 2192|  17.1M|                        break;
 2193|  17.6k|                    case '.':
  ------------------
  |  Branch (2193:21): [True: 17.6k, False: 17.2M]
  ------------------
 2194|  17.6k|                        buffer.push_back('.');
 2195|  17.6k|                        state = numeric_check_state::fraction1;
 2196|  17.6k|                        break;
 2197|   104k|                    case 'e':case 'E':
  ------------------
  |  Branch (2197:21): [True: 11.6k, False: 17.2M]
  |  Branch (2197:30): [True: 92.3k, False: 17.1M]
  ------------------
 2198|   104k|                        buffer.push_back(*p);
 2199|   104k|                        state = numeric_check_state::exp1;
 2200|   104k|                        break;
 2201|  16.9k|                    default:
  ------------------
  |  Branch (2201:21): [True: 16.9k, False: 17.2M]
  ------------------
 2202|  16.9k|                        state = numeric_check_state::not_a_number;
 2203|  16.9k|                        break;
 2204|  17.2M|                    }
 2205|  17.2M|                    break;
 2206|  17.2M|                }
 2207|  17.2M|                case numeric_check_state::minus:
  ------------------
  |  Branch (2207:17): [True: 74.4k, False: 18.0M]
  ------------------
 2208|  74.4k|                {
 2209|  74.4k|                    switch (*p)
 2210|  74.4k|                    {
 2211|  1.20k|                    case '0':
  ------------------
  |  Branch (2211:21): [True: 1.20k, False: 73.2k]
  ------------------
 2212|       |                        //++precision;
 2213|  1.20k|                        buffer.push_back(*p);
 2214|  1.20k|                        state = numeric_check_state::zero;
 2215|  1.20k|                        break;
 2216|  68.8k|                    case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2216:21): [True: 13.2k, False: 61.1k]
  |  Branch (2216:30): [True: 1.12k, False: 73.3k]
  |  Branch (2216:39): [True: 1.27k, False: 73.1k]
  |  Branch (2216:48): [True: 636, False: 73.7k]
  |  Branch (2216:57): [True: 10.1k, False: 64.3k]
  |  Branch (2216:66): [True: 902, False: 73.5k]
  |  Branch (2216:75): [True: 2.04k, False: 72.3k]
  |  Branch (2216:84): [True: 33.7k, False: 40.7k]
  |  Branch (2216:93): [True: 5.77k, False: 68.6k]
  ------------------
 2217|       |                        //++precision;
 2218|  68.8k|                        buffer.push_back(*p);
 2219|  68.8k|                        state = numeric_check_state::integer;
 2220|  68.8k|                        break;
 2221|  4.39k|                    default:
  ------------------
  |  Branch (2221:21): [True: 4.39k, False: 70.0k]
  ------------------
 2222|  4.39k|                        state = numeric_check_state::not_a_number;
 2223|  4.39k|                        break;
 2224|  74.4k|                    }
 2225|  74.4k|                    break;
 2226|  74.4k|                }
 2227|  74.4k|                case numeric_check_state::fraction1:
  ------------------
  |  Branch (2227:17): [True: 19.6k, False: 18.0M]
  ------------------
 2228|  19.6k|                {
 2229|  19.6k|                    switch (*p)
 2230|  19.6k|                    {
 2231|  17.4k|                    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.30k, False: 17.3k]
  |  Branch (2231:30): [True: 1.88k, False: 17.7k]
  |  Branch (2231:39): [True: 1.06k, False: 18.5k]
  |  Branch (2231:48): [True: 587, False: 19.0k]
  |  Branch (2231:57): [True: 4.01k, False: 15.6k]
  |  Branch (2231:66): [True: 449, False: 19.1k]
  |  Branch (2231:75): [True: 540, False: 19.1k]
  |  Branch (2231:84): [True: 4.98k, False: 14.6k]
  |  Branch (2231:93): [True: 964, False: 18.6k]
  |  Branch (2231:102): [True: 642, False: 18.9k]
  ------------------
 2232|       |                        //++precision;
 2233|       |                        //++decimal_places;
 2234|  17.4k|                        buffer.push_back(*p);
 2235|  17.4k|                        state = numeric_check_state::fraction;
 2236|  17.4k|                        break;
 2237|  2.22k|                    default:
  ------------------
  |  Branch (2237:21): [True: 2.22k, False: 17.4k]
  ------------------
 2238|  2.22k|                        state = numeric_check_state::not_a_number;
 2239|  2.22k|                        break;
 2240|  19.6k|                    }
 2241|  19.6k|                    break;
 2242|  19.6k|                }
 2243|   115k|                case numeric_check_state::fraction:
  ------------------
  |  Branch (2243:17): [True: 115k, False: 17.9M]
  ------------------
 2244|   115k|                {
 2245|   115k|                    switch (*p)
 2246|   115k|                    {
 2247|   110k|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2247:21): [True: 18.8k, False: 96.2k]
  |  Branch (2247:30): [True: 40.7k, False: 74.3k]
  |  Branch (2247:39): [True: 2.19k, False: 112k]
  |  Branch (2247:48): [True: 1.87k, False: 113k]
  |  Branch (2247:57): [True: 12.5k, False: 102k]
  |  Branch (2247:66): [True: 5.25k, False: 109k]
  |  Branch (2247:75): [True: 5.95k, False: 109k]
  |  Branch (2247:84): [True: 10.3k, False: 104k]
  |  Branch (2247:93): [True: 9.69k, False: 105k]
  |  Branch (2247:102): [True: 2.83k, False: 112k]
  ------------------
 2248|       |                        //++precision;
 2249|       |                        //++decimal_places;
 2250|   110k|                        buffer.push_back(*p);
 2251|   110k|                        break;
 2252|  2.38k|                    case 'e':case 'E':
  ------------------
  |  Branch (2252:21): [True: 1.70k, False: 113k]
  |  Branch (2252:30): [True: 682, False: 114k]
  ------------------
 2253|  2.38k|                        buffer.push_back(*p);
 2254|  2.38k|                        state = numeric_check_state::exp1;
 2255|  2.38k|                        break;
 2256|  2.45k|                    default:
  ------------------
  |  Branch (2256:21): [True: 2.45k, False: 112k]
  ------------------
 2257|  2.45k|                        state = numeric_check_state::not_a_number;
 2258|  2.45k|                        break;
 2259|   115k|                    }
 2260|   115k|                    break;
 2261|   115k|                }
 2262|   115k|                case numeric_check_state::exp1:
  ------------------
  |  Branch (2262:17): [True: 112k, False: 17.9M]
  ------------------
 2263|   112k|                {
 2264|   112k|                    switch (*p)
 2265|   112k|                    {
 2266|  6.47k|                    case '-':
  ------------------
  |  Branch (2266:21): [True: 6.47k, False: 106k]
  ------------------
 2267|  6.47k|                        buffer.push_back(*p);
 2268|  6.47k|                        break;
 2269|    524|                    case '+':
  ------------------
  |  Branch (2269:21): [True: 524, False: 112k]
  ------------------
 2270|    524|                        break;
 2271|   102k|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2271:21): [True: 5.18k, False: 107k]
  |  Branch (2271:30): [True: 64.9k, False: 47.8k]
  |  Branch (2271:39): [True: 9.83k, False: 102k]
  |  Branch (2271:48): [True: 5.88k, False: 106k]
  |  Branch (2271:57): [True: 6.27k, False: 106k]
  |  Branch (2271:66): [True: 1.40k, False: 111k]
  |  Branch (2271:75): [True: 4.00k, False: 108k]
  |  Branch (2271:84): [True: 3.44k, False: 109k]
  |  Branch (2271:93): [True: 829, False: 111k]
  |  Branch (2271:102): [True: 1.00k, False: 111k]
  ------------------
 2272|   102k|                        state = numeric_check_state::exp;
 2273|   102k|                        buffer.push_back(*p);
 2274|   102k|                        break;
 2275|  3.00k|                    default:
  ------------------
  |  Branch (2275:21): [True: 3.00k, False: 109k]
  ------------------
 2276|  3.00k|                        state = numeric_check_state::not_a_number;
 2277|  3.00k|                        break;
 2278|   112k|                    }
 2279|   112k|                    break;
 2280|   112k|                }
 2281|   141k|                case numeric_check_state::exp:
  ------------------
  |  Branch (2281:17): [True: 141k, False: 17.9M]
  ------------------
 2282|   141k|                {
 2283|   141k|                    switch (*p)
 2284|   141k|                    {
 2285|   135k|                    case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
  ------------------
  |  Branch (2285:21): [True: 31.6k, False: 109k]
  |  Branch (2285:30): [True: 6.22k, False: 135k]
  |  Branch (2285:39): [True: 3.29k, False: 138k]
  |  Branch (2285:48): [True: 7.96k, False: 133k]
  |  Branch (2285:57): [True: 5.71k, False: 135k]
  |  Branch (2285:66): [True: 3.14k, False: 138k]
  |  Branch (2285:75): [True: 66.3k, False: 75.2k]
  |  Branch (2285:84): [True: 7.00k, False: 134k]
  |  Branch (2285:93): [True: 1.44k, False: 140k]
  |  Branch (2285:102): [True: 2.88k, False: 138k]
  ------------------
 2286|   135k|                        buffer.push_back(*p);
 2287|   135k|                        break;
 2288|  5.86k|                    default:
  ------------------
  |  Branch (2288:21): [True: 5.86k, False: 135k]
  ------------------
 2289|  5.86k|                        state = numeric_check_state::not_a_number;
 2290|  5.86k|                        break;
 2291|   141k|                    }
 2292|   141k|                    break;
 2293|   141k|                }
 2294|   141k|                default:
  ------------------
  |  Branch (2294:17): [True: 31.3k, False: 18.0M]
  ------------------
 2295|  31.3k|                    break;
 2296|  18.0M|            }
 2297|  18.0M|        }
 2298|       |
 2299|  11.4M|        switch (state)
 2300|  11.4M|        {
 2301|  2.08k|            case numeric_check_state::null:
  ------------------
  |  Branch (2301:13): [True: 2.08k, False: 11.4M]
  ------------------
 2302|  2.08k|                visitor.null_value(semantic_tag::none, *this, ec);
 2303|  2.08k|                more_ = !cursor_mode_;
 2304|  2.08k|                break;
 2305|  3.73k|            case numeric_check_state::boolean_true:
  ------------------
  |  Branch (2305:13): [True: 3.73k, False: 11.4M]
  ------------------
 2306|  3.73k|                visitor.bool_value(true, semantic_tag::none, *this, ec);
 2307|  3.73k|                more_ = !cursor_mode_;
 2308|  3.73k|                break;
 2309|  3.47k|            case numeric_check_state::boolean_false:
  ------------------
  |  Branch (2309:13): [True: 3.47k, False: 11.4M]
  ------------------
 2310|  3.47k|                visitor.bool_value(false, semantic_tag::none, *this, ec);
 2311|  3.47k|                more_ = !cursor_mode_;
 2312|  3.47k|                break;
 2313|  2.32k|            case numeric_check_state::zero:
  ------------------
  |  Branch (2313:13): [True: 2.32k, False: 11.4M]
  ------------------
 2314|  83.1k|            case numeric_check_state::integer:
  ------------------
  |  Branch (2314:13): [True: 80.8k, False: 11.3M]
  ------------------
 2315|  83.1k|            {
 2316|  83.1k|                if (is_negative)
  ------------------
  |  Branch (2316:21): [True: 51.9k, False: 31.1k]
  ------------------
 2317|  51.9k|                {
 2318|  51.9k|                    int64_t val{ 0 };
 2319|  51.9k|                    auto result = jsoncons::dec_to_integer(buffer_.data(), buffer_.length(), val);
 2320|  51.9k|                    if (result)
  ------------------
  |  Branch (2320:25): [True: 41.2k, False: 10.7k]
  ------------------
 2321|  41.2k|                    {
 2322|  41.2k|                        visitor.int64_value(val, semantic_tag::none, *this, ec);
 2323|  41.2k|                        more_ = !cursor_mode_;
 2324|  41.2k|                    }
 2325|  10.7k|                    else // Must be overflow
 2326|  10.7k|                    {
 2327|  10.7k|                        visitor.string_value(buffer_, semantic_tag::bigint, *this, ec);
 2328|  10.7k|                        more_ = !cursor_mode_;
 2329|  10.7k|                    }
 2330|  51.9k|                }
 2331|  31.1k|                else
 2332|  31.1k|                {
 2333|  31.1k|                    uint64_t val{ 0 };
 2334|  31.1k|                    auto result = jsoncons::dec_to_integer(buffer_.data(), buffer_.length(), val);
 2335|  31.1k|                    if (result)
  ------------------
  |  Branch (2335:25): [True: 26.9k, False: 4.25k]
  ------------------
 2336|  26.9k|                    {
 2337|  26.9k|                        visitor.uint64_value(val, semantic_tag::none, *this, ec);
 2338|  26.9k|                        more_ = !cursor_mode_;
 2339|  26.9k|                    }
 2340|  4.25k|                    else if (result.ec == std::errc::result_out_of_range)
  ------------------
  |  Branch (2340:30): [True: 4.25k, False: 0]
  ------------------
 2341|  4.25k|                    {
 2342|  4.25k|                        visitor.string_value(buffer_, semantic_tag::bigint, *this, ec);
 2343|  4.25k|                        more_ = !cursor_mode_;
 2344|  4.25k|                    }
 2345|      0|                    else
 2346|      0|                    {
 2347|      0|                        ec = csv_errc::invalid_number; 
 2348|      0|                        more_ = false;
 2349|      0|                        return;
 2350|      0|                    }
 2351|  31.1k|                }
 2352|  83.1k|                break;
 2353|  83.1k|            }
 2354|  83.1k|            case numeric_check_state::fraction:
  ------------------
  |  Branch (2354:13): [True: 12.5k, False: 11.4M]
  ------------------
 2355|   109k|            case numeric_check_state::exp:
  ------------------
  |  Branch (2355:13): [True: 96.9k, False: 11.3M]
  ------------------
 2356|   109k|            {
 2357|   109k|                if (lossless_number_)
  ------------------
  |  Branch (2357:21): [True: 0, False: 109k]
  ------------------
 2358|      0|                {
 2359|      0|                    visitor.string_value(buffer_,semantic_tag::bigdec, *this, ec);
 2360|      0|                    more_ = !cursor_mode_;
 2361|      0|                }
 2362|   109k|                else
 2363|   109k|                {
 2364|   109k|                    double d{0};
 2365|   109k|                    auto result = jsoncons::decstr_to_double(buffer.data(), buffer.length(), d);
 2366|   109k|                    if (result.ec == std::errc::result_out_of_range)
  ------------------
  |  Branch (2366:25): [True: 6.94k, False: 102k]
  ------------------
 2367|  6.94k|                    {
 2368|  6.94k|                        d = buffer.front() == '-' ? -HUGE_VAL : HUGE_VAL;
  ------------------
  |  Branch (2368:29): [True: 5.33k, False: 1.60k]
  ------------------
 2369|  6.94k|                    }
 2370|   102k|                    else if (result.ec == std::errc::invalid_argument)
  ------------------
  |  Branch (2370:30): [True: 7, False: 102k]
  ------------------
 2371|      7|                    {
 2372|      7|                        ec = csv_errc::invalid_number; 
 2373|      7|                        more_ = false;
 2374|      7|                        return;
 2375|      7|                    }
 2376|   109k|                    visitor.double_value(d, semantic_tag::none, *this, ec);
 2377|   109k|                    more_ = !cursor_mode_;
 2378|   109k|                }
 2379|   109k|                break;
 2380|   109k|            }
 2381|  11.2M|            default:
  ------------------
  |  Branch (2381:13): [True: 11.2M, False: 201k]
  ------------------
 2382|  11.2M|            {
 2383|  11.2M|                visitor.string_value(buffer_, semantic_tag::none, *this, ec);
 2384|  11.2M|                more_ = !cursor_mode_;
 2385|  11.2M|                break;
 2386|   109k|            }
 2387|  11.4M|        }
 2388|  11.4M|    } 
_ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE5levelEv:
  744|  3.43k|    {
  745|  3.43k|        return level_;
  746|  3.43k|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE12before_valueERNS_18basic_json_visitorIcEERNS2_10error_codeE:
 1516|  11.4M|    {
 1517|  11.4M|        switch (stack_.back())
 1518|  11.4M|        {
 1519|      0|            case csv_mode::header:
  ------------------
  |  Branch (1519:13): [True: 0, False: 11.4M]
  ------------------
 1520|      0|                if (trim_leading_inside_quotes_ || trim_trailing_inside_quotes_)
  ------------------
  |  Branch (1520:21): [True: 0, False: 0]
  |  Branch (1520:52): [True: 0, False: 0]
  ------------------
 1521|      0|                {
 1522|      0|                    trim_string_buffer(trim_leading_inside_quotes_,trim_trailing_inside_quotes_);
 1523|      0|                }
 1524|      0|                if (line_ == (header_line_+header_line_offset_) && column_index_ >= min_column_names_)
  ------------------
  |  Branch (1524:21): [True: 0, False: 0]
  |  Branch (1524:68): [True: 0, False: 0]
  ------------------
 1525|      0|                {
 1526|      0|                    column_names_.push_back(buffer_);
 1527|      0|                    if (assume_header_ && mapping_kind_ == csv_mapping_kind::n_rows)
  ------------------
  |  Branch (1527:25): [True: 0, False: 0]
  |  Branch (1527:43): [True: 0, False: 0]
  ------------------
 1528|      0|                    {
 1529|      0|                        visitor.string_value(buffer_, semantic_tag::none, *this, ec);
 1530|      0|                        more_ = !cursor_mode_;
 1531|      0|                    }
 1532|      0|                }
 1533|      0|                break;
 1534|  11.4M|            case csv_mode::data:
  ------------------
  |  Branch (1534:13): [True: 11.4M, False: 0]
  ------------------
 1535|  11.4M|                if (mapping_kind_ == csv_mapping_kind::n_objects)
  ------------------
  |  Branch (1535:21): [True: 0, False: 11.4M]
  ------------------
 1536|      0|                {
 1537|      0|                    if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1537:27): [True: 0, False: 0]
  |  Branch (1537:51): [True: 0, False: 0]
  ------------------
 1538|      0|                    {
 1539|      0|                        if (column_index_ < column_names_.size() + offset_)
  ------------------
  |  Branch (1539:29): [True: 0, False: 0]
  ------------------
 1540|      0|                        {
 1541|      0|                            visitor.key(column_names_[column_index_ - offset_], *this, ec);
 1542|      0|                            more_ = !cursor_mode_;
 1543|      0|                        }
 1544|      0|                    }
 1545|      0|                }
 1546|  11.4M|                break;
 1547|      0|            default:
  ------------------
  |  Branch (1547:13): [True: 0, False: 11.4M]
  ------------------
 1548|      0|                break;
 1549|  11.4M|        }
 1550|  11.4M|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE23end_quoted_string_valueERNS_18basic_json_visitorIcEERNS2_10error_codeE:
 1813|  2.72k|    {
 1814|  2.72k|        switch (stack_.back())
 1815|  2.72k|        {
 1816|  2.72k|            case csv_mode::data:
  ------------------
  |  Branch (1816:13): [True: 2.72k, False: 0]
  ------------------
 1817|  2.72k|            case csv_mode::subfields:
  ------------------
  |  Branch (1817:13): [True: 0, False: 2.72k]
  ------------------
 1818|  2.72k|                if (trim_leading_inside_quotes_ || trim_trailing_inside_quotes_)
  ------------------
  |  Branch (1818:21): [True: 0, False: 2.72k]
  |  Branch (1818:52): [True: 0, False: 2.72k]
  ------------------
 1819|      0|                {
 1820|      0|                    trim_string_buffer(trim_leading_inside_quotes_,trim_trailing_inside_quotes_);
 1821|      0|                }
 1822|  2.72k|                switch (mapping_kind_)
  ------------------
  |  Branch (1822:25): [True: 2.72k, False: 0]
  ------------------
 1823|  2.72k|                {
 1824|  2.72k|                case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1824:17): [True: 2.72k, False: 0]
  ------------------
 1825|  2.72k|                    end_value(visitor, false, ec);
 1826|  2.72k|                    break;
 1827|      0|                case csv_mapping_kind::n_objects:
  ------------------
  |  Branch (1827:17): [True: 0, False: 2.72k]
  ------------------
 1828|      0|                    if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1828:27): [True: 0, False: 0]
  |  Branch (1828:51): [True: 0, False: 0]
  ------------------
 1829|      0|                    {
 1830|      0|                        if (column_index_ < column_names_.size() + offset_)
  ------------------
  |  Branch (1830:29): [True: 0, False: 0]
  ------------------
 1831|      0|                        {
 1832|      0|                            if (unquoted_empty_value_is_null_ && buffer_.empty())
  ------------------
  |  Branch (1832:33): [True: 0, False: 0]
  |  Branch (1832:66): [True: 0, False: 0]
  ------------------
 1833|      0|                            {
 1834|      0|                                visitor.null_value(semantic_tag::none, *this, ec);
 1835|      0|                                more_ = !cursor_mode_;
 1836|      0|                            }
 1837|      0|                            else 
 1838|      0|                            {
 1839|      0|                                end_value(visitor, false, ec);
 1840|      0|                            }
 1841|      0|                        }
 1842|      0|                        else if (depth_ > 0)
  ------------------
  |  Branch (1842:34): [True: 0, False: 0]
  ------------------
 1843|      0|                        {
 1844|      0|                            if (unquoted_empty_value_is_null_ && buffer_.empty())
  ------------------
  |  Branch (1844:33): [True: 0, False: 0]
  |  Branch (1844:66): [True: 0, False: 0]
  ------------------
 1845|      0|                            {
 1846|      0|                                visitor.null_value(semantic_tag::none, *this, ec);
 1847|      0|                                more_ = !cursor_mode_;
 1848|      0|                            }
 1849|      0|                            else
 1850|      0|                            {
 1851|      0|                                end_value(visitor, false, ec);
 1852|      0|                            }
 1853|      0|                        }
 1854|      0|                    }
 1855|      0|                    break;
 1856|      0|                case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (1856:17): [True: 0, False: 2.72k]
  ------------------
 1857|      0|                    if (!(ignore_empty_values_ && buffer_.empty()))
  ------------------
  |  Branch (1857:27): [True: 0, False: 0]
  |  Branch (1857:51): [True: 0, False: 0]
  ------------------
 1858|      0|                    {
 1859|      0|                        end_value(visitor, false, ec);
 1860|      0|                    }
 1861|      0|                    else
 1862|      0|                    {
 1863|      0|                        m_columns_filter_.skip_column();
 1864|      0|                    }
 1865|      0|                    break;
 1866|  2.72k|                }
 1867|  2.72k|                break;
 1868|  2.72k|            default:
  ------------------
  |  Branch (1868:13): [True: 0, False: 2.72k]
  ------------------
 1869|      0|                break;
 1870|  2.72k|        }
 1871|  2.72k|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE10end_recordERNS_18basic_json_visitorIcEERNS2_10error_codeE:
 1604|   168k|    {
 1605|   168k|        if (!column_types_.empty())
  ------------------
  |  Branch (1605:13): [True: 0, False: 168k]
  ------------------
 1606|      0|        {
 1607|      0|            switch (mapping_kind_)
 1608|      0|            {
 1609|      0|                case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1609:17): [True: 0, False: 0]
  ------------------
 1610|      0|                case csv_mapping_kind::n_objects:
  ------------------
  |  Branch (1610:17): [True: 0, False: 0]
  ------------------
 1611|      0|                    if (depth_ > 0)
  ------------------
  |  Branch (1611:25): [True: 0, False: 0]
  ------------------
 1612|      0|                    {
 1613|      0|                        visitor.end_array(*this, ec);
 1614|      0|                        more_ = !cursor_mode_;
 1615|      0|                        if (level_ == mark_level_)
  ------------------
  |  Branch (1615:29): [True: 0, False: 0]
  ------------------
 1616|      0|                        {
 1617|      0|                            more_ = false;
 1618|      0|                        }
 1619|      0|                        --level_;
 1620|      0|                        depth_ = 0;
 1621|      0|                    }
 1622|      0|                    break;
 1623|      0|                case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (1623:17): [True: 0, False: 0]
  ------------------
 1624|      0|                    if (depth_ > 0)
  ------------------
  |  Branch (1624:25): [True: 0, False: 0]
  ------------------
 1625|      0|                    {
 1626|      0|                        visitor.end_array(*this, ec);
 1627|      0|                        more_ = !cursor_mode_;
 1628|      0|                        --level_;
 1629|      0|                        depth_ = 0;
 1630|      0|                    }
 1631|      0|                    break;
 1632|      0|                default:
  ------------------
  |  Branch (1632:17): [True: 0, False: 0]
  ------------------
 1633|      0|                    break;
 1634|      0|            }
 1635|      0|        }
 1636|   168k|        switch (stack_.back())
 1637|   168k|        {
 1638|      0|            case csv_mode::header:
  ------------------
  |  Branch (1638:13): [True: 0, False: 168k]
  ------------------
 1639|      0|                if (line_ >= header_lines_)
  ------------------
  |  Branch (1639:21): [True: 0, False: 0]
  ------------------
 1640|      0|                {
 1641|      0|                    stack_.back() = csv_mode::data;
 1642|      0|                }
 1643|      0|                switch (mapping_kind_)
 1644|      0|                {
 1645|      0|                    case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1645:21): [True: 0, False: 0]
  ------------------
 1646|      0|                        if (assume_header_)
  ------------------
  |  Branch (1646:29): [True: 0, False: 0]
  ------------------
 1647|      0|                        {
 1648|      0|                            visitor.end_array(*this, ec);
 1649|      0|                            more_ = !cursor_mode_;
 1650|      0|                            if (level() == mark_level_)
  ------------------
  |  Branch (1650:33): [True: 0, False: 0]
  ------------------
 1651|      0|                            {
 1652|      0|                                more_ = false;
 1653|      0|                            }
 1654|      0|                            --level_;
 1655|      0|                        }
 1656|      0|                        break;
 1657|      0|                    case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (1657:21): [True: 0, False: 0]
  ------------------
 1658|      0|                        m_columns_filter_.initialize(column_names_);
 1659|      0|                        break;
 1660|      0|                    default:
  ------------------
  |  Branch (1660:21): [True: 0, False: 0]
  ------------------
 1661|      0|                        break;
 1662|      0|                }
 1663|      0|                break;
 1664|   168k|            case csv_mode::data:
  ------------------
  |  Branch (1664:13): [True: 168k, False: 0]
  ------------------
 1665|   168k|            case csv_mode::subfields:
  ------------------
  |  Branch (1665:13): [True: 0, False: 168k]
  ------------------
 1666|   168k|            {
 1667|   168k|                switch (mapping_kind_)
  ------------------
  |  Branch (1667:25): [True: 168k, False: 0]
  ------------------
 1668|   168k|                {
 1669|   168k|                    case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1669:21): [True: 168k, False: 0]
  ------------------
 1670|   168k|                        visitor.end_array(*this, ec);
 1671|   168k|                        more_ = !cursor_mode_;
 1672|   168k|                        if (level_ == mark_level_)
  ------------------
  |  Branch (1672:29): [True: 0, False: 168k]
  ------------------
 1673|      0|                        {
 1674|      0|                            more_ = false;
 1675|      0|                        }
 1676|   168k|                        --level_;
 1677|   168k|                        break;
 1678|      0|                    case csv_mapping_kind::n_objects:
  ------------------
  |  Branch (1678:21): [True: 0, False: 168k]
  ------------------
 1679|      0|                        visitor.end_object(*this, ec);
 1680|      0|                        more_ = !cursor_mode_;
 1681|      0|                        if (level_ == mark_level_)
  ------------------
  |  Branch (1681:29): [True: 0, False: 0]
  ------------------
 1682|      0|                        {
 1683|      0|                            more_ = false;
 1684|      0|                        }
 1685|      0|                        --level_;
 1686|      0|                        break;
 1687|      0|                    case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (1687:21): [True: 0, False: 168k]
  ------------------
 1688|      0|                        visitor.end_array(*this, ec);
 1689|      0|                        more_ = !cursor_mode_;
 1690|      0|                        --level_;
 1691|      0|                        break;
 1692|   168k|                }
 1693|   168k|                break;
 1694|   168k|            }
 1695|   168k|            default:
  ------------------
  |  Branch (1695:13): [True: 0, False: 168k]
  ------------------
 1696|      0|                break;
 1697|   168k|        }
 1698|   168k|        column_index_ = 0;
 1699|   168k|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE9pop_stateEv:
 2396|  6.44M|    {
 2397|  6.44M|        JSONCONS_ASSERT(!state_stack_.empty())
  ------------------
  |  |   54|  6.44M|#define JSONCONS_ASSERT(x) if (!(x)) { \
  |  |  ------------------
  |  |  |  Branch (54:32): [True: 0, False: 6.44M]
  |  |  ------------------
  |  |   55|      0|    JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at  <> :" \
  |  |  ------------------
  |  |  |  |   35|      0|    #define JSONCONS_THROW(exception) throw exception
  |  |  ------------------
  |  |   56|      0|            JSONCONS_STR( 0 ))); }
  ------------------
 2398|  6.44M|        csv_parse_state state = state_stack_.back();
 2399|  6.44M|        state_stack_.pop_back();
 2400|  6.44M|        return state;
 2401|  6.44M|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE10push_stateENS0_15csv_parse_stateE:
 2391|  6.44M|    {
 2392|  6.44M|        state_stack_.push_back(state);
 2393|  6.44M|    }
_ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE12begin_recordERNS_18basic_json_visitorIcEERNS2_10error_codeE:
 1554|   168k|    {
 1555|   168k|        offset_ = 0;
 1556|       |
 1557|   168k|        if (stack_.back() == csv_mode::header && line_ > (header_lines_+header_line_offset_))
  ------------------
  |  Branch (1557:13): [True: 0, False: 168k]
  |  Branch (1557:50): [True: 0, False: 0]
  ------------------
 1558|      0|        {
 1559|      0|            stack_.back() = csv_mode::data;
 1560|      0|        }
 1561|   168k|        switch (stack_.back())
 1562|   168k|        {
 1563|      0|            case csv_mode::header:
  ------------------
  |  Branch (1563:13): [True: 0, False: 168k]
  ------------------
 1564|      0|                switch (mapping_kind_)
 1565|      0|                {
 1566|      0|                    case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1566:21): [True: 0, False: 0]
  ------------------
 1567|      0|                        if (assume_header_ && line_ == (header_line_+header_line_offset_))
  ------------------
  |  Branch (1567:29): [True: 0, False: 0]
  |  Branch (1567:47): [True: 0, False: 0]
  ------------------
 1568|      0|                        {
 1569|      0|                            visitor.begin_array(semantic_tag::none, *this, ec);
 1570|      0|                            more_ = !cursor_mode_;
 1571|      0|                            ++level_;
 1572|      0|                        }
 1573|      0|                        break;
 1574|      0|                    default:
  ------------------
  |  Branch (1574:21): [True: 0, False: 0]
  ------------------
 1575|      0|                        break;
 1576|      0|                }
 1577|      0|                break;
 1578|   168k|            case csv_mode::data:
  ------------------
  |  Branch (1578:13): [True: 168k, False: 0]
  ------------------
 1579|   168k|                switch (mapping_kind_)
 1580|   168k|                {
 1581|   168k|                    case csv_mapping_kind::n_rows:
  ------------------
  |  Branch (1581:21): [True: 168k, False: 0]
  ------------------
 1582|   168k|                        visitor.begin_array(semantic_tag::none, *this, ec);
 1583|   168k|                        more_ = !cursor_mode_;
 1584|   168k|                        ++level_;
 1585|   168k|                        break;
 1586|      0|                    case csv_mapping_kind::n_objects:
  ------------------
  |  Branch (1586:21): [True: 0, False: 168k]
  ------------------
 1587|      0|                        visitor.begin_object(semantic_tag::none, *this, ec);
 1588|      0|                        more_ = !cursor_mode_;
 1589|      0|                        ++level_;
 1590|      0|                        break;
 1591|      0|                    case csv_mapping_kind::m_columns:
  ------------------
  |  Branch (1591:21): [True: 0, False: 168k]
  ------------------
 1592|      0|                        break;
 1593|      0|                    default:
  ------------------
  |  Branch (1593:21): [True: 0, False: 168k]
  ------------------
 1594|      0|                        break;
 1595|   168k|                }
 1596|   168k|                break;
 1597|   168k|            default:
  ------------------
  |  Branch (1597:13): [True: 0, False: 168k]
  ------------------
 1598|      0|                break;
 1599|   168k|        }
 1600|   168k|    }

_ZN8jsoncons3csv16basic_csv_readerIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES5_ED2Ev:
  109|  3.49k|        ~basic_csv_reader() noexcept = default;
_ZN8jsoncons3csv16basic_csv_readerIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES5_EC2IRNS3_19basic_istringstreamIcNS3_11char_traitsIcEES5_EEEEOT_RNS_18basic_json_visitorIcEERKNS0_24basic_csv_decode_optionsIcEERKS5_:
   62|  3.49k|           : source_(std::forward<Sourceable>(source)),
   63|  3.49k|             visitor_(visitor),
   64|  3.49k|             parser_(options, alloc)
   65|       |
   66|  3.49k|        {
   67|  3.49k|        }
_ZN8jsoncons3csv16basic_csv_readerIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES5_E4readERNS3_10error_codeE:
  122|  3.49k|        {
  123|  3.49k|            read_internal(ec);
  124|  3.49k|        }
_ZN8jsoncons3csv16basic_csv_readerIcNS_13stream_sourceIcNSt3__19allocatorIcEEEES5_E13read_internalERNS3_10error_codeE:
  144|  3.49k|        {
  145|  3.49k|            if (source_.is_error())
  ------------------
  |  Branch (145:17): [True: 0, False: 3.49k]
  ------------------
  146|      0|            {
  147|      0|                ec = csv_errc::source_error;
  148|      0|                return;
  149|      0|            }   
  150|  30.0k|            while (!parser_.stopped())
  ------------------
  |  Branch (150:20): [True: 26.6k, False: 3.43k]
  ------------------
  151|  26.6k|            {
  152|  26.6k|                if (parser_.source_exhausted())
  ------------------
  |  Branch (152:21): [True: 26.6k, False: 0]
  ------------------
  153|  26.6k|                {
  154|  26.6k|                    auto s = source_.read_chunk(ec);
  155|  26.6k|                    if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   79|  26.6k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 10, False: 26.6k]
  |  |  ------------------
  ------------------
  156|  26.6k|                    if (s.size() > 0)
  ------------------
  |  Branch (156:25): [True: 6.51k, False: 20.1k]
  ------------------
  157|  6.51k|                    {
  158|  6.51k|                        parser_.update(s.data(),s.size());
  159|  6.51k|                    }
  160|  26.6k|                }
  161|  26.6k|                parser_.parse_some(visitor_, ec);
  162|  26.6k|                if (JSONCONS_UNLIKELY(ec)) return;
  ------------------
  |  |   79|  26.6k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (79:30): [True: 43, False: 26.6k]
  |  |  ------------------
  ------------------
  163|  26.6k|            }
  164|  3.49k|        }