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.05k|  }
   26|  2.25k|  return 0;
   27|  2.25k|}

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

_ZN7msgpack2v16detail20check_container_sizeILm8EEEvm:
   34|  17.4k|inline void check_container_size(std::size_t size) {
   35|  17.4k|    if (size > 0xffffffff) throw container_size_overflow("container size overflow");
  ------------------
  |  Branch (35:9): [True: 0, False: 17.4k]
  ------------------
   36|  17.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:
  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) {}
_ZN7msgpack2v14zone10chunk_listD2Ev:
  125|  2.25k|        {
  126|  2.25k|            chunk* c = m_head;
  127|  13.6k|            while(c) {
  ------------------
  |  Branch (127:19): [True: 11.3k, False: 2.25k]
  ------------------
  128|  11.3k|                chunk* n = c->m_next;
  129|  11.3k|                ::free(c);
  130|  11.3k|                c = n;
  131|  11.3k|            }
  132|  2.25k|        }
_ZN7msgpack2v14zonedlEPv:
  196|  2.25k|    {
  197|  2.25k|        ::free(p);
  198|  2.25k|    }
_ZN7msgpack2v14zone14allocate_alignEmm:
  243|   432k|{
  244|   432k|    char* aligned = get_aligned(m_chunk_list.m_ptr, align);
  245|   432k|    size_t adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
  246|   432k|    if (m_chunk_list.m_free < adjusted_size) {
  ------------------
  |  Branch (246:9): [True: 9.11k, False: 423k]
  ------------------
  247|  9.11k|        size_t enough_size = size + align - 1;
  248|  9.11k|        char* ptr = allocate_expand(enough_size);
  249|  9.11k|        aligned = get_aligned(ptr, align);
  250|  9.11k|        adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
  251|  9.11k|    }
  252|   432k|    m_chunk_list.m_free -= adjusted_size;
  253|   432k|    m_chunk_list.m_ptr  += adjusted_size;
  254|   432k|    return aligned;
  255|   432k|}
_ZN7msgpack2v14zone11get_alignedEPcm:
  234|   442k|{
  235|   442k|    MSGPACK_ASSERT(align != 0 && (align & (align - 1)) == 0); // align must be 2^n (n >= 0)
  ------------------
  |  |   22|   442k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  236|      0|    return
  237|   442k|        reinterpret_cast<char*>(
  238|   442k|            reinterpret_cast<uintptr_t>(ptr + (align - 1)) & ~static_cast<uintptr_t>(align - 1)
  239|   442k|        );
  240|   442k|}
_ZN7msgpack2v14zone15allocate_expandEm:
  270|  9.11k|{
  271|  9.11k|    chunk_list* const cl = &m_chunk_list;
  272|       |
  273|  9.11k|    size_t sz = m_chunk_size;
  274|       |
  275|  12.3k|    while(sz < size) {
  ------------------
  |  Branch (275:11): [True: 3.19k, False: 9.11k]
  ------------------
  276|  3.19k|        size_t tmp_sz = sz * 2;
  277|  3.19k|        if (tmp_sz <= sz) {
  ------------------
  |  Branch (277:13): [True: 0, False: 3.19k]
  ------------------
  278|      0|            sz = size;
  279|      0|            break;
  280|      0|        }
  281|  3.19k|        sz = tmp_sz;
  282|  3.19k|    }
  283|       |
  284|  9.11k|    chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
  285|  9.11k|    if (!c) throw std::bad_alloc();
  ------------------
  |  Branch (285:9): [True: 0, False: 9.11k]
  ------------------
  286|       |
  287|  9.11k|    char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
  288|       |
  289|  9.11k|    c->m_next  = cl->m_head;
  290|  9.11k|    cl->m_head = c;
  291|  9.11k|    cl->m_free = sz;
  292|  9.11k|    cl->m_ptr  = ptr;
  293|       |
  294|  9.11k|    return ptr;
  295|  9.11k|}
_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.50k|{
 1141|  4.50k|    type = msgpack::type::NIL;
 1142|  4.50k|}
_ZN7msgpack2v113object_handleC2ERKNS_2v26objectEONSt3__110unique_ptrINS0_4zoneENS6_14default_deleteIS8_EEEE:
   62|  1.19k|        m_obj(obj), m_zone(msgpack::move(z)) { }
_ZNK7msgpack2v113object_handle3getEv:
   72|  1.19k|        { return m_obj; }
_ZN7msgpack2v16packerINS0_7sbufferEE4packINS_2v26objectEEERS3_RKT_:
  876|  1.19k|{
  877|  1.19k|    msgpack::operator<<(*this, v);
  878|  1.19k|    return *this;
  879|  1.19k|}
_ZNK7msgpack2v17adaptor4packINS_2v26objectEvEclINS0_7sbufferEEERNS0_6packerIT_EESB_RKS4_:
  680|  1.19k|    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, msgpack::object const& v) const {
  681|  1.19k|        object_pack_visitor<Stream> vis(o);
  682|  1.19k|        msgpack::object_parser(v).parse(vis);
  683|  1.19k|        return o;
  684|  1.19k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEEC2ERNS0_6packerIS2_EE:
  318|  1.19k|        :m_packer(pk) {}
_ZN7msgpack2v113object_parserC2ERKNS_2v26objectE:
  236|  1.19k|    explicit object_parser(msgpack::object const& obj):m_current(&obj) {}
_ZN7msgpack2v113object_parser5parseINS0_19object_pack_visitorINS0_7sbufferEEEEEvRT_:
  238|  1.19k|    void parse(Visitor& v) {
  239|  1.27M|        while (true) {
  ------------------
  |  Branch (239:16): [Folded - Ignored]
  ------------------
  240|  1.27M|            bool start_collection = false;
  241|  1.27M|            switch(m_current->type) {
  242|  3.06k|            case msgpack::type::NIL:
  ------------------
  |  Branch (242:13): [True: 3.06k, False: 1.26M]
  ------------------
  243|  3.06k|                if (!v.visit_nil()) return;
  ------------------
  |  Branch (243:21): [True: 0, False: 3.06k]
  ------------------
  244|  3.06k|                break;
  245|  5.96k|            case msgpack::type::BOOLEAN:
  ------------------
  |  Branch (245:13): [True: 5.96k, False: 1.26M]
  ------------------
  246|  5.96k|                if (!v.visit_boolean(m_current->via.boolean)) return;
  ------------------
  |  Branch (246:21): [True: 0, False: 5.96k]
  ------------------
  247|  5.96k|                break;
  248|   431k|            case msgpack::type::POSITIVE_INTEGER:
  ------------------
  |  Branch (248:13): [True: 431k, False: 839k]
  ------------------
  249|   431k|                if (!v.visit_positive_integer(m_current->via.u64)) return;
  ------------------
  |  Branch (249:21): [True: 0, False: 431k]
  ------------------
  250|   431k|                break;
  251|   431k|            case msgpack::type::NEGATIVE_INTEGER:
  ------------------
  |  Branch (251:13): [True: 105k, False: 1.16M]
  ------------------
  252|   105k|                if (!v.visit_negative_integer(m_current->via.i64)) return;
  ------------------
  |  Branch (252:21): [True: 0, False: 105k]
  ------------------
  253|   105k|                break;
  254|   461k|            case msgpack::type::FLOAT32:
  ------------------
  |  Branch (254:13): [True: 461k, False: 809k]
  ------------------
  255|   461k|                if (!v.visit_float32(static_cast<float>(m_current->via.f64))) return;
  ------------------
  |  Branch (255:21): [True: 0, False: 461k]
  ------------------
  256|   461k|                break;
  257|   461k|            case msgpack::type::FLOAT64:
  ------------------
  |  Branch (257:13): [True: 17.3k, False: 1.25M]
  ------------------
  258|  17.3k|                if (!v.visit_float64(m_current->via.f64)) return;
  ------------------
  |  Branch (258:21): [True: 0, False: 17.3k]
  ------------------
  259|  17.3k|                break;
  260|  17.3k|            case msgpack::type::STR:
  ------------------
  |  Branch (260:13): [True: 14.7k, False: 1.25M]
  ------------------
  261|  14.7k|                if (!v.visit_str(m_current->via.str.ptr, m_current->via.str.size)) return;
  ------------------
  |  Branch (261:21): [True: 0, False: 14.7k]
  ------------------
  262|  14.7k|                break;
  263|  14.7k|            case msgpack::type::BIN:
  ------------------
  |  Branch (263:13): [True: 2.35k, False: 1.26M]
  ------------------
  264|  2.35k|                if (!v.visit_bin(m_current->via.bin.ptr, m_current->via.bin.size)) return;
  ------------------
  |  Branch (264:21): [True: 0, False: 2.35k]
  ------------------
  265|  2.35k|                break;
  266|  17.4k|            case msgpack::type::EXT:
  ------------------
  |  Branch (266:13): [True: 17.4k, False: 1.25M]
  ------------------
  267|  17.4k|                msgpack::detail::check_container_size<sizeof(std::size_t)>(m_current->via.ext.size);
  268|  17.4k|                if (!v.visit_ext(m_current->via.ext.ptr, m_current->via.ext.size + 1)) return;
  ------------------
  |  Branch (268:21): [True: 0, False: 17.4k]
  ------------------
  269|  17.4k|                break;
  270|  83.8k|            case msgpack::type::ARRAY:
  ------------------
  |  Branch (270:13): [True: 83.8k, False: 1.18M]
  ------------------
  271|  83.8k|                if (!v.start_array(m_current->via.array.size)) return;
  ------------------
  |  Branch (271:21): [True: 0, False: 83.8k]
  ------------------
  272|  83.8k|                m_ctx.push_back(elem(m_current->via.array.ptr, m_current->via.array.size));
  273|  83.8k|                start_collection = m_current->via.array.size != 0;
  274|  83.8k|                if (start_collection) {
  ------------------
  |  Branch (274:21): [True: 68.5k, False: 15.2k]
  ------------------
  275|  68.5k|                    if (!v.start_array_item()) return;
  ------------------
  |  Branch (275:25): [True: 0, False: 68.5k]
  ------------------
  276|  68.5k|                }
  277|  83.8k|                break;
  278|   128k|            case msgpack::type::MAP:
  ------------------
  |  Branch (278:13): [True: 128k, False: 1.14M]
  ------------------
  279|   128k|                if (!v.start_map(m_current->via.map.size)) return;
  ------------------
  |  Branch (279:21): [True: 0, False: 128k]
  ------------------
  280|   128k|                m_ctx.push_back(elem(m_current->via.map.ptr, m_current->via.map.size));
  281|   128k|                start_collection = m_current->via.map.size != 0;
  282|   128k|                if (start_collection) {
  ------------------
  |  Branch (282:21): [True: 115k, False: 12.8k]
  ------------------
  283|   115k|                    if (!v.start_map_key()) return;
  ------------------
  |  Branch (283:25): [True: 0, False: 115k]
  ------------------
  284|   115k|                }
  285|   128k|                break;
  286|   128k|            default:
  ------------------
  |  Branch (286:13): [True: 0, False: 1.27M]
  ------------------
  287|      0|                throw msgpack::type_error();
  288|      0|                break;
  289|  1.27M|            }
  290|  1.27M|            if (m_ctx.empty()) return;
  ------------------
  |  Branch (290:17): [True: 710, False: 1.27M]
  ------------------
  291|  1.27M|            if (!start_collection) {
  ------------------
  |  Branch (291:17): [True: 1.08M, False: 183k]
  ------------------
  292|  1.29M|                while (true) {
  ------------------
  |  Branch (292:24): [Folded - Ignored]
  ------------------
  293|  1.29M|                    next_ret r = m_ctx.back().next(v);
  294|  1.29M|                    if (r == finish) {
  ------------------
  |  Branch (294:25): [True: 211k, False: 1.08M]
  ------------------
  295|   211k|                        m_ctx.pop_back();
  296|   211k|                        if (m_ctx.empty()) return;
  ------------------
  |  Branch (296:29): [True: 487, False: 211k]
  ------------------
  297|   211k|                    }
  298|  1.08M|                    else if (r == cont) {
  ------------------
  |  Branch (298:30): [True: 1.08M, False: 0]
  ------------------
  299|  1.08M|                        break;
  300|  1.08M|                    }
  301|      0|                    else {
  302|       |                        // abort
  303|      0|                        return;
  304|      0|                    }
  305|  1.29M|                }
  306|  1.08M|            }
  307|  1.27M|            m_current = &m_ctx.back().get();
  308|  1.27M|        }
  309|  1.19k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE9visit_nilEv:
  319|  3.06k|    bool visit_nil() {
  320|  3.06k|        m_packer.pack_nil();
  321|  3.06k|        return true;
  322|  3.06k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE13visit_booleanEb:
  323|  5.96k|    bool visit_boolean(bool v) {
  324|  5.96k|        if (v) m_packer.pack_true();
  ------------------
  |  Branch (324:13): [True: 4.78k, False: 1.18k]
  ------------------
  325|  1.18k|        else m_packer.pack_false();
  326|  5.96k|        return true;
  327|  5.96k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE22visit_positive_integerEm:
  328|   431k|    bool visit_positive_integer(uint64_t v) {
  329|   431k|        m_packer.pack_uint64(v);
  330|   431k|        return true;
  331|   431k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE22visit_negative_integerEl:
  332|   105k|    bool visit_negative_integer(int64_t v) {
  333|   105k|        m_packer.pack_int64(v);
  334|   105k|        return true;
  335|   105k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE13visit_float32Ef:
  336|   461k|    bool visit_float32(float v) {
  337|   461k|        m_packer.pack_float(v);
  338|   461k|        return true;
  339|   461k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE13visit_float64Ed:
  340|  17.3k|    bool visit_float64(double v) {
  341|  17.3k|        m_packer.pack_double(v);
  342|  17.3k|        return true;
  343|  17.3k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE9visit_strEPKcj:
  344|  14.7k|    bool visit_str(const char* v, uint32_t size) {
  345|  14.7k|        m_packer.pack_str(size);
  346|  14.7k|        m_packer.pack_str_body(v, size);
  347|  14.7k|        return true;
  348|  14.7k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE9visit_binEPKcj:
  349|  2.35k|    bool visit_bin(const char* v, uint32_t size) {
  350|  2.35k|        m_packer.pack_bin(size);
  351|  2.35k|        m_packer.pack_bin_body(v, size);
  352|  2.35k|        return true;
  353|  2.35k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE9visit_extEPKcj:
  354|  17.4k|    bool visit_ext(const char* v, uint32_t size) {
  355|  17.4k|        m_packer.pack_ext(size - 1, static_cast<int8_t>(*v));
  356|  17.4k|        m_packer.pack_ext_body(v + 1, size - 1);
  357|  17.4k|        return true;
  358|  17.4k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE11start_arrayEj:
  359|  83.8k|    bool start_array(uint32_t num_elements) {
  360|  83.8k|        m_packer.pack_array(num_elements);
  361|  83.8k|        return true;
  362|  83.8k|    }
_ZN7msgpack2v113object_parser4elemC2EPKNS_2v26objectEm:
  160|  83.8k|            : rest(r), is_map(false), is_key(false) {
  161|  83.8k|            as.obj_ptr = p;
  162|  83.8k|        }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE16start_array_itemEv:
  363|   396k|    bool start_array_item() {
  364|   396k|        return true;
  365|   396k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE9start_mapEj:
  372|   128k|    bool start_map(uint32_t num_kv_pairs) {
  373|   128k|        m_packer.pack_map(num_kv_pairs);
  374|   128k|        return true;
  375|   128k|    }
_ZN7msgpack2v113object_parser4elemC2EPKNS0_9object_kvEm:
  165|   128k|            : rest(r), is_map(true), is_key(true) {
  166|   128k|            as.kv_ptr = p;
  167|   128k|        }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE13start_map_keyEv:
  376|   436k|    bool start_map_key() {
  377|   436k|        return true;
  378|   436k|    }
_ZN7msgpack2v113object_parser4elem4nextINS0_19object_pack_visitorINS0_7sbufferEEEEENS1_8next_retERT_:
  184|  1.29M|        next_ret next(Visitor& v) {
  185|  1.29M|            if (rest == 0) {
  ------------------
  |  Branch (185:17): [True: 28.1k, False: 1.27M]
  ------------------
  186|  28.1k|                if (is_map) {
  ------------------
  |  Branch (186:21): [True: 12.8k, False: 15.2k]
  ------------------
  187|  12.8k|                    if (!v.end_map()) return abort;
  ------------------
  |  Branch (187:25): [True: 0, False: 12.8k]
  ------------------
  188|  12.8k|                }
  189|  15.2k|                else {
  190|  15.2k|                    if (!v.end_array()) return abort;
  ------------------
  |  Branch (190:25): [True: 0, False: 15.2k]
  ------------------
  191|  15.2k|                }
  192|  28.1k|                return finish;
  193|  28.1k|            }
  194|  1.27M|            else {
  195|  1.27M|                if (is_map) {
  ------------------
  |  Branch (195:21): [True: 873k, False: 396k]
  ------------------
  196|   873k|                    if (is_key) {
  ------------------
  |  Branch (196:25): [True: 436k, False: 436k]
  ------------------
  197|   436k|                        if (!v.end_map_key()) return abort;
  ------------------
  |  Branch (197:29): [True: 0, False: 436k]
  ------------------
  198|   436k|                        if (!v.start_map_value()) return abort;
  ------------------
  |  Branch (198:29): [True: 0, False: 436k]
  ------------------
  199|   436k|                        is_key = false;
  200|   436k|                    }
  201|   436k|                    else {
  202|   436k|                        if (!v.end_map_value()) return abort;
  ------------------
  |  Branch (202:29): [True: 0, False: 436k]
  ------------------
  203|   436k|                        --rest;
  204|   436k|                        if (rest == 0) {
  ------------------
  |  Branch (204:29): [True: 115k, False: 321k]
  ------------------
  205|   115k|                            if (!v.end_map()) return abort;
  ------------------
  |  Branch (205:33): [True: 0, False: 115k]
  ------------------
  206|   115k|                            return finish;
  207|   115k|                        }
  208|   321k|                        if (!v.start_map_key()) return abort;
  ------------------
  |  Branch (208:29): [True: 0, False: 321k]
  ------------------
  209|   321k|                        ++as.kv_ptr;
  210|   321k|                        is_key = true;
  211|   321k|                    }
  212|   873k|                }
  213|   396k|                else {
  214|   396k|                    if (!v.end_array_item()) return abort;
  ------------------
  |  Branch (214:25): [True: 0, False: 396k]
  ------------------
  215|   396k|                    --rest;
  216|   396k|                    if (rest == 0) {
  ------------------
  |  Branch (216:25): [True: 68.5k, False: 328k]
  ------------------
  217|  68.5k|                        if (!v.end_array()) return abort;
  ------------------
  |  Branch (217:29): [True: 0, False: 68.5k]
  ------------------
  218|  68.5k|                        return finish;
  219|  68.5k|                    }
  220|   328k|                    if (!v.start_array_item()) return abort;
  ------------------
  |  Branch (220:25): [True: 0, False: 328k]
  ------------------
  221|   328k|                    ++as.obj_ptr;
  222|   328k|                }
  223|  1.08M|                return cont;
  224|  1.27M|            }
  225|  1.29M|        }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE7end_mapEv:
  388|   128k|    bool end_map() {
  389|   128k|        return true;
  390|   128k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE9end_arrayEv:
  369|  83.8k|    bool end_array() {
  370|  83.8k|        return true;
  371|  83.8k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE11end_map_keyEv:
  379|   436k|    bool end_map_key() {
  380|   436k|        return true;
  381|   436k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE15start_map_valueEv:
  382|   436k|    bool start_map_value() {
  383|   436k|        return true;
  384|   436k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE13end_map_valueEv:
  385|   436k|    bool end_map_value() {
  386|   436k|        return true;
  387|   436k|    }
_ZN7msgpack2v119object_pack_visitorINS0_7sbufferEE14end_array_itemEv:
  366|   396k|    bool end_array_item() {
  367|   396k|        return true;
  368|   396k|    }
_ZNK7msgpack2v113object_parser4elem3getEv:
  169|  1.27M|        msgpack::object const& get() const {
  170|  1.27M|            if (is_map) {
  ------------------
  |  Branch (170:17): [True: 873k, False: 396k]
  ------------------
  171|   873k|                if (is_key) {
  ------------------
  |  Branch (171:21): [True: 436k, False: 436k]
  ------------------
  172|   436k|                    return as.kv_ptr->key;
  173|   436k|                }
  174|   436k|                else {
  175|   436k|                    return as.kv_ptr->val;
  176|   436k|                }
  177|   873k|            }
  178|   396k|            else {
  179|   396k|                return *as.obj_ptr;
  180|   396k|            }
  181|  1.27M|        }

_ZN7msgpack2v14packINS0_7sbufferENS_2v26objectEEEvRT_RKT0_:
  674|  1.19k|{
  675|  1.19k|    packer<Stream>(s).pack(v);
  676|  1.19k|}
_ZN7msgpack2v16packerINS0_7sbufferEEC2ERS2_:
  724|  1.19k|inline packer<Stream>::packer(Stream& s) : m_stream(s) { }
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_nilEv:
 1193|  3.06k|{
 1194|  3.06k|    const char d = static_cast<char>(0xc0u);
 1195|  3.06k|    append_buffer(&d, 1);
 1196|  3.06k|    return *this;
 1197|  3.06k|}
_ZN7msgpack2v16packerINS0_7sbufferEE13append_bufferEPKcm:
  622|  1.30M|    {
  623|  1.30M|        append_buffer(&Stream::write, buf, len);
  624|  1.30M|    }
_ZN7msgpack2v16packerINS0_7sbufferEE13append_bufferIvS2_mEEvMT0_FT_PKcT1_ES8_m:
  628|  1.30M|    {
  629|  1.30M|        m_stream.write(buf, static_cast<SizeType>(len));
  630|  1.30M|    }
_ZN7msgpack2v16packerINS0_7sbufferEE9pack_trueEv:
 1201|  4.78k|{
 1202|  4.78k|    const char d = static_cast<char>(0xc3u);
 1203|  4.78k|    append_buffer(&d, 1);
 1204|  4.78k|    return *this;
 1205|  4.78k|}
_ZN7msgpack2v16packerINS0_7sbufferEE10pack_falseEv:
 1209|  1.18k|{
 1210|  1.18k|    const char d = static_cast<char>(0xc2u);
 1211|  1.18k|    append_buffer(&d, 1);
 1212|  1.18k|    return *this;
 1213|  1.18k|}
_ZN7msgpack2v16packerINS0_7sbufferEE11pack_uint64Em:
  741|   431k|{ pack_imp_uint64(d); return *this; }
_ZN7msgpack2v16packerINS0_7sbufferEE15pack_imp_uint64ImEEvT_:
 1470|   451k|{
 1471|   451k|    if(d < (1ULL<<8)) {
  ------------------
  |  Branch (1471:8): [True: 427k, False: 24.6k]
  ------------------
 1472|   427k|        if(d < (1ULL<<7)) {
  ------------------
  |  Branch (1472:12): [True: 423k, False: 3.51k]
  ------------------
 1473|       |            /* fixnum */
 1474|   423k|            char buf = take8_64(d);
 1475|   423k|            append_buffer(&buf, 1);
 1476|   423k|        } else {
 1477|       |            /* unsigned 8 */
 1478|  3.51k|            char buf[2] = {static_cast<char>(0xccu), take8_64(d)};
 1479|  3.51k|            append_buffer(buf, 2);
 1480|  3.51k|        }
 1481|   427k|    } else {
 1482|  24.6k|        if(d < (1ULL<<16)) {
  ------------------
  |  Branch (1482:12): [True: 1.01k, False: 23.6k]
  ------------------
 1483|       |            /* unsigned 16 */
 1484|  1.01k|            char buf[3];
 1485|  1.01k|            buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
  ------------------
  |  |  186|  1.01k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  1.01k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1486|  1.01k|            append_buffer(buf, 3);
 1487|  23.6k|        } else if(d < (1ULL<<32)) {
  ------------------
  |  Branch (1487:19): [True: 678, False: 22.9k]
  ------------------
 1488|       |            /* unsigned 32 */
 1489|    678|            char buf[5];
 1490|    678|            buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
  ------------------
  |  |  188|    678|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|    678|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1491|    678|            append_buffer(buf, 5);
 1492|  22.9k|        } else {
 1493|       |            /* unsigned 64 */
 1494|  22.9k|            char buf[9];
 1495|  22.9k|            buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
  ------------------
  |  |  190|  22.9k|    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
  |  |  ------------------
  |  |  |  |  146|  22.9k|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  |  Branch (190:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1496|  22.9k|            append_buffer(buf, 9);
 1497|  22.9k|        }
 1498|  24.6k|    }
 1499|   451k|}
_ZN7msgpack2v18take8_64ImEEcT_:
  693|   427k|inline char take8_64(T d) {
  694|   427k|    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
  695|   427k|}
_ZN7msgpack2v16packerINS0_7sbufferEE10pack_int64El:
  757|   105k|{ pack_imp_int64(d); return *this;}
_ZN7msgpack2v16packerINS0_7sbufferEE14pack_imp_int64IlEEvT_:
 1595|   546k|{
 1596|   546k|    if(d < -(1LL<<5)) {
  ------------------
  |  Branch (1596:8): [True: 447k, False: 99.4k]
  ------------------
 1597|   447k|        if(d < -(1LL<<15)) {
  ------------------
  |  Branch (1597:12): [True: 444k, False: 2.66k]
  ------------------
 1598|   444k|            if(d < -(1LL<<31)) {
  ------------------
  |  Branch (1598:16): [True: 443k, False: 1.32k]
  ------------------
 1599|       |                /* signed 64 */
 1600|   443k|                char buf[9];
 1601|   443k|                buf[0] = static_cast<char>(0xd3u); _msgpack_store64(&buf[1], d);
  ------------------
  |  |  190|   443k|    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
  |  |  ------------------
  |  |  |  |  146|   443k|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  |  Branch (190:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1602|   443k|                append_buffer(buf, 9);
 1603|   443k|            } else {
 1604|       |                /* signed 32 */
 1605|  1.32k|                char buf[5];
 1606|  1.32k|                buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], static_cast<int32_t>(d));
  ------------------
  |  |  188|  1.32k|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|  1.32k|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1607|  1.32k|                append_buffer(buf, 5);
 1608|  1.32k|            }
 1609|   444k|        } else {
 1610|  2.66k|            if(d < -(1<<7)) {
  ------------------
  |  Branch (1610:16): [True: 1.58k, False: 1.08k]
  ------------------
 1611|       |                /* signed 16 */
 1612|  1.58k|                char buf[3];
 1613|  1.58k|                buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
  ------------------
  |  |  186|  1.58k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  1.58k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1614|  1.58k|                append_buffer(buf, 3);
 1615|  1.58k|            } else {
 1616|       |                /* signed 8 */
 1617|  1.08k|                char buf[2] = {static_cast<char>(0xd0u), take8_64(d)};
 1618|  1.08k|                append_buffer(buf, 2);
 1619|  1.08k|            }
 1620|  2.66k|        }
 1621|   447k|    } else if(d < (1<<7)) {
  ------------------
  |  Branch (1621:15): [True: 99.4k, False: 0]
  ------------------
 1622|       |        /* fixnum */
 1623|  99.4k|        char buf = take8_64(d);
 1624|  99.4k|        append_buffer(&buf, 1);
 1625|  99.4k|    } else {
 1626|      0|        if(d < (1LL<<16)) {
  ------------------
  |  Branch (1626:12): [True: 0, False: 0]
  ------------------
 1627|      0|            if(d < (1<<8)) {
  ------------------
  |  Branch (1627:16): [True: 0, False: 0]
  ------------------
 1628|       |                /* unsigned 8 */
 1629|      0|                char buf[2] = {static_cast<char>(0xccu), take8_64(d)};
 1630|      0|                append_buffer(buf, 2);
 1631|      0|            } else {
 1632|       |                /* unsigned 16 */
 1633|      0|                char buf[3];
 1634|      0|                buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
  ------------------
  |  |  186|      0|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|      0|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1635|      0|                append_buffer(buf, 3);
 1636|      0|            }
 1637|      0|        } else {
 1638|      0|            if(d < (1LL<<32)) {
  ------------------
  |  Branch (1638:16): [True: 0, False: 0]
  ------------------
 1639|       |                /* unsigned 32 */
 1640|      0|                char buf[5];
 1641|      0|                buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
  ------------------
  |  |  188|      0|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|      0|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1642|      0|                append_buffer(buf, 5);
 1643|      0|            } else {
 1644|       |                /* unsigned 64 */
 1645|      0|                char buf[9];
 1646|      0|                buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
  ------------------
  |  |  190|      0|    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
  |  |  ------------------
  |  |  |  |  146|      0|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  |  Branch (190:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1647|      0|                append_buffer(buf, 9);
 1648|      0|            }
 1649|      0|        }
 1650|      0|    }
 1651|   546k|}
_ZN7msgpack2v18take8_64IlEEcT_:
  693|   100k|inline char take8_64(T d) {
  694|   100k|    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
  695|   100k|}
_ZN7msgpack2v16packerINS0_7sbufferEE10pack_floatEf:
 1140|   461k|{
 1141|   461k|    if(d == d) { // check for nan
  ------------------
  |  Branch (1141:8): [True: 459k, False: 1.85k]
  ------------------
 1142|       |        // compare d to limits to avoid undefined behaviour
 1143|   459k|        if(d >= 0 && d <= float(std::numeric_limits<uint64_t>::max()) && d == float(uint64_t(d))) {
  ------------------
  |  Branch (1143:12): [True: 23.6k, False: 436k]
  |  Branch (1143:22): [True: 22.6k, False: 987]
  |  Branch (1143:74): [True: 20.1k, False: 2.55k]
  ------------------
 1144|  20.1k|            pack_imp_uint64(uint64_t(d));
 1145|  20.1k|            return *this;
 1146|   439k|        } else if(d < 0 && d >= float(std::numeric_limits<int64_t>::min()) && d == float(int64_t(d))) {
  ------------------
  |  Branch (1146:19): [True: 436k, False: 3.54k]
  |  Branch (1146:28): [True: 435k, False: 621]
  |  Branch (1146:79): [True: 434k, False: 1.04k]
  ------------------
 1147|   434k|            pack_imp_int64(int64_t(d));
 1148|   434k|            return *this;
 1149|   434k|        }
 1150|   459k|    }
 1151|       |
 1152|  7.06k|    union { float f; uint32_t i; } mem;
 1153|  7.06k|    mem.f = d;
 1154|  7.06k|    char buf[5];
 1155|  7.06k|    buf[0] = static_cast<char>(0xcau); _msgpack_store32(&buf[1], mem.i);
  ------------------
  |  |  188|  7.06k|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|  7.06k|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1156|  7.06k|    append_buffer(buf, 5);
 1157|  7.06k|    return *this;
 1158|   461k|}
_ZN7msgpack2v16packerINS0_7sbufferEE11pack_doubleEd:
 1162|  17.3k|{
 1163|  17.3k|    if(d == d) { // check for nan
  ------------------
  |  Branch (1163:8): [True: 15.8k, False: 1.47k]
  ------------------
 1164|       |        // compare d to limits to avoid undefined behaviour
 1165|  15.8k|        if(d >= 0 && d <= double(std::numeric_limits<uint64_t>::max()) && d == double(uint64_t(d))) {
  ------------------
  |  Branch (1165:12): [True: 3.56k, False: 12.3k]
  |  Branch (1165:22): [True: 3.22k, False: 332]
  |  Branch (1165:75): [True: 408, False: 2.82k]
  ------------------
 1166|    408|            pack_imp_uint64(uint64_t(d));
 1167|    408|            return *this;
 1168|  15.4k|        } else if(d < 0 && d >= double(std::numeric_limits<int64_t>::min()) && d == double(int64_t(d))) {
  ------------------
  |  Branch (1168:19): [True: 12.3k, False: 3.15k]
  |  Branch (1168:28): [True: 7.49k, False: 4.82k]
  |  Branch (1168:80): [True: 6.85k, False: 637]
  ------------------
 1169|  6.85k|            pack_imp_int64(int64_t(d));
 1170|  6.85k|            return *this;
 1171|  6.85k|        }
 1172|  15.8k|    }
 1173|       |
 1174|  10.0k|    union { double f; uint64_t i; } mem;
 1175|  10.0k|    mem.f = d;
 1176|  10.0k|    char buf[9];
 1177|  10.0k|    buf[0] = static_cast<char>(0xcbu);
 1178|       |
 1179|       |#if defined(TARGET_OS_IPHONE)
 1180|       |    // ok
 1181|       |#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
 1182|       |    // https://github.com/msgpack/msgpack-perl/pull/1
 1183|       |    mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
 1184|       |#endif
 1185|  10.0k|    _msgpack_store64(&buf[1], mem.i);
  ------------------
  |  |  190|  10.0k|    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
  |  |  ------------------
  |  |  |  |  146|  10.0k|#        define _msgpack_be64(x) bswap_64(x)
  |  |  ------------------
  |  |  |  Branch (190:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1186|  10.0k|    append_buffer(buf, 9);
 1187|  10.0k|    return *this;
 1188|  17.3k|}
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_strEj:
 1255|  14.7k|{
 1256|  14.7k|    if(l < 32) {
  ------------------
  |  Branch (1256:8): [True: 11.0k, False: 3.74k]
  ------------------
 1257|  11.0k|        unsigned char d = static_cast<uint8_t>(0xa0u | l);
 1258|  11.0k|        char buf = take8_8(d);
 1259|  11.0k|        append_buffer(&buf, 1);
 1260|  11.0k|    } else if(l < 256) {
  ------------------
  |  Branch (1260:15): [True: 1.16k, False: 2.57k]
  ------------------
 1261|  1.16k|        char buf[2];
 1262|  1.16k|        buf[0] = static_cast<char>(0xd9u); buf[1] = static_cast<char>(l);
 1263|  1.16k|        append_buffer(buf, 2);
 1264|  2.57k|    } else if(l < 65536) {
  ------------------
  |  Branch (1264:15): [True: 2.57k, False: 0]
  ------------------
 1265|  2.57k|        char buf[3];
 1266|  2.57k|        buf[0] = static_cast<char>(0xdau); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
  ------------------
  |  |  186|  2.57k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  2.57k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1267|  2.57k|        append_buffer(buf, 3);
 1268|  2.57k|    } else {
 1269|      0|        char buf[5];
 1270|      0|        buf[0] = static_cast<char>(0xdbu); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
  ------------------
  |  |  188|      0|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|      0|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1271|      0|        append_buffer(buf, 5);
 1272|      0|    }
 1273|  14.7k|    return *this;
 1274|  14.7k|}
_ZN7msgpack2v17take8_8IhEEcT_:
  681|   138k|inline char take8_8(T d) {
  682|   138k|    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
  683|   138k|}
_ZN7msgpack2v16packerINS0_7sbufferEE13pack_str_bodyEPKcj:
 1278|  14.7k|{
 1279|  14.7k|    append_buffer(b, l);
 1280|  14.7k|    return *this;
 1281|  14.7k|}
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_binEj:
 1313|  2.35k|{
 1314|  2.35k|    if(l < 256) {
  ------------------
  |  Branch (1314:8): [True: 2.01k, False: 333]
  ------------------
 1315|  2.01k|        char buf[2];
 1316|  2.01k|        buf[0] = static_cast<char>(0xc4u); buf[1] = static_cast<char>(l);
 1317|  2.01k|        append_buffer(buf, 2);
 1318|  2.01k|    } else if(l < 65536) {
  ------------------
  |  Branch (1318:15): [True: 333, False: 0]
  ------------------
 1319|    333|        char buf[3];
 1320|    333|        buf[0] = static_cast<char>(0xc5u); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
  ------------------
  |  |  186|    333|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|    333|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1321|    333|        append_buffer(buf, 3);
 1322|    333|    } else {
 1323|      0|        char buf[5];
 1324|      0|        buf[0] = static_cast<char>(0xc6u); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
  ------------------
  |  |  188|      0|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|      0|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1325|      0|        append_buffer(buf, 5);
 1326|      0|    }
 1327|  2.35k|    return *this;
 1328|  2.35k|}
_ZN7msgpack2v16packerINS0_7sbufferEE13pack_bin_bodyEPKcj:
 1332|  2.35k|{
 1333|  2.35k|    append_buffer(b, l);
 1334|  2.35k|    return *this;
 1335|  2.35k|}
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_extEma:
 1339|  17.4k|{
 1340|  17.4k|    switch(l) {
 1341|    761|    case 1: {
  ------------------
  |  Branch (1341:5): [True: 761, False: 16.6k]
  ------------------
 1342|    761|        char buf[2];
 1343|    761|        buf[0] = static_cast<char>(0xd4u);
 1344|    761|        buf[1] = static_cast<char>(type);
 1345|    761|        append_buffer(buf, 2);
 1346|    761|    } break;
 1347|  1.19k|    case 2: {
  ------------------
  |  Branch (1347:5): [True: 1.19k, False: 16.2k]
  ------------------
 1348|  1.19k|        char buf[2];
 1349|  1.19k|        buf[0] = static_cast<char>(0xd5u);
 1350|  1.19k|        buf[1] = static_cast<char>(type);
 1351|  1.19k|        append_buffer(buf, 2);
 1352|  1.19k|    } break;
 1353|    852|    case 4: {
  ------------------
  |  Branch (1353:5): [True: 852, False: 16.5k]
  ------------------
 1354|    852|        char buf[2];
 1355|    852|        buf[0] = static_cast<char>(0xd6u);
 1356|    852|        buf[1] = static_cast<char>(type);
 1357|    852|        append_buffer(buf, 2);
 1358|    852|    } break;
 1359|  11.9k|    case 8: {
  ------------------
  |  Branch (1359:5): [True: 11.9k, False: 5.43k]
  ------------------
 1360|  11.9k|        char buf[2];
 1361|  11.9k|        buf[0] = static_cast<char>(0xd7u);
 1362|  11.9k|        buf[1] = static_cast<char>(type);
 1363|  11.9k|        append_buffer(buf, 2);
 1364|  11.9k|    } break;
 1365|    531|    case 16: {
  ------------------
  |  Branch (1365:5): [True: 531, False: 16.8k]
  ------------------
 1366|    531|        char buf[2];
 1367|    531|        buf[0] = static_cast<char>(0xd8u);
 1368|    531|        buf[1] = static_cast<char>(type);
 1369|    531|        append_buffer(buf, 2);
 1370|    531|    } break;
 1371|  2.09k|    default:
  ------------------
  |  Branch (1371:5): [True: 2.09k, False: 15.3k]
  ------------------
 1372|  2.09k|        if(l < 256) {
  ------------------
  |  Branch (1372:12): [True: 466, False: 1.62k]
  ------------------
 1373|    466|            char buf[3];
 1374|    466|            buf[0] = static_cast<char>(0xc7u);
 1375|    466|            buf[1] = static_cast<char>(l);
 1376|    466|            buf[2] = static_cast<char>(type);
 1377|    466|            append_buffer(buf, 3);
 1378|  1.62k|        } else if(l < 65536) {
  ------------------
  |  Branch (1378:19): [True: 1.62k, False: 0]
  ------------------
 1379|  1.62k|            char buf[4];
 1380|  1.62k|            buf[0] = static_cast<char>(0xc8u);
 1381|  1.62k|            _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
  ------------------
  |  |  186|  1.62k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  1.62k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1382|  1.62k|            buf[3] = static_cast<char>(type);
 1383|  1.62k|            append_buffer(buf, 4);
 1384|  1.62k|        } else {
 1385|      0|            char buf[6];
 1386|      0|            buf[0] = static_cast<char>(0xc9u);
 1387|      0|            _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
  ------------------
  |  |  188|      0|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|      0|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1388|      0|            buf[5] = static_cast<char>(type);
 1389|      0|            append_buffer(buf, 6);
 1390|      0|        }
 1391|  2.09k|        break;
 1392|  17.4k|    }
 1393|  17.4k|    return *this;
 1394|  17.4k|}
_ZN7msgpack2v16packerINS0_7sbufferEE13pack_ext_bodyEPKcj:
 1398|  17.4k|{
 1399|  17.4k|    append_buffer(b, l);
 1400|  17.4k|    return *this;
 1401|  17.4k|}
_ZN7msgpack2v16packerINS0_7sbufferEE10pack_arrayEj:
 1218|  83.8k|{
 1219|  83.8k|    if(n < 16) {
  ------------------
  |  Branch (1219:8): [True: 82.5k, False: 1.32k]
  ------------------
 1220|  82.5k|        char d = static_cast<char>(0x90u | n);
 1221|  82.5k|        append_buffer(&d, 1);
 1222|  82.5k|    } else if(n < 65536) {
  ------------------
  |  Branch (1222:15): [True: 1.32k, False: 0]
  ------------------
 1223|  1.32k|        char buf[3];
 1224|  1.32k|        buf[0] = static_cast<char>(0xdcu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
  ------------------
  |  |  186|  1.32k|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|  1.32k|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1225|  1.32k|        append_buffer(buf, 3);
 1226|  1.32k|    } else {
 1227|      0|        char buf[5];
 1228|      0|        buf[0] = static_cast<char>(0xddu); _msgpack_store32(&buf[1], static_cast<uint32_t>(n));
  ------------------
  |  |  188|      0|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|      0|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1229|      0|        append_buffer(buf, 5);
 1230|      0|    }
 1231|  83.8k|    return *this;
 1232|  83.8k|}
_ZN7msgpack2v16packerINS0_7sbufferEE8pack_mapEj:
 1236|   128k|{
 1237|   128k|    if(n < 16) {
  ------------------
  |  Branch (1237:8): [True: 127k, False: 767]
  ------------------
 1238|   127k|        unsigned char d = static_cast<unsigned char>(0x80u | n);
 1239|   127k|        char buf = take8_8(d);
 1240|   127k|        append_buffer(&buf, 1);
 1241|   127k|    } else if(n < 65536) {
  ------------------
  |  Branch (1241:15): [True: 767, False: 0]
  ------------------
 1242|    767|        char buf[3];
 1243|    767|        buf[0] = static_cast<char>(0xdeu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
  ------------------
  |  |  186|    767|    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
  |  |  ------------------
  |  |  |  |  114|    767|#       define _msgpack_be16(x) ntohs((uint16_t)x)
  |  |  ------------------
  |  |  |  Branch (186:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1244|    767|        append_buffer(buf, 3);
 1245|    767|    } else {
 1246|      0|        char buf[5];
 1247|      0|        buf[0] = static_cast<char>(0xdfu); _msgpack_store32(&buf[1], static_cast<uint32_t>(n));
  ------------------
  |  |  188|      0|    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
  |  |  ------------------
  |  |  |  |  128|      0|#       define _msgpack_be32(x) ntohl((uint32_t)x)
  |  |  ------------------
  |  |  |  Branch (188:74): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1248|      0|        append_buffer(buf, 5);
 1249|      0|    }
 1250|   128k|    return *this;
 1251|   128k|}

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

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

_ZNK7msgpack2v112unpack_limit3strEv:
  104|  30.7k|    std::size_t str() const { return str_; }
_ZNK7msgpack2v112unpack_limit5arrayEv:
  102|   177k|    std::size_t array() const { return array_; }
_ZNK7msgpack2v112unpack_limit5depthEv:
  107|   424k|    std::size_t depth() const { return depth_; }
_ZNK7msgpack2v112unpack_limit3mapEv:
  103|   246k|    std::size_t map() const { return map_; }
_ZNK7msgpack2v112unpack_limit3extEv:
  106|  36.3k|    std::size_t ext() const { return ext_; }
_ZNK7msgpack2v112unpack_limit3binEv:
  105|  6.46k|    std::size_t bin() const { return bin_; }
_ZN7msgpack2v112unpack_limitC2Emmmmmm:
  101|  2.25k|         depth_(depth) {}

_ZN7msgpack2v118insufficient_bytesC2EPKc:
   48|    942|        :unpack_error(msg) {}
_ZN7msgpack2v112unpack_errorC2EPKc:
   30|  1.05k|        std::runtime_error(msg) {}
_ZN7msgpack2v117str_size_overflowC2EPKc:
   84|      7|        :size_overflow(msg) {}
_ZN7msgpack2v113size_overflowC2EPKc:
   57|    110|        :unpack_error(msg) {}
_ZN7msgpack2v119array_size_overflowC2EPKc:
   66|     42|        :size_overflow(msg) {}
_ZN7msgpack2v119depth_size_overflowC2EPKc:
  111|      2|        :size_overflow(msg) {}
_ZN7msgpack2v117map_size_overflowC2EPKc:
   75|     51|        :size_overflow(msg) {}
_ZN7msgpack2v111parse_errorC2EPKc:
   39|      1|        :unpack_error(msg) {}
_ZN7msgpack2v117ext_size_overflowC2EPKc:
  102|      4|        :size_overflow(msg) {}
_ZN7msgpack2v117bin_size_overflowC2EPKc:
   93|      4|        :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|   815k|    bool visit_positive_integer(uint64_t v) {
   80|   815k|        msgpack::object* obj = m_stack.back();
   81|   815k|        obj->type = msgpack::type::POSITIVE_INTEGER;
   82|   815k|        obj->via.u64 = v;
   83|   815k|        return true;
   84|   815k|    }
_ZN7msgpack2v26detail21create_object_visitor14end_array_itemEv:
  207|   743k|    bool end_array_item() {
  208|   743k|        ++m_stack.back();
  209|   743k|        return true;
  210|   743k|    }
_ZN7msgpack2v26detail21create_object_visitor9end_arrayEv:
  211|   168k|    bool end_array() {
  212|   168k|        m_stack.pop_back();
  213|   168k|        return true;
  214|   168k|    }
_ZN7msgpack2v26detail21create_object_visitor16start_array_itemEv:
  204|   752k|    bool start_array_item() {
  205|   752k|        return true;
  206|   752k|    }
_ZN7msgpack2v26detail21create_object_visitor11end_map_keyEv:
  240|   643k|    bool end_map_key() {
  241|   643k|        ++m_stack.back();
  242|   643k|        return true;
  243|   643k|    }
_ZN7msgpack2v26detail21create_object_visitor15start_map_valueEv:
  244|   643k|    bool start_map_value() {
  245|   643k|        return true;
  246|   643k|    }
_ZN7msgpack2v26detail21create_object_visitor13end_map_valueEv:
  247|   642k|    bool end_map_value() {
  248|   642k|        ++m_stack.back();
  249|   642k|        return true;
  250|   642k|    }
_ZN7msgpack2v26detail21create_object_visitor7end_mapEv:
  251|   239k|    bool end_map() {
  252|   239k|        m_stack.pop_back();
  253|   239k|        return true;
  254|   239k|    }
_ZN7msgpack2v26detail21create_object_visitor13start_map_keyEv:
  237|   649k|    bool start_map_key() {
  238|   649k|        return true;
  239|   649k|    }
_ZN7msgpack2v26detail21create_object_visitor22visit_negative_integerEl:
   85|   200k|    bool visit_negative_integer(int64_t v) {
   86|   200k|        msgpack::object* obj = m_stack.back();
   87|   200k|        if(v >= 0) {
  ------------------
  |  Branch (87:12): [True: 2.62k, False: 198k]
  ------------------
   88|  2.62k|            obj->type = msgpack::type::POSITIVE_INTEGER;
   89|  2.62k|            obj->via.u64 = static_cast<uint64_t>(v);
   90|  2.62k|        }
   91|   198k|        else {
   92|   198k|            obj->type = msgpack::type::NEGATIVE_INTEGER;
   93|   198k|            obj->via.i64 = v;
   94|   198k|        }
   95|   200k|        return true;
   96|   200k|    }
_ZN7msgpack2v26detail21create_object_visitor9visit_strEPKcj:
  109|  30.7k|    bool visit_str(const char* v, uint32_t size) {
  110|  30.7k|        MSGPACK_ASSERT(v || size == 0);
  ------------------
  |  |   22|  30.7k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  111|  30.7k|        if (size > m_limit.str()) throw msgpack::str_size_overflow("str size overflow");
  ------------------
  |  Branch (111:13): [True: 7, False: 30.7k]
  ------------------
  112|  30.7k|        msgpack::object* obj = m_stack.back();
  113|  30.7k|        obj->type = msgpack::type::STR;
  114|  30.7k|        if (m_func && m_func(obj->type, size, m_user_data)) {
  ------------------
  |  Branch (114:13): [True: 0, False: 30.7k]
  |  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|  30.7k|        else {
  120|  30.7k|            if (v) {
  ------------------
  |  Branch (120:17): [True: 30.0k, False: 706]
  ------------------
  121|  30.0k|                char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
  ------------------
  |  |   32|  30.0k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  122|  30.0k|                std::memcpy(tmp, v, size);
  123|  30.0k|                obj->via.str.ptr = tmp;
  124|  30.0k|                obj->via.str.size = size;
  125|  30.0k|            }
  126|    706|            else {
  127|    706|                obj->via.str.ptr = MSGPACK_NULLPTR;
  ------------------
  |  |   85|    706|#  define MSGPACK_NULLPTR nullptr
  ------------------
  128|    706|                obj->via.str.size = 0;
  129|    706|            }
  130|  30.7k|        }
  131|  30.7k|        return true;
  132|  30.7k|    }
_ZN7msgpack2v26detail21create_object_visitor4zoneEv:
   63|  72.8k|    msgpack::zone& zone() { return *m_zone; }
_ZN7msgpack2v26detail21create_object_visitor11start_arrayEj:
  181|   177k|    bool start_array(uint32_t num_elements) {
  182|   177k|        if (num_elements > m_limit.array()) throw msgpack::array_size_overflow("array size overflow");
  ------------------
  |  Branch (182:13): [True: 42, False: 177k]
  ------------------
  183|   177k|        if (m_stack.size() > m_limit.depth()) throw msgpack::depth_size_overflow("depth size overflow");
  ------------------
  |  Branch (183:13): [True: 1, False: 177k]
  ------------------
  184|   177k|        msgpack::object* obj = m_stack.back();
  185|   177k|        obj->type = msgpack::type::ARRAY;
  186|   177k|        obj->via.array.size = num_elements;
  187|   177k|        if (num_elements == 0) {
  ------------------
  |  Branch (187:13): [True: 31.8k, False: 145k]
  ------------------
  188|  31.8k|            obj->via.array.ptr = MSGPACK_NULLPTR;
  ------------------
  |  |   85|  31.8k|#  define MSGPACK_NULLPTR nullptr
  ------------------
  189|  31.8k|        }
  190|   145k|        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|   145k|            size_t size = num_elements*sizeof(msgpack::object);
  198|   145k|            obj->via.array.ptr =
  199|   145k|                static_cast<msgpack::object*>(m_zone->allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
  ------------------
  |  |   32|   145k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  200|   145k|        }
  201|   177k|        m_stack.push_back(obj->via.array.ptr);
  202|   177k|        return true;
  203|   177k|    }
_ZN7msgpack2v26detail21create_object_visitor9start_mapEj:
  215|   246k|    bool start_map(uint32_t num_kv_pairs) {
  216|   246k|        if (num_kv_pairs > m_limit.map()) throw msgpack::map_size_overflow("map size overflow");
  ------------------
  |  Branch (216:13): [True: 51, False: 246k]
  ------------------
  217|   246k|        if (m_stack.size() > m_limit.depth()) throw msgpack::depth_size_overflow("depth size overflow");
  ------------------
  |  Branch (217:13): [True: 1, False: 246k]
  ------------------
  218|   246k|        msgpack::object* obj = m_stack.back();
  219|   246k|        obj->type = msgpack::type::MAP;
  220|   246k|        obj->via.map.size = num_kv_pairs;
  221|   246k|        if (num_kv_pairs == 0) {
  ------------------
  |  Branch (221:13): [True: 32.2k, False: 214k]
  ------------------
  222|  32.2k|            obj->via.map.ptr = MSGPACK_NULLPTR;
  ------------------
  |  |   85|  32.2k|#  define MSGPACK_NULLPTR nullptr
  ------------------
  223|  32.2k|        }
  224|   214k|        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|   214k|            size_t size = num_kv_pairs*sizeof(msgpack::object_kv);
  231|   214k|            obj->via.map.ptr =
  232|   214k|                static_cast<msgpack::object_kv*>(m_zone->allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
  ------------------
  |  |   32|   214k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  233|   214k|        }
  234|   246k|        m_stack.push_back(reinterpret_cast<msgpack::object*>(obj->via.map.ptr));
  235|   246k|        return true;
  236|   246k|    }
_ZN7msgpack2v26detail21create_object_visitor13visit_booleanEb:
   73|  10.0k|    bool visit_boolean(bool v) {
   74|  10.0k|        msgpack::object* obj = m_stack.back();
   75|  10.0k|        obj->type = msgpack::type::BOOLEAN;
   76|  10.0k|        obj->via.boolean = v;
   77|  10.0k|        return true;
   78|  10.0k|    }
_ZN7msgpack2v26detail21create_object_visitor9visit_nilEv:
   68|  4.70k|    bool visit_nil() {
   69|  4.70k|        msgpack::object* obj = m_stack.back();
   70|  4.70k|        obj->type = msgpack::type::NIL;
   71|  4.70k|        return true;
   72|  4.70k|    }
_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|   488k|    bool visit_float32(float v) {
   98|   488k|        msgpack::object* obj = m_stack.back();
   99|   488k|        obj->type = msgpack::type::FLOAT32;
  100|   488k|        obj->via.f64 = v;
  101|   488k|        return true;
  102|   488k|    }
_ZN7msgpack2v26detail21create_object_visitor13visit_float64Ed:
  103|  29.1k|    bool visit_float64(double v) {
  104|  29.1k|        msgpack::object* obj = m_stack.back();
  105|  29.1k|        obj->type = msgpack::type::FLOAT64;
  106|  29.1k|        obj->via.f64 = v;
  107|  29.1k|        return true;
  108|  29.1k|    }
_ZN7msgpack2v26detail21create_object_visitor9visit_extEPKcj:
  157|  36.3k|    bool visit_ext(const char* v, uint32_t size) {
  158|  36.3k|        MSGPACK_ASSERT(v || size == 0);
  ------------------
  |  |   22|  36.3k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  159|  36.3k|        if (size > m_limit.ext()) throw msgpack::ext_size_overflow("ext size overflow");
  ------------------
  |  Branch (159:13): [True: 4, False: 36.3k]
  ------------------
  160|  36.3k|        msgpack::object* obj = m_stack.back();
  161|  36.3k|        obj->type = msgpack::type::EXT;
  162|  36.3k|        if (m_func && m_func(obj->type, size, m_user_data)) {
  ------------------
  |  Branch (162:13): [True: 0, False: 36.3k]
  |  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|  36.3k|        else {
  168|  36.3k|            if (v) {
  ------------------
  |  Branch (168:17): [True: 36.3k, False: 0]
  ------------------
  169|  36.3k|                char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
  ------------------
  |  |   32|  36.3k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  170|  36.3k|                std::memcpy(tmp, v, size);
  171|  36.3k|                obj->via.ext.ptr = tmp;
  172|  36.3k|                obj->via.ext.size = static_cast<uint32_t>(size - 1);
  173|  36.3k|            }
  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|  36.3k|        }
  179|  36.3k|        return true;
  180|  36.3k|    }
_ZN7msgpack2v26detail21create_object_visitor9visit_binEPKcj:
  133|  6.46k|    bool visit_bin(const char* v, uint32_t size) {
  134|  6.46k|        MSGPACK_ASSERT(v || size == 0);
  ------------------
  |  |   22|  6.46k|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  135|  6.46k|        if (size > m_limit.bin()) throw msgpack::bin_size_overflow("bin size overflow");
  ------------------
  |  Branch (135:13): [True: 4, False: 6.46k]
  ------------------
  136|  6.46k|        msgpack::object* obj = m_stack.back();
  137|  6.46k|        obj->type = msgpack::type::BIN;
  138|  6.46k|        if (m_func && m_func(obj->type, size, m_user_data)) {
  ------------------
  |  Branch (138:13): [True: 0, False: 6.46k]
  |  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|  6.46k|        else {
  144|  6.46k|            if (v) {
  ------------------
  |  Branch (144:17): [True: 6.46k, False: 0]
  ------------------
  145|  6.46k|                char* tmp = static_cast<char*>(zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(char)));
  ------------------
  |  |   32|  6.46k|#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
  ------------------
  146|  6.46k|                std::memcpy(tmp, v, size);
  147|  6.46k|                obj->via.bin.ptr = tmp;
  148|  6.46k|                obj->via.bin.size = size;
  149|  6.46k|            }
  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|  6.46k|        }
  155|  6.46k|        return true;
  156|  6.46k|    }
_ZNK7msgpack2v26detail21create_object_visitor10referencedEv:
   65|  1.19k|    bool referenced() const { return m_referenced; }
_ZNK7msgpack2v26detail21create_object_visitor4dataEv:
   59|  1.19k|    {
   60|  1.19k|        return m_obj;
   61|  1.19k|    }

_ZN7msgpack2v26objectC2Ev:
   24|  4.50k|    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.30k]
  ------------------
 1046|    942|        off = noff;
 1047|    942|        v.insufficient_bytes(noff - 1, noff);
 1048|    942|        return ret;
 1049|  1.19k|    case PARSE_SUCCESS:
  ------------------
  |  Branch (1049:5): [True: 1.19k, False: 1.05k]
  ------------------
 1050|  1.19k|        off = noff;
 1051|  1.19k|        if(noff < len) {
  ------------------
  |  Branch (1051:12): [True: 50, False: 1.14k]
  ------------------
 1052|     50|            return PARSE_EXTRA_BYTES;
 1053|     50|        }
 1054|  1.14k|        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:
   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|      0|    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.06M|    do {
  251|  2.06M|        if (m_cs == MSGPACK_CS_HEADER) {
  ------------------
  |  Branch (251:13): [True: 2.04M, False: 15.5k]
  ------------------
  252|  2.04M|            fixed_trail_again = false;
  253|  2.04M|            int selector = *reinterpret_cast<const unsigned char*>(m_current);
  254|  2.04M|            if (0x00 <= selector && selector <= 0x7f) { // Positive Fixnum
  ------------------
  |  Branch (254:17): [True: 2.04M, False: 0]
  |  Branch (254:37): [True: 800k, False: 1.24M]
  ------------------
  255|   800k|                uint8_t tmp = *reinterpret_cast<const uint8_t*>(m_current);
  256|   800k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  257|   800k|                parse_return upr = after_visit_proc(visret, off);
  258|   800k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (258:21): [True: 121, False: 800k]
  ------------------
  259|  1.24M|            } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum
  ------------------
  |  Branch (259:23): [True: 185k, False: 1.06M]
  |  Branch (259:43): [True: 185k, False: 0]
  ------------------
  260|   185k|                int8_t tmp = *reinterpret_cast<const int8_t*>(m_current);
  261|   185k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  262|   185k|                parse_return upr = after_visit_proc(visret, off);
  263|   185k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (263:21): [True: 46, False: 185k]
  ------------------
  264|  1.06M|            } else if (0xc4 <= selector && selector <= 0xdf) {
  ------------------
  |  Branch (264:24): [True: 623k, False: 436k]
  |  Branch (264:44): [True: 623k, False: 0]
  ------------------
  265|   623k|                const uint32_t trail[] = {
  266|   623k|                    1, // bin     8  0xc4
  267|   623k|                    2, // bin    16  0xc5
  268|   623k|                    4, // bin    32  0xc6
  269|   623k|                    1, // ext     8  0xc7
  270|   623k|                    2, // ext    16  0xc8
  271|   623k|                    4, // ext    32  0xc9
  272|   623k|                    4, // float  32  0xca
  273|   623k|                    8, // float  64  0xcb
  274|   623k|                    1, // uint    8  0xcc
  275|   623k|                    2, // uint   16  0xcd
  276|   623k|                    4, // uint   32  0xce
  277|   623k|                    8, // uint   64  0xcf
  278|   623k|                    1, // int     8  0xd0
  279|   623k|                    2, // int    16  0xd1
  280|   623k|                    4, // int    32  0xd2
  281|   623k|                    8, // int    64  0xd3
  282|   623k|                    2, // fixext  1  0xd4
  283|   623k|                    3, // fixext  2  0xd5
  284|   623k|                    5, // fixext  4  0xd6
  285|   623k|                    9, // fixext  8  0xd7
  286|   623k|                    17,// fixext 16  0xd8
  287|   623k|                    1, // str     8  0xd9
  288|   623k|                    2, // str    16  0xda
  289|   623k|                    4, // str    32  0xdb
  290|   623k|                    2, // array  16  0xdc
  291|   623k|                    4, // array  32  0xdd
  292|   623k|                    2, // map    16  0xde
  293|   623k|                    4, // map    32  0xdf
  294|   623k|                };
  295|   623k|                m_trail = trail[selector - 0xc4];
  296|   623k|                m_cs = next_cs(m_current);
  297|   623k|                fixed_trail_again = true;
  298|   623k|            } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr
  ------------------
  |  Branch (298:23): [True: 31.2k, False: 405k]
  |  Branch (298:43): [True: 16.5k, False: 14.7k]
  ------------------
  299|  16.5k|                m_trail = static_cast<uint32_t>(*m_current) & 0x1f;
  300|  16.5k|                if(m_trail == 0) {
  ------------------
  |  Branch (300:20): [True: 3.46k, False: 13.0k]
  ------------------
  301|  3.46k|                    bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  302|  3.46k|                    parse_return upr = after_visit_proc(visret, off);
  303|  3.46k|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (303:25): [True: 19, False: 3.44k]
  ------------------
  304|  3.46k|                }
  305|  13.0k|                else {
  306|  13.0k|                    m_cs = MSGPACK_ACS_STR_VALUE;
  307|  13.0k|                    fixed_trail_again = true;
  308|  13.0k|                }
  309|   420k|            } else if(0x90 <= selector && selector <= 0x9f) { // FixArray
  ------------------
  |  Branch (309:23): [True: 179k, False: 240k]
  |  Branch (309:43): [True: 165k, False: 14.7k]
  ------------------
  310|   165k|                parse_return ret = start_aggregate<fix_tag>(array_sv(holder()), array_ev(holder()), m_current, off);
  311|   165k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (311:21): [True: 28, False: 165k]
  ------------------
  312|   255k|            } else if(0x80 <= selector && selector <= 0x8f) { // FixMap
  ------------------
  |  Branch (312:23): [True: 255k, False: 0]
  |  Branch (312:43): [True: 240k, False: 14.7k]
  ------------------
  313|   240k|                parse_return ret = start_aggregate<fix_tag>(map_sv(holder()), map_ev(holder()), m_current, off);
  314|   240k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (314:21): [True: 37, False: 240k]
  ------------------
  315|   240k|            } else if(selector == 0xc2) { // false
  ------------------
  |  Branch (315:23): [True: 1.67k, False: 13.0k]
  ------------------
  316|  1.67k|                bool visret = holder().visitor().visit_boolean(false);
  317|  1.67k|                parse_return upr = after_visit_proc(visret, off);
  318|  1.67k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (318:21): [True: 15, False: 1.65k]
  ------------------
  319|  13.0k|            } else if(selector == 0xc3) { // true
  ------------------
  |  Branch (319:23): [True: 8.35k, False: 4.70k]
  ------------------
  320|  8.35k|                bool visret = holder().visitor().visit_boolean(true);
  321|  8.35k|                parse_return upr = after_visit_proc(visret, off);
  322|  8.35k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (322:21): [True: 10, False: 8.34k]
  ------------------
  323|  8.35k|            } else if(selector == 0xc0) { // nil
  ------------------
  |  Branch (323:23): [True: 4.70k, False: 1]
  ------------------
  324|  4.70k|                bool visret = holder().visitor().visit_nil();
  325|  4.70k|                parse_return upr = after_visit_proc(visret, off);
  326|  4.70k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (326:21): [True: 12, False: 4.68k]
  ------------------
  327|  4.70k|            } 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.04M|        }
  334|  2.06M|        if (m_cs != MSGPACK_CS_HEADER || fixed_trail_again) {
  ------------------
  |  Branch (334:13): [True: 652k, False: 1.40M]
  |  Branch (334:42): [True: 0, False: 1.40M]
  ------------------
  335|   652k|            if (fixed_trail_again) {
  ------------------
  |  Branch (335:17): [True: 652k, False: 0]
  ------------------
  336|   652k|                ++m_current;
  337|   652k|                fixed_trail_again = false;
  338|   652k|            }
  339|   652k|            if(static_cast<std::size_t>(pe - m_current) < m_trail) {
  ------------------
  |  Branch (339:16): [True: 253, False: 652k]
  ------------------
  340|    253|                off = static_cast<std::size_t>(m_current - m_start);
  341|    253|                return PARSE_CONTINUE;
  342|    253|            }
  343|   652k|            n = m_current;
  344|   652k|            m_current += m_trail - 1;
  345|   652k|            switch(m_cs) {
  346|       |                //case MSGPACK_CS_
  347|       |                //case MSGPACK_CS_
  348|   488k|            case MSGPACK_CS_FLOAT: {
  ------------------
  |  Branch (348:13): [True: 488k, False: 164k]
  ------------------
  349|   488k|                union { uint32_t i; float f; } mem;
  350|   488k|                load<uint32_t>(mem.i, n);
  351|   488k|                bool visret = holder().visitor().visit_float32(mem.f);
  352|   488k|                parse_return upr = after_visit_proc(visret, off);
  353|   488k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (353:21): [True: 186, False: 487k]
  ------------------
  354|   488k|            } break;
  355|   487k|            case MSGPACK_CS_DOUBLE: {
  ------------------
  |  Branch (355:13): [True: 29.1k, False: 623k]
  ------------------
  356|  29.1k|                union { uint64_t i; double f; } mem;
  357|  29.1k|                load<uint64_t>(mem.i, n);
  358|       |#if defined(TARGET_OS_IPHONE)
  359|       |                // ok
  360|       |#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
  361|       |                // https://github.com/msgpack/msgpack-perl/pull/1
  362|       |                mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
  363|       |#endif
  364|  29.1k|                bool visret = holder().visitor().visit_float64(mem.f);
  365|  29.1k|                parse_return upr = after_visit_proc(visret, off);
  366|  29.1k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (366:21): [True: 54, False: 29.0k]
  ------------------
  367|  29.1k|            } break;
  368|  29.0k|            case MSGPACK_CS_UINT_8: {
  ------------------
  |  Branch (368:13): [True: 7.26k, False: 644k]
  ------------------
  369|  7.26k|                uint8_t tmp;
  370|  7.26k|                load<uint8_t>(tmp, n);
  371|  7.26k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  372|  7.26k|                parse_return upr = after_visit_proc(visret, off);
  373|  7.26k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (373:21): [True: 16, False: 7.25k]
  ------------------
  374|  7.26k|            } break;
  375|  7.25k|            case MSGPACK_CS_UINT_16: {
  ------------------
  |  Branch (375:13): [True: 2.18k, False: 650k]
  ------------------
  376|  2.18k|                uint16_t tmp;
  377|  2.18k|                load<uint16_t>(tmp, n);
  378|  2.18k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  379|  2.18k|                parse_return upr = after_visit_proc(visret, off);
  380|  2.18k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (380:21): [True: 25, False: 2.15k]
  ------------------
  381|  2.18k|            } break;
  382|  2.15k|            case MSGPACK_CS_UINT_32: {
  ------------------
  |  Branch (382:13): [True: 690, False: 651k]
  ------------------
  383|    690|                uint32_t tmp;
  384|    690|                load<uint32_t>(tmp, n);
  385|    690|                bool visret = holder().visitor().visit_positive_integer(tmp);
  386|    690|                parse_return upr = after_visit_proc(visret, off);
  387|    690|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (387:21): [True: 49, False: 641]
  ------------------
  388|    690|            } break;
  389|  4.85k|            case MSGPACK_CS_UINT_64: {
  ------------------
  |  Branch (389:13): [True: 4.85k, False: 647k]
  ------------------
  390|  4.85k|                uint64_t tmp;
  391|  4.85k|                load<uint64_t>(tmp, n);
  392|  4.85k|                bool visret = holder().visitor().visit_positive_integer(tmp);
  393|  4.85k|                parse_return upr = after_visit_proc(visret, off);
  394|  4.85k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (394:21): [True: 65, False: 4.78k]
  ------------------
  395|  4.85k|            } break;
  396|  4.78k|            case MSGPACK_CS_INT_8: {
  ------------------
  |  Branch (396:13): [True: 2.88k, False: 649k]
  ------------------
  397|  2.88k|                int8_t tmp;
  398|  2.88k|                load<int8_t>(tmp, n);
  399|  2.88k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  400|  2.88k|                parse_return upr = after_visit_proc(visret, off);
  401|  2.88k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (401:21): [True: 30, False: 2.85k]
  ------------------
  402|  2.88k|            } break;
  403|  4.37k|            case MSGPACK_CS_INT_16: {
  ------------------
  |  Branch (403:13): [True: 4.37k, False: 647k]
  ------------------
  404|  4.37k|                int16_t tmp;
  405|  4.37k|                load<int16_t>(tmp, n);
  406|  4.37k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  407|  4.37k|                parse_return upr = after_visit_proc(visret, off);
  408|  4.37k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (408:21): [True: 55, False: 4.32k]
  ------------------
  409|  4.37k|            } break;
  410|  4.32k|            case MSGPACK_CS_INT_32: {
  ------------------
  |  Branch (410:13): [True: 2.18k, False: 650k]
  ------------------
  411|  2.18k|                int32_t tmp;
  412|  2.18k|                load<int32_t>(tmp, n);
  413|  2.18k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  414|  2.18k|                parse_return upr = after_visit_proc(visret, off);
  415|  2.18k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (415:21): [True: 84, False: 2.09k]
  ------------------
  416|  2.18k|            } break;
  417|  6.01k|            case MSGPACK_CS_INT_64: {
  ------------------
  |  Branch (417:13): [True: 6.01k, False: 646k]
  ------------------
  418|  6.01k|                int64_t tmp;
  419|  6.01k|                load<int64_t>(tmp, n);
  420|  6.01k|                bool visret = holder().visitor().visit_negative_integer(tmp);
  421|  6.01k|                parse_return upr = after_visit_proc(visret, off);
  422|  6.01k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (422:21): [True: 147, False: 5.86k]
  ------------------
  423|  6.01k|            } break;
  424|  5.86k|            case MSGPACK_CS_FIXEXT_1: {
  ------------------
  |  Branch (424:13): [True: 1.45k, False: 650k]
  ------------------
  425|  1.45k|                bool visret = holder().visitor().visit_ext(n, 1+1);
  426|  1.45k|                parse_return upr = after_visit_proc(visret, off);
  427|  1.45k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (427:21): [True: 8, False: 1.45k]
  ------------------
  428|  1.45k|            } break;
  429|  2.83k|            case MSGPACK_CS_FIXEXT_2: {
  ------------------
  |  Branch (429:13): [True: 2.83k, False: 649k]
  ------------------
  430|  2.83k|                bool visret = holder().visitor().visit_ext(n, 2+1);
  431|  2.83k|                parse_return upr = after_visit_proc(visret, off);
  432|  2.83k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (432:21): [True: 8, False: 2.83k]
  ------------------
  433|  2.83k|            } break;
  434|  2.83k|            case MSGPACK_CS_FIXEXT_4: {
  ------------------
  |  Branch (434:13): [True: 2.13k, False: 650k]
  ------------------
  435|  2.13k|                bool visret = holder().visitor().visit_ext(n, 4+1);
  436|  2.13k|                parse_return upr = after_visit_proc(visret, off);
  437|  2.13k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (437:21): [True: 8, False: 2.12k]
  ------------------
  438|  2.13k|            } break;
  439|  25.2k|            case MSGPACK_CS_FIXEXT_8: {
  ------------------
  |  Branch (439:13): [True: 25.2k, False: 626k]
  ------------------
  440|  25.2k|                bool visret = holder().visitor().visit_ext(n, 8+1);
  441|  25.2k|                parse_return upr = after_visit_proc(visret, off);
  442|  25.2k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (442:21): [True: 8, False: 25.2k]
  ------------------
  443|  25.2k|            } break;
  444|  25.2k|            case MSGPACK_CS_FIXEXT_16: {
  ------------------
  |  Branch (444:13): [True: 905, False: 651k]
  ------------------
  445|    905|                bool visret = holder().visitor().visit_ext(n, 16+1);
  446|    905|                parse_return upr = after_visit_proc(visret, off);
  447|    905|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (447:21): [True: 8, False: 897]
  ------------------
  448|    905|            } break;
  449|  2.14k|            case MSGPACK_CS_STR_8: {
  ------------------
  |  Branch (449:13): [True: 2.14k, False: 650k]
  ------------------
  450|  2.14k|                uint8_t tmp;
  451|  2.14k|                load<uint8_t>(tmp, n);
  452|  2.14k|                m_trail = tmp;
  453|  2.14k|                if(m_trail == 0) {
  ------------------
  |  Branch (453:20): [True: 761, False: 1.38k]
  ------------------
  454|    761|                    bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  455|    761|                    parse_return upr = after_visit_proc(visret, off);
  456|    761|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (456:25): [True: 1, False: 760]
  ------------------
  457|    761|                }
  458|  1.38k|                else {
  459|  1.38k|                    m_cs = MSGPACK_ACS_STR_VALUE;
  460|  1.38k|                    fixed_trail_again = true;
  461|  1.38k|                }
  462|  2.14k|            } break;
  463|  3.26k|            case MSGPACK_CS_BIN_8: {
  ------------------
  |  Branch (463:13): [True: 3.26k, False: 648k]
  ------------------
  464|  3.26k|                uint8_t tmp;
  465|  3.26k|                load<uint8_t>(tmp, n);
  466|  3.26k|                m_trail = tmp;
  467|  3.26k|                if(m_trail == 0) {
  ------------------
  |  Branch (467:20): [True: 1.11k, False: 2.14k]
  ------------------
  468|  1.11k|                    bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
  469|  1.11k|                    parse_return upr = after_visit_proc(visret, off);
  470|  1.11k|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (470:25): [True: 10, False: 1.10k]
  ------------------
  471|  1.11k|                }
  472|  2.14k|                else {
  473|  2.14k|                    m_cs = MSGPACK_ACS_BIN_VALUE;
  474|  2.14k|                    fixed_trail_again = true;
  475|  2.14k|                }
  476|  3.26k|            } break;
  477|  3.25k|            case MSGPACK_CS_EXT_8: {
  ------------------
  |  Branch (477:13): [True: 1.02k, False: 651k]
  ------------------
  478|  1.02k|                uint8_t tmp;
  479|  1.02k|                load<uint8_t>(tmp, n);
  480|  1.02k|                m_trail = tmp + 1;
  481|  1.02k|                if(m_trail == 0) {
  ------------------
  |  Branch (481:20): [True: 0, False: 1.02k]
  ------------------
  482|      0|                    bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
  483|      0|                    parse_return upr = after_visit_proc(visret, off);
  484|      0|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (484:25): [True: 0, False: 0]
  ------------------
  485|      0|                }
  486|  1.02k|                else {
  487|  1.02k|                    m_cs = MSGPACK_ACS_EXT_VALUE;
  488|  1.02k|                    fixed_trail_again = true;
  489|  1.02k|                }
  490|  1.02k|            } break;
  491|  8.46k|            case MSGPACK_CS_STR_16: {
  ------------------
  |  Branch (491:13): [True: 8.46k, False: 643k]
  ------------------
  492|  8.46k|                uint16_t tmp;
  493|  8.46k|                load<uint16_t>(tmp, n);
  494|  8.46k|                m_trail = tmp;
  495|  8.46k|                if(m_trail == 0) {
  ------------------
  |  Branch (495:20): [True: 3.34k, False: 5.11k]
  ------------------
  496|  3.34k|                    bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  497|  3.34k|                    parse_return upr = after_visit_proc(visret, off);
  498|  3.34k|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (498:25): [True: 1, False: 3.34k]
  ------------------
  499|  3.34k|                }
  500|  5.11k|                else {
  501|  5.11k|                    m_cs = MSGPACK_ACS_STR_VALUE;
  502|  5.11k|                    fixed_trail_again = true;
  503|  5.11k|                }
  504|  8.46k|            } break;
  505|  8.46k|            case MSGPACK_CS_BIN_16: {
  ------------------
  |  Branch (505:13): [True: 1.19k, False: 650k]
  ------------------
  506|  1.19k|                uint16_t tmp;
  507|  1.19k|                load<uint16_t>(tmp, n);
  508|  1.19k|                m_trail = tmp;
  509|  1.19k|                if(m_trail == 0) {
  ------------------
  |  Branch (509:20): [True: 229, False: 961]
  ------------------
  510|    229|                    bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
  511|    229|                    parse_return upr = after_visit_proc(visret, off);
  512|    229|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (512:25): [True: 2, False: 227]
  ------------------
  513|    229|                }
  514|    961|                else {
  515|    961|                    m_cs = MSGPACK_ACS_BIN_VALUE;
  516|    961|                    fixed_trail_again = true;
  517|    961|                }
  518|  1.19k|            } break;
  519|  2.60k|            case MSGPACK_CS_EXT_16: {
  ------------------
  |  Branch (519:13): [True: 2.60k, False: 649k]
  ------------------
  520|  2.60k|                uint16_t tmp;
  521|  2.60k|                load<uint16_t>(tmp, n);
  522|  2.60k|                m_trail = tmp + 1;
  523|  2.60k|                if(m_trail == 0) {
  ------------------
  |  Branch (523:20): [True: 0, False: 2.60k]
  ------------------
  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|  2.60k|                else {
  529|  2.60k|                    m_cs = MSGPACK_ACS_EXT_VALUE;
  530|  2.60k|                    fixed_trail_again = true;
  531|  2.60k|                }
  532|  2.60k|            } break;
  533|  3.73k|            case MSGPACK_CS_STR_32: {
  ------------------
  |  Branch (533:13): [True: 3.73k, False: 648k]
  ------------------
  534|  3.73k|                uint32_t tmp;
  535|  3.73k|                load<uint32_t>(tmp, n);
  536|  3.73k|                m_trail = tmp;
  537|  3.73k|                if(m_trail == 0) {
  ------------------
  |  Branch (537:20): [True: 1.83k, False: 1.90k]
  ------------------
  538|  1.83k|                    bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  539|  1.83k|                    parse_return upr = after_visit_proc(visret, off);
  540|  1.83k|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (540:25): [True: 1, False: 1.83k]
  ------------------
  541|  1.83k|                }
  542|  1.90k|                else {
  543|  1.90k|                    m_cs = MSGPACK_ACS_STR_VALUE;
  544|  1.90k|                    fixed_trail_again = true;
  545|  1.90k|                }
  546|  3.73k|            } break;
  547|  3.73k|            case MSGPACK_CS_BIN_32: {
  ------------------
  |  Branch (547:13): [True: 2.11k, False: 650k]
  ------------------
  548|  2.11k|                uint32_t tmp;
  549|  2.11k|                load<uint32_t>(tmp, n);
  550|  2.11k|                m_trail = tmp;
  551|  2.11k|                if(m_trail == 0) {
  ------------------
  |  Branch (551:20): [True: 1.83k, False: 273]
  ------------------
  552|  1.83k|                    bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
  553|  1.83k|                    parse_return upr = after_visit_proc(visret, off);
  554|  1.83k|                    if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (554:25): [True: 1, False: 1.83k]
  ------------------
  555|  1.83k|                }
  556|    273|                else {
  557|    273|                    m_cs = MSGPACK_ACS_BIN_VALUE;
  558|    273|                    fixed_trail_again = true;
  559|    273|                }
  560|  2.11k|            } break;
  561|  2.11k|            case MSGPACK_CS_EXT_32: {
  ------------------
  |  Branch (561:13): [True: 194, False: 651k]
  ------------------
  562|    194|                uint32_t tmp;
  563|    194|                load<uint32_t>(tmp, n);
  564|    194|                check_ext_size<sizeof(std::size_t)>(tmp);
  565|    194|                m_trail = tmp;
  566|    194|                ++m_trail;
  567|    194|                if(m_trail == 0) {
  ------------------
  |  Branch (567:20): [True: 0, False: 194]
  ------------------
  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|    194|                else {
  573|    194|                    m_cs = MSGPACK_ACS_EXT_VALUE;
  574|    194|                    fixed_trail_again = true;
  575|    194|                }
  576|    194|            } break;
  577|  21.3k|            case MSGPACK_ACS_STR_VALUE: {
  ------------------
  |  Branch (577:13): [True: 21.3k, False: 630k]
  ------------------
  578|  21.3k|                bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
  579|  21.3k|                parse_return upr = after_visit_proc(visret, off);
  580|  21.3k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (580:21): [True: 52, False: 21.2k]
  ------------------
  581|  21.3k|            } break;
  582|  21.2k|            case MSGPACK_ACS_BIN_VALUE: {
  ------------------
  |  Branch (582:13): [True: 3.28k, False: 648k]
  ------------------
  583|  3.28k|                bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
  584|  3.28k|                parse_return upr = after_visit_proc(visret, off);
  585|  3.28k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (585:21): [True: 39, False: 3.24k]
  ------------------
  586|  3.28k|            } break;
  587|  3.79k|            case MSGPACK_ACS_EXT_VALUE: {
  ------------------
  |  Branch (587:13): [True: 3.79k, False: 648k]
  ------------------
  588|  3.79k|                bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
  589|  3.79k|                parse_return upr = after_visit_proc(visret, off);
  590|  3.79k|                if (upr != PARSE_CONTINUE) return upr;
  ------------------
  |  Branch (590:21): [True: 45, False: 3.75k]
  ------------------
  591|  3.79k|            } break;
  592|  10.6k|            case MSGPACK_CS_ARRAY_16: {
  ------------------
  |  Branch (592:13): [True: 10.6k, False: 641k]
  ------------------
  593|  10.6k|                parse_return ret = start_aggregate<uint16_t>(array_sv(holder()), array_ev(holder()), n, off);
  594|  10.6k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (594:21): [True: 2, False: 10.6k]
  ------------------
  595|       |
  596|  10.6k|            } break;
  597|  10.6k|            case MSGPACK_CS_ARRAY_32: {
  ------------------
  |  Branch (597:13): [True: 1.78k, False: 650k]
  ------------------
  598|  1.78k|                parse_return ret = start_aggregate<uint32_t>(array_sv(holder()), array_ev(holder()), n, off);
  599|  1.78k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (599:21): [True: 1, False: 1.78k]
  ------------------
  600|  1.78k|            } break;
  601|  3.16k|            case MSGPACK_CS_MAP_16: {
  ------------------
  |  Branch (601:13): [True: 3.16k, False: 649k]
  ------------------
  602|  3.16k|                parse_return ret = start_aggregate<uint16_t>(map_sv(holder()), map_ev(holder()), n, off);
  603|  3.16k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (603:21): [True: 1, False: 3.16k]
  ------------------
  604|  3.16k|            } break;
  605|  3.17k|            case MSGPACK_CS_MAP_32: {
  ------------------
  |  Branch (605:13): [True: 3.17k, False: 649k]
  ------------------
  606|  3.17k|                parse_return ret = start_aggregate<uint32_t>(map_sv(holder()), map_ev(holder()), n, off);
  607|  3.17k|                if (ret != PARSE_CONTINUE) return ret;
  ------------------
  |  Branch (607:21): [True: 2, False: 3.17k]
  ------------------
  608|  3.17k|            } break;
  609|  3.17k|            default:
  ------------------
  |  Branch (609:13): [True: 0, False: 652k]
  ------------------
  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|   652k|            }
  614|   652k|        }
  615|  2.06M|    } while(m_current != pe);
  ------------------
  |  Branch (615:13): [True: 2.05M, False: 691]
  ------------------
  616|       |
  617|    691|    off = static_cast<std::size_t>(m_current - m_start);
  618|    691|    return PARSE_CONTINUE;
  619|  2.25k|}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6holderEv:
   60|  4.51M|    VisitorHolder& holder() {
   61|  4.51M|        return static_cast<VisitorHolder&>(*this);
   62|  4.51M|    }
_ZNK7msgpack2v26detail12parse_helperINS1_21create_object_visitorEE7visitorEv:
 1028|  6.52M|    Visitor& visitor() const { return m_visitor; }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE16after_visit_procEbRm:
  103|  1.62M|    parse_return after_visit_proc(bool visit_result, std::size_t& off) {
  104|  1.62M|        ++m_current;
  105|  1.62M|        if (!visit_result) {
  ------------------
  |  Branch (105:13): [True: 0, False: 1.62M]
  ------------------
  106|      0|            off = static_cast<std::size_t>(m_current - m_start);
  107|      0|            return PARSE_STOP_VISITOR;
  108|      0|        }
  109|  1.62M|        parse_return ret = m_stack.consume(holder());
  110|  1.62M|        if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (110:13): [True: 1.12k, False: 1.62M]
  ------------------
  111|  1.12k|            off = static_cast<std::size_t>(m_current - m_start);
  112|  1.12k|        }
  113|  1.62M|        m_cs = MSGPACK_CS_HEADER;
  114|  1.62M|        return ret;
  115|  1.62M|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE12unpack_stack7consumeERS5_:
  175|  1.68M|        parse_return consume(VisitorHolder& visitor_holder) {
  176|  2.02M|            while (!m_stack.empty()) {
  ------------------
  |  Branch (176:20): [True: 2.02M, False: 1.19k]
  ------------------
  177|  2.02M|                stack_elem& e = m_stack.back();
  178|  2.02M|                switch (e.m_type) {
  ------------------
  |  Branch (178:25): [True: 0, False: 2.02M]
  ------------------
  179|   743k|                case MSGPACK_CT_ARRAY_ITEM:
  ------------------
  |  Branch (179:17): [True: 743k, False: 1.28M]
  ------------------
  180|   743k|                    if (!visitor_holder.visitor().end_array_item()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (180:25): [True: 0, False: 743k]
  ------------------
  181|   743k|                    if (--e.m_rest == 0)  {
  ------------------
  |  Branch (181:25): [True: 136k, False: 606k]
  ------------------
  182|   136k|                        m_stack.pop_back();
  183|   136k|                        if (!visitor_holder.visitor().end_array()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (183:29): [True: 0, False: 136k]
  ------------------
  184|   136k|                    }
  185|   606k|                    else {
  186|   606k|                        if (!visitor_holder.visitor().start_array_item()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (186:29): [True: 0, False: 606k]
  ------------------
  187|   606k|                        return PARSE_CONTINUE;
  188|   606k|                    }
  189|   136k|                    break;
  190|   643k|                case MSGPACK_CT_MAP_KEY:
  ------------------
  |  Branch (190:17): [True: 643k, False: 1.38M]
  ------------------
  191|   643k|                    if (!visitor_holder.visitor().end_map_key()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (191:25): [True: 0, False: 643k]
  ------------------
  192|   643k|                    if (!visitor_holder.visitor().start_map_value()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (192:25): [True: 0, False: 643k]
  ------------------
  193|   643k|                    e.m_type = MSGPACK_CT_MAP_VALUE;
  194|   643k|                    return PARSE_CONTINUE;
  195|   642k|                case MSGPACK_CT_MAP_VALUE:
  ------------------
  |  Branch (195:17): [True: 642k, False: 1.38M]
  ------------------
  196|   642k|                    if (!visitor_holder.visitor().end_map_value()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (196:25): [True: 0, False: 642k]
  ------------------
  197|   642k|                    if (--e.m_rest == 0) {
  ------------------
  |  Branch (197:25): [True: 207k, False: 435k]
  ------------------
  198|   207k|                        m_stack.pop_back();
  199|   207k|                        if (!visitor_holder.visitor().end_map()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (199:29): [True: 0, False: 207k]
  ------------------
  200|   207k|                    }
  201|   435k|                    else {
  202|   435k|                        e.m_type = MSGPACK_CT_MAP_KEY;
  203|   435k|                        if (!visitor_holder.visitor().start_map_key()) return PARSE_STOP_VISITOR;
  ------------------
  |  Branch (203:29): [True: 0, False: 435k]
  ------------------
  204|   435k|                        return PARSE_CONTINUE;
  205|   435k|                    }
  206|   207k|                    break;
  207|  2.02M|                }
  208|  2.02M|            }
  209|  1.19k|            return PARSE_SUCCESS;
  210|  1.68M|        }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE7next_csIPKcEEjT_:
   56|   623k|    {
   57|   623k|        return static_cast<uint32_t>(*p) & 0x1f;
   58|   623k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateINS_2v16detail7fix_tagENS6_8array_svENS6_8array_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|   165k|        std::size_t& off) {
   70|   165k|        typename value<T>::type size;
   71|   165k|        load<T>(size, load_pos);
   72|   165k|        ++m_current;
   73|   165k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 23.3k, False: 141k]
  ------------------
   74|  23.3k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 23.3k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  23.3k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 23.3k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  23.3k|            parse_return ret = m_stack.consume(holder());
   83|  23.3k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 28, False: 23.3k]
  ------------------
   84|     28|                off = static_cast<std::size_t>(m_current - m_start);
   85|     28|                return ret;
   86|     28|            }
   87|  23.3k|        }
   88|   141k|        else {
   89|   141k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 141k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|   141k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|   141k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 141k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|   141k|        }
   99|   165k|        m_cs = MSGPACK_CS_HEADER;
  100|   165k|        return PARSE_CONTINUE;
  101|   165k|    }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_svclEj:
  119|   177k|        bool operator()(uint32_t size) const {
  120|   177k|            return m_visitor_holder.visitor().start_array(size);
  121|   177k|        }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_evclEv:
  128|  31.8k|        bool operator()() const {
  129|  31.8k|            return m_visitor_holder.visitor().end_array();
  130|  31.8k|        }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE12unpack_stack4pushERS5_22msgpack_container_typej:
  161|   360k|        parse_return push(VisitorHolder& visitor_holder, msgpack_container_type type, uint32_t rest) {
  162|   360k|            m_stack.push_back(stack_elem(type, rest));
  163|   360k|            switch (type) {
  ------------------
  |  Branch (163:21): [True: 0, False: 360k]
  ------------------
  164|   145k|            case MSGPACK_CT_ARRAY_ITEM:
  ------------------
  |  Branch (164:13): [True: 145k, False: 214k]
  ------------------
  165|   145k|                return visitor_holder.visitor().start_array_item() ? PARSE_CONTINUE : PARSE_STOP_VISITOR;
  ------------------
  |  Branch (165:24): [True: 145k, False: 0]
  ------------------
  166|   214k|            case MSGPACK_CT_MAP_KEY:
  ------------------
  |  Branch (166:13): [True: 214k, False: 145k]
  ------------------
  167|   214k|                return visitor_holder.visitor().start_map_key() ? PARSE_CONTINUE : PARSE_STOP_VISITOR;
  ------------------
  |  Branch (167:24): [True: 214k, False: 0]
  ------------------
  168|      0|            case MSGPACK_CT_MAP_VALUE:
  ------------------
  |  Branch (168:13): [True: 0, False: 360k]
  ------------------
  169|      0|                MSGPACK_ASSERT(0);
  ------------------
  |  |   22|      0|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  170|      0|                return PARSE_STOP_VISITOR;
  171|   360k|            }
  172|      0|            MSGPACK_ASSERT(0);
  ------------------
  |  |   22|      0|#define MSGPACK_ASSERT BOOST_ASSERT
  ------------------
  173|      0|            return PARSE_STOP_VISITOR;
  174|   360k|        }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE12unpack_stack10stack_elemC2E22msgpack_container_typej:
  154|   360k|            stack_elem(msgpack_container_type type, uint32_t rest):m_type(type), m_rest(rest) {}
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_sv4typeEv:
  122|   145k|        msgpack_container_type type() const { return MSGPACK_CT_ARRAY_ITEM; }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_svC2ERS5_:
  118|   177k|        array_sv(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE8array_evC2ERS5_:
  127|   177k|        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|   240k|        std::size_t& off) {
   70|   240k|        typename value<T>::type size;
   71|   240k|        load<T>(size, load_pos);
   72|   240k|        ++m_current;
   73|   240k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 28.5k, False: 211k]
  ------------------
   74|  28.5k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 28.5k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  28.5k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 28.5k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  28.5k|            parse_return ret = m_stack.consume(holder());
   83|  28.5k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 37, False: 28.4k]
  ------------------
   84|     37|                off = static_cast<std::size_t>(m_current - m_start);
   85|     37|                return ret;
   86|     37|            }
   87|  28.5k|        }
   88|   211k|        else {
   89|   211k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 211k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|   211k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|   211k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 211k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|   211k|        }
   99|   240k|        m_cs = MSGPACK_CS_HEADER;
  100|   240k|        return PARSE_CONTINUE;
  101|   240k|    }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_svclEj:
  136|   246k|        bool operator()(uint32_t size) const {
  137|   246k|            return m_visitor_holder.visitor().start_map(size);
  138|   246k|        }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_evclEv:
  145|  32.2k|        bool operator()() const {
  146|  32.2k|            return m_visitor_holder.visitor().end_map();
  147|  32.2k|        }
_ZNK7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_sv4typeEv:
  139|   214k|        msgpack_container_type type() const { return MSGPACK_CT_MAP_KEY; }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_svC2ERS5_:
  135|   246k|        map_sv(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE6map_evC2ERS5_:
  144|   246k|        map_ev(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
_ZN7msgpack2v26detail14check_ext_sizeILm8EEEvm:
  227|    194|inline void check_ext_size(std::size_t /*size*/) {
  228|    194|}
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateItNS6_8array_svENS6_8array_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  10.6k|        std::size_t& off) {
   70|  10.6k|        typename value<T>::type size;
   71|  10.6k|        load<T>(size, load_pos);
   72|  10.6k|        ++m_current;
   73|  10.6k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 7.15k, False: 3.45k]
  ------------------
   74|  7.15k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 7.15k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  7.15k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 7.15k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  7.15k|            parse_return ret = m_stack.consume(holder());
   83|  7.15k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 2, False: 7.15k]
  ------------------
   84|      2|                off = static_cast<std::size_t>(m_current - m_start);
   85|      2|                return ret;
   86|      2|            }
   87|  7.15k|        }
   88|  3.45k|        else {
   89|  3.45k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 3.45k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|  3.45k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|  3.45k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 3.45k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|  3.45k|        }
   99|  10.6k|        m_cs = MSGPACK_CS_HEADER;
  100|  10.6k|        return PARSE_CONTINUE;
  101|  10.6k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateIjNS6_8array_svENS6_8array_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  1.78k|        std::size_t& off) {
   70|  1.78k|        typename value<T>::type size;
   71|  1.78k|        load<T>(size, load_pos);
   72|  1.78k|        ++m_current;
   73|  1.78k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 1.39k, False: 387]
  ------------------
   74|  1.39k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 1.39k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  1.39k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 1.39k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  1.39k|            parse_return ret = m_stack.consume(holder());
   83|  1.39k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 1, False: 1.39k]
  ------------------
   84|      1|                off = static_cast<std::size_t>(m_current - m_start);
   85|      1|                return ret;
   86|      1|            }
   87|  1.39k|        }
   88|    387|        else {
   89|    387|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 387]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|    387|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|    387|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 387]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|    387|        }
   99|  1.78k|        m_cs = MSGPACK_CS_HEADER;
  100|  1.78k|        return PARSE_CONTINUE;
  101|  1.78k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateItNS6_6map_svENS6_6map_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  3.16k|        std::size_t& off) {
   70|  3.16k|        typename value<T>::type size;
   71|  3.16k|        load<T>(size, load_pos);
   72|  3.16k|        ++m_current;
   73|  3.16k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 1.04k, False: 2.12k]
  ------------------
   74|  1.04k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 1.04k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  1.04k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 1.04k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  1.04k|            parse_return ret = m_stack.consume(holder());
   83|  1.04k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 1, False: 1.04k]
  ------------------
   84|      1|                off = static_cast<std::size_t>(m_current - m_start);
   85|      1|                return ret;
   86|      1|            }
   87|  1.04k|        }
   88|  2.12k|        else {
   89|  2.12k|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 2.12k]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|  2.12k|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|  2.12k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 2.12k]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|  2.12k|        }
   99|  3.16k|        m_cs = MSGPACK_CS_HEADER;
  100|  3.16k|        return PARSE_CONTINUE;
  101|  3.16k|    }
_ZN7msgpack2v26detail7contextINS1_12parse_helperINS1_21create_object_visitorEEEE15start_aggregateIjNS6_6map_svENS6_6map_evEEENS0_12parse_returnERKT0_RKT1_PKcRm:
   69|  3.17k|        std::size_t& off) {
   70|  3.17k|        typename value<T>::type size;
   71|  3.17k|        load<T>(size, load_pos);
   72|  3.17k|        ++m_current;
   73|  3.17k|        if (size == 0) {
  ------------------
  |  Branch (73:13): [True: 2.71k, False: 463]
  ------------------
   74|  2.71k|            if (!sv(size)) {
  ------------------
  |  Branch (74:17): [True: 0, False: 2.71k]
  ------------------
   75|      0|                off = static_cast<std::size_t>(m_current - m_start);
   76|      0|                return PARSE_STOP_VISITOR;
   77|      0|            }
   78|  2.71k|            if (!ev()) {
  ------------------
  |  Branch (78:17): [True: 0, False: 2.71k]
  ------------------
   79|      0|                off = static_cast<std::size_t>(m_current - m_start);
   80|      0|                return PARSE_STOP_VISITOR;
   81|      0|            }
   82|  2.71k|            parse_return ret = m_stack.consume(holder());
   83|  2.71k|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (83:17): [True: 2, False: 2.71k]
  ------------------
   84|      2|                off = static_cast<std::size_t>(m_current - m_start);
   85|      2|                return ret;
   86|      2|            }
   87|  2.71k|        }
   88|    463|        else {
   89|    463|            if (!sv(size)) {
  ------------------
  |  Branch (89:17): [True: 0, False: 463]
  ------------------
   90|      0|                off = static_cast<std::size_t>(m_current - m_start);
   91|      0|                return PARSE_STOP_VISITOR;
   92|      0|            }
   93|    463|            parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
   94|    463|            if (ret != PARSE_CONTINUE) {
  ------------------
  |  Branch (94:17): [True: 0, False: 463]
  ------------------
   95|      0|                off = static_cast<std::size_t>(m_current - m_start);
   96|      0|                return ret;
   97|      0|            }
   98|    463|        }
   99|  3.17k|        m_cs = MSGPACK_CS_HEADER;
  100|  3.17k|        return PARSE_CONTINUE;
  101|  3.17k|    }

_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.14k|    case PARSE_SUCCESS:
  ------------------
  |  Branch (36:5): [True: 1.14k, False: 1.10k]
  ------------------
   37|  1.14k|        return msgpack::object_handle(obj, msgpack::move(z));
   38|     50|    case PARSE_EXTRA_BYTES:
  ------------------
  |  Branch (38:5): [True: 50, False: 2.20k]
  ------------------
   39|     50|        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|}