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

_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|}

_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;

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

_ZNK10CScriptNumanERKS_:
  288|   169k|    inline CScriptNum operator&(   const CScriptNum& rhs) const { return operator&(rhs.m_value);   }
_ZN10CScriptNumaNERKS_:
  290|   307k|    inline CScriptNum& operator&=( const CScriptNum& rhs)       { return operator&=(rhs.m_value);  }
_ZN10CScriptNumaNERKl:
  321|   480k|    {
  322|   480k|        m_value &= rhs;
  323|   480k|        return *this;
  324|   480k|    }
_ZN10CScriptNumC2ERKl:
  240|  24.1M|    {
  241|  24.1M|        m_value = n;
  242|  24.1M|    }
_ZNK10CScriptNum6getvchEv:
  338|  7.13M|    {
  339|  7.13M|        return serialize(m_value);
  340|  7.13M|    }
_ZN10CScriptNum9serializeERKl:
  343|  7.13M|    {
  344|  7.13M|        if(value == 0)
  ------------------
  |  Branch (344:12): [True: 451k, False: 6.68M]
  ------------------
  345|   451k|            return std::vector<unsigned char>();
  346|       |
  347|  6.68M|        std::vector<unsigned char> result;
  348|  6.68M|        const bool neg = value < 0;
  349|  6.68M|        uint64_t absvalue = neg ? ~static_cast<uint64_t>(value) + 1 : static_cast<uint64_t>(value);
  ------------------
  |  Branch (349:29): [True: 3.44M, False: 3.23M]
  ------------------
  350|       |
  351|  59.0M|        while(absvalue)
  ------------------
  |  Branch (351:15): [True: 52.3M, False: 6.68M]
  ------------------
  352|  52.3M|        {
  353|  52.3M|            result.push_back(absvalue & 0xff);
  354|  52.3M|            absvalue >>= 8;
  355|  52.3M|        }
  356|       |
  357|       |//    - If the most significant byte is >= 0x80 and the value is positive, push a
  358|       |//    new zero-byte to make the significant byte < 0x80 again.
  359|       |
  360|       |//    - If the most significant byte is >= 0x80 and the value is negative, push a
  361|       |//    new 0x80 byte that will be popped off when converting to an integral.
  362|       |
  363|       |//    - If the most significant byte is < 0x80 and the value is negative, add
  364|       |//    0x80 to it, since it will be subtracted and interpreted as a negative when
  365|       |//    converting to an integral.
  366|       |
  367|  6.68M|        if (result.back() & 0x80)
  ------------------
  |  Branch (367:13): [True: 372k, False: 6.31M]
  ------------------
  368|   372k|            result.push_back(neg ? 0x80 : 0);
  ------------------
  |  Branch (368:30): [True: 298k, False: 73.2k]
  ------------------
  369|  6.31M|        else if (neg)
  ------------------
  |  Branch (369:18): [True: 3.15M, False: 3.16M]
  ------------------
  370|  3.15M|            result.back() |= 0x80;
  371|       |
  372|  6.68M|        return result;
  373|  7.13M|    }
_ZNK10CScriptNumssERKl:
  274|  20.6M|    inline auto operator<=>(const int64_t& rhs) const    { return m_value <=> rhs; }
_ZNK10CScriptNumanERKl:
  287|   577k|    inline CScriptNum operator&(   const int64_t& rhs)    const { return CScriptNum(m_value & rhs);}
_ZNK10CScriptNumeqERKl:
  273|  12.8M|    inline bool operator==(const int64_t& rhs) const    { return m_value == rhs; }
_ZNK10CScriptNum6getintEv:
  327|  7.13M|    {
  328|  7.13M|        if (m_value > std::numeric_limits<int>::max())
  ------------------
  |  Branch (328:13): [True: 3.17M, False: 3.96M]
  ------------------
  329|  3.17M|            return std::numeric_limits<int>::max();
  330|  3.96M|        else if (m_value < std::numeric_limits<int>::min())
  ------------------
  |  Branch (330:18): [True: 3.40M, False: 559k]
  ------------------
  331|  3.40M|            return std::numeric_limits<int>::min();
  332|   559k|        return m_value;
  333|  7.13M|    }
_ZN10CScriptNumpLERKS_:
  284|   210k|    inline CScriptNum& operator+=( const CScriptNum& rhs)       { return operator+=(rhs.m_value);  }
_ZN10CScriptNumpLERKl:
  305|   340k|    {
  306|   340k|        assert(rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) ||
  ------------------
  |  Branch (306:9): [True: 116k, False: 222k]
  |  Branch (306:9): [True: 116k, False: 0]
  |  Branch (306:9): [True: 1.59k, False: 339k]
  |  Branch (306:9): [True: 222k, False: 0]
  |  Branch (306:9): [True: 222k, False: 0]
  |  Branch (306:9): [True: 340k, False: 0]
  ------------------
  307|   340k|                           (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs));
  308|   340k|        m_value += rhs;
  309|   340k|        return *this;
  310|   340k|    }
_ZN10CScriptNummIERKS_:
  285|   212k|    inline CScriptNum& operator-=( const CScriptNum& rhs)       { return operator-=(rhs.m_value);  }
_ZN10CScriptNummIERKl:
  313|   353k|    {
  314|   353k|        assert(rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) ||
  ------------------
  |  Branch (314:9): [True: 127k, False: 225k]
  |  Branch (314:9): [True: 127k, False: 0]
  |  Branch (314:9): [True: 1.04k, False: 352k]
  |  Branch (314:9): [True: 225k, False: 0]
  |  Branch (314:9): [True: 225k, False: 0]
  |  Branch (314:9): [True: 353k, False: 0]
  ------------------
  315|   353k|                           (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs));
  316|   353k|        m_value -= rhs;
  317|   353k|        return *this;
  318|   353k|    }
_ZNK10CScriptNumngEv:
  293|  2.52M|    {
  294|  2.52M|        assert(m_value != std::numeric_limits<int64_t>::min());
  ------------------
  |  Branch (294:9): [True: 2.52M, False: 0]
  ------------------
  295|  2.52M|        return CScriptNum(-m_value);
  296|  2.52M|    }
_ZNK10CScriptNumssERKS_:
  277|  6.76M|    inline auto operator<=>(const CScriptNum& rhs) const { return operator<=>(rhs.m_value); }
_ZNK10CScriptNumeqERKS_:
  276|  5.63M|    inline bool operator==(const CScriptNum& rhs) const { return operator==(rhs.m_value); }
_ZN10CScriptNumaSERKl:
  299|   441k|    {
  300|   441k|        m_value = rhs;
  301|   441k|        return *this;
  302|   441k|    }
_ZNK10CScriptNumplERKS_:
  281|  3.13M|    inline CScriptNum operator+(   const CScriptNum& rhs) const { return operator+(rhs.m_value);   }
_ZNK10CScriptNummiERKS_:
  282|  3.08M|    inline CScriptNum operator-(   const CScriptNum& rhs) const { return operator-(rhs.m_value);   }
_ZNK10CScriptNummiERKl:
  280|  4.46M|    inline CScriptNum operator-(   const int64_t& rhs)    const { return CScriptNum(m_value - rhs);}
_ZNK10CScriptNumplERKl:
  279|  4.51M|    inline CScriptNum operator+(   const int64_t& rhs)    const { return CScriptNum(m_value + rhs);}

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

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

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|    }

_Z14memory_cleansePvm:
   15|     14|{
   16|       |#if defined(WIN32)
   17|       |    /* SecureZeroMemory is guaranteed not to be optimized out. */
   18|       |    SecureZeroMemory(ptr, len);
   19|       |#else
   20|     14|    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|     14|    __asm__ __volatile__("" : : "r"(ptr) : "memory");
   34|     14|#endif
   35|     14|}

_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|    }

_ZN18FuzzedDataProvider15remaining_bytesEv:
   85|  7.13M|  size_t remaining_bytes() { return remaining_bytes_; }
_ZN18FuzzedDataProviderC2EPKhm:
   37|  1.49k|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_:
  205|  7.13M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  7.13M|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|  7.13M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  7.13M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 7.13M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  7.13M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  7.13M|  uint64_t result = 0;
  215|  7.13M|  size_t offset = 0;
  216|       |
  217|  14.2M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 14.2M, False: 0]
  |  Branch (217:43): [True: 7.13M, False: 7.13M]
  ------------------
  218|  7.13M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 7.13M, False: 0]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  7.13M|    --remaining_bytes_;
  226|  7.13M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  7.13M|    offset += CHAR_BIT;
  228|  7.13M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  7.13M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 7.13M, False: 0]
  ------------------
  232|  7.13M|    result = result % (range + 1);
  233|       |
  234|  7.13M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  7.13M|}
_ZN18FuzzedDataProvider15ConsumeIntegralIlEET_v:
  195|  4.59M|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  4.59M|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  4.59M|                                std::numeric_limits<T>::max());
  198|  4.59M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIlEET_S1_S1_:
  205|  4.59M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  4.59M|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|  4.59M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  4.59M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 4.59M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  4.59M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  4.59M|  uint64_t result = 0;
  215|  4.59M|  size_t offset = 0;
  216|       |
  217|  41.3M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 36.7M, False: 4.59M]
  |  Branch (217:43): [True: 36.7M, False: 0]
  ------------------
  218|  36.7M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 36.7M, False: 746]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  36.7M|    --remaining_bytes_;
  226|  36.7M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  36.7M|    offset += CHAR_BIT;
  228|  36.7M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  4.59M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 0, False: 4.59M]
  ------------------
  232|      0|    result = result % (range + 1);
  233|       |
  234|  4.59M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  4.59M|}

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

_Z25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   28|  1.49k|{
   29|  1.49k|    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
   30|  1.49k|    CScriptNum script_num = ConsumeScriptNum(fuzzed_data_provider);
   31|  7.13M|    LIMITED_WHILE (fuzzed_data_provider.remaining_bytes() > 0, 1000000) {
  ------------------
  |  |   23|  7.13M|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 7.13M, False: 1.49k]
  |  |  |  Branch (23:49): [True: 7.13M, False: 1]
  |  |  ------------------
  ------------------
   32|  7.13M|        CallOneOf(
   33|  7.13M|            fuzzed_data_provider,
   34|  7.13M|            [&] {
   35|  7.13M|                const int64_t i = fuzzed_data_provider.ConsumeIntegral<int64_t>();
   36|  7.13M|                assert((script_num == i) != (script_num != i));
   37|  7.13M|                assert((script_num <= i) != (script_num > i));
   38|  7.13M|                assert((script_num >= i) != (script_num < i));
   39|       |                // Avoid signed integer overflow:
   40|       |                // script/script.h:264:93: runtime error: signed integer overflow: -2261405121394637306 + -9223372036854775802 cannot be represented in type 'long'
   41|  7.13M|                if (IsValidAddition(script_num, CScriptNum{i})) {
   42|  7.13M|                    assert((script_num + i) - i == script_num);
   43|  7.13M|                }
   44|       |                // Avoid signed integer overflow:
   45|       |                // script/script.h:265:93: runtime error: signed integer overflow: 9223371895120855039 - -9223372036854710486 cannot be represented in type 'long'
   46|  7.13M|                if (IsValidSubtraction(script_num, CScriptNum{i})) {
   47|  7.13M|                    assert((script_num - i) + i == script_num);
   48|  7.13M|                }
   49|  7.13M|            },
   50|  7.13M|            [&] {
   51|  7.13M|                const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider);
   52|  7.13M|                assert((script_num == random_script_num) != (script_num != random_script_num));
   53|  7.13M|                assert((script_num <= random_script_num) != (script_num > random_script_num));
   54|  7.13M|                assert((script_num >= random_script_num) != (script_num < random_script_num));
   55|       |                // Avoid signed integer overflow:
   56|       |                // script/script.h:264:93: runtime error: signed integer overflow: -9223126527765971126 + -9223372036854756825 cannot be represented in type 'long'
   57|  7.13M|                if (IsValidAddition(script_num, random_script_num)) {
   58|  7.13M|                    assert((script_num + random_script_num) - random_script_num == script_num);
   59|  7.13M|                }
   60|       |                // Avoid signed integer overflow:
   61|       |                // script/script.h:265:93: runtime error: signed integer overflow: 6052837899185946624 - -9223372036854775808 cannot be represented in type 'long'
   62|  7.13M|                if (IsValidSubtraction(script_num, random_script_num)) {
   63|  7.13M|                    assert((script_num - random_script_num) + random_script_num == script_num);
   64|  7.13M|                }
   65|  7.13M|            },
   66|  7.13M|            [&] {
   67|  7.13M|                const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider);
   68|  7.13M|                if (!IsValidAddition(script_num, random_script_num)) {
   69|       |                    // Avoid assertion failure:
   70|       |                    // ./script/script.h:292: CScriptNum &CScriptNum::operator+=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) || (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs)' failed.
   71|  7.13M|                    return;
   72|  7.13M|                }
   73|  7.13M|                script_num += random_script_num;
   74|  7.13M|            },
   75|  7.13M|            [&] {
   76|  7.13M|                const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider);
   77|  7.13M|                if (!IsValidSubtraction(script_num, random_script_num)) {
   78|       |                    // Avoid assertion failure:
   79|       |                    // ./script/script.h:300: CScriptNum &CScriptNum::operator-=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) || (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs)' failed.
   80|  7.13M|                    return;
   81|  7.13M|                }
   82|  7.13M|                script_num -= random_script_num;
   83|  7.13M|            },
   84|  7.13M|            [&] {
   85|  7.13M|                script_num = script_num & fuzzed_data_provider.ConsumeIntegral<int64_t>();
   86|  7.13M|            },
   87|  7.13M|            [&] {
   88|  7.13M|                script_num = script_num & ConsumeScriptNum(fuzzed_data_provider);
   89|  7.13M|            },
   90|  7.13M|            [&] {
   91|  7.13M|                script_num &= ConsumeScriptNum(fuzzed_data_provider);
   92|  7.13M|            },
   93|  7.13M|            [&] {
   94|  7.13M|                if (script_num == CScriptNum{std::numeric_limits<int64_t>::min()}) {
   95|       |                    // Avoid assertion failure:
   96|       |                    // ./script/script.h:279: CScriptNum CScriptNum::operator-() const: Assertion `m_value != std::numeric_limits<int64_t>::min()' failed.
   97|  7.13M|                    return;
   98|  7.13M|                }
   99|  7.13M|                script_num = -script_num;
  100|  7.13M|            },
  101|  7.13M|            [&] {
  102|  7.13M|                script_num = fuzzed_data_provider.ConsumeIntegral<int64_t>();
  103|  7.13M|            },
  104|  7.13M|            [&] {
  105|  7.13M|                const int64_t random_integer = fuzzed_data_provider.ConsumeIntegral<int64_t>();
  106|  7.13M|                if (!IsValidAddition(script_num, CScriptNum{random_integer})) {
  107|       |                    // Avoid assertion failure:
  108|       |                    // ./script/script.h:292: CScriptNum &CScriptNum::operator+=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) || (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs)' failed.
  109|  7.13M|                    return;
  110|  7.13M|                }
  111|  7.13M|                script_num += random_integer;
  112|  7.13M|            },
  113|  7.13M|            [&] {
  114|  7.13M|                const int64_t random_integer = fuzzed_data_provider.ConsumeIntegral<int64_t>();
  115|  7.13M|                if (!IsValidSubtraction(script_num, CScriptNum{random_integer})) {
  116|       |                    // Avoid assertion failure:
  117|       |                    // ./script/script.h:300: CScriptNum &CScriptNum::operator-=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) || (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs)' failed.
  118|  7.13M|                    return;
  119|  7.13M|                }
  120|  7.13M|                script_num -= random_integer;
  121|  7.13M|            },
  122|  7.13M|            [&] {
  123|  7.13M|                script_num &= fuzzed_data_provider.ConsumeIntegral<int64_t>();
  124|  7.13M|            });
  125|  7.13M|        (void)script_num.getint();
  126|  7.13M|        (void)script_num.getvch();
  127|  7.13M|    }
  128|  1.49k|}
scriptnum_ops.cpp:_ZZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv:
   34|  1.19M|            [&] {
   35|  1.19M|                const int64_t i = fuzzed_data_provider.ConsumeIntegral<int64_t>();
   36|  1.19M|                assert((script_num == i) != (script_num != i));
  ------------------
  |  Branch (36:17): [True: 1.19M, False: 0]
  ------------------
   37|  1.19M|                assert((script_num <= i) != (script_num > i));
  ------------------
  |  Branch (37:17): [True: 1.19M, False: 0]
  ------------------
   38|  1.19M|                assert((script_num >= i) != (script_num < i));
  ------------------
  |  Branch (38:17): [True: 1.19M, False: 0]
  ------------------
   39|       |                // Avoid signed integer overflow:
   40|       |                // script/script.h:264:93: runtime error: signed integer overflow: -2261405121394637306 + -9223372036854775802 cannot be represented in type 'long'
   41|  1.19M|                if (IsValidAddition(script_num, CScriptNum{i})) {
  ------------------
  |  Branch (41:21): [True: 607k, False: 583k]
  ------------------
   42|   607k|                    assert((script_num + i) - i == script_num);
  ------------------
  |  Branch (42:21): [True: 607k, False: 0]
  ------------------
   43|   607k|                }
   44|       |                // Avoid signed integer overflow:
   45|       |                // script/script.h:265:93: runtime error: signed integer overflow: 9223371895120855039 - -9223372036854710486 cannot be represented in type 'long'
   46|  1.19M|                if (IsValidSubtraction(script_num, CScriptNum{i})) {
  ------------------
  |  Branch (46:21): [True: 773k, False: 417k]
  ------------------
   47|       |                    assert((script_num - i) + i == script_num);
  ------------------
  |  Branch (47:21): [True: 773k, False: 0]
  ------------------
   48|   773k|                }
   49|  1.19M|            },
scriptnum_ops.cpp:_ZN12_GLOBAL__N_115IsValidAdditionERK10CScriptNumS2_:
   17|  2.36M|{
   18|  2.36M|    return rhs == 0 || (rhs > 0 && lhs <= CScriptNum{std::numeric_limits<int64_t>::max()} - rhs) || (rhs < 0 && lhs >= CScriptNum{std::numeric_limits<int64_t>::min()} - rhs);
  ------------------
  |  Branch (18:12): [True: 1.71k, False: 2.36M]
  |  Branch (18:25): [True: 486k, False: 1.87M]
  |  Branch (18:36): [True: 236k, False: 250k]
  |  Branch (18:102): [True: 1.87M, False: 250k]
  |  Branch (18:113): [True: 1.05M, False: 819k]
  ------------------
   19|  2.36M|}
scriptnum_ops.cpp:_ZN12_GLOBAL__N_118IsValidSubtractionERK10CScriptNumS2_:
   22|  2.41M|{
   23|  2.41M|    return rhs == 0 || (rhs > 0 && lhs >= CScriptNum{std::numeric_limits<int64_t>::min()} + rhs) || (rhs < 0 && lhs <= CScriptNum{std::numeric_limits<int64_t>::max()} + rhs);
  ------------------
  |  Branch (23:12): [True: 1.16k, False: 2.41M]
  |  Branch (23:25): [True: 350k, False: 2.06M]
  |  Branch (23:36): [True: 225k, False: 125k]
  |  Branch (23:102): [True: 2.06M, False: 125k]
  |  Branch (23:113): [True: 1.27M, False: 790k]
  ------------------
   24|  2.41M|}
scriptnum_ops.cpp:_ZZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_1clEv:
   50|   496k|            [&] {
   51|   496k|                const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider);
   52|   496k|                assert((script_num == random_script_num) != (script_num != random_script_num));
  ------------------
  |  Branch (52:17): [True: 496k, False: 0]
  ------------------
   53|   496k|                assert((script_num <= random_script_num) != (script_num > random_script_num));
  ------------------
  |  Branch (53:17): [True: 496k, False: 0]
  ------------------
   54|   496k|                assert((script_num >= random_script_num) != (script_num < random_script_num));
  ------------------
  |  Branch (54:17): [True: 496k, False: 0]
  ------------------
   55|       |                // Avoid signed integer overflow:
   56|       |                // script/script.h:264:93: runtime error: signed integer overflow: -9223126527765971126 + -9223372036854756825 cannot be represented in type 'long'
   57|   496k|                if (IsValidAddition(script_num, random_script_num)) {
  ------------------
  |  Branch (57:21): [True: 347k, False: 148k]
  ------------------
   58|   347k|                    assert((script_num + random_script_num) - random_script_num == script_num);
  ------------------
  |  Branch (58:21): [True: 347k, False: 0]
  ------------------
   59|   347k|                }
   60|       |                // Avoid signed integer overflow:
   61|       |                // script/script.h:265:93: runtime error: signed integer overflow: 6052837899185946624 - -9223372036854775808 cannot be represented in type 'long'
   62|   496k|                if (IsValidSubtraction(script_num, random_script_num)) {
  ------------------
  |  Branch (62:21): [True: 375k, False: 120k]
  ------------------
   63|       |                    assert((script_num - random_script_num) + random_script_num == script_num);
  ------------------
  |  Branch (63:21): [True: 375k, False: 0]
  ------------------
   64|   375k|                }
   65|   496k|            },
scriptnum_ops.cpp:_ZZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_2clEv:
   66|   494k|            [&] {
   67|   494k|                const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider);
   68|   494k|                if (!IsValidAddition(script_num, random_script_num)) {
  ------------------
  |  Branch (68:21): [True: 284k, False: 210k]
  ------------------
   69|       |                    // Avoid assertion failure:
   70|       |                    // ./script/script.h:292: CScriptNum &CScriptNum::operator+=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) || (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs)' failed.
   71|   284k|                    return;
   72|   284k|                }
   73|   210k|                script_num += random_script_num;
   74|   210k|            },
scriptnum_ops.cpp:_ZZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_3clEv:
   75|   431k|            [&] {
   76|   431k|                const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider);
   77|   431k|                if (!IsValidSubtraction(script_num, random_script_num)) {
  ------------------
  |  Branch (77:21): [True: 219k, False: 212k]
  ------------------
   78|       |                    // Avoid assertion failure:
   79|       |                    // ./script/script.h:300: CScriptNum &CScriptNum::operator-=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) || (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs)' failed.
   80|   219k|                    return;
   81|   219k|                }
   82|   212k|                script_num -= random_script_num;
   83|   212k|            },
scriptnum_ops.cpp:_ZZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_4clEv:
   84|   407k|            [&] {
   85|   407k|                script_num = script_num & fuzzed_data_provider.ConsumeIntegral<int64_t>();
   86|   407k|            },
scriptnum_ops.cpp:_ZZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_5clEv:
   87|   169k|            [&] {
   88|   169k|                script_num = script_num & ConsumeScriptNum(fuzzed_data_provider);
   89|   169k|            },
scriptnum_ops.cpp:_ZZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_6clEv:
   90|   307k|            [&] {
   91|   307k|                script_num &= ConsumeScriptNum(fuzzed_data_provider);
   92|   307k|            },
scriptnum_ops.cpp:_ZZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_7clEv:
   93|  2.54M|            [&] {
   94|  2.54M|                if (script_num == CScriptNum{std::numeric_limits<int64_t>::min()}) {
  ------------------
  |  Branch (94:21): [True: 17.2k, False: 2.52M]
  ------------------
   95|       |                    // Avoid assertion failure:
   96|       |                    // ./script/script.h:279: CScriptNum CScriptNum::operator-() const: Assertion `m_value != std::numeric_limits<int64_t>::min()' failed.
   97|  17.2k|                    return;
   98|  17.2k|                }
   99|  2.52M|                script_num = -script_num;
  100|  2.52M|            },
scriptnum_ops.cpp:_ZZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_8clEv:
  101|   441k|            [&] {
  102|   441k|                script_num = fuzzed_data_provider.ConsumeIntegral<int64_t>();
  103|   441k|            },
scriptnum_ops.cpp:_ZZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_9clEv:
  104|   183k|            [&] {
  105|   183k|                const int64_t random_integer = fuzzed_data_provider.ConsumeIntegral<int64_t>();
  106|   183k|                if (!IsValidAddition(script_num, CScriptNum{random_integer})) {
  ------------------
  |  Branch (106:21): [True: 53.5k, False: 130k]
  ------------------
  107|       |                    // Avoid assertion failure:
  108|       |                    // ./script/script.h:292: CScriptNum &CScriptNum::operator+=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) || (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs)' failed.
  109|  53.5k|                    return;
  110|  53.5k|                }
  111|   130k|                script_num += random_integer;
  112|   130k|            },
scriptnum_ops.cpp:_ZZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_10clEv:
  113|   298k|            [&] {
  114|   298k|                const int64_t random_integer = fuzzed_data_provider.ConsumeIntegral<int64_t>();
  115|   298k|                if (!IsValidSubtraction(script_num, CScriptNum{random_integer})) {
  ------------------
  |  Branch (115:21): [True: 157k, False: 141k]
  ------------------
  116|       |                    // Avoid assertion failure:
  117|       |                    // ./script/script.h:300: CScriptNum &CScriptNum::operator-=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) || (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs)' failed.
  118|   157k|                    return;
  119|   157k|                }
  120|   141k|                script_num -= random_integer;
  121|   141k|            },
scriptnum_ops.cpp:_ZZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_11clEv:
  122|   173k|            [&] {
  123|   173k|                script_num &= fuzzed_data_provider.ConsumeIntegral<int64_t>();
  124|   173k|            });

scriptnum_ops.cpp:_Z9CallOneOfIJZ25scriptnum_ops_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEE3$_0Z25scriptnum_ops_fuzz_targetS3_E3$_1Z25scriptnum_ops_fuzz_targetS3_E3$_2Z25scriptnum_ops_fuzz_targetS3_E3$_3Z25scriptnum_ops_fuzz_targetS3_E3$_4Z25scriptnum_ops_fuzz_targetS3_E3$_5Z25scriptnum_ops_fuzz_targetS3_E3$_6Z25scriptnum_ops_fuzz_targetS3_E3$_7Z25scriptnum_ops_fuzz_targetS3_E3$_8Z25scriptnum_ops_fuzz_targetS3_E3$_9Z25scriptnum_ops_fuzz_targetS3_E4$_10Z25scriptnum_ops_fuzz_targetS3_E4$_11EEmR18FuzzedDataProviderDpT_:
   38|  7.13M|{
   39|  7.13M|    constexpr size_t call_size{sizeof...(callables)};
   40|  7.13M|    static_assert(call_size >= 1);
   41|  7.13M|    const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
   42|       |
   43|  7.13M|    size_t i{0};
   44|  85.6M|    ((i++ == call_index ? callables() : void()), ...);
  ------------------
  |  Branch (44:7): [True: 1.19M, False: 5.94M]
  |  Branch (44:7): [True: 496k, False: 6.64M]
  |  Branch (44:7): [True: 494k, False: 6.64M]
  |  Branch (44:7): [True: 431k, False: 6.70M]
  |  Branch (44:7): [True: 407k, False: 6.73M]
  |  Branch (44:7): [True: 169k, False: 6.96M]
  |  Branch (44:7): [True: 307k, False: 6.83M]
  |  Branch (44:7): [True: 2.54M, False: 4.59M]
  |  Branch (44:7): [True: 441k, False: 6.69M]
  |  Branch (44:7): [True: 183k, False: 6.95M]
  |  Branch (44:7): [True: 298k, False: 6.83M]
  |  Branch (44:7): [True: 173k, False: 6.96M]
  ------------------
   45|  7.13M|    return call_size;
   46|  7.13M|}
_Z16ConsumeScriptNumR18FuzzedDataProvider:
  182|  1.90M|{
  183|  1.90M|    return CScriptNum{fuzzed_data_provider.ConsumeIntegral<int64_t>()};
  184|  1.90M|}

_ZN12CheckGlobalsC2Ev:
   59|  1.49k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique<CheckGlobalsImpl>()) {}
_ZN12CheckGlobalsD2Ev:
   60|  1.49k|CheckGlobals::~CheckGlobals() = default;
_ZN16CheckGlobalsImplC2Ev:
   17|  1.49k|    {
   18|  1.49k|        g_used_g_prng = false;
   19|  1.49k|        g_seeded_g_prng_zero = false;
   20|  1.49k|        g_used_system_time = false;
   21|  1.49k|        SetMockTime(0s);
   22|  1.49k|        MockableSteadyClock::ClearMockTime();
   23|  1.49k|    }
_ZN16CheckGlobalsImplD2Ev:
   25|  1.49k|    {
   26|  1.49k|        if (g_used_g_prng && !g_seeded_g_prng_zero) {
  ------------------
  |  Branch (26:13): [True: 0, False: 1.49k]
  |  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|  1.49k|        if (g_used_system_time) {
  ------------------
  |  Branch (42:13): [True: 0, False: 1.49k]
  ------------------
   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|  1.49k|    }

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

_ZN9base_blobILj256EE4dataEv:
   99|      2|    constexpr unsigned char* data() { return m_data.data(); }
_ZN9base_blobILj256EE4sizeEv:
  107|      2|    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|  1.49k|{
   91|  1.49k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 1.49k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  1.49k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 1.49k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  1.49k|    }
   96|  1.49k|    return std::forward<T>(val);
   97|  1.49k|}
_Z22inline_assertion_checkILb1EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   90|  1.49k|{
   91|  1.49k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 1.49k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  1.49k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 1.49k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  1.49k|    }
   96|  1.49k|    return std::forward<T>(val);
   97|  1.49k|}
_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|}

_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|  1.49k|{
   55|  1.49k|    Assert(mock_time_in >= 0s);
  ------------------
  |  |  116|  1.49k|#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
  ------------------
   56|  1.49k|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   57|  1.49k|}
_ZN19MockableSteadyClock13ClearMockTimeEv:
   84|  1.49k|{
   85|  1.49k|    g_mock_steady_time.store(0ms, std::memory_order_relaxed);
   86|  1.49k|}

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