LLVMFuzzerTestOneInput:
    7|  2.25k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
    8|  2.25k|  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.25k|    const int test_limit = 1000;
   12|  2.25k|    msgpack::object_handle unpacked = msgpack::unpack(reinterpret_cast<const char *>(data),
   13|  2.25k|                                                      size,
   14|  2.25k|                                                      MSGPACK_NULLPTR,
  ------------------
  |  |   85|  2.25k|#  define MSGPACK_NULLPTR nullptr
  ------------------
   15|  2.25k|                                                      MSGPACK_NULLPTR,
  ------------------
  |  |   85|  2.25k|#  define MSGPACK_NULLPTR nullptr
  ------------------
   16|  2.25k|                                                      msgpack::unpack_limit(test_limit,
   17|  2.25k|                                                                            test_limit,
   18|  2.25k|                                                                            test_limit,
   19|  2.25k|                                                                            test_limit,
   20|  2.25k|                                                                            test_limit,
   21|  2.25k|                                                                            test_limit));
   22|  2.25k|    msgpack::sbuffer sbuf;
   23|  2.25k|    msgpack::pack(sbuf, unpacked.get());
   24|  2.25k|  } catch (...) {
   25|  1.09k|  }
   26|  2.25k|  return 0;
   27|  2.25k|}

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

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

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

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

_ZN7msgpack2v14packINS0_7sbufferENS_2v26objectEEEvRT_RKT0_:
  674|  1.16k|{
  675|  1.16k|    packer<Stream>(s).pack(v);
  676|  1.16k|}
_ZN7msgpack2v16packerINS0_7sbufferEEC2ERS2_:
  724|  1.16k|inline packer<Stream>::packer(Stream& s) : m_stream(s) { }
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_nilEv:
 1171|  28.4k|{
 1172|  28.4k|    const char d = static_cast<char>(0xc0u);
 1173|  28.4k|    append_buffer(&d, 1);
 1174|  28.4k|    return *this;
 1175|  28.4k|}
_ZN7msgpack2v16packerINS0_7sbufferEE13append_bufferEPKcm:
  622|  2.26M|    {
  623|  2.26M|        append_buffer(&Stream::write, buf, len);
  624|  2.26M|    }
_ZN7msgpack2v16packerINS0_7sbufferEE13append_bufferIvS2_mEEvMT0_FT_PKcT1_ES8_m:
  628|  2.26M|    {
  629|  2.26M|        m_stream.write(buf, static_cast<SizeType>(len));
  630|  2.26M|    }
_ZN7msgpack2v16packerINS0_7sbufferEE9pack_trueEv:
 1179|  11.2k|{
 1180|  11.2k|    const char d = static_cast<char>(0xc3u);
 1181|  11.2k|    append_buffer(&d, 1);
 1182|  11.2k|    return *this;
 1183|  11.2k|}
_ZN7msgpack2v16packerINS0_7sbufferEE10pack_falseEv:
 1187|  24.7k|{
 1188|  24.7k|    const char d = static_cast<char>(0xc2u);
 1189|  24.7k|    append_buffer(&d, 1);
 1190|  24.7k|    return *this;
 1191|  24.7k|}
_ZN7msgpack2v16packerINS0_7sbufferEE11pack_uint64Em:
  741|   801k|{ pack_imp_uint64(d); return *this; }
_ZN7msgpack2v16packerINS0_7sbufferEE15pack_imp_uint64ImEEvT_:
 1448|   801k|{
 1449|   801k|    if(d < (1ULL<<8)) {
  ------------------
  |  Branch (1449:8): [True: 790k, False: 10.7k]
  ------------------
 1450|   790k|        if(d < (1ULL<<7)) {
  ------------------
  |  Branch (1450:12): [True: 782k, False: 8.77k]
  ------------------
 1451|       |            /* fixnum */
 1452|   782k|            char buf = take8_64(d);
 1453|   782k|            append_buffer(&buf, 1);
 1454|   782k|        } else {
 1455|       |            /* unsigned 8 */
 1456|  8.77k|            char buf[2] = {static_cast<char>(0xccu), take8_64(d)};
 1457|  8.77k|            append_buffer(buf, 2);
 1458|  8.77k|        }
 1459|   790k|    } else {
 1460|  10.7k|        if(d < (1ULL<<16)) {
  ------------------
  |  Branch (1460:12): [True: 4.25k, False: 6.45k]
  ------------------
 1461|       |            /* unsigned 16 */
 1462|  4.25k|            char buf[3];
 1463|  4.25k|            buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
  ------------------
  |  |  186|  4.25k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  4.25k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1464|  4.25k|            append_buffer(buf, 3);
 1465|  6.45k|        } else if(d < (1ULL<<32)) {
  ------------------
  |  Branch (1465:19): [True: 1.83k, False: 4.62k]
  ------------------
 1466|       |            /* unsigned 32 */
 1467|  1.83k|            char buf[5];
 1468|  1.83k|            buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
  ------------------
  |  |  188|  1.83k|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|  1.83k|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1469|  1.83k|            append_buffer(buf, 5);
 1470|  4.62k|        } else {
 1471|       |            /* unsigned 64 */
 1472|  4.62k|            char buf[9];
 1473|  4.62k|            buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
  ------------------
  |  |  190|  4.62k|    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
  |  |  ------------------
  |  |  |  |  146|  4.62k|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  |  Branch (190:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1474|  4.62k|            append_buffer(buf, 9);
 1475|  4.62k|        }
 1476|  10.7k|    }
 1477|   801k|}
_ZN7msgpack2v18take8_64ImEEcT_:
  693|   790k|inline char take8_64(T d) {
  694|   790k|    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
  695|   790k|}
_ZN7msgpack2v16packerINS0_7sbufferEE10pack_int64El:
  757|   315k|{ pack_imp_int64(d); return *this;}
_ZN7msgpack2v16packerINS0_7sbufferEE14pack_imp_int64IlEEvT_:
 1573|   315k|{
 1574|   315k|    if(d < -(1LL<<5)) {
  ------------------
  |  Branch (1574:8): [True: 100k, False: 215k]
  ------------------
 1575|   100k|        if(d < -(1LL<<15)) {
  ------------------
  |  Branch (1575:12): [True: 7.55k, False: 92.5k]
  ------------------
 1576|  7.55k|            if(d < -(1LL<<31)) {
  ------------------
  |  Branch (1576:16): [True: 4.88k, False: 2.66k]
  ------------------
 1577|       |                /* signed 64 */
 1578|  4.88k|                char buf[9];
 1579|  4.88k|                buf[0] = static_cast<char>(0xd3u); _msgpack_store64(&buf[1], d);
  ------------------
  |  |  190|  4.88k|    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
  |  |  ------------------
  |  |  |  |  146|  4.88k|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  |  Branch (190:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1580|  4.88k|                append_buffer(buf, 9);
 1581|  4.88k|            } else {
 1582|       |                /* signed 32 */
 1583|  2.66k|                char buf[5];
 1584|  2.66k|                buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], static_cast<int32_t>(d));
  ------------------
  |  |  188|  2.66k|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|  2.66k|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1585|  2.66k|                append_buffer(buf, 5);
 1586|  2.66k|            }
 1587|  92.5k|        } else {
 1588|  92.5k|            if(d < -(1<<7)) {
  ------------------
  |  Branch (1588:16): [True: 61.9k, False: 30.6k]
  ------------------
 1589|       |                /* signed 16 */
 1590|  61.9k|                char buf[3];
 1591|  61.9k|                buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
  ------------------
  |  |  186|  61.9k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  61.9k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1592|  61.9k|                append_buffer(buf, 3);
 1593|  61.9k|            } else {
 1594|       |                /* signed 8 */
 1595|  30.6k|                char buf[2] = {static_cast<char>(0xd0u), take8_64(d)};
 1596|  30.6k|                append_buffer(buf, 2);
 1597|  30.6k|            }
 1598|  92.5k|        }
 1599|   215k|    } else if(d < (1<<7)) {
  ------------------
  |  Branch (1599:15): [True: 215k, False: 0]
  ------------------
 1600|       |        /* fixnum */
 1601|   215k|        char buf = take8_64(d);
 1602|   215k|        append_buffer(&buf, 1);
 1603|   215k|    } else {
 1604|      0|        if(d < (1LL<<16)) {
  ------------------
  |  Branch (1604:12): [True: 0, False: 0]
  ------------------
 1605|      0|            if(d < (1<<8)) {
  ------------------
  |  Branch (1605:16): [True: 0, False: 0]
  ------------------
 1606|       |                /* unsigned 8 */
 1607|      0|                char buf[2] = {static_cast<char>(0xccu), take8_64(d)};
 1608|      0|                append_buffer(buf, 2);
 1609|      0|            } else {
 1610|       |                /* unsigned 16 */
 1611|      0|                char buf[3];
 1612|      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]
  |  |  ------------------
  ------------------
 1613|      0|                append_buffer(buf, 3);
 1614|      0|            }
 1615|      0|        } else {
 1616|      0|            if(d < (1LL<<32)) {
  ------------------
  |  Branch (1616:16): [True: 0, False: 0]
  ------------------
 1617|       |                /* unsigned 32 */
 1618|      0|                char buf[5];
 1619|      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]
  |  |  ------------------
  ------------------
 1620|      0|                append_buffer(buf, 5);
 1621|      0|            } else {
 1622|       |                /* unsigned 64 */
 1623|      0|                char buf[9];
 1624|      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]
  |  |  ------------------
  ------------------
 1625|      0|                append_buffer(buf, 9);
 1626|      0|            }
 1627|      0|        }
 1628|      0|    }
 1629|   315k|}
_ZN7msgpack2v18take8_64IlEEcT_:
  693|   246k|inline char take8_64(T d) {
  694|   246k|    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
  695|   246k|}
_ZN7msgpack2v16packerINS0_7sbufferEE10pack_floatEf:
 1140|   775k|{
 1141|   775k|    union { float f; uint32_t i; } mem;
 1142|   775k|    mem.f = d;
 1143|   775k|    char buf[5];
 1144|   775k|    buf[0] = static_cast<char>(0xcau); _msgpack_store32(&buf[1], mem.i);
  ------------------
  |  |  188|   775k|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|   775k|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1145|   775k|    append_buffer(buf, 5);
 1146|   775k|    return *this;
 1147|   775k|}
_ZN7msgpack2v16packerINS0_7sbufferEE11pack_doubleEd:
 1151|  10.7k|{
 1152|  10.7k|    union { double f; uint64_t i; } mem;
 1153|  10.7k|    mem.f = d;
 1154|  10.7k|    char buf[9];
 1155|  10.7k|    buf[0] = static_cast<char>(0xcbu);
 1156|       |
 1157|       |#if defined(TARGET_OS_IPHONE)
 1158|       |    // ok
 1159|       |#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
 1160|       |    // https://github.com/msgpack/msgpack-perl/pull/1
 1161|       |    mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
 1162|       |#endif
 1163|  10.7k|    _msgpack_store64(&buf[1], mem.i);
  ------------------
  |  |  190|  10.7k|    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
  |  |  ------------------
  |  |  |  |  146|  10.7k|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  |  Branch (190:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1164|  10.7k|    append_buffer(buf, 9);
 1165|  10.7k|    return *this;
 1166|  10.7k|}
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_strEj:
 1233|  13.9k|{
 1234|  13.9k|    if(l < 32) {
  ------------------
  |  Branch (1234:8): [True: 11.5k, False: 2.42k]
  ------------------
 1235|  11.5k|        unsigned char d = static_cast<uint8_t>(0xa0u | l);
 1236|  11.5k|        char buf = take8_8(d);
 1237|  11.5k|        append_buffer(&buf, 1);
 1238|  11.5k|    } else if(l < 256) {
  ------------------
  |  Branch (1238:15): [True: 1.16k, False: 1.26k]
  ------------------
 1239|  1.16k|        char buf[2];
 1240|  1.16k|        buf[0] = static_cast<char>(0xd9u); buf[1] = static_cast<char>(l);
 1241|  1.16k|        append_buffer(buf, 2);
 1242|  1.26k|    } else if(l < 65536) {
  ------------------
  |  Branch (1242:15): [True: 1.26k, False: 0]
  ------------------
 1243|  1.26k|        char buf[3];
 1244|  1.26k|        buf[0] = static_cast<char>(0xdau); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
  ------------------
  |  |  186|  1.26k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  1.26k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1245|  1.26k|        append_buffer(buf, 3);
 1246|  1.26k|    } else {
 1247|      0|        char buf[5];
 1248|      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]
  |  |  ------------------
  ------------------
 1249|      0|        append_buffer(buf, 5);
 1250|      0|    }
 1251|  13.9k|    return *this;
 1252|  13.9k|}
_ZN7msgpack2v17take8_8IhEEcT_:
  681|   134k|inline char take8_8(T d) {
  682|   134k|    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
  683|   134k|}
_ZN7msgpack2v16packerINS0_7sbufferEE13pack_str_bodyEPKcj:
 1256|  13.9k|{
 1257|  13.9k|    append_buffer(b, l);
 1258|  13.9k|    return *this;
 1259|  13.9k|}
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_binEj:
 1291|  2.39k|{
 1292|  2.39k|    if(l < 256) {
  ------------------
  |  Branch (1292:8): [True: 1.62k, False: 777]
  ------------------
 1293|  1.62k|        char buf[2];
 1294|  1.62k|        buf[0] = static_cast<char>(0xc4u); buf[1] = static_cast<char>(l);
 1295|  1.62k|        append_buffer(buf, 2);
 1296|  1.62k|    } else if(l < 65536) {
  ------------------
  |  Branch (1296:15): [True: 777, False: 0]
  ------------------
 1297|    777|        char buf[3];
 1298|    777|        buf[0] = static_cast<char>(0xc5u); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
  ------------------
  |  |  186|    777|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|    777|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1299|    777|        append_buffer(buf, 3);
 1300|    777|    } else {
 1301|      0|        char buf[5];
 1302|      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]
  |  |  ------------------
  ------------------
 1303|      0|        append_buffer(buf, 5);
 1304|      0|    }
 1305|  2.39k|    return *this;
 1306|  2.39k|}
_ZN7msgpack2v16packerINS0_7sbufferEE13pack_bin_bodyEPKcj:
 1310|  2.39k|{
 1311|  2.39k|    append_buffer(b, l);
 1312|  2.39k|    return *this;
 1313|  2.39k|}
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_extEma:
 1317|  39.4k|{
 1318|  39.4k|    switch(l) {
 1319|  3.66k|    case 1: {
  ------------------
  |  Branch (1319:5): [True: 3.66k, False: 35.7k]
  ------------------
 1320|  3.66k|        char buf[2];
 1321|  3.66k|        buf[0] = static_cast<char>(0xd4u);
 1322|  3.66k|        buf[1] = static_cast<char>(type);
 1323|  3.66k|        append_buffer(buf, 2);
 1324|  3.66k|    } break;
 1325|  5.63k|    case 2: {
  ------------------
  |  Branch (1325:5): [True: 5.63k, False: 33.7k]
  ------------------
 1326|  5.63k|        char buf[2];
 1327|  5.63k|        buf[0] = static_cast<char>(0xd5u);
 1328|  5.63k|        buf[1] = static_cast<char>(type);
 1329|  5.63k|        append_buffer(buf, 2);
 1330|  5.63k|    } break;
 1331|  3.25k|    case 4: {
  ------------------
  |  Branch (1331:5): [True: 3.25k, False: 36.1k]
  ------------------
 1332|  3.25k|        char buf[2];
 1333|  3.25k|        buf[0] = static_cast<char>(0xd6u);
 1334|  3.25k|        buf[1] = static_cast<char>(type);
 1335|  3.25k|        append_buffer(buf, 2);
 1336|  3.25k|    } break;
 1337|  20.3k|    case 8: {
  ------------------
  |  Branch (1337:5): [True: 20.3k, False: 19.1k]
  ------------------
 1338|  20.3k|        char buf[2];
 1339|  20.3k|        buf[0] = static_cast<char>(0xd7u);
 1340|  20.3k|        buf[1] = static_cast<char>(type);
 1341|  20.3k|        append_buffer(buf, 2);
 1342|  20.3k|    } break;
 1343|  2.25k|    case 16: {
  ------------------
  |  Branch (1343:5): [True: 2.25k, False: 37.1k]
  ------------------
 1344|  2.25k|        char buf[2];
 1345|  2.25k|        buf[0] = static_cast<char>(0xd8u);
 1346|  2.25k|        buf[1] = static_cast<char>(type);
 1347|  2.25k|        append_buffer(buf, 2);
 1348|  2.25k|    } break;
 1349|  4.29k|    default:
  ------------------
  |  Branch (1349:5): [True: 4.29k, False: 35.1k]
  ------------------
 1350|  4.29k|        if(l < 256) {
  ------------------
  |  Branch (1350:12): [True: 4.08k, False: 210]
  ------------------
 1351|  4.08k|            char buf[3];
 1352|  4.08k|            buf[0] = static_cast<char>(0xc7u);
 1353|  4.08k|            buf[1] = static_cast<char>(l);
 1354|  4.08k|            buf[2] = static_cast<char>(type);
 1355|  4.08k|            append_buffer(buf, 3);
 1356|  4.08k|        } else if(l < 65536) {
  ------------------
  |  Branch (1356:19): [True: 210, False: 0]
  ------------------
 1357|    210|            char buf[4];
 1358|    210|            buf[0] = static_cast<char>(0xc8u);
 1359|    210|            _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
  ------------------
  |  |  186|    210|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|    210|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1360|    210|            buf[3] = static_cast<char>(type);
 1361|    210|            append_buffer(buf, 4);
 1362|    210|        } else {
 1363|      0|            char buf[6];
 1364|      0|            buf[0] = static_cast<char>(0xc9u);
 1365|      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]
  |  |  ------------------
  ------------------
 1366|      0|            buf[5] = static_cast<char>(type);
 1367|      0|            append_buffer(buf, 6);
 1368|      0|        }
 1369|  4.29k|        break;
 1370|  39.4k|    }
 1371|  39.4k|    return *this;
 1372|  39.4k|}
_ZN7msgpack2v16packerINS0_7sbufferEE13pack_ext_bodyEPKcj:
 1376|  39.4k|{
 1377|  39.4k|    append_buffer(b, l);
 1378|  39.4k|    return *this;
 1379|  39.4k|}
_ZN7msgpack2v16packerINS0_7sbufferEE10pack_arrayEj:
 1196|  57.4k|{
 1197|  57.4k|    if(n < 16) {
  ------------------
  |  Branch (1197:8): [True: 46.6k, False: 10.8k]
  ------------------
 1198|  46.6k|        char d = static_cast<char>(0x90u | n);
 1199|  46.6k|        append_buffer(&d, 1);
 1200|  46.6k|    } else if(n < 65536) {
  ------------------
  |  Branch (1200:15): [True: 10.8k, False: 0]
  ------------------
 1201|  10.8k|        char buf[3];
 1202|  10.8k|        buf[0] = static_cast<char>(0xdcu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
  ------------------
  |  |  186|  10.8k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  10.8k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1203|  10.8k|        append_buffer(buf, 3);
 1204|  10.8k|    } else {
 1205|      0|        char buf[5];
 1206|      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]
  |  |  ------------------
  ------------------
 1207|      0|        append_buffer(buf, 5);
 1208|      0|    }
 1209|  57.4k|    return *this;
 1210|  57.4k|}
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_mapEj:
 1214|   125k|{
 1215|   125k|    if(n < 16) {
  ------------------
  |  Branch (1215:8): [True: 122k, False: 2.33k]
  ------------------
 1216|   122k|        unsigned char d = static_cast<unsigned char>(0x80u | n);
 1217|   122k|        char buf = take8_8(d);
 1218|   122k|        append_buffer(&buf, 1);
 1219|   122k|    } else if(n < 65536) {
  ------------------
  |  Branch (1219:15): [True: 2.33k, False: 0]
  ------------------
 1220|  2.33k|        char buf[3];
 1221|  2.33k|        buf[0] = static_cast<char>(0xdeu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
  ------------------
  |  |  186|  2.33k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  2.33k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1222|  2.33k|        append_buffer(buf, 3);
 1223|  2.33k|    } else {
 1224|      0|        char buf[5];
 1225|      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]
  |  |  ------------------
  ------------------
 1226|      0|        append_buffer(buf, 5);
 1227|      0|    }
 1228|   125k|    return *this;
 1229|   125k|}

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

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

_ZNK7msgpack2v112unpack_limit3strEv:
  104|  20.1k|    std::size_t str() const { return str_; }
_ZNK7msgpack2v112unpack_limit5arrayEv:
  102|  83.4k|    std::size_t array() const { return array_; }
_ZNK7msgpack2v112unpack_limit5depthEv:
  107|   256k|    std::size_t depth() const { return depth_; }
_ZNK7msgpack2v112unpack_limit3mapEv:
  103|   173k|    std::size_t map() const { return map_; }
_ZNK7msgpack2v112unpack_limit3extEv:
  106|  45.0k|    std::size_t ext() const { return ext_; }
_ZNK7msgpack2v112unpack_limit3binEv:
  105|  4.52k|    std::size_t bin() const { return bin_; }
_ZN7msgpack2v112unpack_limitC2Emmmmmm:
   96|  2.25k|        :array_(array),
   97|  2.25k|         map_(map),
   98|  2.25k|         str_(str),
   99|  2.25k|         bin_(bin),
  100|  2.25k|         ext_(ext),
  101|  2.25k|         depth_(depth) {}

_ZN7msgpack2v118insufficient_bytesC2EPKc:
   48|    942|        :unpack_error(msg) {}
_ZN7msgpack2v112unpack_errorC2EPKc:
   30|  1.09k|        std::runtime_error(msg) {}
_ZN7msgpack2v117str_size_overflowC2EPKc:
   84|      8|        :size_overflow(msg) {}
_ZN7msgpack2v113size_overflowC2EPKc:
   57|    154|        :unpack_error(msg) {}
_ZN7msgpack2v119array_size_overflowC2EPKc:
   66|     67|        :size_overflow(msg) {}
_ZN7msgpack2v119depth_size_overflowC2EPKc:
  111|      2|        :size_overflow(msg) {}
_ZN7msgpack2v117map_size_overflowC2EPKc:
   75|     67|        :size_overflow(msg) {}
_ZN7msgpack2v111parse_errorC2EPKc:
   39|      1|        :unpack_error(msg) {}
_ZN7msgpack2v117ext_size_overflowC2EPKc:
  102|      2|        :size_overflow(msg) {}
_ZN7msgpack2v117bin_size_overflowC2EPKc:
   93|      8|        :size_overflow(msg) {}

_ZN7msgpack2v26detail21create_object_visitorC2EPFbNS_2v14type11object_typeEmPvES6_RKNS3_12unpack_limitE:
   30|  2.25k|        :m_func(f), m_user_data(user_data), m_limit(limit) {
   31|  2.25k|        m_stack.reserve(MSGPACK_EMBED_STACK_SIZE);
  ------------------
  |  |   16|  2.25k|#define MSGPACK_EMBED_STACK_SIZE 32
  ------------------
   32|  2.25k|        m_stack.push_back(&m_obj);
   33|  2.25k|    }
_ZN7msgpack2v26detail21create_object_visitor8set_zoneERNS_2v14zoneE:
   64|  2.25k|    void set_zone(msgpack::zone& zone) { m_zone = &zone; }
_ZN7msgpack2v26detail21create_object_visitor14set_referencedEb:
   66|  2.25k|    void set_referenced(bool referenced) { m_referenced = referenced; }
_ZN7msgpack2v26detail21create_object_visitor18insufficient_bytesEmm:
  258|    942|    void insufficient_bytes(size_t /*parsed_offset*/, size_t /*error_offset*/) {
  259|    942|        throw msgpack::insufficient_bytes("insufficient bytes");
  260|    942|    }
_ZN7msgpack2v26detail21create_object_visitor22visit_positive_integerEm:
   79|  1.00M|    bool visit_positive_integer(uint64_t v) {
   80|  1.00M|        msgpack::object* obj = m_stack.back();
   81|  1.00M|        obj->type = msgpack::type::POSITIVE_INTEGER;
   82|  1.00M|        obj->via.u64 = v;
   83|  1.00M|        return true;
   84|  1.00M|    }
_ZN7msgpack2v26detail21create_object_visitor14end_array_itemEv:
  207|   912k|    bool end_array_item() {
  208|   912k|        ++m_stack.back();
  209|   912k|        return true;
  210|   912k|    }
_ZN7msgpack2v26detail21create_object_visitor9end_arrayEv:
  211|  75.8k|    bool end_array() {
  212|  75.8k|        m_stack.pop_back();
  213|  75.8k|        return true;
  214|  75.8k|    }
_ZN7msgpack2v26detail21create_object_visitor16start_array_itemEv:
  204|   920k|    bool start_array_item() {
  205|   920k|        return true;
  206|   920k|    }
_ZN7msgpack2v26detail21create_object_visitor11end_map_keyEv:
  240|   853k|    bool end_map_key() {
  241|   853k|        ++m_stack.back();
  242|   853k|        return true;
  243|   853k|    }
_ZN7msgpack2v26detail21create_object_visitor15start_map_valueEv:
  244|   853k|    bool start_map_value() {
  245|   853k|        return true;
  246|   853k|    }
_ZN7msgpack2v26detail21create_object_visitor13end_map_valueEv:
  247|   852k|    bool end_map_value() {
  248|   852k|        ++m_stack.back();
  249|   852k|        return true;
  250|   852k|    }
_ZN7msgpack2v26detail21create_object_visitor7end_mapEv:
  251|   165k|    bool end_map() {
  252|   165k|        m_stack.pop_back();
  253|   165k|        return true;
  254|   165k|    }
_ZN7msgpack2v26detail21create_object_visitor13start_map_keyEv:
  237|   860k|    bool start_map_key() {
  238|   860k|        return true;
  239|   860k|    }
_ZN7msgpack2v26detail21create_object_visitor22visit_negative_integerEl:
   85|   388k|    bool visit_negative_integer(int64_t v) {
   86|   388k|        msgpack::object* obj = m_stack.back();
   87|   388k|        if(v >= 0) {
  ------------------
  |  Branch (87:12): [True: 11.6k, False: 376k]
  ------------------
   88|  11.6k|            obj->type = msgpack::type::POSITIVE_INTEGER;
   89|  11.6k|            obj->via.u64 = static_cast<uint64_t>(v);
   90|  11.6k|        }
   91|   376k|        else {
   92|   376k|            obj->type = msgpack::type::NEGATIVE_INTEGER;
   93|   376k|            obj->via.i64 = v;
   94|   376k|        }
   95|   388k|        return true;
   96|   388k|    }
_ZN7msgpack2v26detail21create_object_visitor9visit_strEPKcj:
  109|  20.1k|    bool visit_str(const char* v, uint32_t size) {
  110|  20.1k|        MSGPACK_ASSERT(v || size == 0);
  ------------------
  |  |   22|  20.1k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  111|  20.1k|        if (size > m_limit.str()) throw msgpack::str_size_overflow("str size overflow");
  ------------------
  |  Branch (111:13): [True: 8, False: 20.1k]
  ------------------
  112|  20.1k|        msgpack::object* obj = m_stack.back();
  113|  20.1k|        obj->type = msgpack::type::STR;
  114|  20.1k|        if (m_func && m_func(obj->type, size, m_user_data)) {
  ------------------
  |  Branch (114:13): [True: 0, False: 20.1k]
  |  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|  20.1k|        else {
  120|  20.1k|            if (v) {
  ------------------
  |  Branch (120:17): [True: 19.7k, False: 370]
  ------------------
  121|  19.7k|                char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
  ------------------
  |  |   32|  19.7k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  122|  19.7k|                std::memcpy(tmp, v, size);
  123|  19.7k|                obj->via.str.ptr = tmp;
  124|  19.7k|                obj->via.str.size = size;
  125|  19.7k|            }
  126|    370|            else {
  127|    370|                obj->via.str.ptr = MSGPACK_NULLPTR;
  ------------------
  |  |   85|    370|#  define MSGPACK_NULLPTR nullptr
  ------------------
  128|    370|                obj->via.str.size = 0;
  129|    370|            }
  130|  20.1k|        }
  131|  20.1k|        return true;
  132|  20.1k|    }
_ZN7msgpack2v26detail21create_object_visitor4zoneEv:
   63|  69.3k|    msgpack::zone& zone() { return *m_zone; }
_ZN7msgpack2v26detail21create_object_visitor11start_arrayEj:
  181|  83.4k|    bool start_array(uint32_t num_elements) {
  182|  83.4k|        if (num_elements > m_limit.array()) throw msgpack::array_size_overflow("array size overflow");
  ------------------
  |  Branch (182:13): [True: 67, False: 83.4k]
  ------------------
  183|  83.4k|        if (m_stack.size() > m_limit.depth()) throw msgpack::depth_size_overflow("depth size overflow");
  ------------------
  |  Branch (183:13): [True: 1, False: 83.4k]
  ------------------
  184|  83.4k|        msgpack::object* obj = m_stack.back();
  185|  83.4k|        obj->type = msgpack::type::ARRAY;
  186|  83.4k|        obj->via.array.size = num_elements;
  187|  83.4k|        if (num_elements == 0) {
  ------------------
  |  Branch (187:13): [True: 12.1k, False: 71.2k]
  ------------------
  188|  12.1k|            obj->via.array.ptr = MSGPACK_NULLPTR;
  ------------------
  |  |   85|  12.1k|#  define MSGPACK_NULLPTR nullptr
  ------------------
  189|  12.1k|        }
  190|  71.2k|        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|  71.2k|            size_t size = num_elements*sizeof(msgpack::object);
  198|  71.2k|            obj->via.array.ptr =
  199|  71.2k|                static_cast<msgpack::object*>(m_zone->allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
  ------------------
  |  |   32|  71.2k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  200|  71.2k|        }
  201|  83.4k|        m_stack.push_back(obj->via.array.ptr);
  202|  83.4k|        return true;
  203|  83.4k|    }
_ZN7msgpack2v26detail21create_object_visitor9start_mapEj:
  215|   173k|    bool start_map(uint32_t num_kv_pairs) {
  216|   173k|        if (num_kv_pairs > m_limit.map()) throw msgpack::map_size_overflow("map size overflow");
  ------------------
  |  Branch (216:13): [True: 67, False: 173k]
  ------------------
  217|   173k|        if (m_stack.size() > m_limit.depth()) throw msgpack::depth_size_overflow("depth size overflow");
  ------------------
  |  Branch (217:13): [True: 1, False: 173k]
  ------------------
  218|   173k|        msgpack::object* obj = m_stack.back();
  219|   173k|        obj->type = msgpack::type::MAP;
  220|   173k|        obj->via.map.size = num_kv_pairs;
  221|   173k|        if (num_kv_pairs == 0) {
  ------------------
  |  Branch (221:13): [True: 77.8k, False: 95.7k]
  ------------------
  222|  77.8k|            obj->via.map.ptr = MSGPACK_NULLPTR;
  ------------------
  |  |   85|  77.8k|#  define MSGPACK_NULLPTR nullptr
  ------------------
  223|  77.8k|        }
  224|  95.7k|        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|  95.7k|            size_t size = num_kv_pairs*sizeof(msgpack::object_kv);
  231|  95.7k|            obj->via.map.ptr =
  232|  95.7k|                static_cast<msgpack::object_kv*>(m_zone->allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
  ------------------
  |  |   32|  95.7k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  233|  95.7k|        }
  234|   173k|        m_stack.push_back(reinterpret_cast<msgpack::object*>(obj->via.map.ptr));
  235|   173k|        return true;
  236|   173k|    }
_ZN7msgpack2v26detail21create_object_visitor13visit_booleanEb:
   73|  53.8k|    bool visit_boolean(bool v) {
   74|  53.8k|        msgpack::object* obj = m_stack.back();
   75|  53.8k|        obj->type = msgpack::type::BOOLEAN;
   76|  53.8k|        obj->via.boolean = v;
   77|  53.8k|        return true;
   78|  53.8k|    }
_ZN7msgpack2v26detail21create_object_visitor9visit_nilEv:
   68|  46.2k|    bool visit_nil() {
   69|  46.2k|        msgpack::object* obj = m_stack.back();
   70|  46.2k|        obj->type = msgpack::type::NIL;
   71|  46.2k|        return true;
   72|  46.2k|    }
_ZN7msgpack2v26detail21create_object_visitor11parse_errorEmm:
  255|      1|    void parse_error(size_t /*parsed_offset*/, size_t /*error_offset*/) {
  256|      1|        throw msgpack::parse_error("parse error");
  257|      1|    }
_ZN7msgpack2v26detail21create_object_visitor13visit_float32Ef:
   97|   800k|    bool visit_float32(float v) {
   98|   800k|        msgpack::object* obj = m_stack.back();
   99|   800k|        obj->type = msgpack::type::FLOAT32;
  100|   800k|        obj->via.f64 = v;
  101|   800k|        return true;
  102|   800k|    }
_ZN7msgpack2v26detail21create_object_visitor13visit_float64Ed:
  103|  14.4k|    bool visit_float64(double v) {
  104|  14.4k|        msgpack::object* obj = m_stack.back();
  105|  14.4k|        obj->type = msgpack::type::FLOAT64;
  106|  14.4k|        obj->via.f64 = v;
  107|  14.4k|        return true;
  108|  14.4k|    }
_ZN7msgpack2v26detail21create_object_visitor9visit_extEPKcj:
  157|  45.0k|    bool visit_ext(const char* v, uint32_t size) {
  158|  45.0k|        MSGPACK_ASSERT(v || size == 0);
  ------------------
  |  |   22|  45.0k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  159|  45.0k|        if (size > m_limit.ext()) throw msgpack::ext_size_overflow("ext size overflow");
  ------------------
  |  Branch (159:13): [True: 2, False: 45.0k]
  ------------------
  160|  45.0k|        msgpack::object* obj = m_stack.back();
  161|  45.0k|        obj->type = msgpack::type::EXT;
  162|  45.0k|        if (m_func && m_func(obj->type, size, m_user_data)) {
  ------------------
  |  Branch (162:13): [True: 0, False: 45.0k]
  |  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|  45.0k|        else {
  168|  45.0k|            if (v) {
  ------------------
  |  Branch (168:17): [True: 45.0k, False: 0]
  ------------------
  169|  45.0k|                char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
  ------------------
  |  |   32|  45.0k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  170|  45.0k|                std::memcpy(tmp, v, size);
  171|  45.0k|                obj->via.ext.ptr = tmp;
  172|  45.0k|                obj->via.ext.size = static_cast<uint32_t>(size - 1);
  173|  45.0k|            }
  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|  45.0k|        }
  179|  45.0k|        return true;
  180|  45.0k|    }
_ZN7msgpack2v26detail21create_object_visitor9visit_binEPKcj:
  133|  4.52k|    bool visit_bin(const char* v, uint32_t size) {
  134|  4.52k|        MSGPACK_ASSERT(v || size == 0);
  ------------------
  |  |   22|  4.52k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  135|  4.52k|        if (size > m_limit.bin()) throw msgpack::bin_size_overflow("bin size overflow");
  ------------------
  |  Branch (135:13): [True: 8, False: 4.52k]
  ------------------
  136|  4.52k|        msgpack::object* obj = m_stack.back();
  137|  4.52k|        obj->type = msgpack::type::BIN;
  138|  4.52k|        if (m_func && m_func(obj->type, size, m_user_data)) {
  ------------------
  |  Branch (138:13): [True: 0, False: 4.52k]
  |  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|  4.52k|        else {
  144|  4.52k|            if (v) {
  ------------------
  |  Branch (144:17): [True: 4.52k, False: 0]
  ------------------
  145|  4.52k|                char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
  ------------------
  |  |   32|  4.52k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  146|  4.52k|                std::memcpy(tmp, v, size);
  147|  4.52k|                obj->via.bin.ptr = tmp;
  148|  4.52k|                obj->via.bin.size = size;
  149|  4.52k|            }
  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|  4.52k|        }
  155|  4.52k|        return true;
  156|  4.52k|    }
_ZNK7msgpack2v26detail21create_object_visitor10referencedEv:
   65|  1.16k|    bool referenced() const { return m_referenced; }
_ZNK7msgpack2v26detail21create_object_visitor4dataEv:
   59|  1.16k|    {
   60|  1.16k|        return m_obj;
   61|  1.16k|    }

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

_ZN7msgpack2v26detail9parse_impINS1_21create_object_visitorEEENS0_12parse_returnEPKcmRmRT_:
 1034|  2.25k|parse_imp(const char* data, size_t len, size_t& off, Visitor& v) {
 1035|  2.25k|    std::size_t noff = off;
 1036|       |
 1037|  2.25k|    if(len <= noff) {
  ------------------
  |  Branch (1037:8): [True: 0, False: 2.25k]
  ------------------
 1038|       |        // FIXME
 1039|      0|        v.insufficient_bytes(noff, noff);
 1040|      0|        return PARSE_CONTINUE;
 1041|      0|    }
 1042|  2.25k|    detail::parse_helper<Visitor> h(v);
 1043|  2.25k|    parse_return ret = h.execute(data, len, noff);
 1044|  2.25k|    switch (ret) {
 1045|    942|    case PARSE_CONTINUE:
  ------------------
  |  Branch (1045:5): [True: 942, False: 1.31k]
  ------------------
 1046|    942|        off = noff;
 1047|    942|        v.insufficient_bytes(noff - 1, noff);
 1048|    942|        return ret;
 1049|  1.16k|    case PARSE_SUCCESS:
  ------------------
  |  Branch (1049:5): [True: 1.16k, False: 1.09k]
  ------------------
 1050|  1.16k|        off = noff;
 1051|  1.16k|        if(noff < len) {
  ------------------
  |  Branch (1051:12): [True: 45, False: 1.11k]
  ------------------
 1052|     45|            return PARSE_EXTRA_BYTES;
 1053|     45|        }
 1054|  1.11k|        return ret;
 1055|      0|    default:
  ------------------
  |  Branch (1055:5): [True: 0, False: 2.25k]
  ------------------
 1056|      0|        return ret;
 1057|  2.25k|    }
 1058|  2.25k|}
_ZN7msgpack2v26detail12parse_helperINS1_21create_object_visitorEEC2ERS3_:
 1024|  2.25k|    parse_helper(Visitor& v):m_visitor(v) {}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEEC2Ev:
   39|  2.25k|        :m_trail(0), m_cs(MSGPACK_CS_HEADER)
   40|  2.25k|    {
   41|  2.25k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE12unpack_stackC2Ev:
  158|  2.25k|        unpack_stack() {
  159|  2.25k|            m_stack.reserve(MSGPACK_EMBED_STACK_SIZE);
  ------------------
  |  |   16|  2.25k|#define MSGPACK_EMBED_STACK_SIZE 32
  ------------------
  160|  2.25k|        }
_ZN7msgpack2v26detail12parse_helperINS1_21create_object_visitorEE7executeEPKcmRm:
 1025|  2.25k|    parse_return execute(const char* data, std::size_t len, std::size_t& off) {
 1026|  2.25k|        return detail::context<parse_helper<Visitor> >::execute(data, len, off);
 1027|  2.25k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE7executeEPKcmRm:
  237|  2.25k|{
  238|  2.25k|    MSGPACK_ASSERT(len >= off);
  ------------------
  |  |   22|  2.25k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  239|       |
  240|  2.25k|    m_start = data;
  241|  2.25k|    m_current = data + off;
  242|  2.25k|    const char* const pe = data + len;
  243|  2.25k|    const char* n = MSGPACK_NULLPTR;
  ------------------
  |  |   85|  2.25k|#  define MSGPACK_NULLPTR nullptr
  ------------------
  244|       |
  245|  2.25k|    if(m_current == pe) {
  ------------------
  |  Branch (245:8): [True: 0, False: 2.25k]
  ------------------
  246|      0|        off = static_cast<std::size_t>(m_current - m_start);
  247|      0|        return PARSE_CONTINUE;
  248|      0|    }
  249|  2.25k|    bool fixed_trail_again = false;
  250|  2.64M|    do {
  251|  2.64M|        if (m_cs == MSGPACK_CS_HEADER) {
  ------------------
  |  Branch (251:13): [True: 2.63M, False: 13.2k]
  ------------------
  252|  2.63M|            fixed_trail_again = false;
  253|  2.63M|            int selector = *reinterpret_cast<const unsigned char*>(m_current);
  254|  2.63M|            if (0x00 <= selector && selector <= 0x7f) { // Positive Fixnum
  ------------------
  |  Branch (254:17): [True: 2.63M, False: 0]
  |  Branch (254:37): [True: 987k, False: 1.64M]
  ------------------
  255|   987k|                uint8_t tmp = *reinterpret_cast<const uint8_t*>(m_current);
  256|   987k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  257|   987k|                parse_return upr = after_visit_proc(visret, off);
  258|   987k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (258:21): [True: 100, False: 987k]
  ------------------
  259|  1.64M|            } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum
  ------------------
  |  Branch (259:23): [True: 253k, False: 1.39M]
  |  Branch (259:43): [True: 253k, False: 0]
  ------------------
  260|   253k|                int8_t tmp = *reinterpret_cast<const int8_t*>(m_current);
  261|   253k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  262|   253k|                parse_return upr = after_visit_proc(visret, off);
  263|   253k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (263:21): [True: 58, False: 253k]
  ------------------
  264|  1.39M|            } else if (0xc4 <= selector && selector <= 0xdf) {
  ------------------
  |  Branch (264:24): [True: 1.05M, False: 342k]
  |  Branch (264:44): [True: 1.05M, False: 0]
  ------------------
  265|  1.05M|                const uint32_t trail[] = {
  266|  1.05M|                    1, // bin     8  0xc4
  267|  1.05M|                    2, // bin    16  0xc5
  268|  1.05M|                    4, // bin    32  0xc6
  269|  1.05M|                    1, // ext     8  0xc7
  270|  1.05M|                    2, // ext    16  0xc8
  271|  1.05M|                    4, // ext    32  0xc9
  272|  1.05M|                    4, // float  32  0xca
  273|  1.05M|                    8, // float  64  0xcb
  274|  1.05M|                    1, // uint    8  0xcc
  275|  1.05M|                    2, // uint   16  0xcd
  276|  1.05M|                    4, // uint   32  0xce
  277|  1.05M|                    8, // uint   64  0xcf
  278|  1.05M|                    1, // int     8  0xd0
  279|  1.05M|                    2, // int    16  0xd1
  280|  1.05M|                    4, // int    32  0xd2
  281|  1.05M|                    8, // int    64  0xd3
  282|  1.05M|                    2, // fixext  1  0xd4
  283|  1.05M|                    3, // fixext  2  0xd5
  284|  1.05M|                    5, // fixext  4  0xd6
  285|  1.05M|                    9, // fixext  8  0xd7
  286|  1.05M|                    17,// fixext 16  0xd8
  287|  1.05M|                    1, // str     8  0xd9
  288|  1.05M|                    2, // str    16  0xda
  289|  1.05M|                    4, // str    32  0xdb
  290|  1.05M|                    2, // array  16  0xdc
  291|  1.05M|                    4, // array  32  0xdd
  292|  1.05M|                    2, // map    16  0xde
  293|  1.05M|                    4, // map    32  0xdf
  294|  1.05M|                };
  295|  1.05M|                m_trail = trail[selector - 0xc4];
  296|  1.05M|                m_cs = next_cs(m_current);
  297|  1.05M|                fixed_trail_again = true;
  298|  1.05M|            } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr
  ------------------
  |  Branch (298:23): [True: 113k, False: 228k]
  |  Branch (298:43): [True: 13.6k, False: 100k]
  ------------------
  299|  13.6k|                m_trail = static_cast<uint32_t>(*m_current) & 0x1f;
  300|  13.6k|                if(m_trail == 0) {
  ------------------
  |  Branch (300:20): [True: 7.34k, False: 6.34k]
  ------------------
  301|  7.34k|                    bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  302|  7.34k|                    parse_return upr = after_visit_proc(visret, off);
  303|  7.34k|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (303:25): [True: 24, False: 7.32k]
  ------------------
  304|  7.34k|                }
  305|  6.34k|                else {
  306|  6.34k|                    m_cs = MSGPACK_ACS_STR_VALUE;
  307|  6.34k|                    fixed_trail_again = true;
  308|  6.34k|                }
  309|   329k|            } else if(0x90 <= selector && selector <= 0x9f) { // FixArray
  ------------------
  |  Branch (309:23): [True: 161k, False: 167k]
  |  Branch (309:43): [True: 61.1k, False: 100k]
  ------------------
  310|  61.1k|                parse_return ret = start_aggregate<fix_tag>(array_sv(holder()), array_ev(holder()), m_current, off);
  311|  61.1k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (311:21): [True: 29, False: 61.1k]
  ------------------
  312|   267k|            } else if(0x80 <= selector && selector <= 0x8f) { // FixMap
  ------------------
  |  Branch (312:23): [True: 267k, False: 0]
  |  Branch (312:43): [True: 167k, False: 100k]
  ------------------
  313|   167k|                parse_return ret = start_aggregate<fix_tag>(map_sv(holder()), map_ev(holder()), m_current, off);
  314|   167k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (314:21): [True: 30, False: 167k]
  ------------------
  315|   167k|            } else if(selector == 0xc2) { // false
  ------------------
  |  Branch (315:23): [True: 39.8k, False: 60.2k]
  ------------------
  316|  39.8k|                bool visret = holder().visitor().visit_boolean(false);
  317|  39.8k|                parse_return upr = after_visit_proc(visret, off);
  318|  39.8k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (318:21): [True: 8, False: 39.8k]
  ------------------
  319|  60.2k|            } else if(selector == 0xc3) { // true
  ------------------
  |  Branch (319:23): [True: 14.0k, False: 46.2k]
  ------------------
  320|  14.0k|                bool visret = holder().visitor().visit_boolean(true);
  321|  14.0k|                parse_return upr = after_visit_proc(visret, off);
  322|  14.0k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (322:21): [True: 12, False: 14.0k]
  ------------------
  323|  46.2k|            } else if(selector == 0xc0) { // nil
  ------------------
  |  Branch (323:23): [True: 46.2k, False: 1]
  ------------------
  324|  46.2k|                bool visret = holder().visitor().visit_nil();
  325|  46.2k|                parse_return upr = after_visit_proc(visret, off);
  326|  46.2k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (326:21): [True: 17, False: 46.1k]
  ------------------
  327|  46.2k|            } else {
  328|      1|                off = static_cast<std::size_t>(m_current - m_start);
  329|      1|                holder().visitor().parse_error(off - 1, off);
  330|      1|                return PARSE_PARSE_ERROR;
  331|      1|            }
  332|       |            // end MSGPACK_CS_HEADER
  333|  2.63M|        }
  334|  2.64M|        if (m_cs != MSGPACK_CS_HEADER || fixed_trail_again) {
  ------------------
  |  Branch (334:13): [True: 1.07M, False: 1.57M]
  |  Branch (334:42): [True: 0, False: 1.57M]
  ------------------
  335|  1.07M|            if (fixed_trail_again) {
  ------------------
  |  Branch (335:17): [True: 1.07M, False: 0]
  ------------------
  336|  1.07M|                ++m_current;
  337|  1.07M|                fixed_trail_again = false;
  338|  1.07M|            }
  339|  1.07M|            if(static_cast<std::size_t>(pe - m_current) < m_trail) {
  ------------------
  |  Branch (339:16): [True: 258, False: 1.07M]
  ------------------
  340|    258|                off = static_cast<std::size_t>(m_current - m_start);
  341|    258|                return PARSE_CONTINUE;
  342|    258|            }
  343|  1.07M|            n = m_current;
  344|  1.07M|            m_current += m_trail - 1;
  345|  1.07M|            switch(m_cs) {
  346|       |                //case MSGPACK_CS_
  347|       |                //case MSGPACK_CS_
  348|   800k|            case MSGPACK_CS_FLOAT: {
  ------------------
  |  Branch (348:13): [True: 800k, False: 270k]
  ------------------
  349|   800k|                union { uint32_t i; float f; } mem;
  350|   800k|                load<uint32_t>(mem.i, n);
  351|   800k|                bool visret = holder().visitor().visit_float32(mem.f);
  352|   800k|                parse_return upr = after_visit_proc(visret, off);
  353|   800k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (353:21): [True: 178, False: 800k]
  ------------------
  354|   800k|            } break;
  355|   800k|            case MSGPACK_CS_DOUBLE: {
  ------------------
  |  Branch (355:13): [True: 14.4k, False: 1.05M]
  ------------------
  356|  14.4k|                union { uint64_t i; double f; } mem;
  357|  14.4k|                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|  14.4k|                bool visret = holder().visitor().visit_float64(mem.f);
  365|  14.4k|                parse_return upr = after_visit_proc(visret, off);
  366|  14.4k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (366:21): [True: 51, False: 14.4k]
  ------------------
  367|  14.4k|            } break;
  368|  14.4k|            case MSGPACK_CS_UINT_8: {
  ------------------
  |  Branch (368:13): [True: 9.60k, False: 1.06M]
  ------------------
  369|  9.60k|                uint8_t tmp;
  370|  9.60k|                load<uint8_t>(tmp, n);
  371|  9.60k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  372|  9.60k|                parse_return upr = after_visit_proc(visret, off);
  373|  9.60k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (373:21): [True: 18, False: 9.58k]
  ------------------
  374|  9.60k|            } break;
  375|  9.58k|            case MSGPACK_CS_UINT_16: {
  ------------------
  |  Branch (375:13): [True: 3.85k, False: 1.06M]
  ------------------
  376|  3.85k|                uint16_t tmp;
  377|  3.85k|                load<uint16_t>(tmp, n);
  378|  3.85k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  379|  3.85k|                parse_return upr = after_visit_proc(visret, off);
  380|  3.85k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (380:21): [True: 26, False: 3.82k]
  ------------------
  381|  3.85k|            } break;
  382|  3.82k|            case MSGPACK_CS_UINT_32: {
  ------------------
  |  Branch (382:13): [True: 2.06k, False: 1.06M]
  ------------------
  383|  2.06k|                uint32_t tmp;
  384|  2.06k|                load<uint32_t>(tmp, n);
  385|  2.06k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  386|  2.06k|                parse_return upr = after_visit_proc(visret, off);
  387|  2.06k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (387:21): [True: 44, False: 2.02k]
  ------------------
  388|  2.06k|            } break;
  389|  2.02k|            case MSGPACK_CS_UINT_64: {
  ------------------
  |  Branch (389:13): [True: 1.24k, False: 1.06M]
  ------------------
  390|  1.24k|                uint64_t tmp;
  391|  1.24k|                load<uint64_t>(tmp, n);
  392|  1.24k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  393|  1.24k|                parse_return upr = after_visit_proc(visret, off);
  394|  1.24k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (394:21): [True: 67, False: 1.17k]
  ------------------
  395|  1.24k|            } break;
  396|  50.1k|            case MSGPACK_CS_INT_8: {
  ------------------
  |  Branch (396:13): [True: 50.1k, False: 1.02M]
  ------------------
  397|  50.1k|                int8_t tmp;
  398|  50.1k|                load<int8_t>(tmp, n);
  399|  50.1k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  400|  50.1k|                parse_return upr = after_visit_proc(visret, off);
  401|  50.1k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (401:21): [True: 32, False: 50.1k]
  ------------------
  402|  50.1k|            } break;
  403|  69.2k|            case MSGPACK_CS_INT_16: {
  ------------------
  |  Branch (403:13): [True: 69.2k, False: 1.00M]
  ------------------
  404|  69.2k|                int16_t tmp;
  405|  69.2k|                load<int16_t>(tmp, n);
  406|  69.2k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  407|  69.2k|                parse_return upr = after_visit_proc(visret, off);
  408|  69.2k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (408:21): [True: 52, False: 69.2k]
  ------------------
  409|  69.2k|            } break;
  410|  69.2k|            case MSGPACK_CS_INT_32: {
  ------------------
  |  Branch (410:13): [True: 4.76k, False: 1.06M]
  ------------------
  411|  4.76k|                int32_t tmp;
  412|  4.76k|                load<int32_t>(tmp, n);
  413|  4.76k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  414|  4.76k|                parse_return upr = after_visit_proc(visret, off);
  415|  4.76k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (415:21): [True: 78, False: 4.68k]
  ------------------
  416|  4.76k|            } break;
  417|  10.9k|            case MSGPACK_CS_INT_64: {
  ------------------
  |  Branch (417:13): [True: 10.9k, False: 1.06M]
  ------------------
  418|  10.9k|                int64_t tmp;
  419|  10.9k|                load<int64_t>(tmp, n);
  420|  10.9k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  421|  10.9k|                parse_return upr = after_visit_proc(visret, off);
  422|  10.9k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (422:21): [True: 140, False: 10.8k]
  ------------------
  423|  10.9k|            } break;
  424|  10.8k|            case MSGPACK_CS_FIXEXT_1: {
  ------------------
  |  Branch (424:13): [True: 3.19k, False: 1.06M]
  ------------------
  425|  3.19k|                bool visret = holder().visitor().visit_ext(n, 1+1);
  426|  3.19k|                parse_return upr = after_visit_proc(visret, off);
  427|  3.19k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (427:21): [True: 10, False: 3.18k]
  ------------------
  428|  3.19k|            } break;
  429|  6.95k|            case MSGPACK_CS_FIXEXT_2: {
  ------------------
  |  Branch (429:13): [True: 6.95k, False: 1.06M]
  ------------------
  430|  6.95k|                bool visret = holder().visitor().visit_ext(n, 2+1);
  431|  6.95k|                parse_return upr = after_visit_proc(visret, off);
  432|  6.95k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (432:21): [True: 7, False: 6.95k]
  ------------------
  433|  6.95k|            } break;
  434|  6.95k|            case MSGPACK_CS_FIXEXT_4: {
  ------------------
  |  Branch (434:13): [True: 3.58k, False: 1.06M]
  ------------------
  435|  3.58k|                bool visret = holder().visitor().visit_ext(n, 4+1);
  436|  3.58k|                parse_return upr = after_visit_proc(visret, off);
  437|  3.58k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (437:21): [True: 7, False: 3.57k]
  ------------------
  438|  3.58k|            } break;
  439|  21.6k|            case MSGPACK_CS_FIXEXT_8: {
  ------------------
  |  Branch (439:13): [True: 21.6k, False: 1.04M]
  ------------------
  440|  21.6k|                bool visret = holder().visitor().visit_ext(n, 8+1);
  441|  21.6k|                parse_return upr = after_visit_proc(visret, off);
  442|  21.6k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (442:21): [True: 8, False: 21.6k]
  ------------------
  443|  21.6k|            } break;
  444|  21.6k|            case MSGPACK_CS_FIXEXT_16: {
  ------------------
  |  Branch (444:13): [True: 3.19k, False: 1.06M]
  ------------------
  445|  3.19k|                bool visret = holder().visitor().visit_ext(n, 16+1);
  446|  3.19k|                parse_return upr = after_visit_proc(visret, off);
  447|  3.19k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (447:21): [True: 8, False: 3.18k]
  ------------------
  448|  3.19k|            } break;
  449|  3.18k|            case MSGPACK_CS_STR_8: {
  ------------------
  |  Branch (449:13): [True: 1.72k, False: 1.06M]
  ------------------
  450|  1.72k|                uint8_t tmp;
  451|  1.72k|                load<uint8_t>(tmp, n);
  452|  1.72k|                m_trail = tmp;
  453|  1.72k|                if(m_trail == 0) {
  ------------------
  |  Branch (453:20): [True: 601, False: 1.12k]
  ------------------
  454|    601|                    bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  455|    601|                    parse_return upr = after_visit_proc(visret, off);
  456|    601|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (456:25): [True: 3, False: 598]
  ------------------
  457|    601|                }
  458|  1.12k|                else {
  459|  1.12k|                    m_cs = MSGPACK_ACS_STR_VALUE;
  460|  1.12k|                    fixed_trail_again = true;
  461|  1.12k|                }
  462|  1.72k|            } break;
  463|  1.73k|            case MSGPACK_CS_BIN_8: {
  ------------------
  |  Branch (463:13): [True: 1.73k, False: 1.06M]
  ------------------
  464|  1.73k|                uint8_t tmp;
  465|  1.73k|                load<uint8_t>(tmp, n);
  466|  1.73k|                m_trail = tmp;
  467|  1.73k|                if(m_trail == 0) {
  ------------------
  |  Branch (467:20): [True: 736, False: 1.00k]
  ------------------
  468|    736|                    bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
  469|    736|                    parse_return upr = after_visit_proc(visret, off);
  470|    736|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (470:25): [True: 8, False: 728]
  ------------------
  471|    736|                }
  472|  1.00k|                else {
  473|  1.00k|                    m_cs = MSGPACK_ACS_BIN_VALUE;
  474|  1.00k|                    fixed_trail_again = true;
  475|  1.00k|                }
  476|  1.73k|            } break;
  477|  2.83k|            case MSGPACK_CS_EXT_8: {
  ------------------
  |  Branch (477:13): [True: 2.83k, False: 1.06M]
  ------------------
  478|  2.83k|                uint8_t tmp;
  479|  2.83k|                load<uint8_t>(tmp, n);
  480|  2.83k|                m_trail = tmp + 1;
  481|  2.83k|                if(m_trail == 0) {
  ------------------
  |  Branch (481:20): [True: 0, False: 2.83k]
  ------------------
  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|  2.83k|                else {
  487|  2.83k|                    m_cs = MSGPACK_ACS_EXT_VALUE;
  488|  2.83k|                    fixed_trail_again = true;
  489|  2.83k|                }
  490|  2.83k|            } break;
  491|  3.05k|            case MSGPACK_CS_STR_16: {
  ------------------
  |  Branch (491:13): [True: 3.05k, False: 1.06M]
  ------------------
  492|  3.05k|                uint16_t tmp;
  493|  3.05k|                load<uint16_t>(tmp, n);
  494|  3.05k|                m_trail = tmp;
  495|  3.05k|                if(m_trail == 0) {
  ------------------
  |  Branch (495:20): [True: 1.01k, False: 2.04k]
  ------------------
  496|  1.01k|                    bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  497|  1.01k|                    parse_return upr = after_visit_proc(visret, off);
  498|  1.01k|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (498:25): [True: 1, False: 1.01k]
  ------------------
  499|  1.01k|                }
  500|  2.04k|                else {
  501|  2.04k|                    m_cs = MSGPACK_ACS_STR_VALUE;
  502|  2.04k|                    fixed_trail_again = true;
  503|  2.04k|                }
  504|  3.05k|            } break;
  505|  3.05k|            case MSGPACK_CS_BIN_16: {
  ------------------
  |  Branch (505:13): [True: 2.16k, False: 1.06M]
  ------------------
  506|  2.16k|                uint16_t tmp;
  507|  2.16k|                load<uint16_t>(tmp, n);
  508|  2.16k|                m_trail = tmp;
  509|  2.16k|                if(m_trail == 0) {
  ------------------
  |  Branch (509:20): [True: 935, False: 1.23k]
  ------------------
  510|    935|                    bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
  511|    935|                    parse_return upr = after_visit_proc(visret, off);
  512|    935|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (512:25): [True: 1, False: 934]
  ------------------
  513|    935|                }
  514|  1.23k|                else {
  515|  1.23k|                    m_cs = MSGPACK_ACS_BIN_VALUE;
  516|  1.23k|                    fixed_trail_again = true;
  517|  1.23k|                }
  518|  2.16k|            } break;
  519|  2.16k|            case MSGPACK_CS_EXT_16: {
  ------------------
  |  Branch (519:13): [True: 1.31k, False: 1.06M]
  ------------------
  520|  1.31k|                uint16_t tmp;
  521|  1.31k|                load<uint16_t>(tmp, n);
  522|  1.31k|                m_trail = tmp + 1;
  523|  1.31k|                if(m_trail == 0) {
  ------------------
  |  Branch (523:20): [True: 0, False: 1.31k]
  ------------------
  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.31k|                else {
  529|  1.31k|                    m_cs = MSGPACK_ACS_EXT_VALUE;
  530|  1.31k|                    fixed_trail_again = true;
  531|  1.31k|                }
  532|  1.31k|            } break;
  533|  1.82k|            case MSGPACK_CS_STR_32: {
  ------------------
  |  Branch (533:13): [True: 1.82k, False: 1.06M]
  ------------------
  534|  1.82k|                uint32_t tmp;
  535|  1.82k|                load<uint32_t>(tmp, n);
  536|  1.82k|                m_trail = tmp;
  537|  1.82k|                if(m_trail == 0) {
  ------------------
  |  Branch (537:20): [True: 737, False: 1.08k]
  ------------------
  538|    737|                    bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  539|    737|                    parse_return upr = after_visit_proc(visret, off);
  540|    737|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (540:25): [True: 1, False: 736]
  ------------------
  541|    737|                }
  542|  1.08k|                else {
  543|  1.08k|                    m_cs = MSGPACK_ACS_STR_VALUE;
  544|  1.08k|                    fixed_trail_again = true;
  545|  1.08k|                }
  546|  1.82k|            } break;
  547|  1.82k|            case MSGPACK_CS_BIN_32: {
  ------------------
  |  Branch (547:13): [True: 724, False: 1.07M]
  ------------------
  548|    724|                uint32_t tmp;
  549|    724|                load<uint32_t>(tmp, n);
  550|    724|                m_trail = tmp;
  551|    724|                if(m_trail == 0) {
  ------------------
  |  Branch (551:20): [True: 469, False: 255]
  ------------------
  552|    469|                    bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
  553|    469|                    parse_return upr = after_visit_proc(visret, off);
  554|    469|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (554:25): [True: 1, False: 468]
  ------------------
  555|    469|                }
  556|    255|                else {
  557|    255|                    m_cs = MSGPACK_ACS_BIN_VALUE;
  558|    255|                    fixed_trail_again = true;
  559|    255|                }
  560|    724|            } break;
  561|  2.39k|            case MSGPACK_CS_EXT_32: {
  ------------------
  |  Branch (561:13): [True: 2.39k, False: 1.06M]
  ------------------
  562|  2.39k|                uint32_t tmp;
  563|  2.39k|                load<uint32_t>(tmp, n);
  564|  2.39k|                check_ext_size<sizeof(std::size_t)>(tmp);
  565|  2.39k|                m_trail = tmp;
  566|  2.39k|                ++m_trail;
  567|  2.39k|                if(m_trail == 0) {
  ------------------
  |  Branch (567:20): [True: 0, False: 2.39k]
  ------------------
  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|  2.39k|                else {
  573|  2.39k|                    m_cs = MSGPACK_ACS_EXT_VALUE;
  574|  2.39k|                    fixed_trail_again = true;
  575|  2.39k|                }
  576|  2.39k|            } break;
  577|  10.4k|            case MSGPACK_ACS_STR_VALUE: {
  ------------------
  |  Branch (577:13): [True: 10.4k, False: 1.06M]
  ------------------
  578|  10.4k|                bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  579|  10.4k|                parse_return upr = after_visit_proc(visret, off);
  580|  10.4k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (580:21): [True: 58, False: 10.4k]
  ------------------
  581|  10.4k|            } break;
  582|  10.4k|            case MSGPACK_ACS_BIN_VALUE: {
  ------------------
  |  Branch (582:13): [True: 2.38k, False: 1.06M]
  ------------------
  583|  2.38k|                bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
  584|  2.38k|                parse_return upr = after_visit_proc(visret, off);
  585|  2.38k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (585:21): [True: 39, False: 2.34k]
  ------------------
  586|  2.38k|            } break;
  587|  6.52k|            case MSGPACK_ACS_EXT_VALUE: {
  ------------------
  |  Branch (587:13): [True: 6.52k, False: 1.06M]
  ------------------
  588|  6.52k|                bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
  589|  6.52k|                parse_return upr = after_visit_proc(visret, off);
  590|  6.52k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (590:21): [True: 40, False: 6.48k]
  ------------------
  591|  6.52k|            } break;
  592|  20.3k|            case MSGPACK_CS_ARRAY_16: {
  ------------------
  |  Branch (592:13): [True: 20.3k, False: 1.05M]
  ------------------
  593|  20.3k|                parse_return ret = start_aggregate<uint16_t>(array_sv(holder()), array_ev(holder()), n, off);
  594|  20.3k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (594:21): [True: 1, False: 20.3k]
  ------------------
  595|       |
  596|  20.3k|            } break;
  597|  20.3k|            case MSGPACK_CS_ARRAY_32: {
  ------------------
  |  Branch (597:13): [True: 1.97k, False: 1.06M]
  ------------------
  598|  1.97k|                parse_return ret = start_aggregate<uint32_t>(array_sv(holder()), array_ev(holder()), n, off);
  599|  1.97k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (599:21): [True: 1, False: 1.96k]
  ------------------
  600|  1.97k|            } break;
  601|  3.65k|            case MSGPACK_CS_MAP_16: {
  ------------------
  |  Branch (601:13): [True: 3.65k, False: 1.06M]
  ------------------
  602|  3.65k|                parse_return ret = start_aggregate<uint16_t>(map_sv(holder()), map_ev(holder()), n, off);
  603|  3.65k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (603:21): [True: 1, False: 3.65k]
  ------------------
  604|  3.65k|            } break;
  605|  3.65k|            case MSGPACK_CS_MAP_32: {
  ------------------
  |  Branch (605:13): [True: 2.21k, False: 1.06M]
  ------------------
  606|  2.21k|                parse_return ret = start_aggregate<uint32_t>(map_sv(holder()), map_ev(holder()), n, off);
  607|  2.21k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (607:21): [True: 1, False: 2.21k]
  ------------------
  608|  2.21k|            } break;
  609|  2.21k|            default:
  ------------------
  |  Branch (609:13): [True: 0, False: 1.07M]
  ------------------
  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|  1.07M|            }
  614|  1.07M|        }
  615|  2.64M|    } while(m_current != pe);
  ------------------
  |  Branch (615:13): [True: 2.64M, False: 686]
  ------------------
  616|       |
  617|    686|    off = static_cast<std::size_t>(m_current - m_start);
  618|    686|    return PARSE_CONTINUE;
  619|  2.25k|}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6holderEv:
   60|  5.52M|    VisitorHolder& holder() {
   61|  5.52M|        return static_cast<VisitorHolder&>(*this);
   62|  5.52M|    }
_ZNK7msgpack2v26detail12parse_helperINS1_21create_object_visitorEE7visitorEv:
 1028|  8.12M|    Visitor& visitor() const { return m_visitor; }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE16after_visit_procEbRm:
  103|  2.37M|    parse_return after_visit_proc(bool visit_result, std::size_t& off) {
  104|  2.37M|        ++m_current;
  105|  2.37M|        if (!visit_result) {
  ------------------
  |  Branch (105:13): [True: 0, False: 2.37M]
  ------------------
  106|      0|            off = static_cast<std::size_t>(m_current - m_start);
  107|      0|            return PARSE_STOP_VISITOR;
  108|      0|        }
  109|  2.37M|        parse_return ret = m_stack.consume(holder());
  110|  2.37M|        if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (110:13): [True: 1.09k, False: 2.37M]
  ------------------
  111|  1.09k|            off = static_cast<std::size_t>(m_current - m_start);
  112|  1.09k|        }
  113|  2.37M|        m_cs = MSGPACK_CS_HEADER;
  114|  2.37M|        return ret;
  115|  2.37M|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE12unpack_stack7consumeERS5_:
  175|  2.46M|        parse_return consume(VisitorHolder& visitor_holder) {
  176|  2.61M|            while (!m_stack.empty()) {
  ------------------
  |  Branch (176:20): [True: 2.61M, False: 1.16k]
  ------------------
  177|  2.61M|                stack_elem& e = m_stack.back();
  178|  2.61M|                switch (e.m_type) {
  ------------------
  |  Branch (178:25): [True: 0, False: 2.61M]
  ------------------
  179|   912k|                case MSGPACK_CT_ARRAY_ITEM:
  ------------------
  |  Branch (179:17): [True: 912k, False: 1.70M]
  ------------------
  180|   912k|                    if (!visitor_holder.visitor().end_array_item()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (180:25): [True: 0, False: 912k]
  ------------------
  181|   912k|                    if (--e.m_rest == 0)  {
  ------------------
  |  Branch (181:25): [True: 63.6k, False: 848k]
  ------------------
  182|  63.6k|                        m_stack.pop_back();
  183|  63.6k|                        if (!visitor_holder.visitor().end_array()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (183:29): [True: 0, False: 63.6k]
  ------------------
  184|  63.6k|                    }
  185|   848k|                    else {
  186|   848k|                        if (!visitor_holder.visitor().start_array_item()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (186:29): [True: 0, False: 848k]
  ------------------
  187|   848k|                        return PARSE_CONTINUE;
  188|   848k|                    }
  189|  63.6k|                    break;
  190|   853k|                case MSGPACK_CT_MAP_KEY:
  ------------------
  |  Branch (190:17): [True: 853k, False: 1.76M]
  ------------------
  191|   853k|                    if (!visitor_holder.visitor().end_map_key()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (191:25): [True: 0, False: 853k]
  ------------------
  192|   853k|                    if (!visitor_holder.visitor().start_map_value()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (192:25): [True: 0, False: 853k]
  ------------------
  193|   853k|                    e.m_type = MSGPACK_CT_MAP_VALUE;
  194|   853k|                    return PARSE_CONTINUE;
  195|   852k|                case MSGPACK_CT_MAP_VALUE:
  ------------------
  |  Branch (195:17): [True: 852k, False: 1.76M]
  ------------------
  196|   852k|                    if (!visitor_holder.visitor().end_map_value()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (196:25): [True: 0, False: 852k]
  ------------------
  197|   852k|                    if (--e.m_rest == 0) {
  ------------------
  |  Branch (197:25): [True: 88.0k, False: 764k]
  ------------------
  198|  88.0k|                        m_stack.pop_back();
  199|  88.0k|                        if (!visitor_holder.visitor().end_map()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (199:29): [True: 0, False: 88.0k]
  ------------------
  200|  88.0k|                    }
  201|   764k|                    else {
  202|   764k|                        e.m_type = MSGPACK_CT_MAP_KEY;
  203|   764k|                        if (!visitor_holder.visitor().start_map_key()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (203:29): [True: 0, False: 764k]
  ------------------
  204|   764k|                        return PARSE_CONTINUE;
  205|   764k|                    }
  206|  88.0k|                    break;
  207|  2.61M|                }
  208|  2.61M|            }
  209|  1.16k|            return PARSE_SUCCESS;
  210|  2.46M|        }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE7next_csIPKcEEjT_:
   56|  1.05M|    {
   57|  1.05M|        return static_cast<uint32_t>(*p) & 0x1f;
   58|  1.05M|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateINS_2v16detail7fix_tagENS6_8array_svENS6_8array_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  61.1k|        std::size_t& off) {
   70|  61.1k|        typename value<T>::type size;
   71|  61.1k|        load<T>(size, load_pos);
   72|  61.1k|        ++m_current;
   73|  61.1k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 8.02k, False: 53.1k]
  ------------------
   74|  8.02k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 8.02k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  8.02k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 8.02k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  8.02k|            parse_return ret = m_stack.consume(holder());
   83|  8.02k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 29, False: 7.99k]
  ------------------
   84|     29|                off = static_cast<std::size_t>(m_current - m_start);
   85|     29|                return ret;
   86|     29|            }
   87|  8.02k|        }
   88|  53.1k|        else {
   89|  53.1k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 53.1k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|  53.1k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|  53.1k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 53.1k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|  53.1k|        }
   99|  61.1k|        m_cs = MSGPACK_CS_HEADER;
  100|  61.1k|        return PARSE_CONTINUE;
  101|  61.1k|    }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_svclEj:
  119|  83.4k|        bool operator()(uint32_t size) const {
  120|  83.4k|            return m_visitor_holder.visitor().start_array(size);
  121|  83.4k|        }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_evclEv:
  128|  12.1k|        bool operator()() const {
  129|  12.1k|            return m_visitor_holder.visitor().end_array();
  130|  12.1k|        }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE12unpack_stack4pushERS5_22msgpack_container_typej:
  161|   166k|        parse_return push(VisitorHolder& visitor_holder, msgpack_container_type type, uint32_t rest) {
  162|   166k|            m_stack.push_back(stack_elem(type, rest));
  163|   166k|            switch (type) {
  ------------------
  |  Branch (163:21): [True: 0, False: 166k]
  ------------------
  164|  71.2k|            case MSGPACK_CT_ARRAY_ITEM:
  ------------------
  |  Branch (164:13): [True: 71.2k, False: 95.7k]
  ------------------
  165|  71.2k|                return visitor_holder.visitor().start_array_item() ? PARSE_CONTINUE : PARSE_STOP_VISITOR;
  ------------------
  |  Branch (165:24): [True: 71.2k, False: 0]
  ------------------
  166|  95.7k|            case MSGPACK_CT_MAP_KEY:
  ------------------
  |  Branch (166:13): [True: 95.7k, False: 71.2k]
  ------------------
  167|  95.7k|                return visitor_holder.visitor().start_map_key() ? PARSE_CONTINUE : PARSE_STOP_VISITOR;
  ------------------
  |  Branch (167:24): [True: 95.7k, False: 0]
  ------------------
  168|      0|            case MSGPACK_CT_MAP_VALUE:
  ------------------
  |  Branch (168:13): [True: 0, False: 166k]
  ------------------
  169|      0|                MSGPACK_ASSERT(0);
  ------------------
  |  |   22|      0|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  170|      0|                return PARSE_STOP_VISITOR;
  171|   166k|            }
  172|      0|            MSGPACK_ASSERT(0);
  ------------------
  |  |   22|      0|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  173|      0|            return PARSE_STOP_VISITOR;
  174|      0|        }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE12unpack_stack10stack_elemC2E22msgpack_container_typej:
  154|   166k|            stack_elem(msgpack_container_type type, uint32_t rest):m_type(type), m_rest(rest) {}
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_sv4typeEv:
  122|  71.2k|        msgpack_container_type type() const { return MSGPACK_CT_ARRAY_ITEM; }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_svC2ERS5_:
  118|  83.4k|        array_sv(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_evC2ERS5_:
  127|  83.4k|        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|   167k|        std::size_t& off) {
   70|   167k|        typename value<T>::type size;
   71|   167k|        load<T>(size, load_pos);
   72|   167k|        ++m_current;
   73|   167k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 75.3k, False: 92.4k]
  ------------------
   74|  75.3k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 75.3k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  75.3k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 75.3k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  75.3k|            parse_return ret = m_stack.consume(holder());
   83|  75.3k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 30, False: 75.3k]
  ------------------
   84|     30|                off = static_cast<std::size_t>(m_current - m_start);
   85|     30|                return ret;
   86|     30|            }
   87|  75.3k|        }
   88|  92.4k|        else {
   89|  92.4k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 92.4k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|  92.4k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|  92.4k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 92.4k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|  92.4k|        }
   99|   167k|        m_cs = MSGPACK_CS_HEADER;
  100|   167k|        return PARSE_CONTINUE;
  101|   167k|    }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_svclEj:
  136|   173k|        bool operator()(uint32_t size) const {
  137|   173k|            return m_visitor_holder.visitor().start_map(size);
  138|   173k|        }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_evclEv:
  145|  77.8k|        bool operator()() const {
  146|  77.8k|            return m_visitor_holder.visitor().end_map();
  147|  77.8k|        }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_sv4typeEv:
  139|  95.7k|        msgpack_container_type type() const { return MSGPACK_CT_MAP_KEY; }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_svC2ERS5_:
  135|   173k|        map_sv(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_evC2ERS5_:
  144|   173k|        map_ev(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
_ZN7msgpack2v26detail14check_ext_sizeILm8EEEvm:
  227|  2.39k|inline void check_ext_size(std::size_t /*size*/) {
  228|  2.39k|}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateItNS6_8array_svENS6_8array_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  20.3k|        std::size_t& off) {
   70|  20.3k|        typename value<T>::type size;
   71|  20.3k|        load<T>(size, load_pos);
   72|  20.3k|        ++m_current;
   73|  20.3k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 3.62k, False: 16.7k]
  ------------------
   74|  3.62k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 3.62k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  3.62k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 3.62k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  3.62k|            parse_return ret = m_stack.consume(holder());
   83|  3.62k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 1, False: 3.62k]
  ------------------
   84|      1|                off = static_cast<std::size_t>(m_current - m_start);
   85|      1|                return ret;
   86|      1|            }
   87|  3.62k|        }
   88|  16.7k|        else {
   89|  16.7k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 16.7k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|  16.7k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|  16.7k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 16.7k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|  16.7k|        }
   99|  20.3k|        m_cs = MSGPACK_CS_HEADER;
  100|  20.3k|        return PARSE_CONTINUE;
  101|  20.3k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateIjNS6_8array_svENS6_8array_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  1.97k|        std::size_t& off) {
   70|  1.97k|        typename value<T>::type size;
   71|  1.97k|        load<T>(size, load_pos);
   72|  1.97k|        ++m_current;
   73|  1.97k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 539, False: 1.43k]
  ------------------
   74|    539|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 539]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|    539|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 539]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|    539|            parse_return ret = m_stack.consume(holder());
   83|    539|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 1, False: 538]
  ------------------
   84|      1|                off = static_cast<std::size_t>(m_current - m_start);
   85|      1|                return ret;
   86|      1|            }
   87|    539|        }
   88|  1.43k|        else {
   89|  1.43k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 1.43k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|  1.43k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|  1.43k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 1.43k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|  1.43k|        }
   99|  1.96k|        m_cs = MSGPACK_CS_HEADER;
  100|  1.96k|        return PARSE_CONTINUE;
  101|  1.97k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateItNS6_6map_svENS6_6map_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  3.65k|        std::size_t& off) {
   70|  3.65k|        typename value<T>::type size;
   71|  3.65k|        load<T>(size, load_pos);
   72|  3.65k|        ++m_current;
   73|  3.65k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 700, False: 2.95k]
  ------------------
   74|    700|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 700]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|    700|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 700]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|    700|            parse_return ret = m_stack.consume(holder());
   83|    700|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 1, False: 699]
  ------------------
   84|      1|                off = static_cast<std::size_t>(m_current - m_start);
   85|      1|                return ret;
   86|      1|            }
   87|    700|        }
   88|  2.95k|        else {
   89|  2.95k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 2.95k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|  2.95k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|  2.95k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 2.95k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|  2.95k|        }
   99|  3.65k|        m_cs = MSGPACK_CS_HEADER;
  100|  3.65k|        return PARSE_CONTINUE;
  101|  3.65k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateIjNS6_6map_svENS6_6map_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  2.21k|        std::size_t& off) {
   70|  2.21k|        typename value<T>::type size;
   71|  2.21k|        load<T>(size, load_pos);
   72|  2.21k|        ++m_current;
   73|  2.21k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 1.76k, False: 452]
  ------------------
   74|  1.76k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 1.76k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  1.76k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 1.76k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  1.76k|            parse_return ret = m_stack.consume(holder());
   83|  1.76k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 1, False: 1.76k]
  ------------------
   84|      1|                off = static_cast<std::size_t>(m_current - m_start);
   85|      1|                return ret;
   86|      1|            }
   87|  1.76k|        }
   88|    452|        else {
   89|    452|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 452]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|    452|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|    452|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 452]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|    452|        }
   99|  2.21k|        m_cs = MSGPACK_CS_HEADER;
  100|  2.21k|        return PARSE_CONTINUE;
  101|  2.21k|    }

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

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