_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEED2Ev:
 1245|  1.78k|    ~raw_hash_set() { destroy_slots(); }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE13destroy_slotsEv:
 2030|  1.78k|    void destroy_slots() {
 2031|  1.78k|        if (!capacity_)
  ------------------
  |  Branch (2031:13): [True: 1.08k, False: 704]
  ------------------
 2032|  1.08k|            return;
 2033|       |        
 2034|    704|        PHMAP_IF_CONSTEXPR((!std::is_trivially_destructible<typename PolicyTraits::value_type>::value ||
  ------------------
  |  |  654|    704|    #define PHMAP_IF_CONSTEXPR(expr) if constexpr ((expr))
  ------------------
 2035|    704|                            std::is_same<typename Policy::is_flat, std::false_type>::value)) {
 2036|       |            // node map, or not trivially destructible... we  need to iterate and destroy values one by one
 2037|       |            // std::cout << "either this is a node map or " << type_name<typename PolicyTraits::value_type>()  << " is not trivially_destructible\n";
 2038|       |            for (size_t i = 0, cnt = capacity_; i != cnt; ++i) {
 2039|       |                if (IsFull(ctrl_[i])) {
 2040|       |                    PolicyTraits::destroy(&alloc_ref(), slots_ + i);
 2041|       |                }
 2042|       |            }
 2043|       |        } 
 2044|    704|        auto layout = MakeLayout(capacity_);
 2045|       |        // Unpoison before returning the memory to the allocator.
 2046|    704|        SanitizerUnpoisonMemoryRegion(slots_, sizeof(slot_type) * capacity_);
 2047|    704|        Deallocate<Layout::Alignment()>(&alloc_ref(), ctrl_, layout.AllocSize());
 2048|    704|        ctrl_ = EmptyGroup<std_alloc_t>();
 2049|    704|        slots_ = nullptr;
 2050|    704|        size_ = 0;
 2051|    704|        capacity_ = 0;
 2052|    704|        growth_left() = 0;
 2053|    704|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE10MakeLayoutEm:
  887|  6.58k|    static Layout MakeLayout(size_t capacity) {
  888|  6.58k|        assert(IsValidCapacity(capacity));
  ------------------
  |  Branch (888:9): [True: 6.58k, False: 0]
  ------------------
  889|  6.58k|        return Layout(capacity + Group::kWidth + 1, capacity);
  890|  6.58k|    }
_ZN5phmap4priv15IsValidCapacityEm:
  545|  15.6k|inline bool IsValidCapacity(size_t n) { return ((n + 1) & n) == 0 && n > 0; }
  ------------------
  |  Branch (545:48): [True: 15.6k, False: 0]
  |  Branch (545:70): [True: 15.6k, False: 0]
  ------------------
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE9alloc_refEv:
 2365|  1.61M|    allocator_type& alloc_ref() { return std::get<3>(settings_); }
_ZN5phmap4priv10EmptyGroupINSt3__17is_sameINS2_9allocatorINS2_4pairIKjiEEEES8_EEEEPav:
  333|  2.48k|inline ctrl_t* EmptyGroup() {
  334|  2.48k|  PHMAP_IF_CONSTEXPR (std_alloc_t::value) {
  ------------------
  |  |  654|  2.48k|    #define PHMAP_IF_CONSTEXPR(expr) if constexpr ((expr))
  ------------------
  335|  2.48k|      alignas(16) static constexpr ctrl_t empty_group[] = {
  336|  2.48k|          kSentinel, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty,
  337|  2.48k|          kEmpty,    kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty};
  338|       |
  339|  2.48k|      return const_cast<ctrl_t*>(empty_group);
  340|       |  } else {
  341|       |       return nullptr;
  342|       |  }
  343|  2.48k|}
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE11growth_leftEv:
 2331|  1.16M|    size_t& growth_left() { return std::get<0>(settings_); }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EENS0_13StringHashEqTIcE4HashENSC_2EqENS7_INS3_4pairIKS9_S9_EEEEED2Ev:
 1245|    595|    ~raw_hash_set() { destroy_slots(); }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EENS0_13StringHashEqTIcE4HashENSC_2EqENS7_INS3_4pairIKS9_S9_EEEEE13destroy_slotsEv:
 2030|    595|    void destroy_slots() {
 2031|    595|        if (!capacity_)
  ------------------
  |  Branch (2031:13): [True: 595, False: 0]
  ------------------
 2032|    595|            return;
 2033|       |        
 2034|      0|        PHMAP_IF_CONSTEXPR((!std::is_trivially_destructible<typename PolicyTraits::value_type>::value ||
  ------------------
  |  |  654|      0|    #define PHMAP_IF_CONSTEXPR(expr) if constexpr ((expr))
  ------------------
 2035|      0|                            std::is_same<typename Policy::is_flat, std::false_type>::value)) {
 2036|       |            // node map, or not trivially destructible... we  need to iterate and destroy values one by one
 2037|       |            // std::cout << "either this is a node map or " << type_name<typename PolicyTraits::value_type>()  << " is not trivially_destructible\n";
 2038|      0|            for (size_t i = 0, cnt = capacity_; i != cnt; ++i) {
  ------------------
  |  Branch (2038:49): [True: 0, False: 0]
  ------------------
 2039|      0|                if (IsFull(ctrl_[i])) {
  ------------------
  |  Branch (2039:21): [True: 0, False: 0]
  ------------------
 2040|      0|                    PolicyTraits::destroy(&alloc_ref(), slots_ + i);
 2041|      0|                }
 2042|      0|            }
 2043|      0|        } 
 2044|      0|        auto layout = MakeLayout(capacity_);
 2045|       |        // Unpoison before returning the memory to the allocator.
 2046|      0|        SanitizerUnpoisonMemoryRegion(slots_, sizeof(slot_type) * capacity_);
 2047|      0|        Deallocate<Layout::Alignment()>(&alloc_ref(), ctrl_, layout.AllocSize());
 2048|      0|        ctrl_ = EmptyGroup<std_alloc_t>();
 2049|      0|        slots_ = nullptr;
 2050|      0|        size_ = 0;
 2051|      0|        capacity_ = 0;
 2052|      0|        growth_left() = 0;
 2053|      0|    }
_ZN5phmap4priv6IsFullEa:
  373|  2.77M|inline bool IsFull(ctrl_t c)           { return c >= static_cast<ctrl_t>(0); }
_ZN5phmap4priv10EmptyGroupINSt3__17is_sameINS2_9allocatorINS2_4pairIKNS2_12basic_stringIcNS2_11char_traitsIcEENS4_IcEEEESA_EEEESD_EEEEPav:
  333|    595|inline ctrl_t* EmptyGroup() {
  334|    595|  PHMAP_IF_CONSTEXPR (std_alloc_t::value) {
  ------------------
  |  |  654|    595|    #define PHMAP_IF_CONSTEXPR(expr) if constexpr ((expr))
  ------------------
  335|    595|      alignas(16) static constexpr ctrl_t empty_group[] = {
  336|    595|          kSentinel, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty,
  337|    595|          kEmpty,    kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty, kEmpty};
  338|       |
  339|    595|      return const_cast<ctrl_t*>(empty_group);
  340|       |  } else {
  341|       |       return nullptr;
  342|       |  }
  343|    595|}
_ZN5phmap13flat_hash_mapIjiNS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS5_4pairIKjiEEEEEC2Ev:
 4768|  1.19k|    flat_hash_map() {}
_ZN5phmap4priv12raw_hash_mapINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEEC2Ev:
 2420|  1.19k|    raw_hash_map() {}
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEEC2Ev:
 1063|  1.78k|        std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE6insertISC_TnNS8_9enable_ifIXsr5phmap11disjunctionINS8_14is_convertibleIT_NSA_IjiEEEENSE_22SameAsElementReferenceISI_EEEE5valueEiE4typeELi0ETnNSG_IXsr14IsDecomposableISI_EE5valueEiE4typeELi0ETnPSI_LPSC_0EEENSA_INSE_8iteratorEbEEOSI_:
 1303|  10.3M|    std::pair<iterator, bool> insert(T&& value) {
 1304|  10.3M|        return emplace(std::forward<T>(value));
 1305|  10.3M|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE7emplaceIJSC_ETnNS8_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSA_INSE_8iteratorEbEEDpOSH_:
 1442|  10.3M|    std::pair<iterator, bool> emplace(Args&&... args) {
 1443|  10.3M|        return PolicyTraits::apply(EmplaceDecomposable{*this},
 1444|  10.3M|                                   std::forward<Args>(args)...);
 1445|  10.3M|    }
_ZN5phmap4priv17FlatHashMapPolicyIjiE5applyINS0_12raw_hash_setIS2_NS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS9_4pairIKjiEEEEE19EmplaceDecomposableEJSD_EEEDTclsr5phmap4privE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSH_DpOSI_:
 4339|  10.3M|    apply(F&& f, Args&&... args) {
 4340|  10.3M|        return phmap::priv::DecomposePair(std::forward<F>(f),
 4341|  10.3M|                                                        std::forward<Args>(args)...);
 4342|  10.3M|    }
_ZN5phmap4priv13DecomposePairINS0_12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS9_4pairIKjiEEEEE19EmplaceDecomposableEJSD_EEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
 4234|  10.3M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
 4235|  10.3M|    return memory_internal::DecomposePairImpl(
 4236|  10.3M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
 4237|  10.3M|}
_ZN5phmap4priv15memory_internal17DecomposePairImplINS0_12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINSA_4pairIKjiEEEEE19EmplaceDecomposableEOSD_NSA_5tupleIJOiEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSA_19piecewise_constructEEclsr3stdE7declvalINSJ_IJSN_EEEEEclsr3stdE7declvalIT1_EEEEOSM_NSC_ISQ_SR_EE:
  756|  10.3M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  757|  10.3M|    const auto& key = std::get<0>(p.first);
  758|  10.3M|    return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  759|  10.3M|                              std::move(p.second));
  760|  10.3M|}
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE19EmplaceDecomposableclIjJRKNS8_21piecewise_construct_tENS8_5tupleIJOSB_EEENSK_IJOiEEEEEENSA_INSE_8iteratorEbEERKT_DpOT0_:
 1933|  10.3M|        std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 1934|  10.3M|            return s.emplace_decomposable(key, s.hash(key), std::forward<Args>(args)...);
 1935|  10.3M|        }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE20emplace_decomposableIjJRKNS8_21piecewise_construct_tENS8_5tupleIJOSB_EEENSJ_IJOiEEEEEENSA_INSE_8iteratorEbEERKT_mDpOT0_:
 1919|  10.3M|    {
 1920|  10.3M|        size_t offset = _find_key(key, hashval);
 1921|  10.3M|        if (offset == (size_t)-1) {
  ------------------
  |  Branch (1921:13): [True: 578k, False: 9.73M]
  ------------------
 1922|   578k|            offset = prepare_insert(hashval);
 1923|   578k|            emplace_at(offset, std::forward<Args>(args)...);
 1924|   578k|            this->set_ctrl(offset, H2(hashval));
 1925|   578k|            return {iterator_at(offset), true};
 1926|   578k|        }
 1927|  9.73M|        return {iterator_at(offset), false};
 1928|  10.3M|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE9_find_keyIjEEmRKT_m:
 2224|  10.3M|    size_t _find_key(const K& PHMAP_RESTRICT key, size_t hashval) {
 2225|  10.3M|        PHMAP_IF_CONSTEXPR (!std_alloc_t::value) {
  ------------------
  |  |  654|  10.3M|    #define PHMAP_IF_CONSTEXPR(expr) if constexpr ((expr))
  ------------------
 2226|       |            // ctrl_ could be nullptr
 2227|       |            if (!ctrl_)
 2228|       |                return (size_t)-1;
 2229|       |        }
 2230|  10.3M|        auto seq = probe(hashval);
 2231|  11.4M|        while (true) {
  ------------------
  |  Branch (2231:16): [True: 11.4M, Folded]
  ------------------
 2232|  11.4M|            Group g{ctrl_ + seq.offset()};
 2233|  11.4M|            for (uint32_t i : g.Match((h2_t)H2(hashval))) {
  ------------------
  |  Branch (2233:29): [True: 11.3M, False: 1.67M]
  ------------------
 2234|  11.3M|                if (PHMAP_PREDICT_TRUE(PolicyTraits::apply(
  ------------------
  |  |  220|  11.3M|    #define PHMAP_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (220:35): [True: 9.73M, False: 1.61M]
  |  |  ------------------
  ------------------
 2235|  11.3M|                                          EqualElement<K>{key, eq_ref()},
 2236|  11.3M|                                          PolicyTraits::element(slots_ + seq.offset((size_t)i)))))
 2237|  9.73M|                    return seq.offset((size_t)i);
 2238|  11.3M|            }
 2239|  1.67M|            if (PHMAP_PREDICT_TRUE(g.MatchEmpty())) break;
  ------------------
  |  |  220|  1.67M|    #define PHMAP_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (220:35): [True: 578k, False: 1.09M]
  |  |  ------------------
  ------------------
 2240|  1.09M|            seq.next();
 2241|  1.09M|        }
 2242|   578k|        return (size_t)-1;
 2243|  10.3M|    }
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE5probeEm:
 2316|  12.4M|    probe_seq<Group::kWidth> probe(size_t hashval) const {
 2317|  12.4M|        return probe_seq<Group::kWidth>(H1(hashval, ctrl_), capacity_);
 2318|  12.4M|    }
_ZN5phmap4priv2H1EmPKa:
  363|  12.4M|inline size_t H1(size_t hashval, const ctrl_t* ) {
  364|  12.4M|    return (hashval >> 7);
  365|  12.4M|}
_ZN5phmap4priv9probe_seqILm16EEC2Emm:
  148|  12.4M|    probe_seq(size_t hashval, size_t mask) {
  149|  12.4M|        assert(((mask + 1) & mask) == 0 && "not a mask");
  ------------------
  |  Branch (149:9): [True: 12.4M, False: 0]
  |  Branch (149:9): [True: 12.4M, Folded]
  |  Branch (149:9): [True: 12.4M, False: 0]
  ------------------
  150|  12.4M|        mask_ = mask;
  151|  12.4M|        offset_ = hashval & mask_;
  152|  12.4M|    }
_ZNK5phmap4priv9probe_seqILm16EE6offsetEv:
  153|  13.6M|    size_t offset() const { return offset_; }
_ZN5phmap4priv13GroupSse2ImplC2EPKa:
  413|  13.8M|    explicit GroupSse2Impl(const ctrl_t* pos) {
  414|  13.8M|        ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
  415|  13.8M|    }
_ZNK5phmap4priv13GroupSse2Impl5MatchEh:
  419|  13.6M|    BitMask<uint32_t, kWidth> Match(h2_t hash) const {
  420|  13.6M|        auto match = _mm_set1_epi8((char)hash);
  421|  13.6M|        return BitMask<uint32_t, kWidth>(
  422|  13.6M|            static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  423|  13.6M|    }
_ZN5phmap4priv7BitMaskIjLi16ELi0EEC2Ej:
  251|  27.3M|    explicit BitMask(T mask) : mask_(mask) {}
_ZNK5phmap4priv7BitMaskIjLi16ELi0EE5beginEv:
  269|  11.9M|    BitMask begin() const { return *this; }
_ZNK5phmap4priv7BitMaskIjLi16ELi0EE3endEv:
  270|  11.9M|    BitMask end() const { return BitMask(0); }
_ZN5phmap4privneERKNS0_7BitMaskIjLi16ELi0EEES4_:
  286|  13.5M|    friend bool operator!=(const BitMask& a, const BitMask& b) {
  287|  13.5M|        return a.mask_ != b.mask_;
  288|  13.5M|    }
_ZNK5phmap4priv7BitMaskIjLi16ELi0EEdeEv:
  259|  11.9M|    uint32_t operator*() const { return LowestBitSet(); }
_ZNK5phmap4priv7BitMaskIjLi16ELi0EE12LowestBitSetEv:
  261|  13.5M|    uint32_t LowestBitSet() const {
  262|  13.5M|        return priv::TrailingZeros(mask_) >> Shift;
  263|  13.5M|    }
_ZN5phmap4priv13TrailingZerosIjEEjT_:
  208|  13.7M|uint32_t TrailingZeros(T x) {
  209|  13.7M|    uint32_t res;
  210|  13.7M|    PHMAP_IF_CONSTEXPR(sizeof(T) == 8)
  ------------------
  |  |  654|  13.7M|    #define PHMAP_IF_CONSTEXPR(expr) if constexpr ((expr))
  ------------------
  211|       |        res = base_internal::CountTrailingZerosNonZero64(static_cast<uint64_t>(x));
  212|       |    else
  213|  13.7M|        res = base_internal::CountTrailingZerosNonZero32(static_cast<uint32_t>(x));
  214|  13.7M|    return res;
  215|  13.7M|}
_ZN5phmap4priv17FlatHashMapPolicyIjiE5applyINS0_12raw_hash_setIS2_NS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS9_4pairIKjiEEEEE12EqualElementIjEEJRSD_EEEDTclsr5phmap4privE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
 4339|  11.3M|    apply(F&& f, Args&&... args) {
 4340|  11.3M|        return phmap::priv::DecomposePair(std::forward<F>(f),
 4341|  11.3M|                                                        std::forward<Args>(args)...);
 4342|  11.3M|    }
_ZN5phmap4priv13DecomposePairINS0_12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS9_4pairIKjiEEEEE12EqualElementIjEEJRSD_EEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
 4234|  11.3M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
 4235|  11.3M|    return memory_internal::DecomposePairImpl(
 4236|  11.3M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
 4237|  11.3M|}
_ZN5phmap4priv15memory_internal17DecomposePairImplINS0_12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINSA_4pairIKjiEEEEE12EqualElementIjEERSD_NSA_5tupleIJRKiEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSA_19piecewise_constructEEclsr3stdE7declvalINSK_IJSP_EEEEEclsr3stdE7declvalIT1_EEEEOSO_NSC_ISS_ST_EE:
  756|  11.3M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  757|  11.3M|    const auto& key = std::get<0>(p.first);
  758|  11.3M|    return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  759|  11.3M|                              std::move(p.second));
  760|  11.3M|}
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE12EqualElementIjEclIjJRKNS8_21piecewise_construct_tENS8_5tupleIJRSB_EEENSL_IJRKiEEEEEEbRKT_DpOT0_:
 1909|  11.3M|        bool operator()(const K2& lhs, Args&&...) const {
 1910|  11.3M|            return eq(lhs, rhs);
 1911|  11.3M|        }
_ZN5phmap4priv8PairArgsIKjiEENSt3__14pairINS3_5tupleIJRKT_EEENS5_IJRKT0_EEEEERKNS4_IS6_SA_EE:
 4212|  12.9M|    const std::pair<F, S>& p) {
 4213|  12.9M|    return PairArgs(p.first, p.second);
 4214|  12.9M|}
_ZN5phmap4priv8PairArgsIRKjRKiEENSt3__14pairINS6_5tupleIJOT_EEENS8_IJOT0_EEEEESA_SD_:
 4205|  12.9M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
 4206|  12.9M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
 4207|  12.9M|          std::forward_as_tuple(std::forward<S>(s))};
 4208|  12.9M|}
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE6eq_refEv:
 2363|  11.3M|    key_equal& eq_ref() { return std::get<2>(settings_); }
_ZN5phmap4priv17FlatHashMapPolicyIjiE7elementEPNS0_13map_slot_typeIjiEE:
 4346|  13.4M|    static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZNK5phmap4priv9probe_seqILm16EE6offsetEm:
  154|  23.2M|    size_t offset(size_t i) const { return (offset_ + i) & mask_; }
_ZN5phmap4priv7BitMaskIjLi16ELi0EEppEv:
  253|  1.61M|    BitMask& operator++() {    // ++iterator
  254|  1.61M|        mask_ &= (mask_ - 1);  // clear the least significant bit set
  255|  1.61M|        return *this;
  256|  1.61M|    }
_ZNK5phmap4priv13GroupSse2Impl10MatchEmptyEv:
  427|  1.67M|    BitMask<uint32_t, kWidth> MatchEmpty() const {
  428|       |#if PHMAP_HAVE_SSSE3
  429|       |        // This only works because kEmpty is -128.
  430|       |        return BitMask<uint32_t, kWidth>(
  431|       |            static_cast<uint32_t>(_mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl))));
  432|       |#else
  433|  1.67M|        return Match(static_cast<h2_t>(kEmpty));
  434|  1.67M|#endif
  435|  1.67M|    }
_ZNK5phmap4priv7BitMaskIjLi16ELi0EEcvbEv:
  258|  3.37M|    explicit operator bool() const { return mask_ != 0; }
_ZN5phmap4priv9probe_seqILm16EE4nextEv:
  156|  1.18M|    void next() {
  157|  1.18M|        index_ += Width;
  158|  1.18M|        offset_ += index_;
  159|  1.18M|        offset_ &= mask_;
  160|  1.18M|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE14prepare_insertEm:
 2253|   578k|    size_t prepare_insert(size_t hashval) PHMAP_ATTRIBUTE_NOINLINE {
 2254|   578k|        PHMAP_IF_CONSTEXPR (!std_alloc_t::value) {
  ------------------
  |  |  654|   578k|    #define PHMAP_IF_CONSTEXPR(expr) if constexpr ((expr))
  ------------------
 2255|       |            // ctrl_ could be nullptr
 2256|       |            if (!ctrl_)
 2257|       |                rehash_and_grow_if_necessary();
 2258|       |        }
 2259|   578k|        FindInfo target = find_first_non_full(hashval);
 2260|   578k|        if (PHMAP_PREDICT_FALSE(growth_left() == 0 &&
  ------------------
  |  |  219|   581k|    #define PHMAP_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (219:36): [True: 3.15k, False: 575k]
  |  |  |  Branch (219:54): [True: 3.15k, False: 575k]
  |  |  |  Branch (219:54): [True: 3.15k, False: 0]
  |  |  ------------------
  ------------------
 2261|   578k|                               !IsDeleted(ctrl_[target.offset]))) {
 2262|  3.15k|            rehash_and_grow_if_necessary();
 2263|  3.15k|            target = find_first_non_full(hashval);
 2264|  3.15k|        }
 2265|   578k|        ++size_;
 2266|   578k|        growth_left() -= IsEmpty(ctrl_[target.offset]);
 2267|       |        // set_ctrl(target.offset, H2(hashval));
 2268|   578k|        infoz_.RecordInsert(hashval, target.probe_length);
 2269|   578k|        return target.offset;
 2270|   578k|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE19find_first_non_fullEm:
 2197|  1.60M|    FindInfo find_first_non_full(size_t hashval) {
 2198|  1.60M|        auto seq = probe(hashval);
 2199|  1.69M|        while (true) {
  ------------------
  |  Branch (2199:16): [True: 1.69M, Folded]
  ------------------
 2200|  1.69M|            Group g{ctrl_ + seq.offset()};
 2201|  1.69M|            auto mask = g.MatchEmptyOrDeleted();
 2202|  1.69M|            if (mask) {
  ------------------
  |  Branch (2202:17): [True: 1.60M, False: 88.2k]
  ------------------
 2203|  1.60M|                return {seq.offset((size_t)mask.LowestBitSet()), seq.getindex()};
 2204|  1.60M|            }
 2205|  1.69M|            assert(seq.getindex() < capacity_ && "full table!");
  ------------------
  |  Branch (2205:13): [True: 88.2k, False: 0]
  |  Branch (2205:13): [True: 88.2k, Folded]
  |  Branch (2205:13): [True: 88.2k, False: 0]
  ------------------
 2206|  88.2k|            seq.next();
 2207|  88.2k|        }
 2208|  1.60M|    }
_ZNK5phmap4priv13GroupSse2Impl19MatchEmptyOrDeletedEv:
  439|  1.69M|    BitMask<uint32_t, kWidth> MatchEmptyOrDeleted() const {
  440|  1.69M|        auto special = _mm_set1_epi8(static_cast<char>(kSentinel));
  441|  1.69M|        return BitMask<uint32_t, kWidth>(
  442|  1.69M|            static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl))));
  443|  1.69M|    }
_ZN5phmap4priv20_mm_cmpgt_epi8_fixedEDv2_xS1_:
  391|  1.91M|inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) {
  392|       |#if defined(__GNUC__) && !defined(__clang__)
  393|       |  #pragma GCC diagnostic push
  394|       |  #pragma GCC diagnostic ignored "-Woverflow"
  395|       |
  396|       |  if (std::is_unsigned<char>::value) {
  397|       |    const __m128i mask = _mm_set1_epi8(static_cast<char>(0x80));
  398|       |    const __m128i diff = _mm_subs_epi8(b, a);
  399|       |    return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask);
  400|       |  }
  401|       |
  402|       |  #pragma GCC diagnostic pop
  403|       |#endif
  404|  1.91M|  return _mm_cmpgt_epi8(a, b);
  405|  1.91M|}
_ZNK5phmap4priv9probe_seqILm16EE8getindexEv:
  162|  1.69M|    size_t getindex() const { return index_; }
_ZN5phmap4priv9IsDeletedEa:
  374|  3.15k|inline bool IsDeleted(ctrl_t c)        { return c == kDeleted; }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE28rehash_and_grow_if_necessaryEv:
 2145|  3.15k|    void rehash_and_grow_if_necessary() {
 2146|  3.15k|        if (capacity_ == 0) {
  ------------------
  |  Branch (2146:13): [True: 564, False: 2.58k]
  ------------------
 2147|    564|            resize(1);
 2148|  2.58k|        } else if (size() <= CapacityToGrowth(capacity()) / 2) {
  ------------------
  |  Branch (2148:20): [True: 0, False: 2.58k]
  ------------------
 2149|       |            // Squash DELETED without growing if there is enough capacity.
 2150|      0|            drop_deletes_without_resize();
 2151|  2.58k|        } else {
 2152|       |            // Otherwise grow the container.
 2153|  2.58k|            resize(capacity_ * 2 + 1);
 2154|  2.58k|        }
 2155|  3.15k|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE6resizeEm:
 2055|  3.15k|    void resize(size_t new_capacity) {
 2056|  3.15k|        assert(IsValidCapacity(new_capacity));
  ------------------
  |  Branch (2056:9): [True: 3.15k, False: 0]
  ------------------
 2057|  3.15k|        auto* old_ctrl = ctrl_;
 2058|  3.15k|        auto* old_slots = slots_;
 2059|  3.15k|        const size_t old_capacity = capacity_;
 2060|  3.15k|        initialize_slots(new_capacity);
 2061|  3.15k|        capacity_ = new_capacity;
 2062|       |
 2063|  1.17M|        for (size_t i = 0; i != old_capacity; ++i) {
  ------------------
  |  Branch (2063:28): [True: 1.16M, False: 3.15k]
  ------------------
 2064|  1.16M|            if (IsFull(old_ctrl[i])) {
  ------------------
  |  Branch (2064:17): [True: 1.02M, False: 144k]
  ------------------
 2065|  1.02M|                size_t hashval = PolicyTraits::apply(HashElement{hash_ref()},
 2066|  1.02M|                                                     PolicyTraits::element(old_slots + i));
 2067|  1.02M|                auto target = find_first_non_full(hashval);
 2068|  1.02M|                size_t new_i = target.offset;
 2069|  1.02M|                set_ctrl(new_i, H2(hashval));
 2070|  1.02M|                PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, old_slots + i);
 2071|  1.02M|            }
 2072|  1.16M|        }
 2073|  3.15k|        if (old_capacity) {
  ------------------
  |  Branch (2073:13): [True: 2.58k, False: 564]
  ------------------
 2074|  2.58k|            SanitizerUnpoisonMemoryRegion(old_slots,
 2075|  2.58k|                                          sizeof(slot_type) * old_capacity);
 2076|  2.58k|            auto layout = MakeLayout(old_capacity);
 2077|  2.58k|            Deallocate<Layout::Alignment()>(&alloc_ref(), old_ctrl,
 2078|  2.58k|                                            layout.AllocSize());
 2079|  2.58k|        }
 2080|  3.15k|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE16initialize_slotsEm:
 2013|  3.29k|    void initialize_slots(size_t new_capacity) {
 2014|  3.29k|        assert(new_capacity);
  ------------------
  |  Branch (2014:9): [True: 3.29k, False: 0]
  ------------------
 2015|  3.29k|        if (std::is_same<SlotAlloc, std::allocator<slot_type>>::value && 
  ------------------
  |  Branch (2015:13): [True: 3.29k, Folded]
  ------------------
 2016|  3.29k|            slots_ == nullptr) {
  ------------------
  |  Branch (2016:13): [True: 704, False: 2.58k]
  ------------------
 2017|    704|            infoz_ = Sample();
 2018|    704|        }
 2019|       |
 2020|  3.29k|        auto layout = MakeLayout(new_capacity);
 2021|  3.29k|        char* mem = static_cast<char*>(
 2022|  3.29k|            Allocate<Layout::Alignment()>(&alloc_ref(), layout.AllocSize()));
 2023|  3.29k|        ctrl_ = reinterpret_cast<ctrl_t*>(layout.template Pointer<0>(mem));
 2024|  3.29k|        slots_ = layout.template Pointer<1>(mem);
 2025|  3.29k|        reset_ctrl(new_capacity);
 2026|  3.29k|        reset_growth_left(new_capacity);
 2027|  3.29k|        infoz_.RecordStorageChanged(size_, new_capacity);
 2028|  3.29k|    }
phashmap_fuzz.cc:_ZN5phmap4privL6SampleEv:
  684|    704|static inline HashtablezInfoHandle Sample() { return HashtablezInfoHandle(); }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE10reset_ctrlEm:
 2321|  3.29k|    void reset_ctrl(size_t new_capacity) {
 2322|  3.29k|        std::memset(ctrl_, kEmpty, new_capacity + Group::kWidth);
 2323|  3.29k|        ctrl_[new_capacity] = kSentinel;
 2324|  3.29k|        SanitizerPoisonMemoryRegion(slots_, sizeof(slot_type) * new_capacity);
 2325|  3.29k|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE17reset_growth_leftEm:
 2327|  3.29k|    void reset_growth_left(size_t new_capacity) {
 2328|  3.29k|        growth_left() = CapacityToGrowth(new_capacity) - size_;
 2329|  3.29k|    }
_ZN5phmap4priv20HashtablezInfoHandle20RecordStorageChangedEmm:
  676|  3.29k|    inline void RecordStorageChanged(size_t , size_t ) {}
_ZN5phmap4priv17FlatHashMapPolicyIjiE5applyINS0_12raw_hash_setIS2_NS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS9_4pairIKjiEEEEE11HashElementEJRSD_EEEDTclsr5phmap4privE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSI_DpOSJ_:
 4339|  1.02M|    apply(F&& f, Args&&... args) {
 4340|  1.02M|        return phmap::priv::DecomposePair(std::forward<F>(f),
 4341|  1.02M|                                                        std::forward<Args>(args)...);
 4342|  1.02M|    }
_ZN5phmap4priv13DecomposePairINS0_12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS9_4pairIKjiEEEEE11HashElementEJRSD_EEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSI_DpOSJ_:
 4234|  1.02M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
 4235|  1.02M|    return memory_internal::DecomposePairImpl(
 4236|  1.02M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
 4237|  1.02M|}
_ZN5phmap4priv15memory_internal17DecomposePairImplINS0_12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINSA_4pairIKjiEEEEE11HashElementERSD_NSA_5tupleIJRKiEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSA_19piecewise_constructEEclsr3stdE7declvalINSJ_IJSO_EEEEEclsr3stdE7declvalIT1_EEEEOSN_NSC_ISR_SS_EE:
  756|  1.58M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  757|  1.58M|    const auto& key = std::get<0>(p.first);
  758|  1.58M|    return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  759|  1.58M|                              std::move(p.second));
  760|  1.58M|}
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE11HashElementclIjJRKNS8_21piecewise_construct_tENS8_5tupleIJRSB_EEENSK_IJRKiEEEEEEmRKT_DpOT0_:
 1895|  1.58M|        size_t operator()(const K& key, Args&&...) const {
 1896|       |#if PHMAP_DISABLE_MIX
 1897|       |            return h(key);
 1898|       |#else
 1899|  1.58M|            return phmap_mix<sizeof(size_t)>()(h(key));
 1900|  1.58M|#endif
 1901|  1.58M|        }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE8hash_refEv:
 2361|  1.02M|    hasher& hash_ref() { return std::get<1>(settings_); }
_ZN5phmap4priv17FlatHashMapPolicyIjiE8transferINSt3__19allocatorINS4_4pairIKjiEEEEEEvPT_PNS0_13map_slot_typeIjiEESE_:
 4332|  1.02M|                         slot_type* old_slot) {
 4333|  1.02M|        slot_policy::transfer(alloc, new_slot, old_slot);
 4334|  1.02M|    }
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE4sizeEv:
 1270|  3.94k|    size_t size() const { return size_; }
_ZN5phmap4priv16CapacityToGrowthEm:
  583|  5.88k|{
  584|  5.88k|    assert(IsValidCapacity(capacity));
  ------------------
  |  Branch (584:5): [True: 5.88k, False: 0]
  ------------------
  585|       |    // `capacity*7/8`
  586|  5.88k|    PHMAP_IF_CONSTEXPR (Group::kWidth == 8) {
  ------------------
  |  |  654|  5.88k|    #define PHMAP_IF_CONSTEXPR(expr) if constexpr ((expr))
  ------------------
  587|  5.88k|        if (capacity == 7) {
  588|       |            // x-x/8 does not work when x==7.
  589|       |            return 6;
  590|       |        }
  591|       |    }
  592|  5.88k|    return capacity - capacity / 8;
  593|  5.88k|}
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE8capacityEv:
 1271|  2.93k|    size_t capacity() const { return capacity_; }
_ZN5phmap4priv7IsEmptyEa:
  372|   578k|inline bool IsEmpty(ctrl_t c)          { return c == kEmpty; }
_ZN5phmap4priv20HashtablezInfoHandle12RecordInsertEmm:
  678|   578k|    inline void RecordInsert(size_t , size_t ) {}
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE10emplace_atIJRKNS8_21piecewise_construct_tENS8_5tupleIJOSB_EEENSJ_IJOiEEEEEEvmDpOT_:
 2281|   578k|    void emplace_at(size_t i, Args&&... args) {
 2282|   578k|        PolicyTraits::construct(&alloc_ref(), slots_ + i,
 2283|   578k|                                std::forward<Args>(args)...);
 2284|       |        
 2285|       |#ifdef PHMAP_CHECK_CONSTRUCTED_VALUE
 2286|       |        // this check can be costly, so do it only when requested
 2287|       |        assert(PolicyTraits::apply(FindElement{*this}, *iterator_at(i)) ==
 2288|       |               iterator_at(i) &&
 2289|       |               "constructed value does not match the lookup key");
 2290|       |#endif
 2291|   578k|    }
_ZN5phmap4priv17FlatHashMapPolicyIjiE9constructINSt3__19allocatorINS4_4pairIKjiEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJOS7_EEENSD_IJOiEEEEEEvPT_PNS0_13map_slot_typeIjiEEDpOT0_:
 4321|   578k|    static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
 4322|   578k|        slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
 4323|   578k|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE8set_ctrlEma:
 2299|  1.60M|    void set_ctrl(size_t i, ctrl_t h) {
 2300|  1.60M|        assert(i < capacity_);
  ------------------
  |  Branch (2300:9): [True: 1.60M, False: 0]
  ------------------
 2301|       |
 2302|  1.60M|        if (IsFull(h)) {
  ------------------
  |  Branch (2302:13): [True: 1.60M, False: 0]
  ------------------
 2303|  1.60M|            SanitizerUnpoisonObject(slots_ + i);
 2304|  1.60M|        } else {
 2305|      0|            SanitizerPoisonObject(slots_ + i);
 2306|      0|        }
 2307|       |
 2308|  1.60M|        ctrl_[i] = h;
 2309|  1.60M|        ctrl_[((i - Group::kWidth) & capacity_) + 1 +
 2310|  1.60M|              ((Group::kWidth - 1) & capacity_)] = h;
 2311|  1.60M|    }
_ZN5phmap4priv2H2Em:
  370|  13.5M|inline ctrl_t H2(size_t hashval)       { return (ctrl_t)(hashval & 0x7F); }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE11iterator_atEm:
 2293|  10.3M|    iterator iterator_at(size_t i) { return {ctrl_ + i, slots_ + i}; }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE8iteratorC2EPaPNS0_13map_slot_typeIjiEE:
  992|  10.3M|        iterator(ctrl_t* ctrl, slot_type* slot) : ctrl_(ctrl), slot_(slot) {}
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE4hashIjEEmRKT_:
 1852|  10.3M|    size_t hash(const K& key) const {
 1853|  10.3M|        return HashElement{hash_ref()}(key);
 1854|  10.3M|    }
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE8hash_refEv:
 2362|  10.8M|    const hasher& hash_ref() const { return std::get<1>(settings_); }
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE11HashElementclIjJEEEmRKT_DpOT0_:
 1895|  10.3M|        size_t operator()(const K& key, Args&&...) const {
 1896|       |#if PHMAP_DISABLE_MIX
 1897|       |            return h(key);
 1898|       |#else
 1899|  10.3M|            return phmap_mix<sizeof(size_t)>()(h(key));
 1900|  10.3M|#endif
 1901|  10.3M|        }
_ZN5phmap4priv8PairArgsIKjiEENSt3__14pairINS3_5tupleIJOT_EEENS5_IJOT0_EEEEEONS4_IS6_S9_EE:
 4217|  10.3M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(std::pair<F, S>&& p) {
 4218|  10.3M|    return PairArgs(std::forward<F>(p.first), std::forward<S>(p.second));
 4219|  10.3M|}
_ZN5phmap4priv8PairArgsIKjiEENSt3__14pairINS3_5tupleIJOT_EEENS5_IJOT0_EEEEES7_SA_:
 4205|  10.3M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
 4206|  10.3M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
 4207|  10.3M|          std::forward_as_tuple(std::forward<S>(s))};
 4208|  10.3M|}
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE11growth_leftEv:
 2333|    564|    const size_t& growth_left() const { return std::get<0>(settings_); }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE4swapERSE_:
 1678|    595|         IsNoThrowSwappable<allocator_type>(typename AllocTraits::propagate_on_container_swap{}))) {
 1679|    595|        using std::swap;
 1680|    595|        swap(ctrl_, that.ctrl_);
 1681|    595|        swap(slots_, that.slots_);
 1682|    595|        swap(size_, that.size_);
 1683|    595|        swap(capacity_, that.capacity_);
 1684|    595|        swap(growth_left(), that.growth_left());
 1685|    595|        swap(hash_ref(), that.hash_ref());
 1686|    595|        swap(eq_ref(), that.eq_ref());
 1687|    595|        swap(infoz_, that.infoz_);
 1688|    595|        SwapAlloc(alloc_ref(), that.alloc_ref(), typename AllocTraits::propagate_on_container_swap{});
 1689|    595|    }
_ZN5phmap4priv4swapERNS0_20HashtablezInfoHandleES2_:
  681|    595|                            HashtablezInfoHandle& ) noexcept {}
_ZN5phmap4priv9SwapAllocINSt3__19allocatorINS2_4pairIKjiEEEEEEvRT_S9_NS2_17integral_constantIbLb0EEE:
  141|    595|               std::false_type /* propagate_on_container_swap */) {}
_ZN5phmap4priveqERKNS0_12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEEESG_:
 1831|    595|    friend bool operator==(const raw_hash_set& a, const raw_hash_set& b) {
 1832|    595|        if (a.size() != b.size()) return false;
  ------------------
  |  Branch (1832:13): [True: 424, False: 171]
  ------------------
 1833|    171|        const raw_hash_set* outer = &a;
 1834|    171|        const raw_hash_set* inner = &b;
 1835|    171|        if (outer->capacity() > inner->capacity()) 
  ------------------
  |  Branch (1835:13): [True: 0, False: 171]
  ------------------
 1836|      0|            std::swap(outer, inner);
 1837|    171|        for (const value_type& elem : *outer)
  ------------------
  |  Branch (1837:37): [True: 561k, False: 44]
  ------------------
 1838|   561k|            if (!inner->has_element(elem)) return false;
  ------------------
  |  Branch (1838:17): [True: 127, False: 561k]
  ------------------
 1839|     44|        return true;
 1840|    171|    }
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE5beginEv:
 1262|    171|    const_iterator begin() const {
 1263|    171|        return const_cast<raw_hash_set*>(this)->begin();
 1264|    171|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE5beginEv:
 1247|    171|    iterator begin() {
 1248|    171|        if (empty()) return end();
  ------------------
  |  Branch (1248:13): [True: 31, False: 140]
  ------------------
 1249|    140|        auto it = iterator_at(0);
 1250|    140|        it.skip_empty_or_deleted();
 1251|    140|        return it;
 1252|    171|    }
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE5emptyEv:
 1269|    171|    bool empty() const { return !size(); }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE3endEv:
 1254|    202|    {
 1255|       |#if 0 // PHMAP_BIDIRECTIONAL
 1256|       |        return iterator_at(capacity_); 
 1257|       |#else
 1258|    202|        return {ctrl_ + capacity_};
 1259|    202|#endif
 1260|    202|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE8iteratorC2EPa:
  991|    202|        iterator(ctrl_t* ctrl) : ctrl_(ctrl) {}  // for end()
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE8iterator21skip_empty_or_deletedEv:
  994|   561k|        void skip_empty_or_deleted() {
  995|   561k|            PHMAP_IF_CONSTEXPR (!std_alloc_t::value) {
  ------------------
  |  |  654|   561k|    #define PHMAP_IF_CONSTEXPR(expr) if constexpr ((expr))
  ------------------
  996|       |                // ctrl_ could be nullptr
  997|       |                if (!ctrl_)
  998|       |                    return;
  999|       |            }
 1000|   780k|            while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (1000:20): [True: 218k, False: 561k]
  ------------------
 1001|       |                // ctrl is not necessarily aligned to Group::kWidth. It is also likely
 1002|       |                // to read past the space for ctrl bytes and into slots. This is ok
 1003|       |                // because ctrl has sizeof() == 1 and slot has sizeof() >= 1 so there
 1004|       |                // is no way to read outside the combined slot array.
 1005|   218k|                uint32_t shift = Group{ctrl_}.CountLeadingEmptyOrDeleted();
 1006|   218k|                ctrl_ += shift;
 1007|   218k|                slot_ += shift;
 1008|   218k|            }
 1009|   561k|        }
_ZN5phmap4priv16IsEmptyOrDeletedEa:
  375|   780k|inline bool IsEmptyOrDeleted(ctrl_t c) { return c < kSentinel; }
_ZNK5phmap4priv13GroupSse2Impl26CountLeadingEmptyOrDeletedEv:
  447|   218k|    uint32_t CountLeadingEmptyOrDeleted() const {
  448|   218k|        auto special = _mm_set1_epi8(static_cast<char>(kSentinel));
  449|   218k|        return TrailingZeros(
  450|   218k|            static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1));
  451|   218k|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE14const_iteratorC2ENSE_8iteratorE:
 1032|    342|        const_iterator(iterator i) : inner_(std::move(i)) {}
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE3endEv:
 1265|    171|    const_iterator end() const { return const_cast<raw_hash_set*>(this)->end(); }
_ZN5phmap4privneERKNS0_12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE14const_iteratorESH_:
 1046|   561k|        friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 1047|   561k|            return !(a == b);
 1048|   561k|        }
_ZN5phmap4priveqERKNS0_12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE14const_iteratorESH_:
 1043|   561k|        friend bool operator==(const const_iterator& a, const const_iterator& b) {
 1044|   561k|            return a.inner_ == b.inner_;
 1045|   561k|        }
_ZN5phmap4priveqERKNS0_12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE8iteratorESH_:
  983|   561k|        friend bool operator==(const iterator& a, const iterator& b) {
  984|   561k|            return a.ctrl_ == b.ctrl_;
  985|   561k|        }
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE14const_iteratordeEv:
 1034|   561k|        reference operator*() const { return *inner_; }
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE8iteratordeEv:
  945|   561k|        reference operator*() const { return PolicyTraits::element(slot_); }
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE11has_elementERKSC_:
 2178|   561k|    bool has_element(const value_type& elem) const {
 2179|   561k|        size_t hashval = PolicyTraits::apply(HashElement{hash_ref()}, elem);
 2180|   561k|        return has_element(elem, hashval);
 2181|   561k|    }
_ZN5phmap4priv17FlatHashMapPolicyIjiE5applyINS0_12raw_hash_setIS2_NS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS9_4pairIKjiEEEEE11HashElementEJRKSD_EEEDTclsr5phmap4privE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
 4339|   561k|    apply(F&& f, Args&&... args) {
 4340|   561k|        return phmap::priv::DecomposePair(std::forward<F>(f),
 4341|   561k|                                                        std::forward<Args>(args)...);
 4342|   561k|    }
_ZN5phmap4priv13DecomposePairINS0_12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS9_4pairIKjiEEEEE11HashElementEJRKSD_EEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
 4234|   561k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
 4235|   561k|    return memory_internal::DecomposePairImpl(
 4236|   561k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
 4237|   561k|}
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE11has_elementERKSC_m:
 2157|   561k|    bool has_element(const value_type& PHMAP_RESTRICT elem, size_t hashval) const {
 2158|   561k|        PHMAP_IF_CONSTEXPR (!std_alloc_t::value) {
  ------------------
  |  |  654|   561k|    #define PHMAP_IF_CONSTEXPR(expr) if constexpr ((expr))
  ------------------
 2159|       |            // ctrl_ could be nullptr
 2160|       |            if (!ctrl_)
 2161|       |                return false;
 2162|       |        }
 2163|   561k|        auto seq = probe(hashval);
 2164|   564k|        while (true) {
  ------------------
  |  Branch (2164:16): [True: 564k, Folded]
  ------------------
 2165|   564k|            Group g{ctrl_ + seq.offset()};
 2166|   564k|            for (uint32_t i : g.Match((h2_t)H2(hashval))) {
  ------------------
  |  Branch (2166:29): [True: 564k, False: 3.07k]
  ------------------
 2167|   564k|                if (PHMAP_PREDICT_TRUE(PolicyTraits::element(slots_ + seq.offset((size_t)i)) ==
  ------------------
  |  |  220|   564k|    #define PHMAP_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (220:35): [True: 561k, False: 2.87k]
  |  |  ------------------
  ------------------
 2168|   564k|                                      elem))
 2169|   561k|                    return true;
 2170|   564k|            }
 2171|  3.07k|            if (PHMAP_PREDICT_TRUE(g.MatchEmpty())) return false;
  ------------------
  |  |  220|  3.07k|    #define PHMAP_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (220:35): [True: 127, False: 2.95k]
  |  |  ------------------
  ------------------
 2172|  2.95k|            seq.next();
 2173|  2.95k|            assert(seq.getindex() < capacity_ && "full table!");
  ------------------
  |  Branch (2173:13): [True: 2.95k, False: 0]
  |  Branch (2173:13): [True: 2.95k, Folded]
  |  Branch (2173:13): [True: 2.95k, False: 0]
  ------------------
 2174|  2.95k|        }
 2175|      0|        return false;
 2176|   561k|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE14const_iteratorppEv:
 1037|   561k|        const_iterator& operator++() {
 1038|   561k|            ++inner_;
 1039|   561k|            return *this;
 1040|   561k|        }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE8iteratorppEv:
  951|   561k|        iterator& operator++() {
  952|   561k|            ++ctrl_;
  953|   561k|            ++slot_;
  954|   561k|            skip_empty_or_deleted();
  955|   561k|            return *this;
  956|   561k|        }
_ZN5phmap13flat_hash_mapINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_NS_4priv13StringHashEqTIcE4HashENSA_2EqENS5_INS1_4pairIKS7_S7_EEEEEC2Ev:
 4768|    595|    flat_hash_map() {}
_ZN5phmap4priv12raw_hash_mapINS0_17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EENS0_13StringHashEqTIcE4HashENSC_2EqENS7_INS3_4pairIKS9_S9_EEEEEC2Ev:
 2420|    595|    raw_hash_map() {}
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EENS0_13StringHashEqTIcE4HashENSC_2EqENS7_INS3_4pairIKS9_S9_EEEEEC2Ev:
 1063|    595|        std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EENS0_13StringHashEqTIcE4HashENSC_2EqENS7_INS3_4pairIKS9_S9_EEEEE5beginEv:
 1247|    595|    iterator begin() {
 1248|    595|        if (empty()) return end();
  ------------------
  |  Branch (1248:13): [True: 595, False: 0]
  ------------------
 1249|      0|        auto it = iterator_at(0);
 1250|      0|        it.skip_empty_or_deleted();
 1251|      0|        return it;
 1252|    595|    }
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EENS0_13StringHashEqTIcE4HashENSC_2EqENS7_INS3_4pairIKS9_S9_EEEEE5emptyEv:
 1269|    595|    bool empty() const { return !size(); }
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EENS0_13StringHashEqTIcE4HashENSC_2EqENS7_INS3_4pairIKS9_S9_EEEEE4sizeEv:
 1270|    595|    size_t size() const { return size_; }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EENS0_13StringHashEqTIcE4HashENSC_2EqENS7_INS3_4pairIKS9_S9_EEEEE3endEv:
 1254|  1.19k|    {
 1255|       |#if 0 // PHMAP_BIDIRECTIONAL
 1256|       |        return iterator_at(capacity_); 
 1257|       |#else
 1258|  1.19k|        return {ctrl_ + capacity_};
 1259|  1.19k|#endif
 1260|  1.19k|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EENS0_13StringHashEqTIcE4HashENSC_2EqENS7_INS3_4pairIKS9_S9_EEEEE8iteratorC2EPa:
  991|  1.19k|        iterator(ctrl_t* ctrl) : ctrl_(ctrl) {}  // for end()
_ZN5phmap4privneERKNS0_12raw_hash_setINS0_17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EENS0_13StringHashEqTIcE4HashENSC_2EqENS7_INS3_4pairIKS9_S9_EEEEE8iteratorESM_:
  986|    595|        friend bool operator!=(const iterator& a, const iterator& b) {
  987|    595|            return !(a == b);
  988|    595|        }
_ZN5phmap4priveqERKNS0_12raw_hash_setINS0_17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EENS0_13StringHashEqTIcE4HashENSC_2EqENS7_INS3_4pairIKS9_S9_EEEEE8iteratorESM_:
  983|    595|        friend bool operator==(const iterator& a, const iterator& b) {
  984|    595|            return a.ctrl_ == b.ctrl_;
  985|    595|        }

_ZN5phmap4priv6LayoutIJaNS0_13map_slot_typeIjiEEEEC2Emm:
 4176|  6.58k|        : internal_layout::LayoutType<sizeof...(Ts), Ts...>(sizes...) {}
_ZN5phmap4priv15internal_layout10LayoutImplINSt3__15tupleIJaNS0_13map_slot_typeIjiEEEEENS_16integer_sequenceImJLm0ELm1EEEES9_EC2Emm:
 3881|  6.58k|        : size_{sizes...} {}
_ZN5phmap4priv29SanitizerUnpoisonMemoryRegionEPKvm:
 4243|  1.60M|inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
 4244|       |#ifdef ADDRESS_SANITIZER
 4245|       |    ASAN_UNPOISON_MEMORY_REGION(m, s);
 4246|       |#endif
 4247|       |#ifdef MEMORY_SANITIZER
 4248|       |    __msan_unpoison(m, s);
 4249|       |#endif
 4250|  1.60M|    (void)m;
 4251|  1.60M|    (void)s;
 4252|  1.60M|}
_ZN5phmap4priv10DeallocateILm4ENSt3__19allocatorINS2_4pairIKjiEEEEEEvPT0_Pvm:
 4215|  3.29k|void Deallocate(Alloc* alloc, void* p, size_t n) {
 4216|  3.29k|  static_assert(Alignment > 0, "");
 4217|  3.29k|  assert(n && "n must be positive");
  ------------------
  |  Branch (4217:3): [True: 3.29k, False: 0]
  |  Branch (4217:3): [True: 3.29k, Folded]
  |  Branch (4217:3): [True: 3.29k, False: 0]
  ------------------
 4218|  3.29k|  struct alignas(Alignment) M {};
 4219|  3.29k|  using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
 4220|  3.29k|  using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
 4221|  3.29k|  A mem_alloc(*alloc);
 4222|  3.29k|  AT::deallocate(mem_alloc, static_cast<M*>(p),
 4223|  3.29k|                 (n + sizeof(M) - 1) / sizeof(M));
 4224|  3.29k|}
_ZN5phmap16allocator_traitsINSt3__19allocatorIZNS_4priv10DeallocateILm4ENS2_INS1_4pairIKjiEEEEEEvPT0_PvmE1MEEE10deallocateERSD_PSC_m:
 1496|  3.29k|                           size_type n) {
 1497|  3.29k|        a.deallocate(p, n);
 1498|  3.29k|    }
_ZNK5phmap4priv15internal_layout10LayoutImplINSt3__15tupleIJaNS0_13map_slot_typeIjiEEEEENS_16integer_sequenceImJLm0ELm1EEEES9_E9AllocSizeEv:
 4096|  6.58k|    constexpr size_t AllocSize() const {
 4097|  6.58k|        static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
 4098|  6.58k|        return Offset<NumTypes - 1>() +
 4099|  6.58k|            SizeOf<ElementType<NumTypes - 1>>::value * size_[NumTypes - 1];
 4100|  6.58k|    }
_ZNK5phmap4priv15internal_layout10LayoutImplINSt3__15tupleIJaNS0_13map_slot_typeIjiEEEEENS_16integer_sequenceImJLm0ELm1EEEES9_E6OffsetILm1ETnNS3_9enable_ifIXneT_Li0EEiE4typeELi0EEEmv:
 3903|  9.87k|        constexpr size_t Offset() const {
 3904|  9.87k|        static_assert(N < NumOffsets, "Index out of bounds");
 3905|  9.87k|        return adl_barrier::Align(
 3906|  9.87k|            Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
 3907|  9.87k|            ElementAlignment<N>::value);
 3908|  9.87k|    }
_ZN5phmap4priv15internal_layout11adl_barrier5AlignEmm:
 3797|  9.87k|constexpr size_t Align(size_t n, size_t m) { return (n + m - 1) & ~(m - 1); }
_ZNK5phmap4priv15internal_layout10LayoutImplINSt3__15tupleIJaNS0_13map_slot_typeIjiEEEEENS_16integer_sequenceImJLm0ELm1EEEES9_E6OffsetILm0ETnNS3_9enable_ifIXeqT_Li0EEiE4typeELi0EEEmv:
 3898|  13.1k|        constexpr size_t Offset() const {
 3899|  13.1k|        return 0;
 3900|  13.1k|    }
_ZN5phmap4priv18hash_policy_traitsINS0_17FlatHashMapPolicyIjiEEvE5applyINS0_12raw_hash_setIS3_NS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINSB_4pairIKjiEEEEE19EmplaceDecomposableEJSF_ES3_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSK_DpOSL_:
  557|  10.3M|        -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  558|  10.3M|        return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  559|  10.3M|    }
_ZN5phmap4priv18hash_policy_traitsINS0_17FlatHashMapPolicyIjiEEvE5applyINS0_12raw_hash_setIS3_NS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINSB_4pairIKjiEEEEE12EqualElementIjEEJRSF_ES3_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  557|  11.3M|        -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  558|  11.3M|        return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  559|  11.3M|    }
_ZNK5phmap7EqualToIjEclERKjS3_:
   79|  11.3M|    {
   80|  11.3M|        return std::equal_to<T>()(a, b);
   81|  11.3M|    }
_ZN5phmap4priv18hash_policy_traitsINS0_17FlatHashMapPolicyIjiEEvE7elementIS3_EEDTclsrT_7elementfp_EEPNS0_13map_slot_typeIjiEE:
  511|  13.4M|    static auto element(slot_type* slot) -> decltype(P::element(slot)) {
  512|  13.4M|        return P::element(slot);
  513|  13.4M|    }
_ZN5phmap4priv8AllocateILm4ENSt3__19allocatorINS2_4pairIKjiEEEEEEPvPT0_m:
 4197|  3.29k|void* Allocate(Alloc* alloc, size_t n) {
 4198|  3.29k|  static_assert(Alignment > 0, "");
 4199|  3.29k|  assert(n && "n must be positive");
  ------------------
  |  Branch (4199:3): [True: 3.29k, False: 0]
  |  Branch (4199:3): [True: 3.29k, Folded]
  |  Branch (4199:3): [True: 3.29k, False: 0]
  ------------------
 4200|  3.29k|  struct alignas(Alignment) M {};
 4201|  3.29k|  using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
 4202|  3.29k|  using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
 4203|  3.29k|  A mem_alloc(*alloc);
 4204|  3.29k|  void* p = &*AT::allocate(mem_alloc, (n + sizeof(M) - 1) / sizeof(M)); // `&*` to support custom pointers such as boost offset_ptr.
 4205|  3.29k|  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
  ------------------
  |  Branch (4205:3): [True: 3.29k, False: 0]
  |  Branch (4205:3): [True: 3.29k, Folded]
  |  Branch (4205:3): [True: 3.29k, False: 0]
  ------------------
 4206|  3.29k|         "allocator does not respect alignment");
 4207|  3.29k|  return p;
 4208|  3.29k|}
_ZN5phmap16allocator_traitsINSt3__19allocatorIZNS_4priv8AllocateILm4ENS2_INS1_4pairIKjiEEEEEEPvPT0_mE1MEEE8allocateERSD_m:
 1481|  3.29k|                            size_type n) {
 1482|  3.29k|        return a.allocate(n);
 1483|  3.29k|    }
_ZNK5phmap4priv15internal_layout10LayoutImplINSt3__15tupleIJaNS0_13map_slot_typeIjiEEEEENS_16integer_sequenceImJLm0ELm1EEEES9_E7PointerILm0EcEEPNS3_11conditionalIXsr3std8is_constIT0_EE5valueEKNS3_13tuple_elementIXT_ES7_E4typeESG_E4typeEPSD_:
 3974|  3.29k|        CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
 3975|  3.29k|        using C = typename std::remove_const<Char>::type;
 3976|  3.29k|        static_assert(
 3977|  3.29k|            std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
 3978|  3.29k|            std::is_same<C, signed char>(),
 3979|  3.29k|            "The argument must be a pointer to [const] [signed|unsigned] char");
 3980|  3.29k|        constexpr size_t alignment = Alignment();
 3981|  3.29k|        (void)alignment;
 3982|  3.29k|        assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  ------------------
  |  Branch (3982:9): [True: 3.29k, False: 0]
  ------------------
 3983|  3.29k|        return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
 3984|  3.29k|    }
_ZNK5phmap4priv15internal_layout10LayoutImplINSt3__15tupleIJaNS0_13map_slot_typeIjiEEEEENS_16integer_sequenceImJLm0ELm1EEEES9_E7PointerILm1EcEEPNS3_11conditionalIXsr3std8is_constIT0_EE5valueEKNS3_13tuple_elementIXT_ES7_E4typeESG_E4typeEPSD_:
 3974|  3.29k|        CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
 3975|  3.29k|        using C = typename std::remove_const<Char>::type;
 3976|  3.29k|        static_assert(
 3977|  3.29k|            std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
 3978|  3.29k|            std::is_same<C, signed char>(),
 3979|  3.29k|            "The argument must be a pointer to [const] [signed|unsigned] char");
 3980|  3.29k|        constexpr size_t alignment = Alignment();
 3981|  3.29k|        (void)alignment;
 3982|  3.29k|        assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  ------------------
  |  Branch (3982:9): [True: 3.29k, False: 0]
  ------------------
 3983|  3.29k|        return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
 3984|  3.29k|    }
_ZN5phmap4priv27SanitizerPoisonMemoryRegionEPKvm:
 4232|  3.29k|inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
 4233|       |#ifdef ADDRESS_SANITIZER
 4234|       |    ASAN_POISON_MEMORY_REGION(m, s);
 4235|       |#endif
 4236|       |#ifdef MEMORY_SANITIZER
 4237|       |    __msan_poison(m, s);
 4238|       |#endif
 4239|  3.29k|    (void)m;
 4240|  3.29k|    (void)s;
 4241|  3.29k|}
_ZN5phmap4priv18hash_policy_traitsINS0_17FlatHashMapPolicyIjiEEvE5applyINS0_12raw_hash_setIS3_NS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINSB_4pairIKjiEEEEE11HashElementEJRSF_ES3_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSL_DpOSM_:
  557|  1.02M|        -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  558|  1.02M|        return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  559|  1.02M|    }
_ZN5phmap4priv18hash_policy_traitsINS0_17FlatHashMapPolicyIjiEEvE8transferINSt3__19allocatorINS6_4pairIKjiEEEEEEvPT_PNS0_13map_slot_typeIjiEESG_:
  504|  1.02M|    static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
  505|  1.02M|        transfer_impl(alloc, new_slot, old_slot, 0);
  506|  1.02M|    }
_ZN5phmap4priv18hash_policy_traitsINS0_17FlatHashMapPolicyIjiEEvE13transfer_implINSt3__19allocatorINS6_4pairIKjiEEEES3_EEDTcvvclsrT0_8transferfp_fp0_fp1_EEPT_PNS0_13map_slot_typeIjiEESI_i:
  582|  1.02M|        -> decltype((void)P::transfer(alloc, new_slot, old_slot)) {
  583|  1.02M|        P::transfer(alloc, new_slot, old_slot);
  584|  1.02M|    }
_ZN5phmap4priv15map_slot_policyIjiE8transferINSt3__19allocatorINS4_4pairIKjiEEEEEEvPT_PNS0_13map_slot_typeIjiEESE_:
 4544|  1.02M|                         slot_type* old_slot) {
 4545|  1.02M|        emplace(new_slot);
 4546|  1.02M|        if (kMutableKeys::value) {
  ------------------
  |  Branch (4546:13): [True: 1.02M, Folded]
  ------------------
 4547|  1.02M|            phmap::allocator_traits<Allocator>::construct(
 4548|  1.02M|                *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
 4549|  1.02M|        } else {
 4550|      0|            phmap::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
 4551|      0|                                                         std::move(old_slot->value));
 4552|      0|        }
 4553|  1.02M|        destroy(alloc, old_slot);
 4554|  1.02M|    }
_ZN5phmap4priv15map_slot_policyIjiE7emplaceEPNS0_13map_slot_typeIjiEE:
 4488|  1.60M|    static void emplace(slot_type* slot) {
 4489|       |        // The construction of union doesn't do anything at runtime but it allows us
 4490|       |        // to access its members without violating aliasing rules.
 4491|  1.60M|        new (slot) slot_type;
 4492|  1.60M|    }
_ZN5phmap4priv13map_slot_typeIjiEC2Ev:
 4465|  1.60M|    map_slot_type() {}
_ZN5phmap16allocator_traitsINSt3__19allocatorINS1_4pairIKjiEEEEE9constructINS3_IjiEEJS9_EEEvRS6_PT_DpOT0_:
 1506|  1.02M|                          Args&&... args) {
 1507|  1.02M|        construct_impl(0, a, p, std::forward<Args>(args)...);
 1508|  1.02M|    }
_ZN5phmap16allocator_traitsINSt3__19allocatorINS1_4pairIKjiEEEEE14construct_implIS6_JRPNS3_IjiEES9_EEEDTclsr3std16allocator_traitsIT_EE9constructfp0_spclsr3stdE7forwardIT0_Efp1_EEEiRSC_DpOSD_:
 1544|  1.02M|        -> decltype(std::allocator_traits<A>::construct(a, std::forward<Args>(args)...)) {
 1545|  1.02M|        std::allocator_traits<A>::construct(a, std::forward<Args>(args)...);
 1546|  1.02M|    }
_ZN5phmap4priv15map_slot_policyIjiE7destroyINSt3__19allocatorINS4_4pairIKjiEEEEEEvPT_PNS0_13map_slot_typeIjiEE:
 4534|  1.02M|    static void destroy(Allocator* alloc, slot_type* slot) {
 4535|  1.02M|        if (kMutableKeys::value) {
  ------------------
  |  Branch (4535:13): [True: 1.02M, Folded]
  ------------------
 4536|  1.02M|            phmap::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
 4537|  1.02M|        } else {
 4538|      0|            phmap::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
 4539|      0|        }
 4540|  1.02M|    }
_ZN5phmap16allocator_traitsINSt3__19allocatorINS1_4pairIKjiEEEEE7destroyINS3_IjiEEEEvRS6_PT_:
 1513|  1.02M|    static void destroy(Alloc& a, T* p) {  // NOLINT(runtime/references)
 1514|  1.02M|        destroy_impl(0, a, p);
 1515|  1.02M|    }
_ZN5phmap16allocator_traitsINSt3__19allocatorINS1_4pairIKjiEEEEE12destroy_implIS6_NS3_IjiEEEEDTclsr3std16allocator_traitsIT_EE7destroyfp0_fp1_EEiRSA_PT0_:
 1555|  1.02M|                             T* p) -> decltype(std::allocator_traits<A>::destroy(a, p)) {
 1556|  1.02M|        std::allocator_traits<A>::destroy(a, p);
 1557|  1.02M|    }
_ZN5phmap4priv18hash_policy_traitsINS0_17FlatHashMapPolicyIjiEEvE9constructINSt3__19allocatorINS6_4pairIKjiEEEEJRKNS6_21piecewise_construct_tENS6_5tupleIJOS9_EEENSF_IJOiEEEEEEvPT_PNS0_13map_slot_typeIjiEEDpOT0_:
  481|   578k|    static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
  482|   578k|        Policy::construct(alloc, slot, std::forward<Args>(args)...);
  483|   578k|    }
_ZN5phmap4priv15map_slot_policyIjiE9constructINSt3__19allocatorINS4_4pairIKjiEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJOS7_EEENSD_IJOiEEEEEEvPT_PNS0_13map_slot_typeIjiEEDpOT0_:
 4509|   578k|    static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
 4510|   578k|        emplace(slot);
 4511|   578k|        if (kMutableKeys::value) {
  ------------------
  |  Branch (4511:13): [True: 578k, Folded]
  ------------------
 4512|   578k|            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
 4513|   578k|                                                         std::forward<Args>(args)...);
 4514|   578k|        } else {
 4515|      0|            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->value,
 4516|      0|                                                         std::forward<Args>(args)...);
 4517|      0|        }
 4518|   578k|    }
_ZN5phmap16allocator_traitsINSt3__19allocatorINS1_4pairIKjiEEEEE9constructINS3_IjiEEJRKNS1_21piecewise_construct_tENS1_5tupleIJOS4_EEENSD_IJOiEEEEEEvRS6_PT_DpOT0_:
 1506|   578k|                          Args&&... args) {
 1507|   578k|        construct_impl(0, a, p, std::forward<Args>(args)...);
 1508|   578k|    }
_ZN5phmap16allocator_traitsINSt3__19allocatorINS1_4pairIKjiEEEEE14construct_implIS6_JRPNS3_IjiEERKNS1_21piecewise_construct_tENS1_5tupleIJOS4_EEENSF_IJOiEEEEEEDTclsr3std16allocator_traitsIT_EE9constructfp0_spclsr3stdE7forwardIT0_Efp1_EEEiRSK_DpOSL_:
 1544|   578k|        -> decltype(std::allocator_traits<A>::construct(a, std::forward<Args>(args)...)) {
 1545|   578k|        std::allocator_traits<A>::construct(a, std::forward<Args>(args)...);
 1546|   578k|    }
_ZN5phmap4priv23SanitizerUnpoisonObjectINS0_13map_slot_typeIjiEEEEvPKT_:
 4260|  1.60M|inline void SanitizerUnpoisonObject(const T* object) {
 4261|  1.60M|    SanitizerUnpoisonMemoryRegion(object, sizeof(T));
 4262|  1.60M|}
_ZN5phmap4priv18hash_policy_traitsINS0_17FlatHashMapPolicyIjiEEvE5applyINS0_12raw_hash_setIS3_NS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINSB_4pairIKjiEEEEE11HashElementEJRKSF_ES3_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  557|   561k|        -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  558|   561k|        return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  559|   561k|    }

_ZN5phmap13base_internal27CountTrailingZerosNonZero32Ej:
  397|  13.7M|PHMAP_BASE_INTERNAL_FORCEINLINE uint32_t CountTrailingZerosNonZero32(uint32_t n) {
  398|       |#if defined(_MSC_VER) && !defined(__clang__)
  399|       |    unsigned long result = 0;  // NOLINT(runtime/int)
  400|       |    _BitScanForward(&result, n);
  401|       |    return (uint32_t)result;
  402|       |#elif defined(__GNUC__) || defined(__clang__)
  403|       |    static_assert(sizeof(int) == sizeof(n),
  404|  13.7M|                  "__builtin_ctz does not take 32-bit arg");
  405|  13.7M|    return static_cast<uint32_t>(__builtin_ctz(n));
  406|       |#else
  407|       |    return CountTrailingZerosNonZero32Slow(n);
  408|       |#endif
  409|  13.7M|}
_ZN5phmap7umul128EmmPm:
  251|  11.9M|    {
  252|  11.9M|        auto result = static_cast<phmap_uint128>(a) * static_cast<phmap_uint128>(b);
  253|  11.9M|        *high = static_cast<uint64_t>(result >> 64);
  254|  11.9M|        return static_cast<uint64_t>(result);
  255|  11.9M|    }

_ZN5phmap19BinaryOutputArchiveC2EPKc:
  170|    595|    BinaryOutputArchive(const char *file_path) {
  171|    595|      os_ = new std::ofstream(file_path, std::ofstream::out |
  172|    595|                                             std::ofstream::trunc |
  173|    595|                                             std::ofstream::binary);
  174|    595|      destruct_ = [this]() { delete os_; };
  175|    595|    }
_ZZN5phmap19BinaryOutputArchiveC1EPKcENKUlvE_clEv:
  174|    595|      destruct_ = [this]() { delete os_; };
_ZN5phmap18BinaryInputArchiveC2EPKc:
  214|    595|    BinaryInputArchive(const char * file_path) {
  215|    595|      is_ = new std::ifstream(file_path,
  216|    595|                              std::ifstream::in | std::ifstream::binary);
  217|    595|      destruct_ = [this]() { delete is_; };
  218|    595|    }
_ZZN5phmap18BinaryInputArchiveC1EPKcENKUlvE_clEv:
  217|    595|      destruct_ = [this]() { delete is_; };
_ZN5phmap18BinaryInputArchiveD2Ev:
  222|    595|    ~BinaryInputArchive() {
  223|    595|        if (destruct_) {
  ------------------
  |  Branch (223:13): [True: 595, False: 0]
  ------------------
  224|    595|            destruct_();
  225|    595|        }
  226|    595|    }
_ZN5phmap19BinaryOutputArchiveD2Ev:
  179|    595|    ~BinaryOutputArchive() {
  180|    595|        if (destruct_) {
  ------------------
  |  Branch (180:13): [True: 595, False: 0]
  ------------------
  181|    595|            destruct_();
  182|    595|        }
  183|    595|    }
_ZNK5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE10phmap_dumpINS_19BinaryOutputArchiveEEEbRT_:
   54|    595|bool raw_hash_set<Policy, Hash, Eq, Alloc>::phmap_dump(OutputArchive& ar) const {
   55|    595|    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
   56|    595|                    "value_type should be trivially copyable");
   57|       |
   58|    595|    ar.saveBinary(&s_version, sizeof(size_t));
   59|    595|    ar.saveBinary(&size_, sizeof(size_t));
   60|    595|    ar.saveBinary(&capacity_, sizeof(size_t));
   61|    595|    if (size_ == 0)
  ------------------
  |  Branch (61:9): [True: 31, False: 564]
  ------------------
   62|     31|        return true;
   63|    564|    ar.saveBinary(ctrl_,  sizeof(ctrl_t) * (capacity_ + Group::kWidth + 1));
   64|    564|    ar.saveBinary(slots_, sizeof(slot_type) * capacity_);
   65|    564|    ar.saveBinary(&growth_left(), sizeof(size_t));
   66|    564|    return true;
   67|    595|}
_ZN5phmap19BinaryOutputArchive10saveBinaryEPKvm:
  188|  3.47k|    bool saveBinary(const void *p, size_t sz) {
  189|  3.47k|        os_->write(reinterpret_cast<const char*>(p), (std::streamsize)sz);
  190|  3.47k|        return true;
  191|  3.47k|    }
_ZN5phmap4priv12raw_hash_setINS0_17FlatHashMapPolicyIjiEENS_4HashIjEENS_7EqualToIjEENSt3__19allocatorINS8_4pairIKjiEEEEE10phmap_loadINS_18BinaryInputArchiveEEEbRT_:
   71|    595|bool raw_hash_set<Policy, Hash, Eq, Alloc>::phmap_load(InputArchive& ar) {
   72|    595|    static_assert(type_traits_internal::IsTriviallyCopyable<value_type>::value,
   73|    595|                    "value_type should be trivially copyable");
   74|    595|    raw_hash_set<Policy, Hash, Eq, Alloc>().swap(*this); // clear any existing content
   75|       |
   76|    595|    size_t version = 0;
   77|    595|    ar.loadBinary(&version, sizeof(size_t));
   78|    595|    if (version < s_version_base) {
  ------------------
  |  Branch (78:9): [True: 455, False: 140]
  ------------------
   79|       |        // we didn't store the version, version actually contains the size
   80|    455|        size_ = version;
   81|    455|    } else {
   82|    140|        ar.loadBinary(&size_, sizeof(size_t));
   83|    140|    }
   84|    595|    ar.loadBinary(&capacity_, sizeof(size_t));
   85|       |
   86|    595|    if (capacity_) {
  ------------------
  |  Branch (86:9): [True: 140, False: 455]
  ------------------
   87|       |        // allocate memory for ctrl_ and slots_
   88|    140|        initialize_slots(capacity_);
   89|    140|    }
   90|    595|    if (size_ == 0)
  ------------------
  |  Branch (90:9): [True: 455, False: 140]
  ------------------
   91|    455|        return true;
   92|    140|    ar.loadBinary(ctrl_,  sizeof(ctrl_t) * (capacity_ + Group::kWidth + 1));
   93|    140|    ar.loadBinary(slots_, sizeof(slot_type) * capacity_);
   94|    140|    if (version >= s_version_base) {
  ------------------
  |  Branch (94:9): [True: 140, False: 0]
  ------------------
   95|       |        // growth_left should be restored after calling initialize_slots() which resets it.
   96|    140|        ar.loadBinary(&growth_left(), sizeof(size_t));
   97|    140|    } else {
   98|      0|       drop_deletes_without_resize();
   99|      0|    }
  100|    140|    return true;
  101|    595|}
_ZN5phmap18BinaryInputArchive10loadBinaryEPvm:
  231|  1.75k|    bool loadBinary(void* p, size_t sz) {
  232|  1.75k|        is_->read(reinterpret_cast<char*>(p),  (std::streamsize)sz);
  233|  1.75k|        return true;
  234|  1.75k|    }

_ZNK5phmap9phmap_mixILi8EEclEm:
   71|  11.9M|        {
   72|  11.9M|            static constexpr uint64_t k = 0xde5fb9d2630458e9ULL;
   73|  11.9M|            uint64_t h;
   74|  11.9M|            uint64_t l = umul128(a, k, &h);
   75|  11.9M|            return static_cast<size_t>(h + l);
   76|  11.9M|        }
_ZNK5phmap4HashIjEclEj:
  235|  11.9M|    { return static_cast<size_t>(val); }

_Z14serialise_testPKhm:
   22|    595|void serialise_test(const uint8_t *data, size_t size) {
   23|    595|    phmap::flat_hash_map<unsigned int, int> table;
   24|    595|    FuzzedDataProvider fuzzed_data(data, size);
   25|    595|    const int num_items = fuzzed_data.ConsumeIntegral<int16_t>();
   26|       |
   27|  10.3M|    for (int i=0; i < num_items; ++i)  {
  ------------------
  |  Branch (27:19): [True: 10.3M, False: 595]
  ------------------
   28|  10.3M|        table.insert(typename phmap::flat_hash_map<unsigned int, int>::value_type(
   29|  10.3M|                    fuzzed_data.ConsumeIntegral<uint32_t>(), 
   30|  10.3M|                    fuzzed_data.ConsumeIntegral<int32_t>()));
   31|  10.3M|    }
   32|       |
   33|    595|    phmap::BinaryOutputArchive ar_out("/dump.data");
   34|    595|    table.phmap_dump(ar_out);
   35|       |
   36|       |    //MapType table_in;
   37|    595|    phmap::flat_hash_map<unsigned int, int> table_in;
   38|    595|    phmap::BinaryInputArchive ar_in("/dump.data");
   39|    595|    table_in.phmap_load(ar_in);
   40|       |
   41|    595|    if(table == table_in) {
  ------------------
  |  Branch (41:8): [True: 44, False: 551]
  ------------------
   42|     44|        unlink("/dump.data");
   43|     44|        return;
   44|     44|    }
   45|    551|    unlink("/dump.data");
   46|    551|}
_Z16test_assignmentsPKhm:
   49|    595|test_assignments(const uint8_t *data, size_t size) {
   50|    595|    phmap::flat_hash_map<std::string, std::string> email;
   51|    595|    FuzzedDataProvider fuzzed_data(data, size);
   52|    595|    const int num_items = fuzzed_data.ConsumeIntegral<int16_t>();
   53|  10.3M|    for (int i=0; i < num_items; ++i) {
  ------------------
  |  Branch (53:19): [True: 10.3M, False: 595]
  ------------------
   54|  10.3M|            phmap::flat_hash_map<std::string, std::string>::value_type(
   55|  10.3M|                    fuzzed_data.ConsumeRandomLengthString(), 
   56|  10.3M|                    fuzzed_data.ConsumeRandomLengthString());
   57|  10.3M|    }
   58|       |    // Iterate through all of the items.
   59|    595|    for (const auto& n: email) {}
  ------------------
  |  Branch (59:23): [True: 0, False: 595]
  ------------------
   60|    595|}
LLVMFuzzerTestOneInput:
   62|    595|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   63|    595|    serialise_test(data, size);
   64|    595|    test_assignments(data, size);
   65|    595|    return 0;
   66|    595|}