_ZN24BlockTransactionsRequest16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
   52|    475|    {
   53|    475|        READWRITE(obj.blockhash, Using<VectorFormatter<DifferenceFormatter>>(obj.indexes));
  ------------------
  |  |  148|    475|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
   54|    475|    }
_ZN19DifferenceFormatter5UnserI10DataStreamtEEvRT_RT0_:
   37|   985k|    {
   38|   985k|        uint64_t n = ReadCompactSize(s);
   39|   985k|        m_shift += n;
   40|   985k|        if (m_shift < n || m_shift >= std::numeric_limits<uint64_t>::max() || m_shift < std::numeric_limits<I>::min() || m_shift > std::numeric_limits<I>::max()) throw std::ios_base::failure("differential value overflow");
  ------------------
  |  Branch (40:13): [True: 221, False: 985k]
  |  Branch (40:28): [True: 0, False: 985k]
  |  Branch (40:79): [True: 0, False: 985k]
  |  Branch (40:122): [True: 41, False: 985k]
  ------------------
   41|   985k|        v = I(m_shift++);
   42|   985k|    }

_ZN11ArgsManagerD2Ev:
  130|      2|ArgsManager::~ArgsManager() = default;

_Z16le16toh_internalt:
   29|    449|{
   30|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits);
   31|    449|        else return little_endian_16bits;
   32|    449|}
_Z16htole64_internalm:
   59|  1.90k|{
   60|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(host_64bits);
   61|  1.90k|        else return host_64bits;
   62|  1.90k|}
_Z16le64toh_internalm:
   69|    107|{
   70|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits);
   71|    107|        else return little_endian_64bits;
   72|    107|}
_Z16le32toh_internalj:
   49|    164|{
   50|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits);
   51|    164|        else return little_endian_32bits;
   52|    164|}

_ZN15ChaCha20AlignedD2Ev:
   42|      4|{
   43|      4|    memory_cleanse(input, sizeof(input));
   44|      4|}
_ZN8ChaCha20D2Ev:
  332|      4|{
  333|      4|    memory_cleanse(m_buffer.data(), m_buffer.size());
  334|      4|}

_Z9WriteLE64ITk8ByteTypeSt4byteEvPT_m:
   58|  1.90k|{
   59|  1.90k|    uint64_t v = htole64_internal(x);
   60|  1.90k|    memcpy(ptr, &v, 8);
   61|  1.90k|}

_ZN9ChainCodeD2Ev:
   28|      2|    ~ChainCode() { memory_cleanse(data(), size()); }

_ZN11CNetCleanupD2Ev:
 3676|      2|    {
 3677|       |#ifdef WIN32
 3678|       |        // Shutdown Windows Sockets
 3679|       |        WSACleanup();
 3680|       |#endif
 3681|      2|    }

_ZNK9prevectorILj16EhjiE9is_directEv:
  126|     16|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj16EhjiED2Ev:
  422|     16|    ~prevector() {
  423|     16|        if (!is_direct()) {
  ------------------
  |  Branch (423:13): [True: 0, False: 16]
  ------------------
  424|      0|            free(_union.indirect_contents.indirect);
  425|      0|            _union.indirect_contents.indirect = nullptr;
  426|      0|        }
  427|     16|    }
_ZNK9prevectorILj36EhjiE9is_directEv:
  126|     14|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj36EhjiED2Ev:
  422|     14|    ~prevector() {
  423|     14|        if (!is_direct()) {
  ------------------
  |  Branch (423:13): [True: 0, False: 14]
  ------------------
  424|      0|            free(_union.indirect_contents.indirect);
  425|      0|            _union.indirect_contents.indirect = nullptr;
  426|      0|        }
  427|     14|    }

random.cpp:_ZN12_GLOBAL__N_18RNGStateD2Ev:
  367|      2|    ~RNGState() = default;

_ZN11RandomMixinI21InsecureRandomContextE7rand256Ev:
  318|    475|    {
  319|    475|        uint256 ret;
  320|    475|        Impl().fillrand(MakeWritableByteSpan(ret));
  321|    475|        return ret;
  322|    475|    }
_ZN11RandomMixinI21InsecureRandomContextE8fillrandENSt3__14spanISt4byteLm18446744073709551615EEE:
  268|    475|    {
  269|  2.37k|        while (span.size() >= 8) {
  ------------------
  |  Branch (269:16): [True: 1.90k, False: 475]
  ------------------
  270|  1.90k|            uint64_t gen = Impl().rand64();
  271|  1.90k|            WriteLE64(span.data(), gen);
  272|  1.90k|            span = span.subspan(8);
  273|  1.90k|        }
  274|    475|        if (span.size() >= 4) {
  ------------------
  |  Branch (274:13): [True: 0, False: 475]
  ------------------
  275|      0|            uint32_t gen = Impl().rand32();
  276|      0|            WriteLE32(span.data(), gen);
  277|      0|            span = span.subspan(4);
  278|      0|        }
  279|    475|        while (span.size()) {
  ------------------
  |  Branch (279:16): [True: 0, False: 475]
  ------------------
  280|      0|            span[0] = std::byte(Impl().template randbits<8>());
  281|      0|            span = span.subspan(1);
  282|      0|        }
  283|    475|    }
_ZN21InsecureRandomContextC2Em:
  439|    475|        : m_s0(SplitMix64(seedval)), m_s1(SplitMix64(seedval)) {}
_ZN11RandomMixinI21InsecureRandomContextEC2Ev:
  195|    475|    constexpr RandomMixin() noexcept = default;
_ZN21InsecureRandomContext10SplitMix64ERm:
  430|    950|    {
  431|    950|        uint64_t z = (seedval += 0x9e3779b97f4a7c15);
  432|    950|        z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
  433|    950|        z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
  434|    950|        return z ^ (z >> 31);
  435|    950|    }
_ZN21InsecureRandomContext6rand64Ev:
  449|  1.90k|    {
  450|  1.90k|        uint64_t s0 = m_s0, s1 = m_s1;
  451|  1.90k|        const uint64_t result = std::rotl(s0 + s1, 17) + s0;
  452|  1.90k|        s1 ^= s0;
  453|  1.90k|        m_s0 = std::rotl(s0, 49) ^ s1 ^ (s1 << 21);
  454|  1.90k|        m_s1 = std::rotl(s1, 28);
  455|  1.90k|        return result;
  456|  1.90k|    }
_ZN11RandomMixinI21InsecureRandomContextE4ImplEv:
  185|  2.37k|    RandomNumberGenerator auto& Impl() noexcept { return static_cast<T&>(*this); }

_ZN20BaseSignatureCheckerD2Ev:
  298|      2|    virtual ~BaseSignatureChecker() = default;

_ZN20BaseSignatureCreatorD2Ev:
   41|      4|    virtual ~BaseSignatureCreator() = default;

_ZN15SigningProviderD2Ev:
  170|      2|    virtual ~SigningProvider() = default;

difference_formatter.cpp:_ZL5UsingI15VectorFormatterI19DifferenceFormatterERNSt3__16vectorItNS3_9allocatorItEEEEE7WrapperIT_RT0_EOSB_:
  491|    475|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z11UnserializeI10DataStreamR24BlockTransactionsRequestQ14UnserializableIT0_T_EEvRS4_OS3_:
  776|    475|{
  777|    475|    a.Unserialize(is);
  778|    475|}
_ZN24BlockTransactionsRequest11UnserializeI10DataStreamEEvRT_:
  220|    475|    {                                                                                               \
  221|    475|        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
  222|    475|        Unser(s, *this);                                                                            \
  223|    475|    }
_ZN24BlockTransactionsRequest5UnserI10DataStreamEEvRT_RS_:
  172|    475|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJR7uint2567WrapperI15VectorFormatterI19DifferenceFormatterERNSt3__16vectorItNS8_9allocatorItEEEEEEEEvRT_DpOT0_:
 1086|    475|    {
 1087|    475|        ::UnserializeMany(s, args...);
 1088|    475|    }
_Z15UnserializeManyI10DataStreamJR7uint256R7WrapperI15VectorFormatterI19DifferenceFormatterERNSt3__16vectorItNS7_9allocatorItEEEEEEEvRT_DpOT0_:
 1054|    475|{
 1055|    475|    (::Unserialize(s, args), ...);
 1056|    475|}
_Z11UnserializeI10DataStreamR7WrapperI15VectorFormatterI19DifferenceFormatterERNSt3__16vectorItNS5_9allocatorItEEEEEQ14UnserializableIT0_T_EEvRSE_OSD_:
  776|    475|{
  777|    475|    a.Unserialize(is);
  778|    475|}
_ZN7WrapperI15VectorFormatterI19DifferenceFormatterERNSt3__16vectorItNS3_9allocatorItEEEEE11UnserializeI10DataStreamEEvRT_:
  477|    475|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI19DifferenceFormatterE5UnserI10DataStreamNSt3__16vectorItNS4_9allocatorItEEEEEEvRT_RT0_:
  680|    475|    {
  681|    475|        Formatter formatter;
  682|    475|        v.clear();
  683|    475|        size_t size = ReadCompactSize(s);
  684|    475|        size_t allocated = 0;
  685|    801|        while (allocated < size) {
  ------------------
  |  Branch (685:16): [True: 326, False: 475]
  ------------------
  686|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  687|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  688|       |            // X MiB of data to make us allocate X+5 Mib.
  689|    326|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  690|    326|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  691|    326|            v.reserve(allocated);
  692|   985k|            while (v.size() < allocated) {
  ------------------
  |  Branch (692:20): [True: 985k, False: 326]
  ------------------
  693|   985k|                v.emplace_back();
  694|   985k|                formatter.Unser(s, v.back());
  695|   985k|            }
  696|    326|        }
  697|    475|    };
_ZN7WrapperI15VectorFormatterI19DifferenceFormatterERNSt3__16vectorItNS3_9allocatorItEEEEEC2ES8_:
  475|    475|    explicit Wrapper(T obj) : m_object(obj) {}
_Z11UnserializeI10DataStreamR7uint256Q14UnserializableIT0_T_EEvRS4_OS3_:
  776|    475|{
  777|    475|    a.Unserialize(is);
  778|    475|}
_Z15ReadCompactSizeI10DataStreamEmRT_b:
  334|   986k|{
  335|   986k|    uint8_t chSize = ser_readdata8(is);
  336|   986k|    uint64_t nSizeRet = 0;
  337|   986k|    if (chSize < 253)
  ------------------
  |  Branch (337:9): [True: 985k, False: 925]
  ------------------
  338|   985k|    {
  339|   985k|        nSizeRet = chSize;
  340|   985k|    }
  341|    925|    else if (chSize == 253)
  ------------------
  |  Branch (341:14): [True: 452, False: 473]
  ------------------
  342|    452|    {
  343|    452|        nSizeRet = ser_readdata16(is);
  344|    452|        if (nSizeRet < 253)
  ------------------
  |  Branch (344:13): [True: 8, False: 444]
  ------------------
  345|      8|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  346|    452|    }
  347|    473|    else if (chSize == 254)
  ------------------
  |  Branch (347:14): [True: 166, False: 307]
  ------------------
  348|    166|    {
  349|    166|        nSizeRet = ser_readdata32(is);
  350|    166|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (350:13): [True: 18, False: 148]
  ------------------
  351|     18|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|    166|    }
  353|    307|    else
  354|    307|    {
  355|    307|        nSizeRet = ser_readdata64(is);
  356|    307|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (356:13): [True: 40, False: 267]
  ------------------
  357|     40|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|    307|    }
  359|   985k|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (359:9): [True: 985k, False: 205]
  |  Branch (359:24): [True: 89, False: 985k]
  ------------------
  360|     89|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  361|     89|    }
  362|   985k|    return nSizeRet;
  363|   985k|}
_Z14ser_readdata16I10DataStreamEtRT_:
   88|    452|{
   89|    452|    uint16_t obj;
   90|    452|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   91|    452|    return le16toh_internal(obj);
   92|    452|}
_Z14ser_readdata32I10DataStreamEjRT_:
   94|    166|{
   95|    166|    uint32_t obj;
   96|    166|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   97|    166|    return le32toh_internal(obj);
   98|    166|}
_Z14ser_readdata64I10DataStreamEmRT_:
  106|    123|{
  107|    123|    uint64_t obj;
  108|    123|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
  109|    123|    return le64toh_internal(obj);
  110|    123|}
_Z9SerializeI10DataStream7uint256Q12SerializableIT0_T_EEvRS3_RKS2_:
  767|    475|{
  768|    475|    a.Serialize(os);
  769|    475|}
_Z9SerializeI10DataStreamTk9BasicByteKhLm32EEvRT_NSt3__14spanIT0_XT1_EEE:
  260|    475|template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
_Z9SerializeI10DataStreamTk9BasicByteKhEvRT_NSt3__14spanIT0_Lm18446744073709551615EEE:
  261|    475|template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
_Z13ser_readdata8I10DataStreamEhRT_:
   82|   986k|{
   83|   986k|    uint8_t obj;
   84|   986k|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   85|   986k|    return obj;
   86|   986k|}

_Z20MakeWritableByteSpanIR7uint256EDaOT_:
   90|    475|{
   91|    475|    return std::as_writable_bytes(std::span{std::forward<V>(v)});
   92|    475|}
_Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEEDaOT_:
   90|    475|{
   91|    475|    return std::as_writable_bytes(std::span{std::forward<V>(v)});
   92|    475|}

_ZN10DataStreamrsIR24BlockTransactionsRequestEERS_OT_:
  259|    475|    {
  260|    475|        ::Unserialize(*this, obj);
  261|    475|        return (*this);
  262|    475|    }
_ZN10DataStream5writeENSt3__14spanIKSt4byteLm18446744073709551615EEE:
  245|    950|    {
  246|       |        // Write to the end of the buffer
  247|    950|        vch.insert(vch.end(), src.begin(), src.end());
  248|    950|    }
_ZN10DataStreamlsINSt3__14spanIKhLm32EEEEERS_RKT_:
  252|    475|    {
  253|    475|        ::Serialize(*this, obj);
  254|    475|        return (*this);
  255|    475|    }
_ZN10DataStream5clearEv:
  204|    404|    void clear()                                     { vch.clear(); m_read_pos = 0; }
_ZN10DataStreamC2Ev:
  182|    475|    explicit DataStream() = default;
_ZN10DataStreamlsINSt3__14spanIKhLm18446744073709551615EEEEERS_RKT_:
  252|    475|    {
  253|    475|        ::Serialize(*this, obj);
  254|    475|        return (*this);
  255|    475|    }
_ZN10DataStreamlsI7uint256EERS_RKT_:
  252|    475|    {
  253|    475|        ::Serialize(*this, obj);
  254|    475|        return (*this);
  255|    475|    }
_ZN10DataStream4readENSt3__14spanISt4byteLm18446744073709551615EEE:
  212|   987k|    {
  213|   987k|        if (dst.size() == 0) return;
  ------------------
  |  Branch (213:13): [True: 0, False: 987k]
  ------------------
  214|       |
  215|       |        // Read from the beginning of the buffer
  216|   987k|        auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
  217|   987k|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (217:13): [True: 0, False: 987k]
  |  Branch (217:43): [True: 205, False: 987k]
  ------------------
  218|    205|            throw std::ios_base::failure("DataStream::read(): end of data");
  219|    205|        }
  220|   987k|        memcpy(dst.data(), &vch[m_read_pos], dst.size());
  221|   987k|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (221:13): [True: 404, False: 986k]
  ------------------
  222|       |            // If fully consumed, reset to empty state.
  223|    404|            clear();
  224|    404|            return;
  225|    404|        }
  226|   986k|        m_read_pos = next_read_pos.value();
  227|   986k|    }

random.cpp:_ZN16secure_allocatorIN12_GLOBAL__N_18RNGStateEE10deallocateEPS1_m:
   37|      2|    {
   38|      2|        if (p != nullptr) {
  ------------------
  |  Branch (38:13): [True: 2, False: 0]
  ------------------
   39|      2|            memory_cleanse(p, sizeof(T) * n);
   40|      2|        }
   41|      2|        LockedPoolManager::Instance().free(p);
   42|      2|    }

_ZN25zero_after_free_allocatorISt4byteE8allocateEm:
   25|    950|    {
   26|    950|        return std::allocator<T>{}.allocate(n);
   27|    950|    }
_ZN25zero_after_free_allocatorISt4byteE10deallocateEPS0_m:
   30|    950|    {
   31|    950|        if (p != nullptr)
  ------------------
  |  Branch (31:13): [True: 950, False: 0]
  ------------------
   32|    950|            memory_cleanse(p, sizeof(T) * n);
   33|    950|        std::allocator<T>{}.deallocate(p, n);
   34|    950|    }

_Z14memory_cleansePvm:
   15|    964|{
   16|       |#if defined(WIN32)
   17|       |    /* SecureZeroMemory is guaranteed not to be optimized out. */
   18|       |    SecureZeroMemory(ptr, len);
   19|       |#else
   20|    964|    std::memset(ptr, 0, len);
   21|       |
   22|       |    /* Memory barrier that scares the compiler away from optimizing out the memset.
   23|       |     *
   24|       |     * Quoting Adam Langley <agl@google.com> in commit ad1907fe73334d6c696c8539646c21b11178f20f
   25|       |     * in BoringSSL (ISC License):
   26|       |     *    As best as we can tell, this is sufficient to break any optimisations that
   27|       |     *    might try to eliminate "superfluous" memsets.
   28|       |     * This method is used in memzero_explicit() the Linux kernel, too. Its advantage is that it
   29|       |     * is pretty efficient because the compiler can still implement the memset() efficiently,
   30|       |     * just not remove it entirely. See "Dead Store Elimination (Still) Considered Harmful" by
   31|       |     * Yang et al. (USENIX Security 2017) for more background.
   32|       |     */
   33|    964|    __asm__ __volatile__("" : : "r"(ptr) : "memory");
   34|    964|#endif
   35|    964|}

_ZN5ArenaD2Ev:
   48|      2|Arena::~Arena() = default;
_ZN5Arena4freeEPv:
   87|      2|{
   88|       |    // Freeing the nullptr pointer is OK.
   89|      2|    if (ptr == nullptr) {
  ------------------
  |  Branch (89:9): [True: 0, False: 2]
  ------------------
   90|      0|        return;
   91|      0|    }
   92|       |
   93|       |    // Remove chunk from used map
   94|      2|    auto i = chunks_used.find(ptr);
   95|      2|    if (i == chunks_used.end()) {
  ------------------
  |  Branch (95:9): [True: 0, False: 2]
  ------------------
   96|      0|        throw std::runtime_error("Arena: invalid or double free");
   97|      0|    }
   98|      2|    auto freed = std::make_pair(static_cast<char*>(i->first), i->second);
   99|      2|    chunks_used.erase(i);
  100|       |
  101|       |    // coalesce freed with previous chunk
  102|      2|    auto prev = chunks_free_end.find(freed.first);
  103|      2|    if (prev != chunks_free_end.end()) {
  ------------------
  |  Branch (103:9): [True: 2, False: 0]
  ------------------
  104|      2|        freed.first -= prev->second->first;
  105|      2|        freed.second += prev->second->first;
  106|      2|        size_to_free_chunk.erase(prev->second);
  107|      2|        chunks_free_end.erase(prev);
  108|      2|    }
  109|       |
  110|       |    // coalesce freed with chunk after freed
  111|      2|    auto next = chunks_free.find(freed.first + freed.second);
  112|      2|    if (next != chunks_free.end()) {
  ------------------
  |  Branch (112:9): [True: 0, False: 2]
  ------------------
  113|      0|        freed.second += next->second->first;
  114|      0|        size_to_free_chunk.erase(next->second);
  115|      0|        chunks_free.erase(next);
  116|      0|    }
  117|       |
  118|       |    // Add/set space with coalesced free chunk
  119|      2|    auto it = size_to_free_chunk.emplace(freed.second, freed.first);
  120|      2|    chunks_free[freed.first] = it;
  121|      2|    chunks_free_end[freed.first + freed.second] = it;
  122|      2|}
_ZN24PosixLockedPageAllocator10FreeLockedEPvm:
  254|      2|{
  255|      2|    len = align_up(len, page_size);
  256|      2|    memory_cleanse(addr, len);
  257|      2|    munlock(addr, len);
  258|      2|    munmap(addr, len);
  259|      2|}
_ZN10LockedPoolD2Ev:
  283|      2|LockedPool::~LockedPool() = default;
_ZN10LockedPool4freeEPv:
  308|      2|{
  309|      2|    std::lock_guard<std::mutex> lock(mutex);
  310|       |    // TODO we can do better than this linear search by keeping a map of arena
  311|       |    // extents to arena, and looking up the address.
  312|      2|    for (auto &arena: arenas) {
  ------------------
  |  Branch (312:21): [True: 2, False: 0]
  ------------------
  313|      2|        if (arena.addressInArena(ptr)) {
  ------------------
  |  Branch (313:13): [True: 2, False: 0]
  ------------------
  314|      2|            arena.free(ptr);
  315|      2|            return;
  316|      2|        }
  317|      2|    }
  318|      0|    throw std::runtime_error("LockedPool: invalid address not pointing to any arena");
  319|      2|}
_ZN10LockedPool15LockedPageArenaD2Ev:
  370|      2|{
  371|      2|    allocator->FreeLocked(base, size);
  372|      2|}
_ZN17LockedPoolManager8InstanceEv:
  405|      2|{
  406|      2|    static std::once_flag init_flag;
  407|      2|    std::call_once(init_flag, LockedPoolManager::CreateInstance);
  408|      2|    return *LockedPoolManager::_instance;
  409|      2|}
lockedpool.cpp:_ZL8align_upmm:
   32|      2|{
   33|      2|    return (x + align - 1) & ~(align - 1);
   34|      2|}

_ZNK5Arena14addressInArenaEPv:
   90|      2|    bool addressInArena(void *ptr) const { return ptr >= base && ptr < end; }
  ------------------
  |  Branch (90:51): [True: 2, False: 0]
  |  Branch (90:66): [True: 2, False: 0]
  ------------------
_ZN19LockedPageAllocatorD2Ev:
   22|      2|    virtual ~LockedPageAllocator() = default;

_ZN14AnnotatedMixinINSt3__115recursive_mutexEED2Ev:
   96|      2|    ~AnnotatedMixin() {
   97|      2|        DeleteLock((void*)this);
   98|      2|    }
_ZN14AnnotatedMixinINSt3__15mutexEED2Ev:
   96|     64|    ~AnnotatedMixin() {
   97|     64|        DeleteLock((void*)this);
   98|     64|    }
_Z10DeleteLockPv:
   74|     66|inline void DeleteLock(void* cs) {}
_Z17MaybeCheckNotHeldR14AnnotatedMixinINSt3__15mutexEE:
  258|     30|inline Mutex& MaybeCheckNotHeld(Mutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEEC2ERS3_PKcS7_ib:
  181|     30|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  182|     30|    {
  183|     30|        if (fTry)
  ------------------
  |  Branch (183:13): [True: 0, False: 30]
  ------------------
  184|      0|            TryEnter(pszName, pszFile, nLine);
  185|     30|        else
  186|     30|            Enter(pszName, pszFile, nLine);
  187|     30|    }
_Z13EnterCriticalINSt3__15mutexEEvPKcS3_iPT_b:
   67|     30|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_Z13LeaveCriticalv:
   68|     30|inline void LeaveCritical() {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEE5EnterEPKcS6_i:
  159|     30|    {
  160|     30|        EnterCritical(pszName, pszFile, nLine, Base::mutex());
  161|       |#ifdef DEBUG_LOCKCONTENTION
  162|       |        if (!Base::try_lock()) {
  163|       |            ContendedLock(pszName, pszFile, nLine, static_cast<Base&>(*this));
  164|       |        }
  165|       |#else
  166|     30|        Base::lock();
  167|     30|#endif
  168|     30|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEED2Ev:
  201|     30|    {
  202|     30|        if (Base::owns_lock())
  ------------------
  |  Branch (202:13): [True: 30, False: 0]
  ------------------
  203|     30|            LeaveCritical();
  204|     30|    }

_Z32difference_formatter_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   13|    475|{
   14|    475|    const auto block_hash = InsecureRandomContext{{}}.rand256();
   15|    475|    DataStream ss{};
   16|    475|    ss << block_hash << std::span{buffer};
   17|       |
   18|       |    // Test deserialization
   19|    475|    try {
   20|    475|        BlockTransactionsRequest test_container;
   21|    475|        ss >> test_container;
   22|    475|        assert(test_container.blockhash == block_hash);
  ------------------
  |  Branch (22:9): [True: 74, False: 401]
  ------------------
   23|       |
   24|       |        // Invariant: strictly monotonic increasing (no duplicates allowed)
   25|   134k|        for (size_t i = 1; i < test_container.indexes.size(); ++i) {
  ------------------
  |  Branch (25:28): [True: 133k, False: 74]
  ------------------
   26|   133k|            assert(test_container.indexes[i] > test_container.indexes[i-1]);
  ------------------
  |  Branch (26:13): [True: 133k, False: 0]
  ------------------
   27|   133k|        }
   28|       |
   29|    401|    } catch (const std::ios_base::failure&) {
   30|       |        // Expected for malformed input
   31|    401|    }
   32|    475|}

LLVMFuzzerTestOneInput:
  213|    475|{
  214|    475|    test_one_input({data, size});
  215|    475|    return 0;
  216|    475|}
fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE:
   84|    475|{
   85|    475|    CheckGlobals check{};
   86|    475|    (*Assert(g_test_one_input))(buffer);
  ------------------
  |  |  116|    475|#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
  ------------------
   87|    475|}

_ZN12CheckGlobalsC2Ev:
   59|    475|CheckGlobals::CheckGlobals() : m_impl(std::make_unique<CheckGlobalsImpl>()) {}
_ZN12CheckGlobalsD2Ev:
   60|    477|CheckGlobals::~CheckGlobals() = default;
_ZN16CheckGlobalsImplC2Ev:
   17|    475|    {
   18|    475|        g_used_g_prng = false;
   19|    475|        g_seeded_g_prng_zero = false;
   20|    475|        g_used_system_time = false;
   21|    475|        SetMockTime(0s);
   22|    475|        MockableSteadyClock::ClearMockTime();
   23|    475|    }
_ZN16CheckGlobalsImplD2Ev:
   25|    477|    {
   26|    477|        if (g_used_g_prng && !g_seeded_g_prng_zero) {
  ------------------
  |  Branch (26:13): [True: 0, False: 477]
  |  Branch (26:30): [True: 0, False: 0]
  ------------------
   27|      0|            std::cerr << "\n\n"
   28|      0|                         "The current fuzz target used the global random state.\n\n"
   29|       |
   30|      0|                         "This is acceptable, but requires the fuzz target to call \n"
   31|      0|                         "SeedRandomStateForTest(SeedRand::ZEROS) in the first line \n"
   32|      0|                         "of the FUZZ_TARGET function.\n\n"
   33|       |
   34|      0|                         "An alternative solution would be to avoid any use of globals.\n\n"
   35|       |
   36|      0|                         "Without a solution, fuzz instability and non-determinism can lead \n"
   37|      0|                         "to non-reproducible bugs or inefficient fuzzing.\n\n"
   38|      0|                      << std::endl;
   39|      0|            std::abort(); // Abort, because AFL may try to recover from a std::exit
   40|      0|        }
   41|       |
   42|    477|        if (g_used_system_time) {
  ------------------
  |  Branch (42:13): [True: 0, False: 477]
  ------------------
   43|      0|            std::cerr << "\n\n"
   44|      0|                         "The current fuzz target accessed system time.\n\n"
   45|       |
   46|      0|                         "This is acceptable, but requires the fuzz target to use \n"
   47|      0|                         "a FakeNodeClock, FakeSteadyClock or call \n"
   48|      0|                         "SetMockTime() at the \n" "beginning of processing the \n"
   49|      0|                         "fuzz input.\n\n"
   50|       |
   51|      0|                         "Without setting mock time, time-dependent behavior can lead \n"
   52|      0|                         "to non-reproducible bugs or inefficient fuzzing.\n\n"
   53|      0|                      << std::endl;
   54|      0|            std::abort();
   55|      0|        }
   56|    477|    }

__gcov_reset:
   13|      2|extern "C" __attribute__((weak)) void __gcov_reset(void) {}

_ZN9base_blobILj256EE11UnserializeI10DataStreamEEvRT_:
  119|    475|    {
  120|    475|        s.read(MakeWritableByteSpan(m_data));
  121|    475|    }
_ZNK9base_blobILj256EE9SerializeI10DataStreamEEvRT_:
  113|    475|    {
  114|    475|        s << std::span(m_data);
  115|    475|    }
_ZNK9base_blobILj256EEeqERKS0_:
   62|     74|    constexpr bool operator==(const base_blob&) const = default;
_ZN9base_blobILj256EE4dataEv:
   99|    477|    constexpr unsigned char* data() { return m_data.data(); }
_ZN7uint256C2Ev:
  200|    950|    constexpr uint256() = default;
_ZN9base_blobILj256EEC2Ev:
   37|    950|    constexpr base_blob() : m_data() {}
_ZN9base_blobILj256EE4sizeEv:
  107|    477|    static constexpr unsigned int size() { return WIDTH; }

_ZN10btcsignals6signalIFvvENS_10null_valueEED2Ev:
  175|      6|    ~signal() = default;
_ZN10btcsignals6signalIFv20SynchronizationStatellbENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFv20SynchronizationStateRK11CBlockIndexdENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFvRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEibENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFvbENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFviENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFvRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFbRK13bilingual_strRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEjENS_6any_ofEED2Ev:
  175|      2|    ~signal() = default;
_ZN10btcsignals6signalIFvRK13bilingual_strjENS_10null_valueEED2Ev:
  175|      2|    ~signal() = default;

_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_RKNS0_15source_locationENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE:
   90|    475|{
   91|    475|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 475, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|    475|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 475]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|    475|    }
   96|    475|    return std::forward<T>(val);
   97|    475|}
_Z22inline_assertion_checkILb1EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   90|    475|{
   91|    475|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 475, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|    475|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 475]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|    475|    }
   96|    475|    return std::forward<T>(val);
   97|    475|}
_Z22inline_assertion_checkILb0EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   90|     10|{
   91|     10|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [Folded, False: 0]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|     10|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 10]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|     10|    }
   96|     10|    return std::forward<T>(val);
   97|     10|}

_Z10CheckedAddImENSt3__18optionalIT_EES2_S2_:
   28|   987k|{
   29|   987k|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (29:9): [True: 0, False: 987k]
  ------------------
   30|      0|        return std::nullopt;
   31|      0|    }
   32|   987k|    return i + j;
   33|   987k|}
_Z16AdditionOverflowITkNSt3__18integralEmEbT_S1_:
   18|   987k|{
   19|       |    if constexpr (std::numeric_limits<T>::is_signed) {
   20|       |        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
   21|       |               (i < 0 && j < std::numeric_limits<T>::min() - i);
   22|       |    }
   23|   987k|    return std::numeric_limits<T>::max() - i < j;
   24|   987k|}

_ZN16CThreadInterruptD2Ev:
   32|      4|    virtual ~CThreadInterrupt() = default;

_ZN10ThreadPoolD2Ev:
   93|     10|    {
   94|     10|        Stop(); // In case it hasn't been stopped.
   95|     10|    }
_ZN10ThreadPool4StopEv:
  129|     10|    {
  130|       |        // Notify workers and join them
  131|     10|        std::vector<std::thread> threads_to_join;
  132|     10|        {
  133|     10|            LOCK(m_mutex);
  ------------------
  |  |  268|     10|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|     10|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|     10|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|     10|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  134|       |            // Ensure Stop() is not called from a worker thread while workers are still registered,
  135|       |            // otherwise a self-join deadlock would occur.
  136|     10|            auto id = std::this_thread::get_id();
  137|     10|            for (const auto& worker : m_workers) assert(worker.get_id() != id);
  ------------------
  |  Branch (137:37): [True: 0, False: 10]
  |  Branch (137:50): [True: 0, False: 0]
  ------------------
  138|       |            // Early shutdown to return right away on any concurrent Submit() call
  139|     10|            m_interrupt = true;
  140|     10|            threads_to_join.swap(m_workers);
  141|     10|        }
  142|      0|        m_cv.notify_all();
  143|       |        // Help draining queue
  144|     10|        while (ProcessTask()) {}
  ------------------
  |  Branch (144:16): [True: 0, False: 10]
  ------------------
  145|       |        // Free resources
  146|     10|        for (auto& worker : threads_to_join) worker.join();
  ------------------
  |  Branch (146:27): [True: 0, False: 10]
  ------------------
  147|       |
  148|       |        // Since we currently wait for tasks completion, sanity-check empty queue
  149|     10|        LOCK(m_mutex);
  ------------------
  |  |  268|     10|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|     10|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|     10|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|     10|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  150|     10|        Assume(m_work_queue.empty());
  ------------------
  |  |  128|     10|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  151|       |        // Re-allow Start() now that all workers have exited
  152|     10|        m_interrupt = false;
  153|     10|    }
_ZN10ThreadPool11ProcessTaskEv:
  244|     10|    {
  245|     10|        std::packaged_task<void()> task;
  246|     10|        {
  247|     10|            LOCK(m_mutex);
  ------------------
  |  |  268|     10|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|     10|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|     10|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|     10|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  248|     10|            if (m_work_queue.empty()) return false;
  ------------------
  |  Branch (248:17): [True: 10, False: 0]
  ------------------
  249|       |
  250|       |            // Pop the task
  251|      0|            task = std::move(m_work_queue.front());
  252|      0|            m_work_queue.pop();
  253|      0|        }
  254|      0|        task();
  255|      0|        return true;
  256|     10|    }

_Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   54|    475|{
   55|    475|    Assert(mock_time_in >= 0s);
  ------------------
  |  |  116|    475|#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
  ------------------
   56|    475|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   57|    475|}
_ZN19MockableSteadyClock13ClearMockTimeEv:
   84|    475|{
   85|    475|    g_mock_steady_time.store(0ms, std::memory_order_relaxed);
   86|    475|}

_ZN19WalletInitInterfaceD2Ev:
   25|      2|    virtual ~WalletInitInterface() = default;