LLVMFuzzerTestOneInput:
    7|  2.23k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
    8|  2.23k|  try {
    9|       |    // NOTE(derwolfe): by default the limits are set at 2^32-1 length. I'm
   10|       |    // setting these at far smaller values to avoid OOMs
   11|  2.23k|    const int test_limit = 1000;
   12|  2.23k|    msgpack::object_handle unpacked = msgpack::unpack(reinterpret_cast<const char *>(data),
   13|  2.23k|                                                      size,
   14|  2.23k|                                                      MSGPACK_NULLPTR,
  ------------------
  |  |   85|  2.23k|#  define MSGPACK_NULLPTR nullptr
  ------------------
   15|  2.23k|                                                      MSGPACK_NULLPTR,
  ------------------
  |  |   85|  2.23k|#  define MSGPACK_NULLPTR nullptr
  ------------------
   16|  2.23k|                                                      msgpack::unpack_limit(test_limit,
   17|  2.23k|                                                                            test_limit,
   18|  2.23k|                                                                            test_limit,
   19|  2.23k|                                                                            test_limit,
   20|  2.23k|                                                                            test_limit,
   21|  2.23k|                                                                            test_limit));
   22|  2.23k|    msgpack::sbuffer sbuf;
   23|  2.23k|    msgpack::pack(sbuf, unpacked.get());
   24|  2.23k|  } catch (...) {
   25|  1.05k|  }
   26|  2.23k|  return 0;
   27|  2.23k|}

_ZN7msgpack2v1lsINS0_7sbufferENS_2v26objectEEENSt3__19enable_ifIXntsr8is_arrayIT0_EE5valueERNS0_6packerIT_EEE4typeESB_RKS7_:
   72|  1.18k|operator<< (msgpack::packer<Stream>& o, T const& v) {
   73|  1.18k|    return msgpack::adaptor::pack<T>()(o, v);
   74|  1.18k|}

_ZN7msgpack2v16detail20check_container_sizeILm8EEEvm:
   34|  18.9k|inline void check_container_size(std::size_t size) {
   35|  18.9k|    if (size > 0xffffffff) throw container_size_overflow("container size overflow");
  ------------------
  |  Branch (35:9): [True: 0, False: 18.9k]
  ------------------
   36|  18.9k|}

_ZN7msgpack2v14zonenwEm:
  190|  2.23k|    {
  191|  2.23k|        void* p = ::malloc(size);
  192|  2.23k|        if (!p) throw std::bad_alloc();
  ------------------
  |  Branch (192:13): [True: 0, False: 2.23k]
  ------------------
  193|  2.23k|        return p;
  194|  2.23k|    }
_ZN7msgpack2v14zoneC2Em:
  230|  2.23k|{
  231|  2.23k|}
_ZN7msgpack2v14zone10chunk_listC2Em:
  113|  2.23k|        {
  114|  2.23k|            chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
  115|  2.23k|            if(!c) {
  ------------------
  |  Branch (115:16): [True: 0, False: 2.23k]
  ------------------
  116|      0|                throw std::bad_alloc();
  117|      0|            }
  118|       |
  119|  2.23k|            m_head = c;
  120|  2.23k|            m_free = chunk_size;
  121|  2.23k|            m_ptr  = reinterpret_cast<char*>(c) + sizeof(chunk);
  122|  2.23k|            c->m_next = MSGPACK_NULLPTR;
  ------------------
  |  |   85|  2.23k|#  define MSGPACK_NULLPTR nullptr
  ------------------
  123|  2.23k|        }
_ZN7msgpack2v14zone15finalizer_arrayC2Ev:
   38|  2.23k|        finalizer_array():m_tail(MSGPACK_NULLPTR), m_end(MSGPACK_NULLPTR), m_array(MSGPACK_NULLPTR) {}
_ZN7msgpack2v14zone10chunk_listD2Ev:
  125|  2.23k|        {
  126|  2.23k|            chunk* c = m_head;
  127|  12.4k|            while(c) {
  ------------------
  |  Branch (127:19): [True: 10.2k, False: 2.23k]
  ------------------
  128|  10.2k|                chunk* n = c->m_next;
  129|  10.2k|                ::free(c);
  130|  10.2k|                c = n;
  131|  10.2k|            }
  132|  2.23k|        }
_ZN7msgpack2v14zonedlEPv:
  196|  2.23k|    {
  197|  2.23k|        ::free(p);
  198|  2.23k|    }
_ZN7msgpack2v14zone14allocate_alignEmm:
  243|   316k|{
  244|   316k|    char* aligned = get_aligned(m_chunk_list.m_ptr, align);
  245|   316k|    size_t adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
  246|   316k|    if (m_chunk_list.m_free < adjusted_size) {
  ------------------
  |  Branch (246:9): [True: 8.00k, False: 308k]
  ------------------
  247|  8.00k|        size_t enough_size = size + align - 1;
  248|  8.00k|        char* ptr = allocate_expand(enough_size);
  249|  8.00k|        aligned = get_aligned(ptr, align);
  250|  8.00k|        adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
  251|  8.00k|    }
  252|   316k|    m_chunk_list.m_free -= adjusted_size;
  253|   316k|    m_chunk_list.m_ptr  += adjusted_size;
  254|   316k|    return aligned;
  255|   316k|}
_ZN7msgpack2v14zone11get_alignedEPcm:
  234|   324k|{
  235|   324k|    MSGPACK_ASSERT(align != 0 && (align & (align - 1)) == 0); // align must be 2^n (n >= 0)
  ------------------
  |  |   22|   324k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  236|      0|    return
  237|   324k|        reinterpret_cast<char*>(
  238|   324k|            reinterpret_cast<uintptr_t>(ptr + (align - 1)) & ~static_cast<uintptr_t>(align - 1)
  239|   324k|        );
  240|   324k|}
_ZN7msgpack2v14zone15allocate_expandEm:
  270|  8.00k|{
  271|  8.00k|    chunk_list* const cl = &m_chunk_list;
  272|       |
  273|  8.00k|    size_t sz = m_chunk_size;
  274|       |
  275|  11.0k|    while(sz < size) {
  ------------------
  |  Branch (275:11): [True: 3.07k, False: 8.00k]
  ------------------
  276|  3.07k|        size_t tmp_sz = sz * 2;
  277|  3.07k|        if (tmp_sz <= sz) {
  ------------------
  |  Branch (277:13): [True: 0, False: 3.07k]
  ------------------
  278|      0|            sz = size;
  279|      0|            break;
  280|      0|        }
  281|  3.07k|        sz = tmp_sz;
  282|  3.07k|    }
  283|       |
  284|  8.00k|    chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
  285|  8.00k|    if (!c) throw std::bad_alloc();
  ------------------
  |  Branch (285:9): [True: 0, False: 8.00k]
  ------------------
  286|       |
  287|  8.00k|    char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
  288|       |
  289|  8.00k|    c->m_next  = cl->m_head;
  290|  8.00k|    cl->m_head = c;
  291|  8.00k|    cl->m_free = sz;
  292|  8.00k|    cl->m_ptr  = ptr;
  293|       |
  294|  8.00k|    return ptr;
  295|  8.00k|}
_ZN7msgpack2v14zone15finalizer_arrayD2Ev:
   43|  2.23k|        ~finalizer_array() {
   44|  2.23k|            call();
   45|  2.23k|            ::free(m_array);
   46|  2.23k|        }
_ZN7msgpack2v14zone15finalizer_array4callEv:
   39|  2.23k|        void call() {
   40|  2.23k|            finalizer* fin = m_tail;
   41|  2.23k|            for(; fin != m_array; --fin) (*(fin-1))();
  ------------------
  |  Branch (41:19): [True: 0, False: 2.23k]
  ------------------
   42|  2.23k|        }

_ZN7msgpack2v16objectC2Ev:
 1140|  4.47k|{
 1141|  4.47k|    type = msgpack::type::NIL;
 1142|  4.47k|}
_ZN7msgpack2v113object_handleC2ERKNS_2v26objectEONSt3__110unique_ptrINS0_4zoneENS6_14default_deleteIS8_EEEE:
   62|  1.18k|        m_obj(obj), m_zone(msgpack::move(z)) { }
_ZNK7msgpack2v113object_handle3getEv:
   72|  1.18k|        { return m_obj; }
_ZN7msgpack2v16packerINS0_7sbufferEE4packINS_2v26objectEEERS3_RKT_:
  876|  1.18k|{
  877|  1.18k|    msgpack::operator<<(*this, v);
  878|  1.18k|    return *this;
  879|  1.18k|}
_ZNK7msgpack2v17adaptor4packINS_2v26objectEvEclINS0_7sbufferEEERNS0_6packerIT_EESB_RKS4_:
  680|  1.18k|    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, msgpack::object const& v) const {
  681|  1.18k|        object_pack_visitor<Stream> vis(o);
  682|  1.18k|        msgpack::object_parser(v).parse(vis);
  683|  1.18k|        return o;
  684|  1.18k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEEC2ERNS0_6packerIS2_EE:
  318|  1.18k|        :m_packer(pk) {}
_ZN7msgpack2v113object_parserC2ERKNS_2v26objectE:
  236|  1.18k|    explicit object_parser(msgpack::object const& obj):m_current(&obj) {}
_ZN7msgpack2v113object_parser5parseINS0_19object_pack_visitorINS0_7sbufferEEEEEvRT_:
  238|  1.18k|    void parse(Visitor& v) {
  239|  1.35M|        while (true) {
  ------------------
  |  Branch (239:16): [Folded - Ignored]
  ------------------
  240|  1.35M|            bool start_collection = false;
  241|  1.35M|            switch(m_current->type) {
  242|  2.61k|            case msgpack::type::NIL:
  ------------------
  |  Branch (242:13): [True: 2.61k, False: 1.34M]
  ------------------
  243|  2.61k|                if (!v.visit_nil()) return;
  ------------------
  |  Branch (243:21): [True: 0, False: 2.61k]
  ------------------
  244|  2.61k|                break;
  245|  10.1k|            case msgpack::type::BOOLEAN:
  ------------------
  |  Branch (245:13): [True: 10.1k, False: 1.34M]
  ------------------
  246|  10.1k|                if (!v.visit_boolean(m_current->via.boolean)) return;
  ------------------
  |  Branch (246:21): [True: 0, False: 10.1k]
  ------------------
  247|  10.1k|                break;
  248|   611k|            case msgpack::type::POSITIVE_INTEGER:
  ------------------
  |  Branch (248:13): [True: 611k, False: 739k]
  ------------------
  249|   611k|                if (!v.visit_positive_integer(m_current->via.u64)) return;
  ------------------
  |  Branch (249:21): [True: 0, False: 611k]
  ------------------
  250|   611k|                break;
  251|   611k|            case msgpack::type::NEGATIVE_INTEGER:
  ------------------
  |  Branch (251:13): [True: 181k, False: 1.16M]
  ------------------
  252|   181k|                if (!v.visit_negative_integer(m_current->via.i64)) return;
  ------------------
  |  Branch (252:21): [True: 0, False: 181k]
  ------------------
  253|   181k|                break;
  254|   286k|            case msgpack::type::FLOAT32:
  ------------------
  |  Branch (254:13): [True: 286k, False: 1.06M]
  ------------------
  255|   286k|                if (!v.visit_float32(static_cast<float>(m_current->via.f64))) return;
  ------------------
  |  Branch (255:21): [True: 0, False: 286k]
  ------------------
  256|   286k|                break;
  257|   286k|            case msgpack::type::FLOAT64:
  ------------------
  |  Branch (257:13): [True: 12.2k, False: 1.33M]
  ------------------
  258|  12.2k|                if (!v.visit_float64(m_current->via.f64)) return;
  ------------------
  |  Branch (258:21): [True: 0, False: 12.2k]
  ------------------
  259|  12.2k|                break;
  260|  26.6k|            case msgpack::type::STR:
  ------------------
  |  Branch (260:13): [True: 26.6k, False: 1.32M]
  ------------------
  261|  26.6k|                if (!v.visit_str(m_current->via.str.ptr, m_current->via.str.size)) return;
  ------------------
  |  Branch (261:21): [True: 0, False: 26.6k]
  ------------------
  262|  26.6k|                break;
  263|  26.6k|            case msgpack::type::BIN:
  ------------------
  |  Branch (263:13): [True: 5.04k, False: 1.34M]
  ------------------
  264|  5.04k|                if (!v.visit_bin(m_current->via.bin.ptr, m_current->via.bin.size)) return;
  ------------------
  |  Branch (264:21): [True: 0, False: 5.04k]
  ------------------
  265|  5.04k|                break;
  266|  18.9k|            case msgpack::type::EXT:
  ------------------
  |  Branch (266:13): [True: 18.9k, False: 1.33M]
  ------------------
  267|  18.9k|                msgpack::detail::check_container_size<sizeof(std::size_t)>(m_current->via.ext.size);
  268|  18.9k|                if (!v.visit_ext(m_current->via.ext.ptr, m_current->via.ext.size + 1)) return;
  ------------------
  |  Branch (268:21): [True: 0, False: 18.9k]
  ------------------
  269|  18.9k|                break;
  270|  88.4k|            case msgpack::type::ARRAY:
  ------------------
  |  Branch (270:13): [True: 88.4k, False: 1.26M]
  ------------------
  271|  88.4k|                if (!v.start_array(m_current->via.array.size)) return;
  ------------------
  |  Branch (271:21): [True: 0, False: 88.4k]
  ------------------
  272|  88.4k|                m_ctx.push_back(elem(m_current->via.array.ptr, m_current->via.array.size));
  273|  88.4k|                start_collection = m_current->via.array.size != 0;
  274|  88.4k|                if (start_collection) {
  ------------------
  |  Branch (274:21): [True: 73.3k, False: 15.0k]
  ------------------
  275|  73.3k|                    if (!v.start_array_item()) return;
  ------------------
  |  Branch (275:25): [True: 0, False: 73.3k]
  ------------------
  276|  73.3k|                }
  277|  88.4k|                break;
  278|   108k|            case msgpack::type::MAP:
  ------------------
  |  Branch (278:13): [True: 108k, False: 1.24M]
  ------------------
  279|   108k|                if (!v.start_map(m_current->via.map.size)) return;
  ------------------
  |  Branch (279:21): [True: 0, False: 108k]
  ------------------
  280|   108k|                m_ctx.push_back(elem(m_current->via.map.ptr, m_current->via.map.size));
  281|   108k|                start_collection = m_current->via.map.size != 0;
  282|   108k|                if (start_collection) {
  ------------------
  |  Branch (282:21): [True: 89.6k, False: 18.4k]
  ------------------
  283|  89.6k|                    if (!v.start_map_key()) return;
  ------------------
  |  Branch (283:25): [True: 0, False: 89.6k]
  ------------------
  284|  89.6k|                }
  285|   108k|                break;
  286|   108k|            default:
  ------------------
  |  Branch (286:13): [True: 0, False: 1.35M]
  ------------------
  287|      0|                throw msgpack::type_error();
  288|      0|                break;
  289|  1.35M|            }
  290|  1.35M|            if (m_ctx.empty()) return;
  ------------------
  |  Branch (290:17): [True: 705, False: 1.35M]
  ------------------
  291|  1.35M|            if (!start_collection) {
  ------------------
  |  Branch (291:17): [True: 1.18M, False: 163k]
  ------------------
  292|  1.38M|                while (true) {
  ------------------
  |  Branch (292:24): [Folded - Ignored]
  ------------------
  293|  1.38M|                    next_ret r = m_ctx.back().next(v);
  294|  1.38M|                    if (r == finish) {
  ------------------
  |  Branch (294:25): [True: 196k, False: 1.18M]
  ------------------
  295|   196k|                        m_ctx.pop_back();
  296|   196k|                        if (m_ctx.empty()) return;
  ------------------
  |  Branch (296:29): [True: 475, False: 196k]
  ------------------
  297|   196k|                    }
  298|  1.18M|                    else if (r == cont) {
  ------------------
  |  Branch (298:30): [True: 1.18M, False: 0]
  ------------------
  299|  1.18M|                        break;
  300|  1.18M|                    }
  301|      0|                    else {
  302|       |                        // abort
  303|      0|                        return;
  304|      0|                    }
  305|  1.38M|                }
  306|  1.18M|            }
  307|  1.34M|            m_current = &m_ctx.back().get();
  308|  1.34M|        }
  309|  1.18k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE9visit_nilEv:
  319|  2.61k|    bool visit_nil() {
  320|  2.61k|        m_packer.pack_nil();
  321|  2.61k|        return true;
  322|  2.61k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE13visit_booleanEb:
  323|  10.1k|    bool visit_boolean(bool v) {
  324|  10.1k|        if (v) m_packer.pack_true();
  ------------------
  |  Branch (324:13): [True: 9.60k, False: 590]
  ------------------
  325|    590|        else m_packer.pack_false();
  326|  10.1k|        return true;
  327|  10.1k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE22visit_positive_integerEm:
  328|   611k|    bool visit_positive_integer(uint64_t v) {
  329|   611k|        m_packer.pack_uint64(v);
  330|   611k|        return true;
  331|   611k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE22visit_negative_integerEl:
  332|   181k|    bool visit_negative_integer(int64_t v) {
  333|   181k|        m_packer.pack_int64(v);
  334|   181k|        return true;
  335|   181k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE13visit_float32Ef:
  336|   286k|    bool visit_float32(float v) {
  337|   286k|        m_packer.pack_float(v);
  338|   286k|        return true;
  339|   286k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE13visit_float64Ed:
  340|  12.2k|    bool visit_float64(double v) {
  341|  12.2k|        m_packer.pack_double(v);
  342|  12.2k|        return true;
  343|  12.2k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE9visit_strEPKcj:
  344|  26.6k|    bool visit_str(const char* v, uint32_t size) {
  345|  26.6k|        m_packer.pack_str(size);
  346|  26.6k|        m_packer.pack_str_body(v, size);
  347|  26.6k|        return true;
  348|  26.6k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE9visit_binEPKcj:
  349|  5.04k|    bool visit_bin(const char* v, uint32_t size) {
  350|  5.04k|        m_packer.pack_bin(size);
  351|  5.04k|        m_packer.pack_bin_body(v, size);
  352|  5.04k|        return true;
  353|  5.04k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE9visit_extEPKcj:
  354|  18.9k|    bool visit_ext(const char* v, uint32_t size) {
  355|  18.9k|        m_packer.pack_ext(size - 1, static_cast<int8_t>(*v));
  356|  18.9k|        m_packer.pack_ext_body(v + 1, size - 1);
  357|  18.9k|        return true;
  358|  18.9k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE11start_arrayEj:
  359|  88.4k|    bool start_array(uint32_t num_elements) {
  360|  88.4k|        m_packer.pack_array(num_elements);
  361|  88.4k|        return true;
  362|  88.4k|    }
_ZN7msgpack2v113object_parser4elemC2EPKNS_2v26objectEm:
  160|  88.4k|            : rest(r), is_map(false), is_key(false) {
  161|  88.4k|            as.obj_ptr = p;
  162|  88.4k|        }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE16start_array_itemEv:
  363|   614k|    bool start_array_item() {
  364|   614k|        return true;
  365|   614k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE9start_mapEj:
  372|   108k|    bool start_map(uint32_t num_kv_pairs) {
  373|   108k|        m_packer.pack_map(num_kv_pairs);
  374|   108k|        return true;
  375|   108k|    }
_ZN7msgpack2v113object_parser4elemC2EPKNS0_9object_kvEm:
  165|   108k|            : rest(r), is_map(true), is_key(true) {
  166|   108k|            as.kv_ptr = p;
  167|   108k|        }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE13start_map_keyEv:
  376|   367k|    bool start_map_key() {
  377|   367k|        return true;
  378|   367k|    }
_ZN7msgpack2v113object_parser4elem4nextINS0_19object_pack_visitorINS0_7sbufferEEEEENS1_8next_retERT_:
  184|  1.38M|        next_ret next(Visitor& v) {
  185|  1.38M|            if (rest == 0) {
  ------------------
  |  Branch (185:17): [True: 33.4k, False: 1.34M]
  ------------------
  186|  33.4k|                if (is_map) {
  ------------------
  |  Branch (186:21): [True: 18.4k, False: 15.0k]
  ------------------
  187|  18.4k|                    if (!v.end_map()) return abort;
  ------------------
  |  Branch (187:25): [True: 0, False: 18.4k]
  ------------------
  188|  18.4k|                }
  189|  15.0k|                else {
  190|  15.0k|                    if (!v.end_array()) return abort;
  ------------------
  |  Branch (190:25): [True: 0, False: 15.0k]
  ------------------
  191|  15.0k|                }
  192|  33.4k|                return finish;
  193|  33.4k|            }
  194|  1.34M|            else {
  195|  1.34M|                if (is_map) {
  ------------------
  |  Branch (195:21): [True: 735k, False: 614k]
  ------------------
  196|   735k|                    if (is_key) {
  ------------------
  |  Branch (196:25): [True: 367k, False: 367k]
  ------------------
  197|   367k|                        if (!v.end_map_key()) return abort;
  ------------------
  |  Branch (197:29): [True: 0, False: 367k]
  ------------------
  198|   367k|                        if (!v.start_map_value()) return abort;
  ------------------
  |  Branch (198:29): [True: 0, False: 367k]
  ------------------
  199|   367k|                        is_key = false;
  200|   367k|                    }
  201|   367k|                    else {
  202|   367k|                        if (!v.end_map_value()) return abort;
  ------------------
  |  Branch (202:29): [True: 0, False: 367k]
  ------------------
  203|   367k|                        --rest;
  204|   367k|                        if (rest == 0) {
  ------------------
  |  Branch (204:29): [True: 89.6k, False: 277k]
  ------------------
  205|  89.6k|                            if (!v.end_map()) return abort;
  ------------------
  |  Branch (205:33): [True: 0, False: 89.6k]
  ------------------
  206|  89.6k|                            return finish;
  207|  89.6k|                        }
  208|   277k|                        if (!v.start_map_key()) return abort;
  ------------------
  |  Branch (208:29): [True: 0, False: 277k]
  ------------------
  209|   277k|                        ++as.kv_ptr;
  210|   277k|                        is_key = true;
  211|   277k|                    }
  212|   735k|                }
  213|   614k|                else {
  214|   614k|                    if (!v.end_array_item()) return abort;
  ------------------
  |  Branch (214:25): [True: 0, False: 614k]
  ------------------
  215|   614k|                    --rest;
  216|   614k|                    if (rest == 0) {
  ------------------
  |  Branch (216:25): [True: 73.3k, False: 541k]
  ------------------
  217|  73.3k|                        if (!v.end_array()) return abort;
  ------------------
  |  Branch (217:29): [True: 0, False: 73.3k]
  ------------------
  218|  73.3k|                        return finish;
  219|  73.3k|                    }
  220|   541k|                    if (!v.start_array_item()) return abort;
  ------------------
  |  Branch (220:25): [True: 0, False: 541k]
  ------------------
  221|   541k|                    ++as.obj_ptr;
  222|   541k|                }
  223|  1.18M|                return cont;
  224|  1.34M|            }
  225|  1.38M|        }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE7end_mapEv:
  388|   108k|    bool end_map() {
  389|   108k|        return true;
  390|   108k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE9end_arrayEv:
  369|  88.4k|    bool end_array() {
  370|  88.4k|        return true;
  371|  88.4k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE11end_map_keyEv:
  379|   367k|    bool end_map_key() {
  380|   367k|        return true;
  381|   367k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE15start_map_valueEv:
  382|   367k|    bool start_map_value() {
  383|   367k|        return true;
  384|   367k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE13end_map_valueEv:
  385|   367k|    bool end_map_value() {
  386|   367k|        return true;
  387|   367k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE14end_array_itemEv:
  366|   614k|    bool end_array_item() {
  367|   614k|        return true;
  368|   614k|    }
_ZNK7msgpack2v113object_parser4elem3getEv:
  169|  1.34M|        msgpack::object const& get() const {
  170|  1.34M|            if (is_map) {
  ------------------
  |  Branch (170:17): [True: 735k, False: 614k]
  ------------------
  171|   735k|                if (is_key) {
  ------------------
  |  Branch (171:21): [True: 367k, False: 367k]
  ------------------
  172|   367k|                    return as.kv_ptr->key;
  173|   367k|                }
  174|   367k|                else {
  175|   367k|                    return as.kv_ptr->val;
  176|   367k|                }
  177|   735k|            }
  178|   614k|            else {
  179|   614k|                return *as.obj_ptr;
  180|   614k|            }
  181|  1.34M|        }

_ZN7msgpack2v14packINS0_7sbufferENS_2v26objectEEEvRT_RKT0_:
  674|  1.18k|{
  675|  1.18k|    packer<Stream>(s).pack(v);
  676|  1.18k|}
_ZN7msgpack2v16packerINS0_7sbufferEEC2ERS2_:
  724|  1.18k|inline packer<Stream>::packer(Stream& s) : m_stream(s) { }
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_nilEv:
 1193|  2.61k|{
 1194|  2.61k|    const char d = static_cast<char>(0xc0u);
 1195|  2.61k|    append_buffer(&d, 1);
 1196|  2.61k|    return *this;
 1197|  2.61k|}
_ZN7msgpack2v16packerINS0_7sbufferEE13append_bufferEPKcm:
  622|  1.40M|    {
  623|  1.40M|        append_buffer(&Stream::write, buf, len);
  624|  1.40M|    }
_ZN7msgpack2v16packerINS0_7sbufferEE13append_bufferIvS2_mEEvMT0_FT_PKcT1_ES8_m:
  628|  1.40M|    {
  629|  1.40M|        m_stream.write(buf, static_cast<SizeType>(len));
  630|  1.40M|    }
_ZN7msgpack2v16packerINS0_7sbufferEE9pack_trueEv:
 1201|  9.60k|{
 1202|  9.60k|    const char d = static_cast<char>(0xc3u);
 1203|  9.60k|    append_buffer(&d, 1);
 1204|  9.60k|    return *this;
 1205|  9.60k|}
_ZN7msgpack2v16packerINS0_7sbufferEE10pack_falseEv:
 1209|    590|{
 1210|    590|    const char d = static_cast<char>(0xc2u);
 1211|    590|    append_buffer(&d, 1);
 1212|    590|    return *this;
 1213|    590|}
_ZN7msgpack2v16packerINS0_7sbufferEE11pack_uint64Em:
  741|   611k|{ pack_imp_uint64(d); return *this; }
_ZN7msgpack2v16packerINS0_7sbufferEE15pack_imp_uint64ImEEvT_:
 1470|   884k|{
 1471|   884k|    if(d < (1ULL<<8)) {
  ------------------
  |  Branch (1471:8): [True: 605k, False: 279k]
  ------------------
 1472|   605k|        if(d < (1ULL<<7)) {
  ------------------
  |  Branch (1472:12): [True: 539k, False: 65.8k]
  ------------------
 1473|       |            /* fixnum */
 1474|   539k|            char buf = take8_64(d);
 1475|   539k|            append_buffer(&buf, 1);
 1476|   539k|        } else {
 1477|       |            /* unsigned 8 */
 1478|  65.8k|            char buf[2] = {static_cast<char>(0xccu), take8_64(d)};
 1479|  65.8k|            append_buffer(buf, 2);
 1480|  65.8k|        }
 1481|   605k|    } else {
 1482|   279k|        if(d < (1ULL<<16)) {
  ------------------
  |  Branch (1482:12): [True: 1.86k, False: 277k]
  ------------------
 1483|       |            /* unsigned 16 */
 1484|  1.86k|            char buf[3];
 1485|  1.86k|            buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
  ------------------
  |  |  186|  1.86k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  1.86k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1486|  1.86k|            append_buffer(buf, 3);
 1487|   277k|        } else if(d < (1ULL<<32)) {
  ------------------
  |  Branch (1487:19): [True: 1.02k, False: 276k]
  ------------------
 1488|       |            /* unsigned 32 */
 1489|  1.02k|            char buf[5];
 1490|  1.02k|            buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
  ------------------
  |  |  188|  1.02k|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|  1.02k|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1491|  1.02k|            append_buffer(buf, 5);
 1492|   276k|        } else {
 1493|       |            /* unsigned 64 */
 1494|   276k|            char buf[9];
 1495|   276k|            buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
  ------------------
  |  |  190|   276k|    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
  |  |  ------------------
  |  |  |  |  146|   276k|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  |  Branch (190:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1496|   276k|            append_buffer(buf, 9);
 1497|   276k|        }
 1498|   279k|    }
 1499|   884k|}
_ZN7msgpack2v18take8_64ImEEcT_:
  693|   605k|inline char take8_64(T d) {
  694|   605k|    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
  695|   605k|}
_ZN7msgpack2v16packerINS0_7sbufferEE10pack_int64El:
  757|   181k|{ pack_imp_int64(d); return *this;}
_ZN7msgpack2v16packerINS0_7sbufferEE14pack_imp_int64IlEEvT_:
 1595|   186k|{
 1596|   186k|    if(d < -(1LL<<5)) {
  ------------------
  |  Branch (1596:8): [True: 16.7k, False: 169k]
  ------------------
 1597|  16.7k|        if(d < -(1LL<<15)) {
  ------------------
  |  Branch (1597:12): [True: 8.12k, False: 8.58k]
  ------------------
 1598|  8.12k|            if(d < -(1LL<<31)) {
  ------------------
  |  Branch (1598:16): [True: 5.16k, False: 2.95k]
  ------------------
 1599|       |                /* signed 64 */
 1600|  5.16k|                char buf[9];
 1601|  5.16k|                buf[0] = static_cast<char>(0xd3u); _msgpack_store64(&buf[1], d);
  ------------------
  |  |  190|  5.16k|    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
  |  |  ------------------
  |  |  |  |  146|  5.16k|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  |  Branch (190:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1602|  5.16k|                append_buffer(buf, 9);
 1603|  5.16k|            } else {
 1604|       |                /* signed 32 */
 1605|  2.95k|                char buf[5];
 1606|  2.95k|                buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], static_cast<int32_t>(d));
  ------------------
  |  |  188|  2.95k|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|  2.95k|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1607|  2.95k|                append_buffer(buf, 5);
 1608|  2.95k|            }
 1609|  8.58k|        } else {
 1610|  8.58k|            if(d < -(1<<7)) {
  ------------------
  |  Branch (1610:16): [True: 6.99k, False: 1.59k]
  ------------------
 1611|       |                /* signed 16 */
 1612|  6.99k|                char buf[3];
 1613|  6.99k|                buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
  ------------------
  |  |  186|  6.99k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  6.99k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1614|  6.99k|                append_buffer(buf, 3);
 1615|  6.99k|            } else {
 1616|       |                /* signed 8 */
 1617|  1.59k|                char buf[2] = {static_cast<char>(0xd0u), take8_64(d)};
 1618|  1.59k|                append_buffer(buf, 2);
 1619|  1.59k|            }
 1620|  8.58k|        }
 1621|   169k|    } else if(d < (1<<7)) {
  ------------------
  |  Branch (1621:15): [True: 169k, False: 0]
  ------------------
 1622|       |        /* fixnum */
 1623|   169k|        char buf = take8_64(d);
 1624|   169k|        append_buffer(&buf, 1);
 1625|   169k|    } else {
 1626|      0|        if(d < (1LL<<16)) {
  ------------------
  |  Branch (1626:12): [True: 0, False: 0]
  ------------------
 1627|      0|            if(d < (1<<8)) {
  ------------------
  |  Branch (1627:16): [True: 0, False: 0]
  ------------------
 1628|       |                /* unsigned 8 */
 1629|      0|                char buf[2] = {static_cast<char>(0xccu), take8_64(d)};
 1630|      0|                append_buffer(buf, 2);
 1631|      0|            } else {
 1632|       |                /* unsigned 16 */
 1633|      0|                char buf[3];
 1634|      0|                buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
  ------------------
  |  |  186|      0|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|      0|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1635|      0|                append_buffer(buf, 3);
 1636|      0|            }
 1637|      0|        } else {
 1638|      0|            if(d < (1LL<<32)) {
  ------------------
  |  Branch (1638:16): [True: 0, False: 0]
  ------------------
 1639|       |                /* unsigned 32 */
 1640|      0|                char buf[5];
 1641|      0|                buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
  ------------------
  |  |  188|      0|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|      0|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1642|      0|                append_buffer(buf, 5);
 1643|      0|            } else {
 1644|       |                /* unsigned 64 */
 1645|      0|                char buf[9];
 1646|      0|                buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
  ------------------
  |  |  190|      0|    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
  |  |  ------------------
  |  |  |  |  146|      0|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  |  Branch (190:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1647|      0|                append_buffer(buf, 9);
 1648|      0|            }
 1649|      0|        }
 1650|      0|    }
 1651|   186k|}
_ZN7msgpack2v18take8_64IlEEcT_:
  693|   171k|inline char take8_64(T d) {
  694|   171k|    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
  695|   171k|}
_ZN7msgpack2v16packerINS0_7sbufferEE10pack_floatEf:
 1140|   286k|{
 1141|   286k|    if(d == d) { // check for nan
  ------------------
  |  Branch (1141:8): [True: 285k, False: 672]
  ------------------
 1142|       |        // compare d to limits to avoid undefined behaviour
 1143|   285k|        if(d >= 0 && d <= float(std::numeric_limits<uint64_t>::max()) && d == float(uint64_t(d))) {
  ------------------
  |  Branch (1143:12): [True: 276k, False: 8.90k]
  |  Branch (1143:22): [True: 274k, False: 1.90k]
  |  Branch (1143:74): [True: 272k, False: 1.83k]
  ------------------
 1144|   272k|            pack_imp_uint64(uint64_t(d));
 1145|   272k|            return *this;
 1146|   272k|        } else if(d < 0 && d >= float(std::numeric_limits<int64_t>::min()) && d == float(int64_t(d))) {
  ------------------
  |  Branch (1146:19): [True: 8.90k, False: 3.74k]
  |  Branch (1146:28): [True: 6.95k, False: 1.95k]
  |  Branch (1146:79): [True: 4.38k, False: 2.57k]
  ------------------
 1147|  4.38k|            pack_imp_int64(int64_t(d));
 1148|  4.38k|            return *this;
 1149|  4.38k|        }
 1150|   285k|    }
 1151|       |
 1152|  8.94k|    union { float f; uint32_t i; } mem;
 1153|  8.94k|    mem.f = d;
 1154|  8.94k|    char buf[5];
 1155|  8.94k|    buf[0] = static_cast<char>(0xcau); _msgpack_store32(&buf[1], mem.i);
  ------------------
  |  |  188|  8.94k|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|  8.94k|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1156|  8.94k|    append_buffer(buf, 5);
 1157|  8.94k|    return *this;
 1158|   286k|}
_ZN7msgpack2v16packerINS0_7sbufferEE11pack_doubleEd:
 1162|  12.2k|{
 1163|  12.2k|    if(d == d) { // check for nan
  ------------------
  |  Branch (1163:8): [True: 11.7k, False: 501]
  ------------------
 1164|       |        // compare d to limits to avoid undefined behaviour
 1165|  11.7k|        if(d >= 0 && d <= double(std::numeric_limits<uint64_t>::max()) && d == double(uint64_t(d))) {
  ------------------
  |  Branch (1165:12): [True: 2.64k, False: 9.10k]
  |  Branch (1165:22): [True: 2.10k, False: 537]
  |  Branch (1165:75): [True: 212, False: 1.89k]
  ------------------
 1166|    212|            pack_imp_uint64(uint64_t(d));
 1167|    212|            return *this;
 1168|  11.5k|        } else if(d < 0 && d >= double(std::numeric_limits<int64_t>::min()) && d == double(int64_t(d))) {
  ------------------
  |  Branch (1168:19): [True: 9.10k, False: 2.43k]
  |  Branch (1168:28): [True: 1.35k, False: 7.74k]
  |  Branch (1168:80): [True: 689, False: 669]
  ------------------
 1169|    689|            pack_imp_int64(int64_t(d));
 1170|    689|            return *this;
 1171|    689|        }
 1172|  11.7k|    }
 1173|       |
 1174|  11.3k|    union { double f; uint64_t i; } mem;
 1175|  11.3k|    mem.f = d;
 1176|  11.3k|    char buf[9];
 1177|  11.3k|    buf[0] = static_cast<char>(0xcbu);
 1178|       |
 1179|       |#if defined(TARGET_OS_IPHONE)
 1180|       |    // ok
 1181|       |#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
 1182|       |    // https://github.com/msgpack/msgpack-perl/pull/1
 1183|       |    mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
 1184|       |#endif
 1185|  11.3k|    _msgpack_store64(&buf[1], mem.i);
  ------------------
  |  |  190|  11.3k|    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
  |  |  ------------------
  |  |  |  |  146|  11.3k|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  |  Branch (190:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1186|  11.3k|    append_buffer(buf, 9);
 1187|  11.3k|    return *this;
 1188|  12.2k|}
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_strEj:
 1255|  26.6k|{
 1256|  26.6k|    if(l < 32) {
  ------------------
  |  Branch (1256:8): [True: 23.1k, False: 3.46k]
  ------------------
 1257|  23.1k|        unsigned char d = static_cast<uint8_t>(0xa0u | l);
 1258|  23.1k|        char buf = take8_8(d);
 1259|  23.1k|        append_buffer(&buf, 1);
 1260|  23.1k|    } else if(l < 256) {
  ------------------
  |  Branch (1260:15): [True: 1.51k, False: 1.95k]
  ------------------
 1261|  1.51k|        char buf[2];
 1262|  1.51k|        buf[0] = static_cast<char>(0xd9u); buf[1] = static_cast<char>(l);
 1263|  1.51k|        append_buffer(buf, 2);
 1264|  1.95k|    } else if(l < 65536) {
  ------------------
  |  Branch (1264:15): [True: 1.95k, False: 0]
  ------------------
 1265|  1.95k|        char buf[3];
 1266|  1.95k|        buf[0] = static_cast<char>(0xdau); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
  ------------------
  |  |  186|  1.95k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  1.95k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1267|  1.95k|        append_buffer(buf, 3);
 1268|  1.95k|    } else {
 1269|      0|        char buf[5];
 1270|      0|        buf[0] = static_cast<char>(0xdbu); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
  ------------------
  |  |  188|      0|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|      0|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1271|      0|        append_buffer(buf, 5);
 1272|      0|    }
 1273|  26.6k|    return *this;
 1274|  26.6k|}
_ZN7msgpack2v17take8_8IhEEcT_:
  681|   130k|inline char take8_8(T d) {
  682|   130k|    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
  683|   130k|}
_ZN7msgpack2v16packerINS0_7sbufferEE13pack_str_bodyEPKcj:
 1278|  26.6k|{
 1279|  26.6k|    append_buffer(b, l);
 1280|  26.6k|    return *this;
 1281|  26.6k|}
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_binEj:
 1313|  5.04k|{
 1314|  5.04k|    if(l < 256) {
  ------------------
  |  Branch (1314:8): [True: 3.66k, False: 1.37k]
  ------------------
 1315|  3.66k|        char buf[2];
 1316|  3.66k|        buf[0] = static_cast<char>(0xc4u); buf[1] = static_cast<char>(l);
 1317|  3.66k|        append_buffer(buf, 2);
 1318|  3.66k|    } else if(l < 65536) {
  ------------------
  |  Branch (1318:15): [True: 1.37k, False: 0]
  ------------------
 1319|  1.37k|        char buf[3];
 1320|  1.37k|        buf[0] = static_cast<char>(0xc5u); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
  ------------------
  |  |  186|  1.37k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  1.37k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1321|  1.37k|        append_buffer(buf, 3);
 1322|  1.37k|    } else {
 1323|      0|        char buf[5];
 1324|      0|        buf[0] = static_cast<char>(0xc6u); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
  ------------------
  |  |  188|      0|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|      0|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1325|      0|        append_buffer(buf, 5);
 1326|      0|    }
 1327|  5.04k|    return *this;
 1328|  5.04k|}
_ZN7msgpack2v16packerINS0_7sbufferEE13pack_bin_bodyEPKcj:
 1332|  5.04k|{
 1333|  5.04k|    append_buffer(b, l);
 1334|  5.04k|    return *this;
 1335|  5.04k|}
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_extEma:
 1339|  18.9k|{
 1340|  18.9k|    switch(l) {
 1341|    462|    case 1: {
  ------------------
  |  Branch (1341:5): [True: 462, False: 18.5k]
  ------------------
 1342|    462|        char buf[2];
 1343|    462|        buf[0] = static_cast<char>(0xd4u);
 1344|    462|        buf[1] = static_cast<char>(type);
 1345|    462|        append_buffer(buf, 2);
 1346|    462|    } break;
 1347|  1.72k|    case 2: {
  ------------------
  |  Branch (1347:5): [True: 1.72k, False: 17.2k]
  ------------------
 1348|  1.72k|        char buf[2];
 1349|  1.72k|        buf[0] = static_cast<char>(0xd5u);
 1350|  1.72k|        buf[1] = static_cast<char>(type);
 1351|  1.72k|        append_buffer(buf, 2);
 1352|  1.72k|    } break;
 1353|  3.99k|    case 4: {
  ------------------
  |  Branch (1353:5): [True: 3.99k, False: 14.9k]
  ------------------
 1354|  3.99k|        char buf[2];
 1355|  3.99k|        buf[0] = static_cast<char>(0xd6u);
 1356|  3.99k|        buf[1] = static_cast<char>(type);
 1357|  3.99k|        append_buffer(buf, 2);
 1358|  3.99k|    } break;
 1359|  10.0k|    case 8: {
  ------------------
  |  Branch (1359:5): [True: 10.0k, False: 8.94k]
  ------------------
 1360|  10.0k|        char buf[2];
 1361|  10.0k|        buf[0] = static_cast<char>(0xd7u);
 1362|  10.0k|        buf[1] = static_cast<char>(type);
 1363|  10.0k|        append_buffer(buf, 2);
 1364|  10.0k|    } break;
 1365|    690|    case 16: {
  ------------------
  |  Branch (1365:5): [True: 690, False: 18.2k]
  ------------------
 1366|    690|        char buf[2];
 1367|    690|        buf[0] = static_cast<char>(0xd8u);
 1368|    690|        buf[1] = static_cast<char>(type);
 1369|    690|        append_buffer(buf, 2);
 1370|    690|    } break;
 1371|  2.06k|    default:
  ------------------
  |  Branch (1371:5): [True: 2.06k, False: 16.9k]
  ------------------
 1372|  2.06k|        if(l < 256) {
  ------------------
  |  Branch (1372:12): [True: 1.16k, False: 909]
  ------------------
 1373|  1.16k|            char buf[3];
 1374|  1.16k|            buf[0] = static_cast<char>(0xc7u);
 1375|  1.16k|            buf[1] = static_cast<char>(l);
 1376|  1.16k|            buf[2] = static_cast<char>(type);
 1377|  1.16k|            append_buffer(buf, 3);
 1378|  1.16k|        } else if(l < 65536) {
  ------------------
  |  Branch (1378:19): [True: 909, False: 0]
  ------------------
 1379|    909|            char buf[4];
 1380|    909|            buf[0] = static_cast<char>(0xc8u);
 1381|    909|            _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
  ------------------
  |  |  186|    909|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|    909|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1382|    909|            buf[3] = static_cast<char>(type);
 1383|    909|            append_buffer(buf, 4);
 1384|    909|        } else {
 1385|      0|            char buf[6];
 1386|      0|            buf[0] = static_cast<char>(0xc9u);
 1387|      0|            _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
  ------------------
  |  |  188|      0|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|      0|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1388|      0|            buf[5] = static_cast<char>(type);
 1389|      0|            append_buffer(buf, 6);
 1390|      0|        }
 1391|  2.06k|        break;
 1392|  18.9k|    }
 1393|  18.9k|    return *this;
 1394|  18.9k|}
_ZN7msgpack2v16packerINS0_7sbufferEE13pack_ext_bodyEPKcj:
 1398|  18.9k|{
 1399|  18.9k|    append_buffer(b, l);
 1400|  18.9k|    return *this;
 1401|  18.9k|}
_ZN7msgpack2v16packerINS0_7sbufferEE10pack_arrayEj:
 1218|  88.4k|{
 1219|  88.4k|    if(n < 16) {
  ------------------
  |  Branch (1219:8): [True: 87.2k, False: 1.19k]
  ------------------
 1220|  87.2k|        char d = static_cast<char>(0x90u | n);
 1221|  87.2k|        append_buffer(&d, 1);
 1222|  87.2k|    } else if(n < 65536) {
  ------------------
  |  Branch (1222:15): [True: 1.19k, False: 0]
  ------------------
 1223|  1.19k|        char buf[3];
 1224|  1.19k|        buf[0] = static_cast<char>(0xdcu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
  ------------------
  |  |  186|  1.19k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  1.19k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1225|  1.19k|        append_buffer(buf, 3);
 1226|  1.19k|    } else {
 1227|      0|        char buf[5];
 1228|      0|        buf[0] = static_cast<char>(0xddu); _msgpack_store32(&buf[1], static_cast<uint32_t>(n));
  ------------------
  |  |  188|      0|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|      0|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1229|      0|        append_buffer(buf, 5);
 1230|      0|    }
 1231|  88.4k|    return *this;
 1232|  88.4k|}
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_mapEj:
 1236|   108k|{
 1237|   108k|    if(n < 16) {
  ------------------
  |  Branch (1237:8): [True: 107k, False: 451]
  ------------------
 1238|   107k|        unsigned char d = static_cast<unsigned char>(0x80u | n);
 1239|   107k|        char buf = take8_8(d);
 1240|   107k|        append_buffer(&buf, 1);
 1241|   107k|    } else if(n < 65536) {
  ------------------
  |  Branch (1241:15): [True: 451, False: 0]
  ------------------
 1242|    451|        char buf[3];
 1243|    451|        buf[0] = static_cast<char>(0xdeu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
  ------------------
  |  |  186|    451|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|    451|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1244|    451|        append_buffer(buf, 3);
 1245|    451|    } else {
 1246|      0|        char buf[5];
 1247|      0|        buf[0] = static_cast<char>(0xdfu); _msgpack_store32(&buf[1], static_cast<uint32_t>(n));
  ------------------
  |  |  188|      0|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|      0|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1248|      0|        append_buffer(buf, 5);
 1249|      0|    }
 1250|   108k|    return *this;
 1251|   108k|}

_ZN7msgpack2v17sbufferC2Em:
   29|  1.18k|    {
   30|  1.18k|        if(initsz == 0) {
  ------------------
  |  Branch (30:12): [True: 0, False: 1.18k]
  ------------------
   31|      0|            m_data = MSGPACK_NULLPTR;
  ------------------
  |  |   85|      0|#  define MSGPACK_NULLPTR nullptr
  ------------------
   32|  1.18k|        } else {
   33|  1.18k|            m_data = (char*)::malloc(initsz);
   34|  1.18k|            if(!m_data) {
  ------------------
  |  Branch (34:16): [True: 0, False: 1.18k]
  ------------------
   35|      0|                throw std::bad_alloc();
   36|      0|            }
   37|  1.18k|        }
   38|  1.18k|    }
_ZN7msgpack2v17sbufferD2Ev:
   41|  1.18k|    {
   42|  1.18k|        ::free(m_data);
   43|  1.18k|    }
_ZN7msgpack2v17sbuffer5writeEPKcm:
   72|  1.40M|    {
   73|  1.40M|        MSGPACK_ASSERT(buf || len == 0);
  ------------------
  |  |   22|  1.40M|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
   74|       |
   75|  1.40M|        if (!buf) return;
  ------------------
  |  Branch (75:13): [True: 288, False: 1.40M]
  ------------------
   76|       |
   77|  1.40M|        if(m_alloc - m_size < len) {
  ------------------
  |  Branch (77:12): [True: 117, False: 1.40M]
  ------------------
   78|    117|            expand_buffer(len);
   79|    117|        }
   80|  1.40M|        std::memcpy(m_data + m_size, buf, len);
   81|  1.40M|        m_size += len;
   82|  1.40M|    }
_ZN7msgpack2v17sbuffer13expand_bufferEm:
  115|    117|    {
  116|    117|        size_t nsize = (m_alloc > 0) ?
  ------------------
  |  Branch (116:24): [True: 117, False: 0]
  ------------------
  117|    117|                m_alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
  ------------------
  |  |   16|      0|#define MSGPACK_SBUFFER_INIT_SIZE 8192
  ------------------
  118|       |
  119|    117|        while(nsize < m_size + len) {
  ------------------
  |  Branch (119:15): [True: 0, False: 117]
  ------------------
  120|      0|            size_t tmp_nsize = nsize * 2;
  121|      0|            if (tmp_nsize <= nsize) {
  ------------------
  |  Branch (121:17): [True: 0, False: 0]
  ------------------
  122|      0|                nsize = m_size + len;
  123|      0|                break;
  124|      0|            }
  125|      0|            nsize = tmp_nsize;
  126|      0|        }
  127|       |
  128|    117|        void* tmp = ::realloc(m_data, nsize);
  129|    117|        if(!tmp) {
  ------------------
  |  Branch (129:12): [True: 0, False: 117]
  ------------------
  130|      0|            throw std::bad_alloc();
  131|      0|        }
  132|       |
  133|    117|        m_data = static_cast<char*>(tmp);
  134|    117|        m_alloc = nsize;
  135|    117|    }

_ZN7msgpack2v16detail4loadINS1_7fix_tagEEENSt3__19enable_ifIXeqstT_Lm65EEvE4typeERjPKc:
  293|   273k|inline typename msgpack::enable_if<sizeof(T) == sizeof(fix_tag)>::type load(uint32_t& dst, const char* n) {
  294|   273k|    dst = static_cast<uint32_t>(*reinterpret_cast<const uint8_t*>(n)) & 0x0f;
  295|   273k|}
_ZN7msgpack2v16detail4loadIjEENSt3__19enable_ifIXeqstT_Li4EEvE4typeERS5_PKc:
  308|   316k|inline typename msgpack::enable_if<sizeof(T) == 4>::type load(T& dst, const char* n) {
  309|   316k|    _msgpack_load32(T, n, &dst);
  ------------------
  |  |  176|   316k|#define _msgpack_load32(cast, from, to) do {       \
  |  |  177|   316k|        memcpy((cast*)(to), (from), sizeof(cast)); \
  |  |  178|   316k|        *(to) = (cast)_msgpack_be32(*(to));        \
  |  |  ------------------
  |  |  |  |  128|   316k|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  179|   316k|    } while (0);
  |  |  ------------------
  |  |  |  Branch (179:14): [Folded - Ignored]
  |  |  ------------------
  ------------------
  310|   316k|}
_ZN7msgpack2v16detail4loadImEENSt3__19enable_ifIXeqstT_Li8EEvE4typeERS5_PKc:
  313|  20.2k|inline typename msgpack::enable_if<sizeof(T) == 8>::type load(T& dst, const char* n) {
  314|  20.2k|    _msgpack_load64(T, n, &dst);
  ------------------
  |  |  180|  20.2k|#define _msgpack_load64(cast, from, to) do {       \
  |  |  181|  20.2k|        memcpy((cast*)(to), (from), sizeof(cast)); \
  |  |  182|  20.2k|        *(to) = (cast)_msgpack_be64(*(to));        \
  |  |  ------------------
  |  |  |  |  146|  20.2k|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  183|  20.2k|    } while (0);
  |  |  ------------------
  |  |  |  Branch (183:14): [Folded - Ignored]
  |  |  ------------------
  ------------------
  315|  20.2k|}
_ZN7msgpack2v16detail4loadIhEENSt3__19enable_ifIXeqstT_Li1EEvE4typeERS5_PKc:
  298|  98.5k|inline typename msgpack::enable_if<sizeof(T) == 1>::type load(T& dst, const char* n) {
  299|  98.5k|    dst = static_cast<T>(*reinterpret_cast<const uint8_t*>(n));
  300|  98.5k|}
_ZN7msgpack2v16detail4loadItEENSt3__19enable_ifIXeqstT_Li2EEvE4typeERS5_PKc:
  303|  22.1k|inline typename msgpack::enable_if<sizeof(T) == 2>::type load(T& dst, const char* n) {
  304|  22.1k|    _msgpack_load16(T, n, &dst);
  ------------------
  |  |  171|  22.1k|#define _msgpack_load16(cast, from, to) do {       \
  |  |  172|  22.1k|        memcpy((cast*)(to), (from), sizeof(cast)); \
  |  |  173|  22.1k|        *(to) = (cast)_msgpack_be16(*(to));      \
  |  |  ------------------
  |  |  |  |  114|  22.1k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  174|  22.1k|    } while (0);
  |  |  ------------------
  |  |  |  Branch (174:14): [Folded - Ignored]
  |  |  ------------------
  ------------------
  305|  22.1k|}
_ZN7msgpack2v16detail4loadIaEENSt3__19enable_ifIXeqstT_Li1EEvE4typeERS5_PKc:
  298|  4.18k|inline typename msgpack::enable_if<sizeof(T) == 1>::type load(T& dst, const char* n) {
  299|  4.18k|    dst = static_cast<T>(*reinterpret_cast<const uint8_t*>(n));
  300|  4.18k|}
_ZN7msgpack2v16detail4loadIsEENSt3__19enable_ifIXeqstT_Li2EEvE4typeERS5_PKc:
  303|  11.4k|inline typename msgpack::enable_if<sizeof(T) == 2>::type load(T& dst, const char* n) {
  304|  11.4k|    _msgpack_load16(T, n, &dst);
  ------------------
  |  |  171|  11.4k|#define _msgpack_load16(cast, from, to) do {       \
  |  |  172|  11.4k|        memcpy((cast*)(to), (from), sizeof(cast)); \
  |  |  173|  11.4k|        *(to) = (cast)_msgpack_be16(*(to));      \
  |  |  ------------------
  |  |  |  |  114|  11.4k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  174|  11.4k|    } while (0);
  |  |  ------------------
  |  |  |  Branch (174:14): [Folded - Ignored]
  |  |  ------------------
  ------------------
  305|  11.4k|}
_ZN7msgpack2v16detail4loadIiEENSt3__19enable_ifIXeqstT_Li4EEvE4typeERS5_PKc:
  308|  2.34k|inline typename msgpack::enable_if<sizeof(T) == 4>::type load(T& dst, const char* n) {
  309|  2.34k|    _msgpack_load32(T, n, &dst);
  ------------------
  |  |  176|  2.34k|#define _msgpack_load32(cast, from, to) do {       \
  |  |  177|  2.34k|        memcpy((cast*)(to), (from), sizeof(cast)); \
  |  |  178|  2.34k|        *(to) = (cast)_msgpack_be32(*(to));        \
  |  |  ------------------
  |  |  |  |  128|  2.34k|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  179|  2.34k|    } while (0);
  |  |  ------------------
  |  |  |  Branch (179:14): [Folded - Ignored]
  |  |  ------------------
  ------------------
  310|  2.34k|}
_ZN7msgpack2v16detail4loadIlEENSt3__19enable_ifIXeqstT_Li8EEvE4typeERS5_PKc:
  313|  7.33k|inline typename msgpack::enable_if<sizeof(T) == 8>::type load(T& dst, const char* n) {
  314|  7.33k|    _msgpack_load64(T, n, &dst);
  ------------------
  |  |  180|  7.33k|#define _msgpack_load64(cast, from, to) do {       \
  |  |  181|  7.33k|        memcpy((cast*)(to), (from), sizeof(cast)); \
  |  |  182|  7.33k|        *(to) = (cast)_msgpack_be64(*(to));        \
  |  |  ------------------
  |  |  |  |  146|  7.33k|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  183|  7.33k|    } while (0);
  |  |  ------------------
  |  |  |  Branch (183:14): [Folded - Ignored]
  |  |  ------------------
  ------------------
  315|  7.33k|}

_ZNK7msgpack2v112unpack_limit3strEv:
  104|  36.9k|    std::size_t str() const { return str_; }
_ZNK7msgpack2v112unpack_limit5arrayEv:
  102|   132k|    std::size_t array() const { return array_; }
_ZNK7msgpack2v112unpack_limit5depthEv:
  107|   292k|    std::size_t depth() const { return depth_; }
_ZNK7msgpack2v112unpack_limit3mapEv:
  103|   159k|    std::size_t map() const { return map_; }
_ZNK7msgpack2v112unpack_limit3extEv:
  106|  30.2k|    std::size_t ext() const { return ext_; }
_ZNK7msgpack2v112unpack_limit3binEv:
  105|  9.19k|    std::size_t bin() const { return bin_; }
_ZN7msgpack2v112unpack_limitC2Emmmmmm:
  101|  2.23k|         depth_(depth) {}

_ZN7msgpack2v118insufficient_bytesC2EPKc:
   48|    947|        :unpack_error(msg) {}
_ZN7msgpack2v112unpack_errorC2EPKc:
   30|  1.05k|        std::runtime_error(msg) {}
_ZN7msgpack2v117str_size_overflowC2EPKc:
   84|      8|        :size_overflow(msg) {}
_ZN7msgpack2v113size_overflowC2EPKc:
   57|    106|        :unpack_error(msg) {}
_ZN7msgpack2v119array_size_overflowC2EPKc:
   66|     45|        :size_overflow(msg) {}
_ZN7msgpack2v119depth_size_overflowC2EPKc:
  111|      2|        :size_overflow(msg) {}
_ZN7msgpack2v117map_size_overflowC2EPKc:
   75|     42|        :size_overflow(msg) {}
_ZN7msgpack2v111parse_errorC2EPKc:
   39|      2|        :unpack_error(msg) {}
_ZN7msgpack2v117ext_size_overflowC2EPKc:
  102|      1|        :size_overflow(msg) {}
_ZN7msgpack2v117bin_size_overflowC2EPKc:
   93|      8|        :size_overflow(msg) {}

_ZN7msgpack2v26detail21create_object_visitorC2EPFbNS_2v14type11object_typeEmPvES6_RKNS3_12unpack_limitE:
   30|  2.23k|        :m_func(f), m_user_data(user_data), m_limit(limit) {
   31|  2.23k|        m_stack.reserve(MSGPACK_EMBED_STACK_SIZE);
  ------------------
  |  |   16|  2.23k|#define MSGPACK_EMBED_STACK_SIZE 32
  ------------------
   32|  2.23k|        m_stack.push_back(&m_obj);
   33|  2.23k|    }
_ZN7msgpack2v26detail21create_object_visitor8set_zoneERNS_2v14zoneE:
   64|  2.23k|    void set_zone(msgpack::zone& zone) { m_zone = &zone; }
_ZN7msgpack2v26detail21create_object_visitor14set_referencedEb:
   66|  2.23k|    void set_referenced(bool referenced) { m_referenced = referenced; }
_ZN7msgpack2v26detail21create_object_visitor18insufficient_bytesEmm:
  258|    947|    void insufficient_bytes(size_t /*parsed_offset*/, size_t /*error_offset*/) {
  259|    947|        throw msgpack::insufficient_bytes("insufficient bytes");
  260|    947|    }
_ZN7msgpack2v26detail21create_object_visitor22visit_positive_integerEm:
   79|   853k|    bool visit_positive_integer(uint64_t v) {
   80|   853k|        msgpack::object* obj = m_stack.back();
   81|   853k|        obj->type = msgpack::type::POSITIVE_INTEGER;
   82|   853k|        obj->via.u64 = v;
   83|   853k|        return true;
   84|   853k|    }
_ZN7msgpack2v26detail21create_object_visitor14end_array_itemEv:
  207|   826k|    bool end_array_item() {
  208|   826k|        ++m_stack.back();
  209|   826k|        return true;
  210|   826k|    }
_ZN7msgpack2v26detail21create_object_visitor9end_arrayEv:
  211|   122k|    bool end_array() {
  212|   122k|        m_stack.pop_back();
  213|   122k|        return true;
  214|   122k|    }
_ZN7msgpack2v26detail21create_object_visitor16start_array_itemEv:
  204|   836k|    bool start_array_item() {
  205|   836k|        return true;
  206|   836k|    }
_ZN7msgpack2v26detail21create_object_visitor11end_map_keyEv:
  240|   491k|    bool end_map_key() {
  241|   491k|        ++m_stack.back();
  242|   491k|        return true;
  243|   491k|    }
_ZN7msgpack2v26detail21create_object_visitor15start_map_valueEv:
  244|   491k|    bool start_map_value() {
  245|   491k|        return true;
  246|   491k|    }
_ZN7msgpack2v26detail21create_object_visitor13end_map_valueEv:
  247|   490k|    bool end_map_value() {
  248|   490k|        ++m_stack.back();
  249|   490k|        return true;
  250|   490k|    }
_ZN7msgpack2v26detail21create_object_visitor7end_mapEv:
  251|   154k|    bool end_map() {
  252|   154k|        m_stack.pop_back();
  253|   154k|        return true;
  254|   154k|    }
_ZN7msgpack2v26detail21create_object_visitor13start_map_keyEv:
  237|   496k|    bool start_map_key() {
  238|   496k|        return true;
  239|   496k|    }
_ZN7msgpack2v26detail21create_object_visitor22visit_negative_integerEl:
   85|   268k|    bool visit_negative_integer(int64_t v) {
   86|   268k|        msgpack::object* obj = m_stack.back();
   87|   268k|        if(v >= 0) {
  ------------------
  |  Branch (87:12): [True: 5.17k, False: 263k]
  ------------------
   88|  5.17k|            obj->type = msgpack::type::POSITIVE_INTEGER;
   89|  5.17k|            obj->via.u64 = static_cast<uint64_t>(v);
   90|  5.17k|        }
   91|   263k|        else {
   92|   263k|            obj->type = msgpack::type::NEGATIVE_INTEGER;
   93|   263k|            obj->via.i64 = v;
   94|   263k|        }
   95|   268k|        return true;
   96|   268k|    }
_ZN7msgpack2v26detail21create_object_visitor9visit_strEPKcj:
  109|  36.9k|    bool visit_str(const char* v, uint32_t size) {
  110|  36.9k|        MSGPACK_ASSERT(v || size == 0);
  ------------------
  |  |   22|  36.9k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  111|  36.9k|        if (size > m_limit.str()) throw msgpack::str_size_overflow("str size overflow");
  ------------------
  |  Branch (111:13): [True: 8, False: 36.9k]
  ------------------
  112|  36.9k|        msgpack::object* obj = m_stack.back();
  113|  36.9k|        obj->type = msgpack::type::STR;
  114|  36.9k|        if (m_func && m_func(obj->type, size, m_user_data)) {
  ------------------
  |  Branch (114:13): [True: 0, False: 36.9k]
  |  Branch (114:23): [True: 0, False: 0]
  ------------------
  115|      0|            obj->via.str.ptr = v;
  116|      0|            obj->via.str.size = size;
  117|      0|            set_referenced(true);
  118|      0|        }
  119|  36.9k|        else {
  120|  36.9k|            if (v) {
  ------------------
  |  Branch (120:17): [True: 36.5k, False: 355]
  ------------------
  121|  36.5k|                char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
  ------------------
  |  |   32|  36.5k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  122|  36.5k|                std::memcpy(tmp, v, size);
  123|  36.5k|                obj->via.str.ptr = tmp;
  124|  36.5k|                obj->via.str.size = size;
  125|  36.5k|            }
  126|    355|            else {
  127|    355|                obj->via.str.ptr = MSGPACK_NULLPTR;
  ------------------
  |  |   85|    355|#  define MSGPACK_NULLPTR nullptr
  ------------------
  128|    355|                obj->via.str.size = 0;
  129|    355|            }
  130|  36.9k|        }
  131|  36.9k|        return true;
  132|  36.9k|    }
_ZN7msgpack2v26detail21create_object_visitor4zoneEv:
   63|  76.0k|    msgpack::zone& zone() { return *m_zone; }
_ZN7msgpack2v26detail21create_object_visitor11start_arrayEj:
  181|   132k|    bool start_array(uint32_t num_elements) {
  182|   132k|        if (num_elements > m_limit.array()) throw msgpack::array_size_overflow("array size overflow");
  ------------------
  |  Branch (182:13): [True: 45, False: 132k]
  ------------------
  183|   132k|        if (m_stack.size() > m_limit.depth()) throw msgpack::depth_size_overflow("depth size overflow");
  ------------------
  |  Branch (183:13): [True: 1, False: 132k]
  ------------------
  184|   132k|        msgpack::object* obj = m_stack.back();
  185|   132k|        obj->type = msgpack::type::ARRAY;
  186|   132k|        obj->via.array.size = num_elements;
  187|   132k|        if (num_elements == 0) {
  ------------------
  |  Branch (187:13): [True: 21.8k, False: 110k]
  ------------------
  188|  21.8k|            obj->via.array.ptr = MSGPACK_NULLPTR;
  ------------------
  |  |   85|  21.8k|#  define MSGPACK_NULLPTR nullptr
  ------------------
  189|  21.8k|        }
  190|   110k|        else {
  191|       |
  192|       |#if SIZE_MAX == UINT_MAX
  193|       |            if (num_elements > SIZE_MAX/sizeof(msgpack::object))
  194|       |                throw msgpack::array_size_overflow("array size overflow");
  195|       |#endif // SIZE_MAX == UINT_MAX
  196|       |
  197|   110k|            size_t size = num_elements*sizeof(msgpack::object);
  198|   110k|            obj->via.array.ptr =
  199|   110k|                static_cast<msgpack::object*>(m_zone->allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
  ------------------
  |  |   32|   110k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  200|   110k|        }
  201|   132k|        m_stack.push_back(obj->via.array.ptr);
  202|   132k|        return true;
  203|   132k|    }
_ZN7msgpack2v26detail21create_object_visitor9start_mapEj:
  215|   159k|    bool start_map(uint32_t num_kv_pairs) {
  216|   159k|        if (num_kv_pairs > m_limit.map()) throw msgpack::map_size_overflow("map size overflow");
  ------------------
  |  Branch (216:13): [True: 42, False: 159k]
  ------------------
  217|   159k|        if (m_stack.size() > m_limit.depth()) throw msgpack::depth_size_overflow("depth size overflow");
  ------------------
  |  Branch (217:13): [True: 1, False: 159k]
  ------------------
  218|   159k|        msgpack::object* obj = m_stack.back();
  219|   159k|        obj->type = msgpack::type::MAP;
  220|   159k|        obj->via.map.size = num_kv_pairs;
  221|   159k|        if (num_kv_pairs == 0) {
  ------------------
  |  Branch (221:13): [True: 29.7k, False: 129k]
  ------------------
  222|  29.7k|            obj->via.map.ptr = MSGPACK_NULLPTR;
  ------------------
  |  |   85|  29.7k|#  define MSGPACK_NULLPTR nullptr
  ------------------
  223|  29.7k|        }
  224|   129k|        else {
  225|       |
  226|       |#if SIZE_MAX == UINT_MAX
  227|       |            if (num_kv_pairs > SIZE_MAX/sizeof(msgpack::object_kv))
  228|       |                throw msgpack::map_size_overflow("map size overflow");
  229|       |#endif // SIZE_MAX == UINT_MAX
  230|   129k|            size_t size = num_kv_pairs*sizeof(msgpack::object_kv);
  231|   129k|            obj->via.map.ptr =
  232|   129k|                static_cast<msgpack::object_kv*>(m_zone->allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
  ------------------
  |  |   32|   129k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  233|   129k|        }
  234|   159k|        m_stack.push_back(reinterpret_cast<msgpack::object*>(obj->via.map.ptr));
  235|   159k|        return true;
  236|   159k|    }
_ZN7msgpack2v26detail21create_object_visitor13visit_booleanEb:
   73|  14.3k|    bool visit_boolean(bool v) {
   74|  14.3k|        msgpack::object* obj = m_stack.back();
   75|  14.3k|        obj->type = msgpack::type::BOOLEAN;
   76|  14.3k|        obj->via.boolean = v;
   77|  14.3k|        return true;
   78|  14.3k|    }
_ZN7msgpack2v26detail21create_object_visitor9visit_nilEv:
   68|  4.07k|    bool visit_nil() {
   69|  4.07k|        msgpack::object* obj = m_stack.back();
   70|  4.07k|        obj->type = msgpack::type::NIL;
   71|  4.07k|        return true;
   72|  4.07k|    }
_ZN7msgpack2v26detail21create_object_visitor11parse_errorEmm:
  255|      2|    void parse_error(size_t /*parsed_offset*/, size_t /*error_offset*/) {
  256|      2|        throw msgpack::parse_error("parse error");
  257|      2|    }
_ZN7msgpack2v26detail21create_object_visitor13visit_float32Ef:
   97|   298k|    bool visit_float32(float v) {
   98|   298k|        msgpack::object* obj = m_stack.back();
   99|   298k|        obj->type = msgpack::type::FLOAT32;
  100|   298k|        obj->via.f64 = v;
  101|   298k|        return true;
  102|   298k|    }
_ZN7msgpack2v26detail21create_object_visitor13visit_float64Ed:
  103|  17.1k|    bool visit_float64(double v) {
  104|  17.1k|        msgpack::object* obj = m_stack.back();
  105|  17.1k|        obj->type = msgpack::type::FLOAT64;
  106|  17.1k|        obj->via.f64 = v;
  107|  17.1k|        return true;
  108|  17.1k|    }
_ZN7msgpack2v26detail21create_object_visitor9visit_extEPKcj:
  157|  30.2k|    bool visit_ext(const char* v, uint32_t size) {
  158|  30.2k|        MSGPACK_ASSERT(v || size == 0);
  ------------------
  |  |   22|  30.2k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  159|  30.2k|        if (size > m_limit.ext()) throw msgpack::ext_size_overflow("ext size overflow");
  ------------------
  |  Branch (159:13): [True: 1, False: 30.2k]
  ------------------
  160|  30.2k|        msgpack::object* obj = m_stack.back();
  161|  30.2k|        obj->type = msgpack::type::EXT;
  162|  30.2k|        if (m_func && m_func(obj->type, size, m_user_data)) {
  ------------------
  |  Branch (162:13): [True: 0, False: 30.2k]
  |  Branch (162:23): [True: 0, False: 0]
  ------------------
  163|      0|            obj->via.ext.ptr = v;
  164|      0|            obj->via.ext.size = static_cast<uint32_t>(size - 1);
  165|      0|            set_referenced(true);
  166|      0|        }
  167|  30.2k|        else {
  168|  30.2k|            if (v) {
  ------------------
  |  Branch (168:17): [True: 30.2k, False: 0]
  ------------------
  169|  30.2k|                char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
  ------------------
  |  |   32|  30.2k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  170|  30.2k|                std::memcpy(tmp, v, size);
  171|  30.2k|                obj->via.ext.ptr = tmp;
  172|  30.2k|                obj->via.ext.size = static_cast<uint32_t>(size - 1);
  173|  30.2k|            }
  174|      0|            else {
  175|      0|                obj->via.ext.ptr = MSGPACK_NULLPTR;
  ------------------
  |  |   85|      0|#  define MSGPACK_NULLPTR nullptr
  ------------------
  176|      0|                obj->via.ext.size = 0;
  177|      0|            }
  178|  30.2k|        }
  179|  30.2k|        return true;
  180|  30.2k|    }
_ZN7msgpack2v26detail21create_object_visitor9visit_binEPKcj:
  133|  9.19k|    bool visit_bin(const char* v, uint32_t size) {
  134|  9.19k|        MSGPACK_ASSERT(v || size == 0);
  ------------------
  |  |   22|  9.19k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  135|  9.19k|        if (size > m_limit.bin()) throw msgpack::bin_size_overflow("bin size overflow");
  ------------------
  |  Branch (135:13): [True: 8, False: 9.19k]
  ------------------
  136|  9.19k|        msgpack::object* obj = m_stack.back();
  137|  9.19k|        obj->type = msgpack::type::BIN;
  138|  9.19k|        if (m_func && m_func(obj->type, size, m_user_data)) {
  ------------------
  |  Branch (138:13): [True: 0, False: 9.19k]
  |  Branch (138:23): [True: 0, False: 0]
  ------------------
  139|      0|            obj->via.bin.ptr = v;
  140|      0|            obj->via.bin.size = size;
  141|      0|            set_referenced(true);
  142|      0|        }
  143|  9.19k|        else {
  144|  9.19k|            if (v) {
  ------------------
  |  Branch (144:17): [True: 9.19k, False: 0]
  ------------------
  145|  9.19k|                char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
  ------------------
  |  |   32|  9.19k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  146|  9.19k|                std::memcpy(tmp, v, size);
  147|  9.19k|                obj->via.bin.ptr = tmp;
  148|  9.19k|                obj->via.bin.size = size;
  149|  9.19k|            }
  150|      0|            else {
  151|      0|                obj->via.bin.ptr = MSGPACK_NULLPTR;
  ------------------
  |  |   85|      0|#  define MSGPACK_NULLPTR nullptr
  ------------------
  152|      0|                obj->via.bin.size = 0;
  153|      0|            }
  154|  9.19k|        }
  155|  9.19k|        return true;
  156|  9.19k|    }
_ZNK7msgpack2v26detail21create_object_visitor10referencedEv:
   65|  1.18k|    bool referenced() const { return m_referenced; }
_ZNK7msgpack2v26detail21create_object_visitor4dataEv:
   59|  1.18k|    {
   60|  1.18k|        return m_obj;
   61|  1.18k|    }

_ZN7msgpack2v26objectC2Ev:
   24|  4.47k|    object() {}

_ZN7msgpack2v26detail9parse_impINS1_21create_object_visitorEEENS0_12parse_returnEPKcmRmRT_:
 1034|  2.23k|parse_imp(const char* data, size_t len, size_t& off, Visitor& v) {
 1035|  2.23k|    std::size_t noff = off;
 1036|       |
 1037|  2.23k|    if(len <= noff) {
  ------------------
  |  Branch (1037:8): [True: 0, False: 2.23k]
  ------------------
 1038|       |        // FIXME
 1039|      0|        v.insufficient_bytes(noff, noff);
 1040|      0|        return PARSE_CONTINUE;
 1041|      0|    }
 1042|  2.23k|    detail::parse_helper<Visitor> h(v);
 1043|  2.23k|    parse_return ret = h.execute(data, len, noff);
 1044|  2.23k|    switch (ret) {
 1045|    947|    case PARSE_CONTINUE:
  ------------------
  |  Branch (1045:5): [True: 947, False: 1.28k]
  ------------------
 1046|    947|        off = noff;
 1047|    947|        v.insufficient_bytes(noff - 1, noff);
 1048|    947|        return ret;
 1049|  1.18k|    case PARSE_SUCCESS:
  ------------------
  |  Branch (1049:5): [True: 1.18k, False: 1.05k]
  ------------------
 1050|  1.18k|        off = noff;
 1051|  1.18k|        if(noff < len) {
  ------------------
  |  Branch (1051:12): [True: 54, False: 1.12k]
  ------------------
 1052|     54|            return PARSE_EXTRA_BYTES;
 1053|     54|        }
 1054|  1.12k|        return ret;
 1055|      0|    default:
  ------------------
  |  Branch (1055:5): [True: 0, False: 2.23k]
  ------------------
 1056|      0|        return ret;
 1057|  2.23k|    }
 1058|  2.23k|}
_ZN7msgpack2v26detail12parse_helperINS1_21create_object_visitorEEC2ERS3_:
 1024|  2.23k|    parse_helper(Visitor& v):m_visitor(v) {}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEEC2Ev:
   40|  2.23k|    {
   41|  2.23k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE12unpack_stackC2Ev:
  158|  2.23k|        unpack_stack() {
  159|  2.23k|            m_stack.reserve(MSGPACK_EMBED_STACK_SIZE);
  ------------------
  |  |   16|  2.23k|#define MSGPACK_EMBED_STACK_SIZE 32
  ------------------
  160|  2.23k|        }
_ZN7msgpack2v26detail12parse_helperINS1_21create_object_visitorEE7executeEPKcmRm:
 1025|  2.23k|    parse_return execute(const char* data, std::size_t len, std::size_t& off) {
 1026|  2.23k|        return detail::context<parse_helper<Visitor> >::execute(data, len, off);
 1027|  2.23k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE7executeEPKcmRm:
  237|  2.23k|{
  238|  2.23k|    MSGPACK_ASSERT(len >= off);
  ------------------
  |  |   22|  2.23k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  239|       |
  240|      0|    m_start = data;
  241|  2.23k|    m_current = data + off;
  242|  2.23k|    const char* const pe = data + len;
  243|  2.23k|    const char* n = MSGPACK_NULLPTR;
  ------------------
  |  |   85|  2.23k|#  define MSGPACK_NULLPTR nullptr
  ------------------
  244|       |
  245|  2.23k|    if(m_current == pe) {
  ------------------
  |  Branch (245:8): [True: 0, False: 2.23k]
  ------------------
  246|      0|        off = static_cast<std::size_t>(m_current - m_start);
  247|      0|        return PARSE_CONTINUE;
  248|      0|    }
  249|  2.23k|    bool fixed_trail_again = false;
  250|  1.84M|    do {
  251|  1.84M|        if (m_cs == MSGPACK_CS_HEADER) {
  ------------------
  |  Branch (251:13): [True: 1.82M, False: 14.6k]
  ------------------
  252|  1.82M|            fixed_trail_again = false;
  253|  1.82M|            int selector = *reinterpret_cast<const unsigned char*>(m_current);
  254|  1.82M|            if (0x00 <= selector && selector <= 0x7f) { // Positive Fixnum
  ------------------
  |  Branch (254:17): [True: 1.82M, False: 0]
  |  Branch (254:37): [True: 763k, False: 1.06M]
  ------------------
  255|   763k|                uint8_t tmp = *reinterpret_cast<const uint8_t*>(m_current);
  256|   763k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  257|   763k|                parse_return upr = after_visit_proc(visret, off);
  258|   763k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (258:21): [True: 132, False: 763k]
  ------------------
  259|  1.06M|            } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum
  ------------------
  |  Branch (259:23): [True: 243k, False: 818k]
  |  Branch (259:43): [True: 243k, False: 0]
  ------------------
  260|   243k|                int8_t tmp = *reinterpret_cast<const int8_t*>(m_current);
  261|   243k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  262|   243k|                parse_return upr = after_visit_proc(visret, off);
  263|   243k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (263:21): [True: 51, False: 243k]
  ------------------
  264|   818k|            } else if (0xc4 <= selector && selector <= 0xdf) {
  ------------------
  |  Branch (264:24): [True: 508k, False: 309k]
  |  Branch (264:44): [True: 508k, False: 0]
  ------------------
  265|   508k|                const uint32_t trail[] = {
  266|   508k|                    1, // bin     8  0xc4
  267|   508k|                    2, // bin    16  0xc5
  268|   508k|                    4, // bin    32  0xc6
  269|   508k|                    1, // ext     8  0xc7
  270|   508k|                    2, // ext    16  0xc8
  271|   508k|                    4, // ext    32  0xc9
  272|   508k|                    4, // float  32  0xca
  273|   508k|                    8, // float  64  0xcb
  274|   508k|                    1, // uint    8  0xcc
  275|   508k|                    2, // uint   16  0xcd
  276|   508k|                    4, // uint   32  0xce
  277|   508k|                    8, // uint   64  0xcf
  278|   508k|                    1, // int     8  0xd0
  279|   508k|                    2, // int    16  0xd1
  280|   508k|                    4, // int    32  0xd2
  281|   508k|                    8, // int    64  0xd3
  282|   508k|                    2, // fixext  1  0xd4
  283|   508k|                    3, // fixext  2  0xd5
  284|   508k|                    5, // fixext  4  0xd6
  285|   508k|                    9, // fixext  8  0xd7
  286|   508k|                    17,// fixext 16  0xd8
  287|   508k|                    1, // str     8  0xd9
  288|   508k|                    2, // str    16  0xda
  289|   508k|                    4, // str    32  0xdb
  290|   508k|                    2, // array  16  0xdc
  291|   508k|                    4, // array  32  0xdd
  292|   508k|                    2, // map    16  0xde
  293|   508k|                    4, // map    32  0xdf
  294|   508k|                };
  295|   508k|                m_trail = trail[selector - 0xc4];
  296|   508k|                m_cs = next_cs(m_current);
  297|   508k|                fixed_trail_again = true;
  298|   508k|            } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr
  ------------------
  |  Branch (298:23): [True: 36.0k, False: 273k]
  |  Branch (298:43): [True: 17.6k, False: 18.4k]
  ------------------
  299|  17.6k|                m_trail = static_cast<uint32_t>(*m_current) & 0x1f;
  300|  17.6k|                if(m_trail == 0) {
  ------------------
  |  Branch (300:20): [True: 8.55k, False: 9.06k]
  ------------------
  301|  8.55k|                    bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  302|  8.55k|                    parse_return upr = after_visit_proc(visret, off);
  303|  8.55k|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (303:25): [True: 18, False: 8.53k]
  ------------------
  304|  8.55k|                }
  305|  9.06k|                else {
  306|  9.06k|                    m_cs = MSGPACK_ACS_STR_VALUE;
  307|  9.06k|                    fixed_trail_again = true;
  308|  9.06k|                }
  309|   292k|            } else if(0x90 <= selector && selector <= 0x9f) { // FixArray
  ------------------
  |  Branch (309:23): [True: 139k, False: 152k]
  |  Branch (309:43): [True: 120k, False: 18.4k]
  ------------------
  310|   120k|                parse_return ret = start_aggregate<fix_tag>(array_sv(holder()), array_ev(holder()), m_current, off);
  311|   120k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (311:21): [True: 34, False: 120k]
  ------------------
  312|   171k|            } else if(0x80 <= selector && selector <= 0x8f) { // FixMap
  ------------------
  |  Branch (312:23): [True: 171k, False: 0]
  |  Branch (312:43): [True: 152k, False: 18.4k]
  ------------------
  313|   152k|                parse_return ret = start_aggregate<fix_tag>(map_sv(holder()), map_ev(holder()), m_current, off);
  314|   152k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (314:21): [True: 28, False: 152k]
  ------------------
  315|   152k|            } else if(selector == 0xc2) { // false
  ------------------
  |  Branch (315:23): [True: 861, False: 17.5k]
  ------------------
  316|    861|                bool visret = holder().visitor().visit_boolean(false);
  317|    861|                parse_return upr = after_visit_proc(visret, off);
  318|    861|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (318:21): [True: 12, False: 849]
  ------------------
  319|  17.5k|            } else if(selector == 0xc3) { // true
  ------------------
  |  Branch (319:23): [True: 13.5k, False: 4.07k]
  ------------------
  320|  13.5k|                bool visret = holder().visitor().visit_boolean(true);
  321|  13.5k|                parse_return upr = after_visit_proc(visret, off);
  322|  13.5k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (322:21): [True: 12, False: 13.5k]
  ------------------
  323|  13.5k|            } else if(selector == 0xc0) { // nil
  ------------------
  |  Branch (323:23): [True: 4.07k, False: 2]
  ------------------
  324|  4.07k|                bool visret = holder().visitor().visit_nil();
  325|  4.07k|                parse_return upr = after_visit_proc(visret, off);
  326|  4.07k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (326:21): [True: 11, False: 4.06k]
  ------------------
  327|  4.07k|            } else {
  328|      2|                off = static_cast<std::size_t>(m_current - m_start);
  329|      2|                holder().visitor().parse_error(off - 1, off);
  330|      2|                return PARSE_PARSE_ERROR;
  331|      2|            }
  332|       |            // end MSGPACK_CS_HEADER
  333|  1.82M|        }
  334|  1.83M|        if (m_cs != MSGPACK_CS_HEADER || fixed_trail_again) {
  ------------------
  |  Branch (334:13): [True: 532k, False: 1.30M]
  |  Branch (334:42): [True: 0, False: 1.30M]
  ------------------
  335|   532k|            if (fixed_trail_again) {
  ------------------
  |  Branch (335:17): [True: 532k, False: 0]
  ------------------
  336|   532k|                ++m_current;
  337|   532k|                fixed_trail_again = false;
  338|   532k|            }
  339|   532k|            if(static_cast<std::size_t>(pe - m_current) < m_trail) {
  ------------------
  |  Branch (339:16): [True: 248, False: 532k]
  ------------------
  340|    248|                off = static_cast<std::size_t>(m_current - m_start);
  341|    248|                return PARSE_CONTINUE;
  342|    248|            }
  343|   532k|            n = m_current;
  344|   532k|            m_current += m_trail - 1;
  345|   532k|            switch(m_cs) {
  346|       |                //case MSGPACK_CS_
  347|       |                //case MSGPACK_CS_
  348|   298k|            case MSGPACK_CS_FLOAT: {
  ------------------
  |  Branch (348:13): [True: 298k, False: 233k]
  ------------------
  349|   298k|                union { uint32_t i; float f; } mem;
  350|   298k|                load<uint32_t>(mem.i, n);
  351|   298k|                bool visret = holder().visitor().visit_float32(mem.f);
  352|   298k|                parse_return upr = after_visit_proc(visret, off);
  353|   298k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (353:21): [True: 174, False: 298k]
  ------------------
  354|   298k|            } break;
  355|   298k|            case MSGPACK_CS_DOUBLE: {
  ------------------
  |  Branch (355:13): [True: 17.1k, False: 515k]
  ------------------
  356|  17.1k|                union { uint64_t i; double f; } mem;
  357|  17.1k|                load<uint64_t>(mem.i, n);
  358|       |#if defined(TARGET_OS_IPHONE)
  359|       |                // ok
  360|       |#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
  361|       |                // https://github.com/msgpack/msgpack-perl/pull/1
  362|       |                mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
  363|       |#endif
  364|  17.1k|                bool visret = holder().visitor().visit_float64(mem.f);
  365|  17.1k|                parse_return upr = after_visit_proc(visret, off);
  366|  17.1k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (366:21): [True: 51, False: 17.0k]
  ------------------
  367|  17.1k|            } break;
  368|  83.3k|            case MSGPACK_CS_UINT_8: {
  ------------------
  |  Branch (368:13): [True: 83.3k, False: 449k]
  ------------------
  369|  83.3k|                uint8_t tmp;
  370|  83.3k|                load<uint8_t>(tmp, n);
  371|  83.3k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  372|  83.3k|                parse_return upr = after_visit_proc(visret, off);
  373|  83.3k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (373:21): [True: 17, False: 83.3k]
  ------------------
  374|  83.3k|            } break;
  375|  83.3k|            case MSGPACK_CS_UINT_16: {
  ------------------
  |  Branch (375:13): [True: 2.60k, False: 529k]
  ------------------
  376|  2.60k|                uint16_t tmp;
  377|  2.60k|                load<uint16_t>(tmp, n);
  378|  2.60k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  379|  2.60k|                parse_return upr = after_visit_proc(visret, off);
  380|  2.60k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (380:21): [True: 26, False: 2.57k]
  ------------------
  381|  2.60k|            } break;
  382|  2.57k|            case MSGPACK_CS_UINT_32: {
  ------------------
  |  Branch (382:13): [True: 1.52k, False: 530k]
  ------------------
  383|  1.52k|                uint32_t tmp;
  384|  1.52k|                load<uint32_t>(tmp, n);
  385|  1.52k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  386|  1.52k|                parse_return upr = after_visit_proc(visret, off);
  387|  1.52k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (387:21): [True: 45, False: 1.48k]
  ------------------
  388|  1.52k|            } break;
  389|  3.11k|            case MSGPACK_CS_UINT_64: {
  ------------------
  |  Branch (389:13): [True: 3.11k, False: 529k]
  ------------------
  390|  3.11k|                uint64_t tmp;
  391|  3.11k|                load<uint64_t>(tmp, n);
  392|  3.11k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  393|  3.11k|                parse_return upr = after_visit_proc(visret, off);
  394|  3.11k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (394:21): [True: 58, False: 3.06k]
  ------------------
  395|  3.11k|            } break;
  396|  4.18k|            case MSGPACK_CS_INT_8: {
  ------------------
  |  Branch (396:13): [True: 4.18k, False: 528k]
  ------------------
  397|  4.18k|                int8_t tmp;
  398|  4.18k|                load<int8_t>(tmp, n);
  399|  4.18k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  400|  4.18k|                parse_return upr = after_visit_proc(visret, off);
  401|  4.18k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (401:21): [True: 31, False: 4.15k]
  ------------------
  402|  4.18k|            } break;
  403|  11.4k|            case MSGPACK_CS_INT_16: {
  ------------------
  |  Branch (403:13): [True: 11.4k, False: 520k]
  ------------------
  404|  11.4k|                int16_t tmp;
  405|  11.4k|                load<int16_t>(tmp, n);
  406|  11.4k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  407|  11.4k|                parse_return upr = after_visit_proc(visret, off);
  408|  11.4k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (408:21): [True: 55, False: 11.3k]
  ------------------
  409|  11.4k|            } break;
  410|  11.3k|            case MSGPACK_CS_INT_32: {
  ------------------
  |  Branch (410:13): [True: 2.34k, False: 530k]
  ------------------
  411|  2.34k|                int32_t tmp;
  412|  2.34k|                load<int32_t>(tmp, n);
  413|  2.34k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  414|  2.34k|                parse_return upr = after_visit_proc(visret, off);
  415|  2.34k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (415:21): [True: 87, False: 2.26k]
  ------------------
  416|  2.34k|            } break;
  417|  7.33k|            case MSGPACK_CS_INT_64: {
  ------------------
  |  Branch (417:13): [True: 7.33k, False: 525k]
  ------------------
  418|  7.33k|                int64_t tmp;
  419|  7.33k|                load<int64_t>(tmp, n);
  420|  7.33k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  421|  7.33k|                parse_return upr = after_visit_proc(visret, off);
  422|  7.33k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (422:21): [True: 142, False: 7.19k]
  ------------------
  423|  7.33k|            } break;
  424|  7.19k|            case MSGPACK_CS_FIXEXT_1: {
  ------------------
  |  Branch (424:13): [True: 1.04k, False: 531k]
  ------------------
  425|  1.04k|                bool visret = holder().visitor().visit_ext(n, 1+1);
  426|  1.04k|                parse_return upr = after_visit_proc(visret, off);
  427|  1.04k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (427:21): [True: 9, False: 1.03k]
  ------------------
  428|  1.04k|            } break;
  429|  3.53k|            case MSGPACK_CS_FIXEXT_2: {
  ------------------
  |  Branch (429:13): [True: 3.53k, False: 528k]
  ------------------
  430|  3.53k|                bool visret = holder().visitor().visit_ext(n, 2+1);
  431|  3.53k|                parse_return upr = after_visit_proc(visret, off);
  432|  3.53k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (432:21): [True: 8, False: 3.53k]
  ------------------
  433|  3.53k|            } break;
  434|  5.36k|            case MSGPACK_CS_FIXEXT_4: {
  ------------------
  |  Branch (434:13): [True: 5.36k, False: 527k]
  ------------------
  435|  5.36k|                bool visret = holder().visitor().visit_ext(n, 4+1);
  436|  5.36k|                parse_return upr = after_visit_proc(visret, off);
  437|  5.36k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (437:21): [True: 9, False: 5.35k]
  ------------------
  438|  5.36k|            } break;
  439|  15.5k|            case MSGPACK_CS_FIXEXT_8: {
  ------------------
  |  Branch (439:13): [True: 15.5k, False: 516k]
  ------------------
  440|  15.5k|                bool visret = holder().visitor().visit_ext(n, 8+1);
  441|  15.5k|                parse_return upr = after_visit_proc(visret, off);
  442|  15.5k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (442:21): [True: 8, False: 15.5k]
  ------------------
  443|  15.5k|            } break;
  444|  15.5k|            case MSGPACK_CS_FIXEXT_16: {
  ------------------
  |  Branch (444:13): [True: 1.08k, False: 531k]
  ------------------
  445|  1.08k|                bool visret = holder().visitor().visit_ext(n, 16+1);
  446|  1.08k|                parse_return upr = after_visit_proc(visret, off);
  447|  1.08k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (447:21): [True: 7, False: 1.07k]
  ------------------
  448|  1.08k|            } break;
  449|  10.6k|            case MSGPACK_CS_STR_8: {
  ------------------
  |  Branch (449:13): [True: 10.6k, False: 521k]
  ------------------
  450|  10.6k|                uint8_t tmp;
  451|  10.6k|                load<uint8_t>(tmp, n);
  452|  10.6k|                m_trail = tmp;
  453|  10.6k|                if(m_trail == 0) {
  ------------------
  |  Branch (453:20): [True: 9.97k, False: 667]
  ------------------
  454|  9.97k|                    bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  455|  9.97k|                    parse_return upr = after_visit_proc(visret, off);
  456|  9.97k|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (456:25): [True: 1, False: 9.97k]
  ------------------
  457|  9.97k|                }
  458|    667|                else {
  459|    667|                    m_cs = MSGPACK_ACS_STR_VALUE;
  460|    667|                    fixed_trail_again = true;
  461|    667|                }
  462|  10.6k|            } break;
  463|  10.6k|            case MSGPACK_CS_BIN_8: {
  ------------------
  |  Branch (463:13): [True: 2.77k, False: 529k]
  ------------------
  464|  2.77k|                uint8_t tmp;
  465|  2.77k|                load<uint8_t>(tmp, n);
  466|  2.77k|                m_trail = tmp;
  467|  2.77k|                if(m_trail == 0) {
  ------------------
  |  Branch (467:20): [True: 831, False: 1.94k]
  ------------------
  468|    831|                    bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
  469|    831|                    parse_return upr = after_visit_proc(visret, off);
  470|    831|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (470:25): [True: 8, False: 823]
  ------------------
  471|    831|                }
  472|  1.94k|                else {
  473|  1.94k|                    m_cs = MSGPACK_ACS_BIN_VALUE;
  474|  1.94k|                    fixed_trail_again = true;
  475|  1.94k|                }
  476|  2.77k|            } break;
  477|  2.76k|            case MSGPACK_CS_EXT_8: {
  ------------------
  |  Branch (477:13): [True: 1.73k, False: 530k]
  ------------------
  478|  1.73k|                uint8_t tmp;
  479|  1.73k|                load<uint8_t>(tmp, n);
  480|  1.73k|                m_trail = tmp + 1;
  481|  1.73k|                if(m_trail == 0) {
  ------------------
  |  Branch (481:20): [True: 0, False: 1.73k]
  ------------------
  482|      0|                    bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
  483|      0|                    parse_return upr = after_visit_proc(visret, off);
  484|      0|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (484:25): [True: 0, False: 0]
  ------------------
  485|      0|                }
  486|  1.73k|                else {
  487|  1.73k|                    m_cs = MSGPACK_ACS_EXT_VALUE;
  488|  1.73k|                    fixed_trail_again = true;
  489|  1.73k|                }
  490|  1.73k|            } break;
  491|  4.72k|            case MSGPACK_CS_STR_16: {
  ------------------
  |  Branch (491:13): [True: 4.72k, False: 527k]
  ------------------
  492|  4.72k|                uint16_t tmp;
  493|  4.72k|                load<uint16_t>(tmp, n);
  494|  4.72k|                m_trail = tmp;
  495|  4.72k|                if(m_trail == 0) {
  ------------------
  |  Branch (495:20): [True: 1.89k, False: 2.83k]
  ------------------
  496|  1.89k|                    bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  497|  1.89k|                    parse_return upr = after_visit_proc(visret, off);
  498|  1.89k|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (498:25): [True: 1, False: 1.88k]
  ------------------
  499|  1.89k|                }
  500|  2.83k|                else {
  501|  2.83k|                    m_cs = MSGPACK_ACS_STR_VALUE;
  502|  2.83k|                    fixed_trail_again = true;
  503|  2.83k|                }
  504|  4.72k|            } break;
  505|  4.71k|            case MSGPACK_CS_BIN_16: {
  ------------------
  |  Branch (505:13): [True: 3.52k, False: 528k]
  ------------------
  506|  3.52k|                uint16_t tmp;
  507|  3.52k|                load<uint16_t>(tmp, n);
  508|  3.52k|                m_trail = tmp;
  509|  3.52k|                if(m_trail == 0) {
  ------------------
  |  Branch (509:20): [True: 333, False: 3.19k]
  ------------------
  510|    333|                    bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
  511|    333|                    parse_return upr = after_visit_proc(visret, off);
  512|    333|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (512:25): [True: 1, False: 332]
  ------------------
  513|    333|                }
  514|  3.19k|                else {
  515|  3.19k|                    m_cs = MSGPACK_ACS_BIN_VALUE;
  516|  3.19k|                    fixed_trail_again = true;
  517|  3.19k|                }
  518|  3.52k|            } break;
  519|  3.52k|            case MSGPACK_CS_EXT_16: {
  ------------------
  |  Branch (519:13): [True: 1.71k, False: 530k]
  ------------------
  520|  1.71k|                uint16_t tmp;
  521|  1.71k|                load<uint16_t>(tmp, n);
  522|  1.71k|                m_trail = tmp + 1;
  523|  1.71k|                if(m_trail == 0) {
  ------------------
  |  Branch (523:20): [True: 0, False: 1.71k]
  ------------------
  524|      0|                    bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
  525|      0|                    parse_return upr = after_visit_proc(visret, off);
  526|      0|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (526:25): [True: 0, False: 0]
  ------------------
  527|      0|                }
  528|  1.71k|                else {
  529|  1.71k|                    m_cs = MSGPACK_ACS_EXT_VALUE;
  530|  1.71k|                    fixed_trail_again = true;
  531|  1.71k|                }
  532|  1.71k|            } break;
  533|  4.07k|            case MSGPACK_CS_STR_32: {
  ------------------
  |  Branch (533:13): [True: 4.07k, False: 528k]
  ------------------
  534|  4.07k|                uint32_t tmp;
  535|  4.07k|                load<uint32_t>(tmp, n);
  536|  4.07k|                m_trail = tmp;
  537|  4.07k|                if(m_trail == 0) {
  ------------------
  |  Branch (537:20): [True: 1.99k, False: 2.07k]
  ------------------
  538|  1.99k|                    bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  539|  1.99k|                    parse_return upr = after_visit_proc(visret, off);
  540|  1.99k|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (540:25): [True: 1, False: 1.99k]
  ------------------
  541|  1.99k|                }
  542|  2.07k|                else {
  543|  2.07k|                    m_cs = MSGPACK_ACS_STR_VALUE;
  544|  2.07k|                    fixed_trail_again = true;
  545|  2.07k|                }
  546|  4.07k|            } break;
  547|  4.07k|            case MSGPACK_CS_BIN_32: {
  ------------------
  |  Branch (547:13): [True: 2.99k, False: 529k]
  ------------------
  548|  2.99k|                uint32_t tmp;
  549|  2.99k|                load<uint32_t>(tmp, n);
  550|  2.99k|                m_trail = tmp;
  551|  2.99k|                if(m_trail == 0) {
  ------------------
  |  Branch (551:20): [True: 2.73k, False: 262]
  ------------------
  552|  2.73k|                    bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
  553|  2.73k|                    parse_return upr = after_visit_proc(visret, off);
  554|  2.73k|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (554:25): [True: 1, False: 2.72k]
  ------------------
  555|  2.73k|                }
  556|    262|                else {
  557|    262|                    m_cs = MSGPACK_ACS_BIN_VALUE;
  558|    262|                    fixed_trail_again = true;
  559|    262|                }
  560|  2.99k|            } break;
  561|  2.99k|            case MSGPACK_CS_EXT_32: {
  ------------------
  |  Branch (561:13): [True: 275, False: 532k]
  ------------------
  562|    275|                uint32_t tmp;
  563|    275|                load<uint32_t>(tmp, n);
  564|    275|                check_ext_size<sizeof(std::size_t)>(tmp);
  565|    275|                m_trail = tmp;
  566|    275|                ++m_trail;
  567|    275|                if(m_trail == 0) {
  ------------------
  |  Branch (567:20): [True: 0, False: 275]
  ------------------
  568|      0|                    bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
  569|      0|                    parse_return upr = after_visit_proc(visret, off);
  570|      0|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (570:25): [True: 0, False: 0]
  ------------------
  571|      0|                }
  572|    275|                else {
  573|    275|                    m_cs = MSGPACK_ACS_EXT_VALUE;
  574|    275|                    fixed_trail_again = true;
  575|    275|                }
  576|    275|            } break;
  577|  14.5k|            case MSGPACK_ACS_STR_VALUE: {
  ------------------
  |  Branch (577:13): [True: 14.5k, False: 517k]
  ------------------
  578|  14.5k|                bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  579|  14.5k|                parse_return upr = after_visit_proc(visret, off);
  580|  14.5k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (580:21): [True: 57, False: 14.4k]
  ------------------
  581|  14.5k|            } break;
  582|  14.4k|            case MSGPACK_ACS_BIN_VALUE: {
  ------------------
  |  Branch (582:13): [True: 5.30k, False: 527k]
  ------------------
  583|  5.30k|                bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
  584|  5.30k|                parse_return upr = after_visit_proc(visret, off);
  585|  5.30k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (585:21): [True: 37, False: 5.26k]
  ------------------
  586|  5.30k|            } break;
  587|  5.26k|            case MSGPACK_ACS_EXT_VALUE: {
  ------------------
  |  Branch (587:13): [True: 3.69k, False: 528k]
  ------------------
  588|  3.69k|                bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
  589|  3.69k|                parse_return upr = after_visit_proc(visret, off);
  590|  3.69k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (590:21): [True: 44, False: 3.65k]
  ------------------
  591|  3.69k|            } break;
  592|  6.77k|            case MSGPACK_CS_ARRAY_16: {
  ------------------
  |  Branch (592:13): [True: 6.77k, False: 525k]
  ------------------
  593|  6.77k|                parse_return ret = start_aggregate<uint16_t>(array_sv(holder()), array_ev(holder()), n, off);
  594|  6.77k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (594:21): [True: 1, False: 6.77k]
  ------------------
  595|       |
  596|  6.77k|            } break;
  597|  6.77k|            case MSGPACK_CS_ARRAY_32: {
  ------------------
  |  Branch (597:13): [True: 4.96k, False: 527k]
  ------------------
  598|  4.96k|                parse_return ret = start_aggregate<uint32_t>(array_sv(holder()), array_ev(holder()), n, off);
  599|  4.96k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (599:21): [True: 1, False: 4.96k]
  ------------------
  600|  4.96k|            } break;
  601|  4.96k|            case MSGPACK_CS_MAP_16: {
  ------------------
  |  Branch (601:13): [True: 2.83k, False: 529k]
  ------------------
  602|  2.83k|                parse_return ret = start_aggregate<uint16_t>(map_sv(holder()), map_ev(holder()), n, off);
  603|  2.83k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (603:21): [True: 1, False: 2.83k]
  ------------------
  604|  2.83k|            } break;
  605|  3.86k|            case MSGPACK_CS_MAP_32: {
  ------------------
  |  Branch (605:13): [True: 3.86k, False: 528k]
  ------------------
  606|  3.86k|                parse_return ret = start_aggregate<uint32_t>(map_sv(holder()), map_ev(holder()), n, off);
  607|  3.86k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (607:21): [True: 1, False: 3.86k]
  ------------------
  608|  3.86k|            } break;
  609|  3.86k|            default:
  ------------------
  |  Branch (609:13): [True: 0, False: 532k]
  ------------------
  610|      0|                off = static_cast<std::size_t>(m_current - m_start);
  611|      0|                holder().visitor().parse_error(static_cast<std::size_t>(n - m_start - 1), static_cast<std::size_t>(n - m_start));
  612|      0|                return PARSE_PARSE_ERROR;
  613|   532k|            }
  614|   532k|        }
  615|  1.83M|    } while(m_current != pe);
  ------------------
  |  Branch (615:13): [True: 1.83M, False: 701]
  ------------------
  616|       |
  617|    701|    off = static_cast<std::size_t>(m_current - m_start);
  618|    701|    return PARSE_CONTINUE;
  619|  2.23k|}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6holderEv:
   60|  3.94M|    VisitorHolder& holder() {
   61|  3.94M|        return static_cast<VisitorHolder&>(*this);
   62|  3.94M|    }
_ZNK7msgpack2v26detail12parse_helperINS1_21create_object_visitorEE7visitorEv:
 1028|  5.73M|    Visitor& visitor() const { return m_visitor; }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE16after_visit_procEbRm:
  103|  1.53M|    parse_return after_visit_proc(bool visit_result, std::size_t& off) {
  104|  1.53M|        ++m_current;
  105|  1.53M|        if (!visit_result) {
  ------------------
  |  Branch (105:13): [True: 0, False: 1.53M]
  ------------------
  106|      0|            off = static_cast<std::size_t>(m_current - m_start);
  107|      0|            return PARSE_STOP_VISITOR;
  108|      0|        }
  109|  1.53M|        parse_return ret = m_stack.consume(holder());
  110|  1.53M|        if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (110:13): [True: 1.11k, False: 1.53M]
  ------------------
  111|  1.11k|            off = static_cast<std::size_t>(m_current - m_start);
  112|  1.11k|        }
  113|  1.53M|        m_cs = MSGPACK_CS_HEADER;
  114|  1.53M|        return ret;
  115|  1.53M|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE12unpack_stack7consumeERS5_:
  175|  1.58M|        parse_return consume(VisitorHolder& visitor_holder) {
  176|  1.80M|            while (!m_stack.empty()) {
  ------------------
  |  Branch (176:20): [True: 1.80M, False: 1.18k]
  ------------------
  177|  1.80M|                stack_elem& e = m_stack.back();
  178|  1.80M|                switch (e.m_type) {
  ------------------
  |  Branch (178:25): [True: 0, False: 1.80M]
  ------------------
  179|   826k|                case MSGPACK_CT_ARRAY_ITEM:
  ------------------
  |  Branch (179:17): [True: 826k, False: 981k]
  ------------------
  180|   826k|                    if (!visitor_holder.visitor().end_array_item()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (180:25): [True: 0, False: 826k]
  ------------------
  181|   826k|                    if (--e.m_rest == 0)  {
  ------------------
  |  Branch (181:25): [True: 100k, False: 725k]
  ------------------
  182|   100k|                        m_stack.pop_back();
  183|   100k|                        if (!visitor_holder.visitor().end_array()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (183:29): [True: 0, False: 100k]
  ------------------
  184|   100k|                    }
  185|   725k|                    else {
  186|   725k|                        if (!visitor_holder.visitor().start_array_item()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (186:29): [True: 0, False: 725k]
  ------------------
  187|   725k|                        return PARSE_CONTINUE;
  188|   725k|                    }
  189|   100k|                    break;
  190|   491k|                case MSGPACK_CT_MAP_KEY:
  ------------------
  |  Branch (190:17): [True: 491k, False: 1.31M]
  ------------------
  191|   491k|                    if (!visitor_holder.visitor().end_map_key()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (191:25): [True: 0, False: 491k]
  ------------------
  192|   491k|                    if (!visitor_holder.visitor().start_map_value()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (192:25): [True: 0, False: 491k]
  ------------------
  193|   491k|                    e.m_type = MSGPACK_CT_MAP_VALUE;
  194|   491k|                    return PARSE_CONTINUE;
  195|   490k|                case MSGPACK_CT_MAP_VALUE:
  ------------------
  |  Branch (195:17): [True: 490k, False: 1.31M]
  ------------------
  196|   490k|                    if (!visitor_holder.visitor().end_map_value()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (196:25): [True: 0, False: 490k]
  ------------------
  197|   490k|                    if (--e.m_rest == 0) {
  ------------------
  |  Branch (197:25): [True: 124k, False: 366k]
  ------------------
  198|   124k|                        m_stack.pop_back();
  199|   124k|                        if (!visitor_holder.visitor().end_map()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (199:29): [True: 0, False: 124k]
  ------------------
  200|   124k|                    }
  201|   366k|                    else {
  202|   366k|                        e.m_type = MSGPACK_CT_MAP_KEY;
  203|   366k|                        if (!visitor_holder.visitor().start_map_key()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (203:29): [True: 0, False: 366k]
  ------------------
  204|   366k|                        return PARSE_CONTINUE;
  205|   366k|                    }
  206|   124k|                    break;
  207|  1.80M|                }
  208|  1.80M|            }
  209|  1.18k|            return PARSE_SUCCESS;
  210|  1.58M|        }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE7next_csIPKcEEjT_:
   56|   508k|    {
   57|   508k|        return static_cast<uint32_t>(*p) & 0x1f;
   58|   508k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateINS_2v16detail7fix_tagENS6_8array_svENS6_8array_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|   120k|        std::size_t& off) {
   70|   120k|        typename value<T>::type size;
   71|   120k|        load<T>(size, load_pos);
   72|   120k|        ++m_current;
   73|   120k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 13.4k, False: 107k]
  ------------------
   74|  13.4k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 13.4k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  13.4k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 13.4k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  13.4k|            parse_return ret = m_stack.consume(holder());
   83|  13.4k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 34, False: 13.4k]
  ------------------
   84|     34|                off = static_cast<std::size_t>(m_current - m_start);
   85|     34|                return ret;
   86|     34|            }
   87|  13.4k|        }
   88|   107k|        else {
   89|   107k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 107k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|   107k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|   107k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 107k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|   107k|        }
   99|   120k|        m_cs = MSGPACK_CS_HEADER;
  100|   120k|        return PARSE_CONTINUE;
  101|   120k|    }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_svclEj:
  119|   132k|        bool operator()(uint32_t size) const {
  120|   132k|            return m_visitor_holder.visitor().start_array(size);
  121|   132k|        }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_evclEv:
  128|  21.8k|        bool operator()() const {
  129|  21.8k|            return m_visitor_holder.visitor().end_array();
  130|  21.8k|        }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE12unpack_stack4pushERS5_22msgpack_container_typej:
  161|   240k|        parse_return push(VisitorHolder& visitor_holder, msgpack_container_type type, uint32_t rest) {
  162|   240k|            m_stack.push_back(stack_elem(type, rest));
  163|   240k|            switch (type) {
  ------------------
  |  Branch (163:21): [True: 0, False: 240k]
  ------------------
  164|   110k|            case MSGPACK_CT_ARRAY_ITEM:
  ------------------
  |  Branch (164:13): [True: 110k, False: 129k]
  ------------------
  165|   110k|                return visitor_holder.visitor().start_array_item() ? PARSE_CONTINUE : PARSE_STOP_VISITOR;
  ------------------
  |  Branch (165:24): [True: 110k, False: 0]
  ------------------
  166|   129k|            case MSGPACK_CT_MAP_KEY:
  ------------------
  |  Branch (166:13): [True: 129k, False: 110k]
  ------------------
  167|   129k|                return visitor_holder.visitor().start_map_key() ? PARSE_CONTINUE : PARSE_STOP_VISITOR;
  ------------------
  |  Branch (167:24): [True: 129k, False: 0]
  ------------------
  168|      0|            case MSGPACK_CT_MAP_VALUE:
  ------------------
  |  Branch (168:13): [True: 0, False: 240k]
  ------------------
  169|      0|                MSGPACK_ASSERT(0);
  ------------------
  |  |   22|      0|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  170|      0|                return PARSE_STOP_VISITOR;
  171|   240k|            }
  172|      0|            MSGPACK_ASSERT(0);
  ------------------
  |  |   22|      0|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  173|      0|            return PARSE_STOP_VISITOR;
  174|   240k|        }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE12unpack_stack10stack_elemC2E22msgpack_container_typej:
  154|   240k|            stack_elem(msgpack_container_type type, uint32_t rest):m_type(type), m_rest(rest) {}
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_sv4typeEv:
  122|   110k|        msgpack_container_type type() const { return MSGPACK_CT_ARRAY_ITEM; }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_svC2ERS5_:
  118|   132k|        array_sv(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_evC2ERS5_:
  127|   132k|        array_ev(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateINS_2v16detail7fix_tagENS6_6map_svENS6_6map_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|   152k|        std::size_t& off) {
   70|   152k|        typename value<T>::type size;
   71|   152k|        load<T>(size, load_pos);
   72|   152k|        ++m_current;
   73|   152k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 24.9k, False: 127k]
  ------------------
   74|  24.9k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 24.9k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  24.9k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 24.9k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  24.9k|            parse_return ret = m_stack.consume(holder());
   83|  24.9k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 28, False: 24.9k]
  ------------------
   84|     28|                off = static_cast<std::size_t>(m_current - m_start);
   85|     28|                return ret;
   86|     28|            }
   87|  24.9k|        }
   88|   127k|        else {
   89|   127k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 127k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|   127k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|   127k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 127k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|   127k|        }
   99|   152k|        m_cs = MSGPACK_CS_HEADER;
  100|   152k|        return PARSE_CONTINUE;
  101|   152k|    }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_svclEj:
  136|   159k|        bool operator()(uint32_t size) const {
  137|   159k|            return m_visitor_holder.visitor().start_map(size);
  138|   159k|        }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_evclEv:
  145|  29.7k|        bool operator()() const {
  146|  29.7k|            return m_visitor_holder.visitor().end_map();
  147|  29.7k|        }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_sv4typeEv:
  139|   129k|        msgpack_container_type type() const { return MSGPACK_CT_MAP_KEY; }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_svC2ERS5_:
  135|   159k|        map_sv(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_evC2ERS5_:
  144|   159k|        map_ev(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
_ZN7msgpack2v26detail14check_ext_sizeILm8EEEvm:
  227|    275|inline void check_ext_size(std::size_t /*size*/) {
  228|    275|}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateItNS6_8array_svENS6_8array_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  6.77k|        std::size_t& off) {
   70|  6.77k|        typename value<T>::type size;
   71|  6.77k|        load<T>(size, load_pos);
   72|  6.77k|        ++m_current;
   73|  6.77k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 3.93k, False: 2.84k]
  ------------------
   74|  3.93k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 3.93k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  3.93k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 3.93k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  3.93k|            parse_return ret = m_stack.consume(holder());
   83|  3.93k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 1, False: 3.93k]
  ------------------
   84|      1|                off = static_cast<std::size_t>(m_current - m_start);
   85|      1|                return ret;
   86|      1|            }
   87|  3.93k|        }
   88|  2.84k|        else {
   89|  2.84k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 2.84k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|  2.84k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|  2.84k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 2.84k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|  2.84k|        }
   99|  6.77k|        m_cs = MSGPACK_CS_HEADER;
  100|  6.77k|        return PARSE_CONTINUE;
  101|  6.77k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateIjNS6_8array_svENS6_8array_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  4.96k|        std::size_t& off) {
   70|  4.96k|        typename value<T>::type size;
   71|  4.96k|        load<T>(size, load_pos);
   72|  4.96k|        ++m_current;
   73|  4.96k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 4.41k, False: 551]
  ------------------
   74|  4.41k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 4.41k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  4.41k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 4.41k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  4.41k|            parse_return ret = m_stack.consume(holder());
   83|  4.41k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 1, False: 4.41k]
  ------------------
   84|      1|                off = static_cast<std::size_t>(m_current - m_start);
   85|      1|                return ret;
   86|      1|            }
   87|  4.41k|        }
   88|    551|        else {
   89|    551|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 551]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|    551|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|    551|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 551]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|    551|        }
   99|  4.96k|        m_cs = MSGPACK_CS_HEADER;
  100|  4.96k|        return PARSE_CONTINUE;
  101|  4.96k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateItNS6_6map_svENS6_6map_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  2.83k|        std::size_t& off) {
   70|  2.83k|        typename value<T>::type size;
   71|  2.83k|        load<T>(size, load_pos);
   72|  2.83k|        ++m_current;
   73|  2.83k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 1.34k, False: 1.49k]
  ------------------
   74|  1.34k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 1.34k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  1.34k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 1.34k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  1.34k|            parse_return ret = m_stack.consume(holder());
   83|  1.34k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 1, False: 1.34k]
  ------------------
   84|      1|                off = static_cast<std::size_t>(m_current - m_start);
   85|      1|                return ret;
   86|      1|            }
   87|  1.34k|        }
   88|  1.49k|        else {
   89|  1.49k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 1.49k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|  1.49k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|  1.49k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 1.49k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|  1.49k|        }
   99|  2.83k|        m_cs = MSGPACK_CS_HEADER;
  100|  2.83k|        return PARSE_CONTINUE;
  101|  2.83k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateIjNS6_6map_svENS6_6map_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  3.86k|        std::size_t& off) {
   70|  3.86k|        typename value<T>::type size;
   71|  3.86k|        load<T>(size, load_pos);
   72|  3.86k|        ++m_current;
   73|  3.86k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 3.49k, False: 375]
  ------------------
   74|  3.49k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 3.49k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  3.49k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 3.49k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  3.49k|            parse_return ret = m_stack.consume(holder());
   83|  3.49k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 1, False: 3.49k]
  ------------------
   84|      1|                off = static_cast<std::size_t>(m_current - m_start);
   85|      1|                return ret;
   86|      1|            }
   87|  3.49k|        }
   88|    375|        else {
   89|    375|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 375]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|    375|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|    375|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 375]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|    375|        }
   99|  3.86k|        m_cs = MSGPACK_CS_HEADER;
  100|  3.86k|        return PARSE_CONTINUE;
  101|  3.86k|    }

_ZN7msgpack2v26detail10unpack_impEPKcmRmRNS_2v14zoneERNS0_6objectERbPFbNS5_4type11object_typeEmPvESD_RKNS5_12unpack_limitE:
  326|  2.23k|{
  327|  2.23k|    create_object_visitor v(f, user_data, limit);
  328|  2.23k|    v.set_zone(result_zone);
  329|  2.23k|    referenced = false;
  330|  2.23k|    v.set_referenced(referenced);
  331|  2.23k|    parse_return ret = parse_imp(data, len, off, v);
  332|  2.23k|    referenced = v.referenced();
  333|  2.23k|    result = v.data();
  334|  2.23k|    return ret;
  335|  2.23k|}

_ZN7msgpack2v36unpackEPKcmPFbNS_2v14type11object_typeEmPvES6_RKNS3_12unpack_limitE:
   68|  2.23k|{
   69|  2.23k|    bool referenced;
   70|  2.23k|    std::size_t off = 0;
   71|  2.23k|    return msgpack::v3::unpack(data, len, off, referenced, f, user_data, limit);
   72|  2.23k|}
_ZN7msgpack2v36unpackEPKcmRmRbPFbNS_2v14type11object_typeEmPvES8_RKNS5_12unpack_limitE:
   28|  2.23k|{
   29|  2.23k|    msgpack::object obj;
   30|  2.23k|    msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone);
   31|  2.23k|    referenced = false;
   32|  2.23k|    parse_return ret = detail::unpack_imp(
   33|  2.23k|        data, len, off, *z, obj, referenced, f, user_data, limit);
   34|       |
   35|  2.23k|    switch(ret) {
   36|  1.12k|    case PARSE_SUCCESS:
  ------------------
  |  Branch (36:5): [True: 1.12k, False: 1.10k]
  ------------------
   37|  1.12k|        return msgpack::object_handle(obj, msgpack::move(z));
   38|     54|    case PARSE_EXTRA_BYTES:
  ------------------
  |  Branch (38:5): [True: 54, False: 2.18k]
  ------------------
   39|     54|        return msgpack::object_handle(obj, msgpack::move(z));
   40|      0|    default:
  ------------------
  |  Branch (40:5): [True: 0, False: 2.23k]
  ------------------
   41|      0|        break;
   42|  2.23k|    }
   43|      0|    return msgpack::object_handle();
   44|  2.23k|}