_ZNK10CCoinsView7GetCoinERK9COutPoint:
   16|  1.00M|std::optional<Coin> CCoinsView::GetCoin(const COutPoint& outpoint) const { return std::nullopt; }
_ZNK10CCoinsView12GetBestBlockEv:
   17|  19.3k|uint256 CCoinsView::GetBestBlock() const { return uint256(); }
_ZNK10CCoinsView13GetHeadBlocksEv:
   18|  17.3k|std::vector<uint256> CCoinsView::GetHeadBlocks() const { return std::vector<uint256>(); }
_ZN10CCoinsView10BatchWriteER20CoinsViewCacheCursorRK7uint256:
   19|  31.4k|bool CCoinsView::BatchWrite(CoinsViewCacheCursor& cursor, const uint256 &hashBlock) { return false; }
_ZNK10CCoinsView6CursorEv:
   20|  8.67k|std::unique_ptr<CCoinsViewCursor> CCoinsView::Cursor() const { return nullptr; }
_ZNK10CCoinsView8HaveCoinERK9COutPoint:
   23|  8.67k|{
   24|  8.67k|    return GetCoin(outpoint).has_value();
   25|  8.67k|}
_ZN16CCoinsViewBackedC2EP10CCoinsView:
   27|  8.67k|CCoinsViewBacked::CCoinsViewBacked(CCoinsView *viewIn) : base(viewIn) { }
_ZNK16CCoinsViewBacked13GetHeadBlocksEv:
   31|  8.67k|std::vector<uint256> CCoinsViewBacked::GetHeadBlocks() const { return base->GetHeadBlocks(); }
_ZN16CCoinsViewBacked10SetBackendER10CCoinsView:
   32|  9.30k|void CCoinsViewBacked::SetBackend(CCoinsView &viewIn) { base = &viewIn; }
_ZNK16CCoinsViewBacked12EstimateSizeEv:
   35|  8.67k|size_t CCoinsViewBacked::EstimateSize() const { return base->EstimateSize(); }
_ZN15CCoinsViewCacheC2EP10CCoinsViewb:
   38|  8.67k|    CCoinsViewBacked(baseIn), m_deterministic(deterministic),
   39|  8.67k|    cacheCoins(0, SaltedOutpointHasher(/*deterministic=*/deterministic), CCoinsMap::key_equal{}, &m_cache_coins_memory_resource)
   40|  8.67k|{
   41|  8.67k|    m_sentinel.second.SelfRef(m_sentinel);
   42|  8.67k|}
_ZNK15CCoinsViewCache18DynamicMemoryUsageEv:
   44|  8.67k|size_t CCoinsViewCache::DynamicMemoryUsage() const {
   45|  8.67k|    return memusage::DynamicUsage(cacheCoins) + cachedCoinsUsage;
   46|  8.67k|}
_ZNK15CCoinsViewCache9FetchCoinERK9COutPoint:
   48|  1.05M|CCoinsMap::iterator CCoinsViewCache::FetchCoin(const COutPoint &outpoint) const {
   49|  1.05M|    const auto [ret, inserted] = cacheCoins.try_emplace(outpoint);
   50|  1.05M|    if (inserted) {
  ------------------
  |  Branch (50:9): [True: 988k, False: 62.3k]
  ------------------
   51|   988k|        if (auto coin{base->GetCoin(outpoint)}) {
  ------------------
  |  Branch (51:18): [True: 0, False: 988k]
  ------------------
   52|      0|            ret->second.coin = std::move(*coin);
   53|      0|            cachedCoinsUsage += ret->second.coin.DynamicMemoryUsage();
   54|      0|            if (ret->second.coin.IsSpent()) { // TODO GetCoin cannot return spent coins
  ------------------
  |  Branch (54:17): [True: 0, False: 0]
  ------------------
   55|       |                // The parent only has an empty entry for this outpoint; we can consider our version as fresh.
   56|      0|                CCoinsCacheEntry::SetFresh(*ret, m_sentinel);
   57|      0|            }
   58|   988k|        } else {
   59|   988k|            cacheCoins.erase(ret);
   60|   988k|            return cacheCoins.end();
   61|   988k|        }
   62|   988k|    }
   63|  62.3k|    return ret;
   64|  1.05M|}
_ZNK15CCoinsViewCache7GetCoinERK9COutPoint:
   67|  8.67k|{
   68|  8.67k|    if (auto it{FetchCoin(outpoint)}; it != cacheCoins.end() && !it->second.coin.IsSpent()) return it->second.coin;
  ------------------
  |  Branch (68:39): [True: 5.00k, False: 3.66k]
  |  Branch (68:39): [True: 4.92k, False: 3.75k]
  |  Branch (68:65): [True: 4.92k, False: 85]
  ------------------
   69|  3.75k|    return std::nullopt;
   70|  8.67k|}
_ZN15CCoinsViewCache7AddCoinERK9COutPointO4Coinb:
   72|  1.24M|void CCoinsViewCache::AddCoin(const COutPoint &outpoint, Coin&& coin, bool possible_overwrite) {
   73|  1.24M|    assert(!coin.IsSpent());
   74|  1.24M|    if (coin.out.scriptPubKey.IsUnspendable()) return;
  ------------------
  |  Branch (74:9): [True: 695, False: 1.24M]
  ------------------
   75|  1.24M|    CCoinsMap::iterator it;
   76|  1.24M|    bool inserted;
   77|  1.24M|    std::tie(it, inserted) = cacheCoins.emplace(std::piecewise_construct, std::forward_as_tuple(outpoint), std::tuple<>());
   78|  1.24M|    bool fresh = false;
   79|  1.24M|    if (!inserted) {
  ------------------
  |  Branch (79:9): [True: 22.0k, False: 1.22M]
  ------------------
   80|  22.0k|        cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
   81|  22.0k|    }
   82|  1.24M|    if (!possible_overwrite) {
  ------------------
  |  Branch (82:9): [True: 1.23M, False: 12.1k]
  ------------------
   83|  1.23M|        if (!it->second.coin.IsSpent()) {
  ------------------
  |  Branch (83:13): [True: 15.0k, False: 1.21M]
  ------------------
   84|  15.0k|            throw std::logic_error("Attempted to overwrite an unspent coin (when possible_overwrite is false)");
   85|  15.0k|        }
   86|       |        // If the coin exists in this cache as a spent coin and is DIRTY, then
   87|       |        // its spentness hasn't been flushed to the parent cache. We're
   88|       |        // re-adding the coin to this cache now but we can't mark it as FRESH.
   89|       |        // If we mark it FRESH and then spend it before the cache is flushed
   90|       |        // we would remove it from this cache and would never flush spentness
   91|       |        // to the parent cache.
   92|       |        //
   93|       |        // Re-adding a spent coin can happen in the case of a re-org (the coin
   94|       |        // is 'spent' when the block adding it is disconnected and then
   95|       |        // re-added when it is also added in a newly connected block).
   96|       |        //
   97|       |        // If the coin doesn't exist in the current cache, or is spent but not
   98|       |        // DIRTY, then it can be marked FRESH.
   99|  1.21M|        fresh = !it->second.IsDirty();
  100|  1.21M|    }
  101|  1.22M|    it->second.coin = std::move(coin);
  102|  1.22M|    CCoinsCacheEntry::SetDirty(*it, m_sentinel);
  103|  1.22M|    if (fresh) CCoinsCacheEntry::SetFresh(*it, m_sentinel);
  ------------------
  |  Branch (103:9): [True: 1.21M, False: 12.6k]
  ------------------
  104|  1.22M|    cachedCoinsUsage += it->second.coin.DynamicMemoryUsage();
  105|  1.22M|    TRACEPOINT(utxocache, add,
  106|  1.22M|           outpoint.hash.data(),
  107|  1.22M|           (uint32_t)outpoint.n,
  108|  1.22M|           (uint32_t)it->second.coin.nHeight,
  109|  1.22M|           (int64_t)it->second.coin.out.nValue,
  110|  1.22M|           (bool)it->second.coin.IsCoinBase());
  111|  1.22M|}
_Z8AddCoinsR15CCoinsViewCacheRK12CTransactionib:
  119|    667|void AddCoins(CCoinsViewCache& cache, const CTransaction &tx, int nHeight, bool check_for_overwrite) {
  120|    667|    bool fCoinbase = tx.IsCoinBase();
  121|    667|    const Txid& txid = tx.GetHash();
  122|  1.21M|    for (size_t i = 0; i < tx.vout.size(); ++i) {
  ------------------
  |  Branch (122:24): [True: 1.21M, False: 667]
  ------------------
  123|  1.21M|        bool overwrite = check_for_overwrite ? cache.HaveCoin(COutPoint(txid, i)) : fCoinbase;
  ------------------
  |  Branch (123:26): [True: 968k, False: 246k]
  ------------------
  124|       |        // Coinbase transactions can always be overwritten, in order to correctly
  125|       |        // deal with the pre-BIP30 occurrences of duplicate coinbase transactions.
  126|  1.21M|        cache.AddCoin(COutPoint(txid, i), Coin(tx.vout[i], nHeight, fCoinbase), overwrite);
  127|  1.21M|    }
  128|    667|}
_ZN15CCoinsViewCache9SpendCoinERK9COutPointP4Coin:
  130|  12.8k|bool CCoinsViewCache::SpendCoin(const COutPoint &outpoint, Coin* moveout) {
  131|  12.8k|    CCoinsMap::iterator it = FetchCoin(outpoint);
  132|  12.8k|    if (it == cacheCoins.end()) return false;
  ------------------
  |  Branch (132:9): [True: 4.18k, False: 8.62k]
  ------------------
  133|  8.62k|    cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
  134|  8.62k|    TRACEPOINT(utxocache, spent,
  135|  8.62k|           outpoint.hash.data(),
  136|  8.62k|           (uint32_t)outpoint.n,
  137|  8.62k|           (uint32_t)it->second.coin.nHeight,
  138|  8.62k|           (int64_t)it->second.coin.out.nValue,
  139|  8.62k|           (bool)it->second.coin.IsCoinBase());
  140|  8.62k|    if (moveout) {
  ------------------
  |  Branch (140:9): [True: 4.01k, False: 4.61k]
  ------------------
  141|  4.01k|        *moveout = std::move(it->second.coin);
  142|  4.01k|    }
  143|  8.62k|    if (it->second.IsFresh()) {
  ------------------
  |  Branch (143:9): [True: 3.70k, False: 4.92k]
  ------------------
  144|  3.70k|        cacheCoins.erase(it);
  145|  4.92k|    } else {
  146|  4.92k|        CCoinsCacheEntry::SetDirty(*it, m_sentinel);
  147|  4.92k|        it->second.coin.Clear();
  148|  4.92k|    }
  149|  8.62k|    return true;
  150|  12.8k|}
_ZNK15CCoinsViewCache10AccessCoinERK9COutPoint:
  154|  34.9k|const Coin& CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
  155|  34.9k|    CCoinsMap::const_iterator it = FetchCoin(outpoint);
  156|  34.9k|    if (it == cacheCoins.end()) {
  ------------------
  |  Branch (156:9): [True: 4.50k, False: 30.4k]
  ------------------
  157|  4.50k|        return coinEmpty;
  158|  30.4k|    } else {
  159|  30.4k|        return it->second.coin;
  160|  30.4k|    }
  161|  34.9k|}
_ZNK15CCoinsViewCache8HaveCoinERK9COutPoint:
  163|   993k|bool CCoinsViewCache::HaveCoin(const COutPoint &outpoint) const {
  164|   993k|    CCoinsMap::const_iterator it = FetchCoin(outpoint);
  165|   993k|    return (it != cacheCoins.end() && !it->second.coin.IsSpent());
  ------------------
  |  Branch (165:13): [True: 18.2k, False: 975k]
  |  Branch (165:39): [True: 18.1k, False: 85]
  ------------------
  166|   993k|}
_ZNK15CCoinsViewCache15HaveCoinInCacheERK9COutPoint:
  168|  8.67k|bool CCoinsViewCache::HaveCoinInCache(const COutPoint &outpoint) const {
  169|  8.67k|    CCoinsMap::const_iterator it = cacheCoins.find(outpoint);
  170|  8.67k|    return (it != cacheCoins.end() && !it->second.coin.IsSpent());
  ------------------
  |  Branch (170:13): [True: 5.00k, False: 3.66k]
  |  Branch (170:39): [True: 4.92k, False: 85]
  ------------------
  171|  8.67k|}
_ZNK15CCoinsViewCache12GetBestBlockEv:
  173|  15.5k|uint256 CCoinsViewCache::GetBestBlock() const {
  174|  15.5k|    if (hashBlock.IsNull())
  ------------------
  |  Branch (174:9): [True: 10.6k, False: 4.90k]
  ------------------
  175|  10.6k|        hashBlock = base->GetBestBlock();
  176|  15.5k|    return hashBlock;
  177|  15.5k|}
_ZN15CCoinsViewCache12SetBestBlockERK7uint256:
  179|  6.72k|void CCoinsViewCache::SetBestBlock(const uint256 &hashBlockIn) {
  180|  6.72k|    hashBlock = hashBlockIn;
  181|  6.72k|}
_ZN15CCoinsViewCache10BatchWriteER20CoinsViewCacheCursorRK7uint256:
  183|  9.08k|bool CCoinsViewCache::BatchWrite(CoinsViewCacheCursor& cursor, const uint256 &hashBlockIn) {
  184|  14.5k|    for (auto it{cursor.Begin()}; it != cursor.End(); it = cursor.NextAndMaybeErase(*it)) {
  ------------------
  |  Branch (184:35): [True: 6.82k, False: 7.73k]
  ------------------
  185|       |        // Ignore non-dirty entries (optimization).
  186|  6.82k|        if (!it->second.IsDirty()) {
  ------------------
  |  Branch (186:13): [True: 665, False: 6.16k]
  ------------------
  187|    665|            continue;
  188|    665|        }
  189|  6.16k|        CCoinsMap::iterator itUs = cacheCoins.find(it->first);
  190|  6.16k|        if (itUs == cacheCoins.end()) {
  ------------------
  |  Branch (190:13): [True: 2.76k, False: 3.39k]
  ------------------
  191|       |            // The parent cache does not have an entry, while the child cache does.
  192|       |            // We can ignore it if it's both spent and FRESH in the child
  193|  2.76k|            if (!(it->second.IsFresh() && it->second.coin.IsSpent())) {
  ------------------
  |  Branch (193:19): [True: 2.60k, False: 161]
  |  Branch (193:43): [True: 745, False: 1.85k]
  ------------------
  194|       |                // Create the coin in the parent cache, move the data up
  195|       |                // and mark it as dirty.
  196|  2.02k|                itUs = cacheCoins.try_emplace(it->first).first;
  197|  2.02k|                CCoinsCacheEntry& entry{itUs->second};
  198|  2.02k|                if (cursor.WillErase(*it)) {
  ------------------
  |  Branch (198:21): [True: 2.02k, False: 0]
  ------------------
  199|       |                    // Since this entry will be erased,
  200|       |                    // we can move the coin into us instead of copying it
  201|  2.02k|                    entry.coin = std::move(it->second.coin);
  202|  2.02k|                } else {
  203|      0|                    entry.coin = it->second.coin;
  204|      0|                }
  205|  2.02k|                cachedCoinsUsage += entry.coin.DynamicMemoryUsage();
  206|  2.02k|                CCoinsCacheEntry::SetDirty(*itUs, m_sentinel);
  207|       |                // We can mark it FRESH in the parent if it was FRESH in the child
  208|       |                // Otherwise it might have just been flushed from the parent's cache
  209|       |                // and already exist in the grandparent
  210|  2.02k|                if (it->second.IsFresh()) CCoinsCacheEntry::SetFresh(*itUs, m_sentinel);
  ------------------
  |  Branch (210:21): [True: 1.85k, False: 161]
  ------------------
  211|  2.02k|            }
  212|  3.39k|        } else {
  213|       |            // Found the entry in the parent cache
  214|  3.39k|            if (it->second.IsFresh() && !itUs->second.coin.IsSpent()) {
  ------------------
  |  Branch (214:17): [True: 2.44k, False: 950]
  |  Branch (214:41): [True: 1.35k, False: 1.09k]
  ------------------
  215|       |                // The coin was marked FRESH in the child cache, but the coin
  216|       |                // exists in the parent cache. If this ever happens, it means
  217|       |                // the FRESH flag was misapplied and there is a logic error in
  218|       |                // the calling code.
  219|  1.35k|                throw std::logic_error("FRESH flag misapplied to coin that exists in parent cache");
  220|  1.35k|            }
  221|       |
  222|  2.04k|            if (itUs->second.IsFresh() && it->second.coin.IsSpent()) {
  ------------------
  |  Branch (222:17): [True: 431, False: 1.61k]
  |  Branch (222:43): [True: 47, False: 384]
  ------------------
  223|       |                // The grandparent cache does not have an entry, and the coin
  224|       |                // has been spent. We can just delete it from the parent cache.
  225|     47|                cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
  226|     47|                cacheCoins.erase(itUs);
  227|  1.99k|            } else {
  228|       |                // A normal modification.
  229|  1.99k|                cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
  230|  1.99k|                if (cursor.WillErase(*it)) {
  ------------------
  |  Branch (230:21): [True: 1.99k, False: 0]
  ------------------
  231|       |                    // Since this entry will be erased,
  232|       |                    // we can move the coin into us instead of copying it
  233|  1.99k|                    itUs->second.coin = std::move(it->second.coin);
  234|  1.99k|                } else {
  235|      0|                    itUs->second.coin = it->second.coin;
  236|      0|                }
  237|  1.99k|                cachedCoinsUsage += itUs->second.coin.DynamicMemoryUsage();
  238|  1.99k|                CCoinsCacheEntry::SetDirty(*itUs, m_sentinel);
  239|       |                // NOTE: It isn't safe to mark the coin as FRESH in the parent
  240|       |                // cache. If it already existed and was spent in the parent
  241|       |                // cache then marking it FRESH would prevent that spentness
  242|       |                // from being flushed to the grandparent.
  243|  1.99k|            }
  244|  2.04k|        }
  245|  6.16k|    }
  246|  7.73k|    hashBlock = hashBlockIn;
  247|  7.73k|    return true;
  248|  9.08k|}
_ZN15CCoinsViewCache5FlushEv:
  250|  5.14k|bool CCoinsViewCache::Flush() {
  251|  5.14k|    auto cursor{CoinsViewCacheCursor(cachedCoinsUsage, m_sentinel, cacheCoins, /*will_erase=*/true)};
  252|  5.14k|    bool fOk = base->BatchWrite(cursor, hashBlock);
  253|  5.14k|    if (fOk) {
  ------------------
  |  Branch (253:9): [True: 0, False: 5.14k]
  ------------------
  254|      0|        cacheCoins.clear();
  255|      0|        ReallocateCache();
  256|      0|    }
  257|  5.14k|    cachedCoinsUsage = 0;
  258|  5.14k|    return fOk;
  259|  5.14k|}
_ZN15CCoinsViewCache4SyncEv:
  262|  26.3k|{
  263|  26.3k|    auto cursor{CoinsViewCacheCursor(cachedCoinsUsage, m_sentinel, cacheCoins, /*will_erase=*/false)};
  264|  26.3k|    bool fOk = base->BatchWrite(cursor, hashBlock);
  265|  26.3k|    if (fOk) {
  ------------------
  |  Branch (265:9): [True: 0, False: 26.3k]
  ------------------
  266|      0|        if (m_sentinel.second.Next() != &m_sentinel) {
  ------------------
  |  Branch (266:13): [True: 0, False: 0]
  ------------------
  267|       |            /* BatchWrite must clear flags of all entries */
  268|      0|            throw std::logic_error("Not all unspent flagged entries were cleared");
  269|      0|        }
  270|      0|    }
  271|  26.3k|    return fOk;
  272|  26.3k|}
_ZN15CCoinsViewCache7UncacheERK9COutPoint:
  275|  5.59k|{
  276|  5.59k|    CCoinsMap::iterator it = cacheCoins.find(hash);
  277|  5.59k|    if (it != cacheCoins.end() && !it->second.IsDirty() && !it->second.IsFresh()) {
  ------------------
  |  Branch (277:9): [True: 3.57k, False: 2.01k]
  |  Branch (277:9): [True: 0, False: 5.59k]
  |  Branch (277:35): [True: 0, False: 3.57k]
  |  Branch (277:60): [True: 0, False: 0]
  ------------------
  278|      0|        cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
  279|      0|        TRACEPOINT(utxocache, uncache,
  280|      0|               hash.hash.data(),
  281|      0|               (uint32_t)hash.n,
  282|      0|               (uint32_t)it->second.coin.nHeight,
  283|      0|               (int64_t)it->second.coin.out.nValue,
  284|      0|               (bool)it->second.coin.IsCoinBase());
  285|      0|        cacheCoins.erase(it);
  286|      0|    }
  287|  5.59k|}
_ZNK15CCoinsViewCache12GetCacheSizeEv:
  289|  8.67k|unsigned int CCoinsViewCache::GetCacheSize() const {
  290|  8.67k|    return cacheCoins.size();
  291|  8.67k|}
_ZNK15CCoinsViewCache10HaveInputsERK12CTransaction:
  294|  9.06k|{
  295|  9.06k|    if (!tx.IsCoinBase()) {
  ------------------
  |  Branch (295:9): [True: 7.96k, False: 1.09k]
  ------------------
  296|  21.1k|        for (unsigned int i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (296:34): [True: 17.2k, False: 3.92k]
  ------------------
  297|  17.2k|            if (!HaveCoin(tx.vin[i].prevout)) {
  ------------------
  |  Branch (297:17): [True: 4.04k, False: 13.2k]
  ------------------
  298|  4.04k|                return false;
  299|  4.04k|            }
  300|  17.2k|        }
  301|  7.96k|    }
  302|  5.02k|    return true;
  303|  9.06k|}

_ZN4CoinC2ERK6CTxOutib:
   46|  2.42M|    Coin(const CTxOut& outIn, int nHeightIn, bool fCoinBaseIn) : out(outIn), fCoinBase(fCoinBaseIn),nHeight(nHeightIn) {}
_ZN4Coin5ClearEv:
   48|  4.92k|    void Clear() {
   49|  4.92k|        out.SetNull();
   50|  4.92k|        fCoinBase = false;
   51|  4.92k|        nHeight = 0;
   52|  4.92k|    }
_ZN4CoinC2Ev:
   55|  2.40M|    Coin() : fCoinBase(false), nHeight(0) { }
_ZNK4Coin10IsCoinBaseEv:
   57|    390|    bool IsCoinBase() const {
   58|    390|        return fCoinBase;
   59|    390|    }
_ZNK4Coin7IsSpentEv:
   81|  3.81M|    bool IsSpent() const {
   82|  3.81M|        return out.IsNull();
   83|  3.81M|    }
_ZNK4Coin18DynamicMemoryUsageEv:
   85|  1.38M|    size_t DynamicMemoryUsage() const {
   86|  1.38M|        return memusage::DynamicUsage(out.scriptPubKey);
   87|  1.38M|    }
_ZN16CCoinsCacheEntry8AddFlagsEhRNSt3__14pairIK9COutPointS_EES5_:
  133|  2.68M|    {
  134|  2.68M|        Assume(flags & (DIRTY | FRESH));
  ------------------
  |  |   97|  2.68M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  135|  2.68M|        if (!pair.second.m_flags) {
  ------------------
  |  Branch (135:13): [True: 1.23M, False: 1.45M]
  ------------------
  136|  1.23M|            Assume(!pair.second.m_prev && !pair.second.m_next);
  ------------------
  |  |   97|  2.46M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  |  |  ------------------
  |  |  |  Branch (97:51): [True: 1.23M, False: 0]
  |  |  |  Branch (97:51): [True: 1.23M, False: 0]
  |  |  ------------------
  ------------------
  137|  1.23M|            pair.second.m_prev = sentinel.second.m_prev;
  138|  1.23M|            pair.second.m_next = &sentinel;
  139|  1.23M|            sentinel.second.m_prev = &pair;
  140|  1.23M|            pair.second.m_prev->second.m_next = &pair;
  141|  1.23M|        }
  142|  2.68M|        Assume(pair.second.m_prev && pair.second.m_next);
  ------------------
  |  |   97|  5.36M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  |  |  ------------------
  |  |  |  Branch (97:51): [True: 2.68M, False: 0]
  |  |  |  Branch (97:51): [True: 2.68M, False: 0]
  |  |  ------------------
  ------------------
  143|  2.68M|        pair.second.m_flags |= flags;
  144|  2.68M|    }
_ZN16CCoinsCacheEntryD2Ev:
  173|  2.37M|    {
  174|  2.37M|        SetClean();
  175|  2.37M|    }
_ZN16CCoinsCacheEntry8SetDirtyERNSt3__14pairIK9COutPointS_EES5_:
  177|  1.35M|    static void SetDirty(CoinsCachePair& pair, CoinsCachePair& sentinel) noexcept { AddFlags(DIRTY, pair, sentinel); }
_ZN16CCoinsCacheEntry8SetFreshERNSt3__14pairIK9COutPointS_EES5_:
  178|  1.33M|    static void SetFresh(CoinsCachePair& pair, CoinsCachePair& sentinel) noexcept { AddFlags(FRESH, pair, sentinel); }
_ZN16CCoinsCacheEntry8SetCleanEv:
  181|  2.37M|    {
  182|  2.37M|        if (!m_flags) return;
  ------------------
  |  Branch (182:13): [True: 1.12M, False: 1.24M]
  ------------------
  183|  1.24M|        m_next->second.m_prev = m_prev;
  184|  1.24M|        m_prev->second.m_next = m_next;
  185|  1.24M|        m_flags = 0;
  186|  1.24M|        m_prev = m_next = nullptr;
  187|  1.24M|    }
_ZNK16CCoinsCacheEntry7IsDirtyEv:
  188|  1.22M|    bool IsDirty() const noexcept { return m_flags & DIRTY; }
_ZNK16CCoinsCacheEntry7IsFreshEv:
  189|  18.8k|    bool IsFresh() const noexcept { return m_flags & FRESH; }
_ZNK16CCoinsCacheEntry4NextEv:
  193|  14.5k|    {
  194|  14.5k|        Assume(m_flags);
  ------------------
  |  |   97|  14.5k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  195|  14.5k|        return m_next;
  196|  14.5k|    }
_ZN16CCoinsCacheEntry7SelfRefERNSt3__14pairIK9COutPointS_EE:
  207|  17.8k|    {
  208|  17.8k|        Assume(&pair.second == this);
  ------------------
  |  |   97|  17.8k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  209|  17.8k|        m_prev = &pair;
  210|  17.8k|        m_next = &pair;
  211|       |        // Set sentinel to DIRTY so we can call Next on it
  212|  17.8k|        m_flags = DIRTY;
  213|  17.8k|    }
_ZN20CoinsViewCacheCursorC2ERmRNSt3__14pairIK9COutPoint16CCoinsCacheEntryEERNS1_13unordered_mapIS3_S5_20SaltedOutpointHasherNS1_8equal_toIS3_EE13PoolAllocatorIS6_Lm144ELm8EEEEb:
  278|  40.5k|        : m_usage(usage), m_sentinel(sentinel), m_map(map), m_will_erase(will_erase) {}
_ZNK20CoinsViewCacheCursor5BeginEv:
  280|  9.08k|    inline CoinsCachePair* Begin() const noexcept { return m_sentinel.second.Next(); }
_ZNK20CoinsViewCacheCursor3EndEv:
  281|  14.5k|    inline CoinsCachePair* End() const noexcept { return &m_sentinel; }
_ZN20CoinsViewCacheCursor17NextAndMaybeEraseERNSt3__14pairIK9COutPoint16CCoinsCacheEntryEE:
  285|  5.47k|    {
  286|  5.47k|        const auto next_entry{current.second.Next()};
  287|       |        // If we are not going to erase the cache, we must still erase spent entries.
  288|       |        // Otherwise, clear the state of the entry.
  289|  5.47k|        if (!m_will_erase) {
  ------------------
  |  Branch (289:13): [True: 0, False: 5.47k]
  ------------------
  290|      0|            if (current.second.coin.IsSpent()) {
  ------------------
  |  Branch (290:17): [True: 0, False: 0]
  ------------------
  291|      0|                m_usage -= current.second.coin.DynamicMemoryUsage();
  292|      0|                m_map.erase(current.first);
  293|      0|            } else {
  294|      0|                current.second.SetClean();
  295|      0|            }
  296|      0|        }
  297|  5.47k|        return next_entry;
  298|  5.47k|    }
_ZNK20CoinsViewCacheCursor9WillEraseERNSt3__14pairIK9COutPoint16CCoinsCacheEntryEE:
  300|  4.01k|    inline bool WillErase(CoinsCachePair& current) const noexcept { return m_will_erase || current.second.coin.IsSpent(); }
  ------------------
  |  Branch (300:76): [True: 4.01k, False: 0]
  |  Branch (300:92): [True: 0, False: 0]
  ------------------
_ZNK10CCoinsView12EstimateSizeEv:
  338|  17.3k|    virtual size_t EstimateSize() const { return 0; }
_ZNK15CCoinsViewCache6CursorEv:
  395|  8.67k|    std::unique_ptr<CCoinsViewCursor> Cursor() const override {
  396|  8.67k|        throw std::logic_error("CCoinsViewCache cursor iteration not supported.");
  397|  8.67k|    }
_ZN10CCoinsViewD2Ev:
  335|  17.7k|    virtual ~CCoinsView() = default;
_ZN4Coin11UnserializeI10DataStreamEEvRT_:
   70|  15.6k|    void Unserialize(Stream &s) {
   71|  15.6k|        uint32_t code = 0;
   72|  15.6k|        ::Unserialize(s, VARINT(code));
  ------------------
  |  |  500|  15.6k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
   73|  15.6k|        nHeight = code >> 1;
   74|  15.6k|        fCoinBase = code & 1;
   75|  15.6k|        ::Unserialize(s, Using<TxOutCompression>(out));
   76|  15.6k|    }
_ZN16CCoinsCacheEntryC2Ev:
  170|  2.36M|    CCoinsCacheEntry() noexcept = default;

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

_ZN11ArgsManager9ClearArgsEv:
  362|      2|    void ClearArgs() {
  363|      2|        LOCK(cs_args);
  ------------------
  |  |  257|      2|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  364|      2|        m_available_args.clear();
  365|      2|        m_network_only_args.clear();
  366|      2|    }

_Z17internal_bswap_32j:
   54|   319k|{
   55|   319k|#ifdef bitcoin_builtin_bswap32
   56|   319k|    return bitcoin_builtin_bswap32(x);
  ------------------
  |  |   24|   319k|#      define bitcoin_builtin_bswap32(x) __builtin_bswap32(x)
  ------------------
   57|       |#else
   58|       |    return (((x & 0xff000000U) >> 24) | ((x & 0x00ff0000U) >>  8) |
   59|       |            ((x & 0x0000ff00U) <<  8) | ((x & 0x000000ffU) << 24));
   60|       |#endif
   61|   319k|}
_Z17internal_bswap_64m:
   64|  35.8k|{
   65|  35.8k|#ifdef bitcoin_builtin_bswap64
   66|  35.8k|    return bitcoin_builtin_bswap64(x);
  ------------------
  |  |   27|  35.8k|#      define bitcoin_builtin_bswap64(x) __builtin_bswap64(x)
  ------------------
   67|       |#else
   68|       |     return (((x & 0xff00000000000000ull) >> 56)
   69|       |          | ((x & 0x00ff000000000000ull) >> 40)
   70|       |          | ((x & 0x0000ff0000000000ull) >> 24)
   71|       |          | ((x & 0x000000ff00000000ull) >> 8)
   72|       |          | ((x & 0x00000000ff000000ull) << 8)
   73|       |          | ((x & 0x0000000000ff0000ull) << 24)
   74|       |          | ((x & 0x000000000000ff00ull) << 40)
   75|       |          | ((x & 0x00000000000000ffull) << 56));
   76|       |#endif
   77|  35.8k|}

_Z16htole16_internalt:
   19|  2.07k|{
   20|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(host_16bits);
   21|  2.07k|        else return host_16bits;
   22|  2.07k|}
_Z16le16toh_internalt:
   29|  7.38k|{
   30|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits);
   31|  7.38k|        else return little_endian_16bits;
   32|  7.38k|}
_Z16htobe32_internalj:
   34|   280k|{
   35|   280k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(host_32bits);
   36|       |        else return host_32bits;
   37|   280k|}
_Z16htole32_internalj:
   39|   284k|{
   40|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits);
   41|   284k|        else return host_32bits;
   42|   284k|}
_Z16be32toh_internalj:
   44|  38.6k|{
   45|  38.6k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(big_endian_32bits);
   46|       |        else return big_endian_32bits;
   47|  38.6k|}
_Z16le32toh_internalj:
   49|   287k|{
   50|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits);
   51|   287k|        else return little_endian_32bits;
   52|   287k|}
_Z16htobe64_internalm:
   54|  35.8k|{
   55|  35.8k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(host_64bits);
   56|       |        else return host_64bits;
   57|  35.8k|}
_Z16htole64_internalm:
   59|  5.00M|{
   60|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(host_64bits);
   61|  5.00M|        else return host_64bits;
   62|  5.00M|}
_Z16le64toh_internalm:
   69|  16.8M|{
   70|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits);
   71|  16.8M|        else return little_endian_64bits;
   72|  16.8M|}

_Z20GetSpecialScriptSizej:
   87|  9.60k|{
   88|  9.60k|    if (nSize == 0 || nSize == 1)
  ------------------
  |  Branch (88:9): [True: 822, False: 8.78k]
  |  Branch (88:23): [True: 3.42k, False: 5.36k]
  ------------------
   89|  4.24k|        return 20;
   90|  5.36k|    if (nSize == 2 || nSize == 3 || nSize == 4 || nSize == 5)
  ------------------
  |  Branch (90:9): [True: 376, False: 4.98k]
  |  Branch (90:23): [True: 294, False: 4.69k]
  |  Branch (90:37): [True: 683, False: 4.00k]
  |  Branch (90:51): [True: 4.00k, False: 0]
  ------------------
   91|  5.36k|        return 32;
   92|      0|    return 0;
   93|  5.36k|}
_Z16DecompressScriptR7CScriptjRK9prevectorILj33EhjiE:
   96|  9.53k|{
   97|  9.53k|    switch(nSize) {
  ------------------
  |  Branch (97:12): [True: 0, False: 9.53k]
  ------------------
   98|    790|    case 0x00:
  ------------------
  |  Branch (98:5): [True: 790, False: 8.74k]
  ------------------
   99|    790|        script.resize(25);
  100|    790|        script[0] = OP_DUP;
  101|    790|        script[1] = OP_HASH160;
  102|    790|        script[2] = 20;
  103|    790|        memcpy(&script[3], in.data(), 20);
  104|    790|        script[23] = OP_EQUALVERIFY;
  105|    790|        script[24] = OP_CHECKSIG;
  106|    790|        return true;
  107|  3.40k|    case 0x01:
  ------------------
  |  Branch (107:5): [True: 3.40k, False: 6.13k]
  ------------------
  108|  3.40k|        script.resize(23);
  109|  3.40k|        script[0] = OP_HASH160;
  110|  3.40k|        script[1] = 20;
  111|  3.40k|        memcpy(&script[2], in.data(), 20);
  112|  3.40k|        script[22] = OP_EQUAL;
  113|  3.40k|        return true;
  114|    371|    case 0x02:
  ------------------
  |  Branch (114:5): [True: 371, False: 9.16k]
  ------------------
  115|    661|    case 0x03:
  ------------------
  |  Branch (115:5): [True: 290, False: 9.24k]
  ------------------
  116|    661|        script.resize(35);
  117|    661|        script[0] = 33;
  118|    661|        script[1] = nSize;
  119|    661|        memcpy(&script[2], in.data(), 32);
  120|    661|        script[34] = OP_CHECKSIG;
  121|    661|        return true;
  122|    676|    case 0x04:
  ------------------
  |  Branch (122:5): [True: 676, False: 8.86k]
  ------------------
  123|  4.67k|    case 0x05:
  ------------------
  |  Branch (123:5): [True: 4.00k, False: 5.53k]
  ------------------
  124|  4.67k|        unsigned char vch[33] = {};
  125|  4.67k|        vch[0] = nSize - 2;
  126|  4.67k|        memcpy(&vch[1], in.data(), 32);
  127|  4.67k|        CPubKey pubkey{vch};
  128|  4.67k|        if (!pubkey.Decompress())
  ------------------
  |  Branch (128:13): [True: 1.46k, False: 3.21k]
  ------------------
  129|  1.46k|            return false;
  130|  3.21k|        assert(pubkey.size() == 65);
  131|  3.21k|        script.resize(67);
  132|  3.21k|        script[0] = 65;
  133|  3.21k|        memcpy(&script[1], pubkey.begin(), 65);
  134|  3.21k|        script[66] = OP_CHECKSIG;
  135|  3.21k|        return true;
  136|  9.53k|    }
  137|      0|    return false;
  138|  9.53k|}
_Z16DecompressAmountm:
  169|  15.2k|{
  170|       |    // x = 0  OR  x = 1+10*(9*n + d - 1) + e  OR  x = 1+10*(n - 1) + 9
  171|  15.2k|    if (x == 0)
  ------------------
  |  Branch (171:9): [True: 3.72k, False: 11.5k]
  ------------------
  172|  3.72k|        return 0;
  173|  11.5k|    x--;
  174|       |    // x = 10*(9*n + d - 1) + e
  175|  11.5k|    int e = x % 10;
  176|  11.5k|    x /= 10;
  177|  11.5k|    uint64_t n = 0;
  178|  11.5k|    if (e < 9) {
  ------------------
  |  Branch (178:9): [True: 10.5k, False: 1.05k]
  ------------------
  179|       |        // x = 9*n + d - 1
  180|  10.5k|        int d = (x % 9) + 1;
  181|  10.5k|        x /= 9;
  182|       |        // x = n
  183|  10.5k|        n = x*10 + d;
  184|  10.5k|    } else {
  185|  1.05k|        n = x+1;
  186|  1.05k|    }
  187|  57.6k|    while (e) {
  ------------------
  |  Branch (187:12): [True: 46.1k, False: 11.5k]
  ------------------
  188|  46.1k|        n *= 10;
  189|  46.1k|        e--;
  190|  46.1k|    }
  191|  11.5k|    return n;
  192|  15.2k|}

_ZN16TxOutCompression16SerializationOpsI10DataStream6CTxOut17ActionUnserializeEEvRT0_RT_T1_:
  115|  15.4k|    FORMATTER_METHODS(CTxOut, obj) { READWRITE(Using<AmountCompression>(obj.nValue), Using<ScriptCompression>(obj.scriptPubKey)); }
  ------------------
  |  |  156|  15.4k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN17AmountCompression5UnserI10DataStreamlEEvRT_RT0_:
  105|  15.4k|    {
  106|  15.4k|        uint64_t v;
  107|  15.4k|        s >> VARINT(v);
  ------------------
  |  |  500|  15.4k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
  108|  15.4k|        val = DecompressAmount(v);
  109|  15.4k|    }
_ZN17ScriptCompression5UnserI10DataStreamEEvRT_R7CScript:
   77|  15.2k|    void Unser(Stream &s, CScript& script) {
   78|  15.2k|        unsigned int nSize = 0;
   79|  15.2k|        s >> VARINT(nSize);
  ------------------
  |  |  500|  15.2k|#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
  ------------------
   80|  15.2k|        if (nSize < nSpecialScripts) {
  ------------------
  |  Branch (80:13): [True: 9.60k, False: 5.68k]
  ------------------
   81|  9.60k|            CompressedScript vch(GetSpecialScriptSize(nSize), 0x00);
   82|  9.60k|            s >> Span{vch};
   83|  9.60k|            DecompressScript(script, nSize, vch);
   84|  9.60k|            return;
   85|  9.60k|        }
   86|  5.68k|        nSize -= nSpecialScripts;
   87|  5.68k|        if (nSize > MAX_SCRIPT_SIZE) {
  ------------------
  |  Branch (87:13): [True: 213, False: 5.47k]
  ------------------
   88|       |            // Overly long script, replace with a short invalid one
   89|    213|            script << OP_RETURN;
   90|    213|            s.ignore(nSize);
   91|  5.47k|        } else {
   92|  5.47k|            script.resize(nSize);
   93|  5.47k|            s >> Span{script};
   94|  5.47k|        }
   95|  5.68k|    }

_Z10MoneyRangeRKl:
   27|  4.75k|inline bool MoneyRange(const CAmount& nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  ------------------
  |  Branch (27:57): [True: 4.70k, False: 47]
  |  Branch (27:72): [True: 4.69k, False: 14]
  ------------------

_Z16CheckTransactionRK12CTransactionR17TxValidationState:
   12|    586|{
   13|       |    // Basic checks that don't depend on any context
   14|    586|    if (tx.vin.empty())
  ------------------
  |  Branch (14:9): [True: 17, False: 569]
  ------------------
   15|     17|        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vin-empty");
   16|    569|    if (tx.vout.empty())
  ------------------
  |  Branch (16:9): [True: 13, False: 556]
  ------------------
   17|     13|        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vout-empty");
   18|       |    // Size limits (this doesn't take the witness into account, as that hasn't been checked for malleability)
   19|    556|    if (::GetSerializeSize(TX_NO_WITNESS(tx)) * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT) {
  ------------------
  |  Branch (19:9): [True: 2, False: 554]
  ------------------
   20|      2|        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-oversize");
   21|      2|    }
   22|       |
   23|       |    // Check for negative or overflow output values (see CVE-2010-5139)
   24|    554|    CAmount nValueOut = 0;
   25|    554|    for (const auto& txout : tx.vout)
  ------------------
  |  Branch (25:28): [True: 1.73k, False: 421]
  ------------------
   26|  1.73k|    {
   27|  1.73k|        if (txout.nValue < 0)
  ------------------
  |  Branch (27:13): [True: 50, False: 1.68k]
  ------------------
   28|     50|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vout-negative");
   29|  1.68k|        if (txout.nValue > MAX_MONEY)
  ------------------
  |  Branch (29:13): [True: 80, False: 1.60k]
  ------------------
   30|     80|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-vout-toolarge");
   31|  1.60k|        nValueOut += txout.nValue;
   32|  1.60k|        if (!MoneyRange(nValueOut))
  ------------------
  |  Branch (32:13): [True: 3, False: 1.60k]
  ------------------
   33|      3|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-txouttotal-toolarge");
   34|  1.60k|    }
   35|       |
   36|       |    // Check for duplicate inputs (see CVE-2018-17144)
   37|       |    // While Consensus::CheckTxInputs does check if all inputs of a tx are available, and UpdateCoins marks all inputs
   38|       |    // of a tx as spent, it does not check if the tx has duplicate inputs.
   39|       |    // Failure to run this check will result in either a crash or an inflation bug, depending on the implementation of
   40|       |    // the underlying coins database.
   41|    421|    std::set<COutPoint> vInOutPoints;
   42|    433|    for (const auto& txin : tx.vin) {
  ------------------
  |  Branch (42:27): [True: 433, False: 412]
  ------------------
   43|    433|        if (!vInOutPoints.insert(txin.prevout).second)
  ------------------
  |  Branch (43:13): [True: 9, False: 424]
  ------------------
   44|      9|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-inputs-duplicate");
   45|    433|    }
   46|       |
   47|    412|    if (tx.IsCoinBase())
  ------------------
  |  Branch (47:9): [True: 408, False: 4]
  ------------------
   48|    408|    {
   49|    408|        if (tx.vin[0].scriptSig.size() < 2 || tx.vin[0].scriptSig.size() > 100)
  ------------------
  |  Branch (49:13): [True: 13, False: 395]
  |  Branch (49:47): [True: 9, False: 386]
  ------------------
   50|     22|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cb-length");
   51|    408|    }
   52|      4|    else
   53|      4|    {
   54|      4|        for (const auto& txin : tx.vin)
  ------------------
  |  Branch (54:31): [True: 4, False: 4]
  ------------------
   55|      4|            if (txin.prevout.IsNull())
  ------------------
  |  Branch (55:17): [True: 0, False: 4]
  ------------------
   56|      0|                return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-prevout-null");
   57|      4|    }
   58|       |
   59|    390|    return true;
   60|    412|}

_Z19GetLegacySigOpCountRK12CTransaction:
  113|    500|{
  114|    500|    unsigned int nSigOps = 0;
  115|    500|    for (const auto& txin : tx.vin)
  ------------------
  |  Branch (115:27): [True: 5.76k, False: 500]
  ------------------
  116|  5.76k|    {
  117|  5.76k|        nSigOps += txin.scriptSig.GetSigOpCount(false);
  118|  5.76k|    }
  119|    500|    for (const auto& txout : tx.vout)
  ------------------
  |  Branch (119:28): [True: 3.14k, False: 500]
  ------------------
  120|  3.14k|    {
  121|  3.14k|        nSigOps += txout.scriptPubKey.GetSigOpCount(false);
  122|  3.14k|    }
  123|    500|    return nSigOps;
  124|    500|}
_Z17GetP2SHSigOpCountRK12CTransactionRK15CCoinsViewCache:
  127|    421|{
  128|    421|    if (tx.IsCoinBase())
  ------------------
  |  Branch (128:9): [True: 2, False: 419]
  ------------------
  129|      2|        return 0;
  130|       |
  131|    419|    unsigned int nSigOps = 0;
  132|  6.11k|    for (unsigned int i = 0; i < tx.vin.size(); i++)
  ------------------
  |  Branch (132:30): [True: 5.69k, False: 419]
  ------------------
  133|  5.69k|    {
  134|  5.69k|        const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
  135|  5.69k|        assert(!coin.IsSpent());
  136|  5.69k|        const CTxOut &prevout = coin.out;
  137|  5.69k|        if (prevout.scriptPubKey.IsPayToScriptHash())
  ------------------
  |  Branch (137:13): [True: 2.61k, False: 3.08k]
  ------------------
  138|  2.61k|            nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
  139|  5.69k|    }
  140|    419|    return nSigOps;
  141|    419|}
_Z23GetTransactionSigOpCostRK12CTransactionRK15CCoinsViewCachej:
  144|    500|{
  145|    500|    int64_t nSigOps = GetLegacySigOpCount(tx) * WITNESS_SCALE_FACTOR;
  146|       |
  147|    500|    if (tx.IsCoinBase())
  ------------------
  |  Branch (147:9): [True: 128, False: 372]
  ------------------
  148|    128|        return nSigOps;
  149|       |
  150|    372|    if (flags & SCRIPT_VERIFY_P2SH) {
  ------------------
  |  Branch (150:9): [True: 360, False: 12]
  ------------------
  151|    360|        nSigOps += GetP2SHSigOpCount(tx, inputs) * WITNESS_SCALE_FACTOR;
  152|    360|    }
  153|       |
  154|  6.00k|    for (unsigned int i = 0; i < tx.vin.size(); i++)
  ------------------
  |  Branch (154:30): [True: 5.63k, False: 372]
  ------------------
  155|  5.63k|    {
  156|  5.63k|        const Coin& coin = inputs.AccessCoin(tx.vin[i].prevout);
  157|  5.63k|        assert(!coin.IsSpent());
  158|  5.63k|        const CTxOut &prevout = coin.out;
  159|  5.63k|        nSigOps += CountWitnessSigOps(tx.vin[i].scriptSig, prevout.scriptPubKey, &tx.vin[i].scriptWitness, flags);
  160|  5.63k|    }
  161|    372|    return nSigOps;
  162|    372|}
_ZN9Consensus13CheckTxInputsERK12CTransactionR17TxValidationStateRK15CCoinsViewCacheiRl:
  165|    390|{
  166|       |    // are the actual inputs available?
  167|    390|    if (!inputs.HaveInputs(tx)) {
  ------------------
  |  Branch (167:9): [True: 0, False: 390]
  ------------------
  168|      0|        return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-txns-inputs-missingorspent",
  169|      0|                         strprintf("%s: inputs missing/spent", __func__));
  ------------------
  |  | 1172|      0|#define strprintf tfm::format
  ------------------
  170|      0|    }
  171|       |
  172|    390|    CAmount nValueIn = 0;
  173|    666|    for (unsigned int i = 0; i < tx.vin.size(); ++i) {
  ------------------
  |  Branch (173:30): [True: 390, False: 276]
  ------------------
  174|    390|        const COutPoint &prevout = tx.vin[i].prevout;
  175|    390|        const Coin& coin = inputs.AccessCoin(prevout);
  176|    390|        assert(!coin.IsSpent());
  177|       |
  178|       |        // If prev is coinbase, check that it's matured
  179|    390|        if (coin.IsCoinBase() && nSpendHeight - coin.nHeight < COINBASE_MATURITY) {
  ------------------
  |  Branch (179:13): [True: 260, False: 130]
  |  Branch (179:34): [True: 56, False: 204]
  ------------------
  180|     56|            return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "bad-txns-premature-spend-of-coinbase",
  181|     56|                strprintf("tried to spend coinbase at depth %d", nSpendHeight - coin.nHeight));
  ------------------
  |  | 1172|     56|#define strprintf tfm::format
  ------------------
  182|     56|        }
  183|       |
  184|       |        // Check for negative or overflow input values
  185|    334|        nValueIn += coin.out.nValue;
  186|    334|        if (!MoneyRange(coin.out.nValue) || !MoneyRange(nValueIn)) {
  ------------------
  |  Branch (186:13): [True: 58, False: 276]
  |  Branch (186:45): [True: 0, False: 276]
  ------------------
  187|     58|            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-inputvalues-outofrange");
  188|     58|        }
  189|    334|    }
  190|       |
  191|    276|    const CAmount value_out = tx.GetValueOut();
  192|    276|    if (nValueIn < value_out) {
  ------------------
  |  Branch (192:9): [True: 154, False: 122]
  ------------------
  193|    154|        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-in-belowout",
  194|    154|            strprintf("value in (%s) < value out (%s)", FormatMoney(nValueIn), FormatMoney(value_out)));
  ------------------
  |  | 1172|    154|#define strprintf tfm::format
  ------------------
  195|    154|    }
  196|       |
  197|       |    // Tally transaction fees
  198|    122|    const CAmount txfee_aux = nValueIn - value_out;
  199|    122|    if (!MoneyRange(txfee_aux)) {
  ------------------
  |  Branch (199:9): [True: 0, False: 122]
  ------------------
  200|      0|        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-fee-outofrange");
  201|      0|    }
  202|       |
  203|    122|    txfee = txfee_aux;
  204|    122|    return true;
  205|    122|}

_ZN15ValidationStateI18TxValidationResultE7InvalidES0_RKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_:
   92|    464|    {
   93|    464|        m_result = result;
   94|    464|        m_reject_reason = reject_reason;
   95|    464|        m_debug_message = debug_message;
   96|    464|        if (m_mode != ModeState::M_ERROR) m_mode = ModeState::M_INVALID;
  ------------------
  |  Branch (96:13): [True: 464, False: 0]
  ------------------
   97|    464|        return false;
   98|    464|    }

_ZN15ChaCha20AlignedD2Ev:
   43|      2|{
   44|      2|    memory_cleanse(input, sizeof(input));
   45|      2|}
_ZN8ChaCha20D2Ev:
  333|      2|{
  334|      2|    memory_cleanse(m_buffer.data(), m_buffer.size());
  335|      2|}

_Z8ReadLE64ITk8ByteTypehEmPKT_:
   36|  14.7M|{
   37|  14.7M|    uint64_t x;
   38|  14.7M|    memcpy(&x, ptr, 8);
   39|  14.7M|    return le64toh_internal(x);
   40|  14.7M|}
_Z9WriteLE16ITk8ByteTypehEvPT_t:
   44|    125|{
   45|    125|    uint16_t v = htole16_internal(x);
   46|    125|    memcpy(ptr, &v, 2);
   47|    125|}
_Z9WriteLE32ITk8ByteTypehEvPT_j:
   51|  10.5k|{
   52|  10.5k|    uint32_t v = htole32_internal(x);
   53|  10.5k|    memcpy(ptr, &v, 4);
   54|  10.5k|}
_Z8ReadLE16ITk8ByteTypehEtPKT_:
   20|  6.05k|{
   21|  6.05k|    uint16_t x;
   22|  6.05k|    memcpy(&x, ptr, 2);
   23|  6.05k|    return le16toh_internal(x);
   24|  6.05k|}
_Z8ReadLE32ITk8ByteTypehEjPKT_:
   28|  40.0k|{
   29|  40.0k|    uint32_t x;
   30|  40.0k|    memcpy(&x, ptr, 4);
   31|  40.0k|    return le32toh_internal(x);
   32|  40.0k|}
_Z9WriteLE64ITk8ByteTypehEvPT_m:
   58|  2.10k|{
   59|  2.10k|    uint64_t v = htole64_internal(x);
   60|  2.10k|    memcpy(ptr, &v, 8);
   61|  2.10k|}
_Z9WriteBE32ITk8ByteTypehEvPT_j:
   96|   280k|{
   97|   280k|    uint32_t v = htobe32_internal(x);
   98|   280k|    memcpy(ptr, &v, 4);
   99|   280k|}
_Z8ReadBE32ITk8ByteTypehEjPKT_:
   73|  38.6k|{
   74|  38.6k|    uint32_t x;
   75|  38.6k|    memcpy(&x, ptr, 4);
   76|  38.6k|    return be32toh_internal(x);
   77|  38.6k|}
_Z9WriteBE64ITk8ByteTypehEvPT_m:
  103|  35.8k|{
  104|  35.8k|    uint64_t v = htobe64_internal(x);
  105|  35.8k|    memcpy(ptr, &v, 8);
  106|  35.8k|}

_ZN10CRIPEMD160C2Ev:
  243|  2.10k|{
  244|  2.10k|    ripemd160::Initialize(s);
  245|  2.10k|}
_ZN10CRIPEMD1605WriteEPKhm:
  248|  6.32k|{
  249|  6.32k|    const unsigned char* end = data + len;
  250|  6.32k|    size_t bufsize = bytes % 64;
  251|  6.32k|    if (bufsize && bufsize + len >= 64) {
  ------------------
  |  Branch (251:9): [True: 4.12k, False: 2.19k]
  |  Branch (251:20): [True: 2.12k, False: 2.00k]
  ------------------
  252|       |        // Fill the buffer, and process it.
  253|  2.12k|        memcpy(buf + bufsize, data, 64 - bufsize);
  254|  2.12k|        bytes += 64 - bufsize;
  255|  2.12k|        data += 64 - bufsize;
  256|  2.12k|        ripemd160::Transform(s, buf);
  257|  2.12k|        bufsize = 0;
  258|  2.12k|    }
  259|  6.55k|    while (end - data >= 64) {
  ------------------
  |  Branch (259:12): [True: 228, False: 6.32k]
  ------------------
  260|       |        // Process full chunks directly from the source.
  261|    228|        ripemd160::Transform(s, data);
  262|    228|        bytes += 64;
  263|    228|        data += 64;
  264|    228|    }
  265|  6.32k|    if (end > data) {
  ------------------
  |  Branch (265:9): [True: 4.12k, False: 2.19k]
  ------------------
  266|       |        // Fill the buffer with what remains.
  267|  4.12k|        memcpy(buf + bufsize, data, end - data);
  268|  4.12k|        bytes += end - data;
  269|  4.12k|    }
  270|  6.32k|    return *this;
  271|  6.32k|}
_ZN10CRIPEMD1608FinalizeEPh:
  274|  2.10k|{
  275|  2.10k|    static const unsigned char pad[64] = {0x80};
  276|  2.10k|    unsigned char sizedesc[8];
  277|  2.10k|    WriteLE64(sizedesc, bytes << 3);
  278|  2.10k|    Write(pad, 1 + ((119 - (bytes % 64)) % 64));
  279|  2.10k|    Write(sizedesc, 8);
  280|  2.10k|    WriteLE32(hash, s[0]);
  281|  2.10k|    WriteLE32(hash + 4, s[1]);
  282|  2.10k|    WriteLE32(hash + 8, s[2]);
  283|  2.10k|    WriteLE32(hash + 12, s[3]);
  284|  2.10k|    WriteLE32(hash + 16, s[4]);
  285|  2.10k|}
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd16010InitializeEPj:
   25|  2.10k|{
   26|  2.10k|    s[0] = 0x67452301ul;
   27|  2.10k|    s[1] = 0xEFCDAB89ul;
   28|  2.10k|    s[2] = 0x98BADCFEul;
   29|  2.10k|    s[3] = 0x10325476ul;
   30|  2.10k|    s[4] = 0xC3D2E1F0ul;
   31|  2.10k|}
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1609TransformEPjPKh:
   55|  2.35k|{
   56|  2.35k|    uint32_t a1 = s[0], b1 = s[1], c1 = s[2], d1 = s[3], e1 = s[4];
   57|  2.35k|    uint32_t a2 = a1, b2 = b1, c2 = c1, d2 = d1, e2 = e1;
   58|  2.35k|    uint32_t w0 = ReadLE32(chunk + 0), w1 = ReadLE32(chunk + 4), w2 = ReadLE32(chunk + 8), w3 = ReadLE32(chunk + 12);
   59|  2.35k|    uint32_t w4 = ReadLE32(chunk + 16), w5 = ReadLE32(chunk + 20), w6 = ReadLE32(chunk + 24), w7 = ReadLE32(chunk + 28);
   60|  2.35k|    uint32_t w8 = ReadLE32(chunk + 32), w9 = ReadLE32(chunk + 36), w10 = ReadLE32(chunk + 40), w11 = ReadLE32(chunk + 44);
   61|  2.35k|    uint32_t w12 = ReadLE32(chunk + 48), w13 = ReadLE32(chunk + 52), w14 = ReadLE32(chunk + 56), w15 = ReadLE32(chunk + 60);
   62|       |
   63|  2.35k|    R11(a1, b1, c1, d1, e1, w0, 11);
   64|  2.35k|    R12(a2, b2, c2, d2, e2, w5, 8);
   65|  2.35k|    R11(e1, a1, b1, c1, d1, w1, 14);
   66|  2.35k|    R12(e2, a2, b2, c2, d2, w14, 9);
   67|  2.35k|    R11(d1, e1, a1, b1, c1, w2, 15);
   68|  2.35k|    R12(d2, e2, a2, b2, c2, w7, 9);
   69|  2.35k|    R11(c1, d1, e1, a1, b1, w3, 12);
   70|  2.35k|    R12(c2, d2, e2, a2, b2, w0, 11);
   71|  2.35k|    R11(b1, c1, d1, e1, a1, w4, 5);
   72|  2.35k|    R12(b2, c2, d2, e2, a2, w9, 13);
   73|  2.35k|    R11(a1, b1, c1, d1, e1, w5, 8);
   74|  2.35k|    R12(a2, b2, c2, d2, e2, w2, 15);
   75|  2.35k|    R11(e1, a1, b1, c1, d1, w6, 7);
   76|  2.35k|    R12(e2, a2, b2, c2, d2, w11, 15);
   77|  2.35k|    R11(d1, e1, a1, b1, c1, w7, 9);
   78|  2.35k|    R12(d2, e2, a2, b2, c2, w4, 5);
   79|  2.35k|    R11(c1, d1, e1, a1, b1, w8, 11);
   80|  2.35k|    R12(c2, d2, e2, a2, b2, w13, 7);
   81|  2.35k|    R11(b1, c1, d1, e1, a1, w9, 13);
   82|  2.35k|    R12(b2, c2, d2, e2, a2, w6, 7);
   83|  2.35k|    R11(a1, b1, c1, d1, e1, w10, 14);
   84|  2.35k|    R12(a2, b2, c2, d2, e2, w15, 8);
   85|  2.35k|    R11(e1, a1, b1, c1, d1, w11, 15);
   86|  2.35k|    R12(e2, a2, b2, c2, d2, w8, 11);
   87|  2.35k|    R11(d1, e1, a1, b1, c1, w12, 6);
   88|  2.35k|    R12(d2, e2, a2, b2, c2, w1, 14);
   89|  2.35k|    R11(c1, d1, e1, a1, b1, w13, 7);
   90|  2.35k|    R12(c2, d2, e2, a2, b2, w10, 14);
   91|  2.35k|    R11(b1, c1, d1, e1, a1, w14, 9);
   92|  2.35k|    R12(b2, c2, d2, e2, a2, w3, 12);
   93|  2.35k|    R11(a1, b1, c1, d1, e1, w15, 8);
   94|  2.35k|    R12(a2, b2, c2, d2, e2, w12, 6);
   95|       |
   96|  2.35k|    R21(e1, a1, b1, c1, d1, w7, 7);
   97|  2.35k|    R22(e2, a2, b2, c2, d2, w6, 9);
   98|  2.35k|    R21(d1, e1, a1, b1, c1, w4, 6);
   99|  2.35k|    R22(d2, e2, a2, b2, c2, w11, 13);
  100|  2.35k|    R21(c1, d1, e1, a1, b1, w13, 8);
  101|  2.35k|    R22(c2, d2, e2, a2, b2, w3, 15);
  102|  2.35k|    R21(b1, c1, d1, e1, a1, w1, 13);
  103|  2.35k|    R22(b2, c2, d2, e2, a2, w7, 7);
  104|  2.35k|    R21(a1, b1, c1, d1, e1, w10, 11);
  105|  2.35k|    R22(a2, b2, c2, d2, e2, w0, 12);
  106|  2.35k|    R21(e1, a1, b1, c1, d1, w6, 9);
  107|  2.35k|    R22(e2, a2, b2, c2, d2, w13, 8);
  108|  2.35k|    R21(d1, e1, a1, b1, c1, w15, 7);
  109|  2.35k|    R22(d2, e2, a2, b2, c2, w5, 9);
  110|  2.35k|    R21(c1, d1, e1, a1, b1, w3, 15);
  111|  2.35k|    R22(c2, d2, e2, a2, b2, w10, 11);
  112|  2.35k|    R21(b1, c1, d1, e1, a1, w12, 7);
  113|  2.35k|    R22(b2, c2, d2, e2, a2, w14, 7);
  114|  2.35k|    R21(a1, b1, c1, d1, e1, w0, 12);
  115|  2.35k|    R22(a2, b2, c2, d2, e2, w15, 7);
  116|  2.35k|    R21(e1, a1, b1, c1, d1, w9, 15);
  117|  2.35k|    R22(e2, a2, b2, c2, d2, w8, 12);
  118|  2.35k|    R21(d1, e1, a1, b1, c1, w5, 9);
  119|  2.35k|    R22(d2, e2, a2, b2, c2, w12, 7);
  120|  2.35k|    R21(c1, d1, e1, a1, b1, w2, 11);
  121|  2.35k|    R22(c2, d2, e2, a2, b2, w4, 6);
  122|  2.35k|    R21(b1, c1, d1, e1, a1, w14, 7);
  123|  2.35k|    R22(b2, c2, d2, e2, a2, w9, 15);
  124|  2.35k|    R21(a1, b1, c1, d1, e1, w11, 13);
  125|  2.35k|    R22(a2, b2, c2, d2, e2, w1, 13);
  126|  2.35k|    R21(e1, a1, b1, c1, d1, w8, 12);
  127|  2.35k|    R22(e2, a2, b2, c2, d2, w2, 11);
  128|       |
  129|  2.35k|    R31(d1, e1, a1, b1, c1, w3, 11);
  130|  2.35k|    R32(d2, e2, a2, b2, c2, w15, 9);
  131|  2.35k|    R31(c1, d1, e1, a1, b1, w10, 13);
  132|  2.35k|    R32(c2, d2, e2, a2, b2, w5, 7);
  133|  2.35k|    R31(b1, c1, d1, e1, a1, w14, 6);
  134|  2.35k|    R32(b2, c2, d2, e2, a2, w1, 15);
  135|  2.35k|    R31(a1, b1, c1, d1, e1, w4, 7);
  136|  2.35k|    R32(a2, b2, c2, d2, e2, w3, 11);
  137|  2.35k|    R31(e1, a1, b1, c1, d1, w9, 14);
  138|  2.35k|    R32(e2, a2, b2, c2, d2, w7, 8);
  139|  2.35k|    R31(d1, e1, a1, b1, c1, w15, 9);
  140|  2.35k|    R32(d2, e2, a2, b2, c2, w14, 6);
  141|  2.35k|    R31(c1, d1, e1, a1, b1, w8, 13);
  142|  2.35k|    R32(c2, d2, e2, a2, b2, w6, 6);
  143|  2.35k|    R31(b1, c1, d1, e1, a1, w1, 15);
  144|  2.35k|    R32(b2, c2, d2, e2, a2, w9, 14);
  145|  2.35k|    R31(a1, b1, c1, d1, e1, w2, 14);
  146|  2.35k|    R32(a2, b2, c2, d2, e2, w11, 12);
  147|  2.35k|    R31(e1, a1, b1, c1, d1, w7, 8);
  148|  2.35k|    R32(e2, a2, b2, c2, d2, w8, 13);
  149|  2.35k|    R31(d1, e1, a1, b1, c1, w0, 13);
  150|  2.35k|    R32(d2, e2, a2, b2, c2, w12, 5);
  151|  2.35k|    R31(c1, d1, e1, a1, b1, w6, 6);
  152|  2.35k|    R32(c2, d2, e2, a2, b2, w2, 14);
  153|  2.35k|    R31(b1, c1, d1, e1, a1, w13, 5);
  154|  2.35k|    R32(b2, c2, d2, e2, a2, w10, 13);
  155|  2.35k|    R31(a1, b1, c1, d1, e1, w11, 12);
  156|  2.35k|    R32(a2, b2, c2, d2, e2, w0, 13);
  157|  2.35k|    R31(e1, a1, b1, c1, d1, w5, 7);
  158|  2.35k|    R32(e2, a2, b2, c2, d2, w4, 7);
  159|  2.35k|    R31(d1, e1, a1, b1, c1, w12, 5);
  160|  2.35k|    R32(d2, e2, a2, b2, c2, w13, 5);
  161|       |
  162|  2.35k|    R41(c1, d1, e1, a1, b1, w1, 11);
  163|  2.35k|    R42(c2, d2, e2, a2, b2, w8, 15);
  164|  2.35k|    R41(b1, c1, d1, e1, a1, w9, 12);
  165|  2.35k|    R42(b2, c2, d2, e2, a2, w6, 5);
  166|  2.35k|    R41(a1, b1, c1, d1, e1, w11, 14);
  167|  2.35k|    R42(a2, b2, c2, d2, e2, w4, 8);
  168|  2.35k|    R41(e1, a1, b1, c1, d1, w10, 15);
  169|  2.35k|    R42(e2, a2, b2, c2, d2, w1, 11);
  170|  2.35k|    R41(d1, e1, a1, b1, c1, w0, 14);
  171|  2.35k|    R42(d2, e2, a2, b2, c2, w3, 14);
  172|  2.35k|    R41(c1, d1, e1, a1, b1, w8, 15);
  173|  2.35k|    R42(c2, d2, e2, a2, b2, w11, 14);
  174|  2.35k|    R41(b1, c1, d1, e1, a1, w12, 9);
  175|  2.35k|    R42(b2, c2, d2, e2, a2, w15, 6);
  176|  2.35k|    R41(a1, b1, c1, d1, e1, w4, 8);
  177|  2.35k|    R42(a2, b2, c2, d2, e2, w0, 14);
  178|  2.35k|    R41(e1, a1, b1, c1, d1, w13, 9);
  179|  2.35k|    R42(e2, a2, b2, c2, d2, w5, 6);
  180|  2.35k|    R41(d1, e1, a1, b1, c1, w3, 14);
  181|  2.35k|    R42(d2, e2, a2, b2, c2, w12, 9);
  182|  2.35k|    R41(c1, d1, e1, a1, b1, w7, 5);
  183|  2.35k|    R42(c2, d2, e2, a2, b2, w2, 12);
  184|  2.35k|    R41(b1, c1, d1, e1, a1, w15, 6);
  185|  2.35k|    R42(b2, c2, d2, e2, a2, w13, 9);
  186|  2.35k|    R41(a1, b1, c1, d1, e1, w14, 8);
  187|  2.35k|    R42(a2, b2, c2, d2, e2, w9, 12);
  188|  2.35k|    R41(e1, a1, b1, c1, d1, w5, 6);
  189|  2.35k|    R42(e2, a2, b2, c2, d2, w7, 5);
  190|  2.35k|    R41(d1, e1, a1, b1, c1, w6, 5);
  191|  2.35k|    R42(d2, e2, a2, b2, c2, w10, 15);
  192|  2.35k|    R41(c1, d1, e1, a1, b1, w2, 12);
  193|  2.35k|    R42(c2, d2, e2, a2, b2, w14, 8);
  194|       |
  195|  2.35k|    R51(b1, c1, d1, e1, a1, w4, 9);
  196|  2.35k|    R52(b2, c2, d2, e2, a2, w12, 8);
  197|  2.35k|    R51(a1, b1, c1, d1, e1, w0, 15);
  198|  2.35k|    R52(a2, b2, c2, d2, e2, w15, 5);
  199|  2.35k|    R51(e1, a1, b1, c1, d1, w5, 5);
  200|  2.35k|    R52(e2, a2, b2, c2, d2, w10, 12);
  201|  2.35k|    R51(d1, e1, a1, b1, c1, w9, 11);
  202|  2.35k|    R52(d2, e2, a2, b2, c2, w4, 9);
  203|  2.35k|    R51(c1, d1, e1, a1, b1, w7, 6);
  204|  2.35k|    R52(c2, d2, e2, a2, b2, w1, 12);
  205|  2.35k|    R51(b1, c1, d1, e1, a1, w12, 8);
  206|  2.35k|    R52(b2, c2, d2, e2, a2, w5, 5);
  207|  2.35k|    R51(a1, b1, c1, d1, e1, w2, 13);
  208|  2.35k|    R52(a2, b2, c2, d2, e2, w8, 14);
  209|  2.35k|    R51(e1, a1, b1, c1, d1, w10, 12);
  210|  2.35k|    R52(e2, a2, b2, c2, d2, w7, 6);
  211|  2.35k|    R51(d1, e1, a1, b1, c1, w14, 5);
  212|  2.35k|    R52(d2, e2, a2, b2, c2, w6, 8);
  213|  2.35k|    R51(c1, d1, e1, a1, b1, w1, 12);
  214|  2.35k|    R52(c2, d2, e2, a2, b2, w2, 13);
  215|  2.35k|    R51(b1, c1, d1, e1, a1, w3, 13);
  216|  2.35k|    R52(b2, c2, d2, e2, a2, w13, 6);
  217|  2.35k|    R51(a1, b1, c1, d1, e1, w8, 14);
  218|  2.35k|    R52(a2, b2, c2, d2, e2, w14, 5);
  219|  2.35k|    R51(e1, a1, b1, c1, d1, w11, 11);
  220|  2.35k|    R52(e2, a2, b2, c2, d2, w0, 15);
  221|  2.35k|    R51(d1, e1, a1, b1, c1, w6, 8);
  222|  2.35k|    R52(d2, e2, a2, b2, c2, w3, 13);
  223|  2.35k|    R51(c1, d1, e1, a1, b1, w15, 5);
  224|  2.35k|    R52(c2, d2, e2, a2, b2, w9, 11);
  225|  2.35k|    R51(b1, c1, d1, e1, a1, w13, 6);
  226|  2.35k|    R52(b2, c2, d2, e2, a2, w11, 11);
  227|       |
  228|  2.35k|    uint32_t t = s[0];
  229|  2.35k|    s[0] = s[1] + c1 + d2;
  230|  2.35k|    s[1] = s[2] + d1 + e2;
  231|  2.35k|    s[2] = s[3] + e1 + a2;
  232|  2.35k|    s[3] = s[4] + a1 + b2;
  233|  2.35k|    s[4] = t + b1 + c2;
  234|  2.35k|}
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R11ERjjS1_jjji:
   41|  37.6k|void inline R11(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f1(b, c, d), x, 0, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1605RoundERjjS1_jjjjji:
   36|   376k|{
   37|   376k|    a = rol(a + f + x + k, r) + e;
   38|   376k|    c = rol(c, 10);
   39|   376k|}
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603rolEji:
   33|   752k|uint32_t inline rol(uint32_t x, int i) { return (x << i) | (x >> (32 - i)); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1602f1Ejjj:
   17|  75.2k|uint32_t inline f1(uint32_t x, uint32_t y, uint32_t z) { return x ^ y ^ z; }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R12ERjjS1_jjji:
   47|  37.6k|void inline R12(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f5(b, c, d), x, 0x50A28BE6ul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1602f5Ejjj:
   21|  75.2k|uint32_t inline f5(uint32_t x, uint32_t y, uint32_t z) { return x ^ (y | ~z); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R21ERjjS1_jjji:
   42|  37.6k|void inline R21(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f2(b, c, d), x, 0x5A827999ul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1602f2Ejjj:
   18|  75.2k|uint32_t inline f2(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (~x & z); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R22ERjjS1_jjji:
   48|  37.6k|void inline R22(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f4(b, c, d), x, 0x5C4DD124ul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1602f4Ejjj:
   20|  75.2k|uint32_t inline f4(uint32_t x, uint32_t y, uint32_t z) { return (x & z) | (y & ~z); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R31ERjjS1_jjji:
   43|  37.6k|void inline R31(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f3(b, c, d), x, 0x6ED9EBA1ul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1602f3Ejjj:
   19|  75.2k|uint32_t inline f3(uint32_t x, uint32_t y, uint32_t z) { return (x | ~y) ^ z; }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R32ERjjS1_jjji:
   49|  37.6k|void inline R32(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f3(b, c, d), x, 0x6D703EF3ul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R41ERjjS1_jjji:
   44|  37.6k|void inline R41(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f4(b, c, d), x, 0x8F1BBCDCul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R42ERjjS1_jjji:
   50|  37.6k|void inline R42(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f2(b, c, d), x, 0x7A6D76E9ul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R51ERjjS1_jjji:
   45|  37.6k|void inline R51(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f5(b, c, d), x, 0xA953FD4Eul, r); }
ripemd160.cpp:_ZN12_GLOBAL__N_19ripemd1603R52ERjjS1_jjji:
   51|  37.6k|void inline R52(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f1(b, c, d), x, 0, r); }

_ZN5CSHA1C2Ev:
  150|  2.15k|{
  151|  2.15k|    sha1::Initialize(s);
  152|  2.15k|}
_ZN5CSHA15WriteEPKhm:
  155|  6.45k|{
  156|  6.45k|    const unsigned char* end = data + len;
  157|  6.45k|    size_t bufsize = bytes % 64;
  158|  6.45k|    if (bufsize && bufsize + len >= 64) {
  ------------------
  |  Branch (158:9): [True: 4.23k, False: 2.22k]
  |  Branch (158:20): [True: 2.15k, False: 2.07k]
  ------------------
  159|       |        // Fill the buffer, and process it.
  160|  2.15k|        memcpy(buf + bufsize, data, 64 - bufsize);
  161|  2.15k|        bytes += 64 - bufsize;
  162|  2.15k|        data += 64 - bufsize;
  163|  2.15k|        sha1::Transform(s, buf);
  164|  2.15k|        bufsize = 0;
  165|  2.15k|    }
  166|  6.71k|    while (end - data >= 64) {
  ------------------
  |  Branch (166:12): [True: 257, False: 6.45k]
  ------------------
  167|       |        // Process full chunks directly from the source.
  168|    257|        sha1::Transform(s, data);
  169|    257|        bytes += 64;
  170|    257|        data += 64;
  171|    257|    }
  172|  6.45k|    if (end > data) {
  ------------------
  |  Branch (172:9): [True: 4.23k, False: 2.22k]
  ------------------
  173|       |        // Fill the buffer with what remains.
  174|  4.23k|        memcpy(buf + bufsize, data, end - data);
  175|  4.23k|        bytes += end - data;
  176|  4.23k|    }
  177|  6.45k|    return *this;
  178|  6.45k|}
_ZN5CSHA18FinalizeEPh:
  181|  2.15k|{
  182|  2.15k|    static const unsigned char pad[64] = {0x80};
  183|  2.15k|    unsigned char sizedesc[8];
  184|  2.15k|    WriteBE64(sizedesc, bytes << 3);
  185|  2.15k|    Write(pad, 1 + ((119 - (bytes % 64)) % 64));
  186|  2.15k|    Write(sizedesc, 8);
  187|  2.15k|    WriteBE32(hash, s[0]);
  188|  2.15k|    WriteBE32(hash + 4, s[1]);
  189|  2.15k|    WriteBE32(hash + 8, s[2]);
  190|  2.15k|    WriteBE32(hash + 12, s[3]);
  191|  2.15k|    WriteBE32(hash + 16, s[4]);
  192|  2.15k|}
sha1.cpp:_ZN12_GLOBAL__N_14sha110InitializeEPj:
   32|  2.15k|{
   33|  2.15k|    s[0] = 0x67452301ul;
   34|  2.15k|    s[1] = 0xEFCDAB89ul;
   35|  2.15k|    s[2] = 0x98BADCFEul;
   36|  2.15k|    s[3] = 0x10325476ul;
   37|  2.15k|    s[4] = 0xC3D2E1F0ul;
   38|  2.15k|}
sha1.cpp:_ZN12_GLOBAL__N_14sha19TransformEPjPKh:
   47|  2.41k|{
   48|  2.41k|    uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4];
   49|  2.41k|    uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
   50|       |
   51|  2.41k|    Round(a, b, c, d, e, f1(b, c, d), k1, w0 = ReadBE32(chunk + 0));
   52|  2.41k|    Round(e, a, b, c, d, f1(a, b, c), k1, w1 = ReadBE32(chunk + 4));
   53|  2.41k|    Round(d, e, a, b, c, f1(e, a, b), k1, w2 = ReadBE32(chunk + 8));
   54|  2.41k|    Round(c, d, e, a, b, f1(d, e, a), k1, w3 = ReadBE32(chunk + 12));
   55|  2.41k|    Round(b, c, d, e, a, f1(c, d, e), k1, w4 = ReadBE32(chunk + 16));
   56|  2.41k|    Round(a, b, c, d, e, f1(b, c, d), k1, w5 = ReadBE32(chunk + 20));
   57|  2.41k|    Round(e, a, b, c, d, f1(a, b, c), k1, w6 = ReadBE32(chunk + 24));
   58|  2.41k|    Round(d, e, a, b, c, f1(e, a, b), k1, w7 = ReadBE32(chunk + 28));
   59|  2.41k|    Round(c, d, e, a, b, f1(d, e, a), k1, w8 = ReadBE32(chunk + 32));
   60|  2.41k|    Round(b, c, d, e, a, f1(c, d, e), k1, w9 = ReadBE32(chunk + 36));
   61|  2.41k|    Round(a, b, c, d, e, f1(b, c, d), k1, w10 = ReadBE32(chunk + 40));
   62|  2.41k|    Round(e, a, b, c, d, f1(a, b, c), k1, w11 = ReadBE32(chunk + 44));
   63|  2.41k|    Round(d, e, a, b, c, f1(e, a, b), k1, w12 = ReadBE32(chunk + 48));
   64|  2.41k|    Round(c, d, e, a, b, f1(d, e, a), k1, w13 = ReadBE32(chunk + 52));
   65|  2.41k|    Round(b, c, d, e, a, f1(c, d, e), k1, w14 = ReadBE32(chunk + 56));
   66|  2.41k|    Round(a, b, c, d, e, f1(b, c, d), k1, w15 = ReadBE32(chunk + 60));
   67|       |
   68|  2.41k|    Round(e, a, b, c, d, f1(a, b, c), k1, w0 = left(w0 ^ w13 ^ w8 ^ w2));
   69|  2.41k|    Round(d, e, a, b, c, f1(e, a, b), k1, w1 = left(w1 ^ w14 ^ w9 ^ w3));
   70|  2.41k|    Round(c, d, e, a, b, f1(d, e, a), k1, w2 = left(w2 ^ w15 ^ w10 ^ w4));
   71|  2.41k|    Round(b, c, d, e, a, f1(c, d, e), k1, w3 = left(w3 ^ w0 ^ w11 ^ w5));
   72|  2.41k|    Round(a, b, c, d, e, f2(b, c, d), k2, w4 = left(w4 ^ w1 ^ w12 ^ w6));
   73|  2.41k|    Round(e, a, b, c, d, f2(a, b, c), k2, w5 = left(w5 ^ w2 ^ w13 ^ w7));
   74|  2.41k|    Round(d, e, a, b, c, f2(e, a, b), k2, w6 = left(w6 ^ w3 ^ w14 ^ w8));
   75|  2.41k|    Round(c, d, e, a, b, f2(d, e, a), k2, w7 = left(w7 ^ w4 ^ w15 ^ w9));
   76|  2.41k|    Round(b, c, d, e, a, f2(c, d, e), k2, w8 = left(w8 ^ w5 ^ w0 ^ w10));
   77|  2.41k|    Round(a, b, c, d, e, f2(b, c, d), k2, w9 = left(w9 ^ w6 ^ w1 ^ w11));
   78|  2.41k|    Round(e, a, b, c, d, f2(a, b, c), k2, w10 = left(w10 ^ w7 ^ w2 ^ w12));
   79|  2.41k|    Round(d, e, a, b, c, f2(e, a, b), k2, w11 = left(w11 ^ w8 ^ w3 ^ w13));
   80|  2.41k|    Round(c, d, e, a, b, f2(d, e, a), k2, w12 = left(w12 ^ w9 ^ w4 ^ w14));
   81|  2.41k|    Round(b, c, d, e, a, f2(c, d, e), k2, w13 = left(w13 ^ w10 ^ w5 ^ w15));
   82|  2.41k|    Round(a, b, c, d, e, f2(b, c, d), k2, w14 = left(w14 ^ w11 ^ w6 ^ w0));
   83|  2.41k|    Round(e, a, b, c, d, f2(a, b, c), k2, w15 = left(w15 ^ w12 ^ w7 ^ w1));
   84|       |
   85|  2.41k|    Round(d, e, a, b, c, f2(e, a, b), k2, w0 = left(w0 ^ w13 ^ w8 ^ w2));
   86|  2.41k|    Round(c, d, e, a, b, f2(d, e, a), k2, w1 = left(w1 ^ w14 ^ w9 ^ w3));
   87|  2.41k|    Round(b, c, d, e, a, f2(c, d, e), k2, w2 = left(w2 ^ w15 ^ w10 ^ w4));
   88|  2.41k|    Round(a, b, c, d, e, f2(b, c, d), k2, w3 = left(w3 ^ w0 ^ w11 ^ w5));
   89|  2.41k|    Round(e, a, b, c, d, f2(a, b, c), k2, w4 = left(w4 ^ w1 ^ w12 ^ w6));
   90|  2.41k|    Round(d, e, a, b, c, f2(e, a, b), k2, w5 = left(w5 ^ w2 ^ w13 ^ w7));
   91|  2.41k|    Round(c, d, e, a, b, f2(d, e, a), k2, w6 = left(w6 ^ w3 ^ w14 ^ w8));
   92|  2.41k|    Round(b, c, d, e, a, f2(c, d, e), k2, w7 = left(w7 ^ w4 ^ w15 ^ w9));
   93|  2.41k|    Round(a, b, c, d, e, f3(b, c, d), k3, w8 = left(w8 ^ w5 ^ w0 ^ w10));
   94|  2.41k|    Round(e, a, b, c, d, f3(a, b, c), k3, w9 = left(w9 ^ w6 ^ w1 ^ w11));
   95|  2.41k|    Round(d, e, a, b, c, f3(e, a, b), k3, w10 = left(w10 ^ w7 ^ w2 ^ w12));
   96|  2.41k|    Round(c, d, e, a, b, f3(d, e, a), k3, w11 = left(w11 ^ w8 ^ w3 ^ w13));
   97|  2.41k|    Round(b, c, d, e, a, f3(c, d, e), k3, w12 = left(w12 ^ w9 ^ w4 ^ w14));
   98|  2.41k|    Round(a, b, c, d, e, f3(b, c, d), k3, w13 = left(w13 ^ w10 ^ w5 ^ w15));
   99|  2.41k|    Round(e, a, b, c, d, f3(a, b, c), k3, w14 = left(w14 ^ w11 ^ w6 ^ w0));
  100|  2.41k|    Round(d, e, a, b, c, f3(e, a, b), k3, w15 = left(w15 ^ w12 ^ w7 ^ w1));
  101|       |
  102|  2.41k|    Round(c, d, e, a, b, f3(d, e, a), k3, w0 = left(w0 ^ w13 ^ w8 ^ w2));
  103|  2.41k|    Round(b, c, d, e, a, f3(c, d, e), k3, w1 = left(w1 ^ w14 ^ w9 ^ w3));
  104|  2.41k|    Round(a, b, c, d, e, f3(b, c, d), k3, w2 = left(w2 ^ w15 ^ w10 ^ w4));
  105|  2.41k|    Round(e, a, b, c, d, f3(a, b, c), k3, w3 = left(w3 ^ w0 ^ w11 ^ w5));
  106|  2.41k|    Round(d, e, a, b, c, f3(e, a, b), k3, w4 = left(w4 ^ w1 ^ w12 ^ w6));
  107|  2.41k|    Round(c, d, e, a, b, f3(d, e, a), k3, w5 = left(w5 ^ w2 ^ w13 ^ w7));
  108|  2.41k|    Round(b, c, d, e, a, f3(c, d, e), k3, w6 = left(w6 ^ w3 ^ w14 ^ w8));
  109|  2.41k|    Round(a, b, c, d, e, f3(b, c, d), k3, w7 = left(w7 ^ w4 ^ w15 ^ w9));
  110|  2.41k|    Round(e, a, b, c, d, f3(a, b, c), k3, w8 = left(w8 ^ w5 ^ w0 ^ w10));
  111|  2.41k|    Round(d, e, a, b, c, f3(e, a, b), k3, w9 = left(w9 ^ w6 ^ w1 ^ w11));
  112|  2.41k|    Round(c, d, e, a, b, f3(d, e, a), k3, w10 = left(w10 ^ w7 ^ w2 ^ w12));
  113|  2.41k|    Round(b, c, d, e, a, f3(c, d, e), k3, w11 = left(w11 ^ w8 ^ w3 ^ w13));
  114|  2.41k|    Round(a, b, c, d, e, f2(b, c, d), k4, w12 = left(w12 ^ w9 ^ w4 ^ w14));
  115|  2.41k|    Round(e, a, b, c, d, f2(a, b, c), k4, w13 = left(w13 ^ w10 ^ w5 ^ w15));
  116|  2.41k|    Round(d, e, a, b, c, f2(e, a, b), k4, w14 = left(w14 ^ w11 ^ w6 ^ w0));
  117|  2.41k|    Round(c, d, e, a, b, f2(d, e, a), k4, w15 = left(w15 ^ w12 ^ w7 ^ w1));
  118|       |
  119|  2.41k|    Round(b, c, d, e, a, f2(c, d, e), k4, w0 = left(w0 ^ w13 ^ w8 ^ w2));
  120|  2.41k|    Round(a, b, c, d, e, f2(b, c, d), k4, w1 = left(w1 ^ w14 ^ w9 ^ w3));
  121|  2.41k|    Round(e, a, b, c, d, f2(a, b, c), k4, w2 = left(w2 ^ w15 ^ w10 ^ w4));
  122|  2.41k|    Round(d, e, a, b, c, f2(e, a, b), k4, w3 = left(w3 ^ w0 ^ w11 ^ w5));
  123|  2.41k|    Round(c, d, e, a, b, f2(d, e, a), k4, w4 = left(w4 ^ w1 ^ w12 ^ w6));
  124|  2.41k|    Round(b, c, d, e, a, f2(c, d, e), k4, w5 = left(w5 ^ w2 ^ w13 ^ w7));
  125|  2.41k|    Round(a, b, c, d, e, f2(b, c, d), k4, w6 = left(w6 ^ w3 ^ w14 ^ w8));
  126|  2.41k|    Round(e, a, b, c, d, f2(a, b, c), k4, w7 = left(w7 ^ w4 ^ w15 ^ w9));
  127|  2.41k|    Round(d, e, a, b, c, f2(e, a, b), k4, w8 = left(w8 ^ w5 ^ w0 ^ w10));
  128|  2.41k|    Round(c, d, e, a, b, f2(d, e, a), k4, w9 = left(w9 ^ w6 ^ w1 ^ w11));
  129|  2.41k|    Round(b, c, d, e, a, f2(c, d, e), k4, w10 = left(w10 ^ w7 ^ w2 ^ w12));
  130|  2.41k|    Round(a, b, c, d, e, f2(b, c, d), k4, w11 = left(w11 ^ w8 ^ w3 ^ w13));
  131|  2.41k|    Round(e, a, b, c, d, f2(a, b, c), k4, w12 = left(w12 ^ w9 ^ w4 ^ w14));
  132|  2.41k|    Round(d, e, a, b, c, f2(e, a, b), k4, left(w13 ^ w10 ^ w5 ^ w15));
  133|  2.41k|    Round(c, d, e, a, b, f2(d, e, a), k4, left(w14 ^ w11 ^ w6 ^ w0));
  134|  2.41k|    Round(b, c, d, e, a, f2(c, d, e), k4, left(w15 ^ w12 ^ w7 ^ w1));
  135|       |
  136|  2.41k|    s[0] += a;
  137|  2.41k|    s[1] += b;
  138|  2.41k|    s[2] += c;
  139|  2.41k|    s[3] += d;
  140|  2.41k|    s[4] += e;
  141|  2.41k|}
sha1.cpp:_ZN12_GLOBAL__N_14sha15RoundEjRjjjS1_jjj:
   19|   193k|{
   20|   193k|    e += ((a << 5) | (a >> 27)) + f + k + w;
   21|   193k|    b = (b << 30) | (b >> 2);
   22|   193k|}
sha1.cpp:_ZN12_GLOBAL__N_14sha12f1Ejjj:
   24|  48.3k|uint32_t inline f1(uint32_t b, uint32_t c, uint32_t d) { return d ^ (b & (c ^ d)); }
sha1.cpp:_ZN12_GLOBAL__N_14sha14leftEj:
   28|   154k|uint32_t inline left(uint32_t x) { return (x << 1) | (x >> 31); }
sha1.cpp:_ZN12_GLOBAL__N_14sha12f2Ejjj:
   25|  96.6k|uint32_t inline f2(uint32_t b, uint32_t c, uint32_t d) { return b ^ c ^ d; }
sha1.cpp:_ZN12_GLOBAL__N_14sha12f3Ejjj:
   26|  48.3k|uint32_t inline f3(uint32_t b, uint32_t c, uint32_t d) { return (b & c) | (d & (b | c)); }

_ZN7CSHA256C2Ev:
  697|  17.4k|{
  698|  17.4k|    sha256::Initialize(s);
  699|  17.4k|}
_ZN7CSHA2565WriteEPKhm:
  702|  10.7M|{
  703|  10.7M|    const unsigned char* end = data + len;
  704|  10.7M|    size_t bufsize = bytes % 64;
  705|  10.7M|    if (bufsize && bufsize + len >= 64) {
  ------------------
  |  Branch (705:9): [True: 10.5M, False: 198k]
  |  Branch (705:20): [True: 792k, False: 9.77M]
  ------------------
  706|       |        // Fill the buffer, and process it.
  707|   792k|        memcpy(buf + bufsize, data, 64 - bufsize);
  708|   792k|        bytes += 64 - bufsize;
  709|   792k|        data += 64 - bufsize;
  710|   792k|        Transform(s, buf, 1);
  711|   792k|        bufsize = 0;
  712|   792k|    }
  713|  10.7M|    if (end - data >= 64) {
  ------------------
  |  Branch (713:9): [True: 12.5k, False: 10.7M]
  ------------------
  714|  12.5k|        size_t blocks = (end - data) / 64;
  715|  12.5k|        Transform(s, data, blocks);
  716|  12.5k|        data += 64 * blocks;
  717|  12.5k|        bytes += 64 * blocks;
  718|  12.5k|    }
  719|  10.7M|    if (end > data) {
  ------------------
  |  Branch (719:9): [True: 10.5M, False: 198k]
  ------------------
  720|       |        // Fill the buffer with what remains.
  721|  10.5M|        memcpy(buf + bufsize, data, end - data);
  722|  10.5M|        bytes += end - data;
  723|  10.5M|    }
  724|  10.7M|    return *this;
  725|  10.7M|}
_ZN7CSHA2568FinalizeEPh:
  728|  33.7k|{
  729|  33.7k|    static const unsigned char pad[64] = {0x80};
  730|  33.7k|    unsigned char sizedesc[8];
  731|  33.7k|    WriteBE64(sizedesc, bytes << 3);
  732|  33.7k|    Write(pad, 1 + ((119 - (bytes % 64)) % 64));
  733|  33.7k|    Write(sizedesc, 8);
  734|  33.7k|    WriteBE32(hash, s[0]);
  735|  33.7k|    WriteBE32(hash + 4, s[1]);
  736|  33.7k|    WriteBE32(hash + 8, s[2]);
  737|  33.7k|    WriteBE32(hash + 12, s[3]);
  738|  33.7k|    WriteBE32(hash + 16, s[4]);
  739|  33.7k|    WriteBE32(hash + 20, s[5]);
  740|  33.7k|    WriteBE32(hash + 24, s[6]);
  741|  33.7k|    WriteBE32(hash + 28, s[7]);
  742|  33.7k|}
_ZN7CSHA2565ResetEv:
  745|  16.2k|{
  746|  16.2k|    bytes = 0;
  747|  16.2k|    sha256::Initialize(s);
  748|  16.2k|    return *this;
  749|  16.2k|}
sha256.cpp:_ZN12_GLOBAL__N_16sha25610InitializeEPj:
   89|  33.7k|{
   90|  33.7k|    s[0] = 0x6a09e667ul;
   91|  33.7k|    s[1] = 0xbb67ae85ul;
   92|  33.7k|    s[2] = 0x3c6ef372ul;
   93|  33.7k|    s[3] = 0xa54ff53aul;
   94|  33.7k|    s[4] = 0x510e527ful;
   95|  33.7k|    s[5] = 0x9b05688cul;
   96|  33.7k|    s[6] = 0x1f83d9abul;
   97|  33.7k|    s[7] = 0x5be0cd19ul;
   98|  33.7k|}

_ZN11sha256_sse49TransformEPjPKhm:
   23|   805k|{
   24|   805k|    static const uint32_t K256 alignas(16) [] = {
   25|   805k|        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
   26|   805k|        0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
   27|   805k|        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
   28|   805k|        0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
   29|   805k|        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
   30|   805k|        0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
   31|   805k|        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
   32|   805k|        0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
   33|   805k|        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
   34|   805k|        0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
   35|   805k|        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
   36|   805k|        0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
   37|   805k|        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
   38|   805k|        0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
   39|   805k|        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
   40|   805k|        0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
   41|   805k|    };
   42|   805k|    static const uint32_t FLIP_MASK alignas(16) [] = {0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f};
   43|   805k|    static const uint32_t SHUF_00BA alignas(16) [] = {0x03020100, 0x0b0a0908, 0xffffffff, 0xffffffff};
   44|   805k|    static const uint32_t SHUF_DC00 alignas(16) [] = {0xffffffff, 0xffffffff, 0x03020100, 0x0b0a0908};
   45|   805k|    uint32_t a, b, c, d, f, g, h, y0, y1, y2;
   46|   805k|    uint64_t tbl;
   47|   805k|    uint64_t inp_end, inp;
   48|   805k|    uint32_t xfer alignas(16) [4];
   49|       |
   50|   805k|    __asm__ __volatile__(
   51|   805k|        "shl    $0x6,%2;"
   52|   805k|        "je     Ldone_hash_%=;"
   53|   805k|        "add    %1,%2;"
   54|   805k|        "mov    %2,%14;"
   55|   805k|        "mov    (%0),%3;"
   56|   805k|        "mov    0x4(%0),%4;"
   57|   805k|        "mov    0x8(%0),%5;"
   58|   805k|        "mov    0xc(%0),%6;"
   59|   805k|        "mov    0x10(%0),%k2;"
   60|   805k|        "mov    0x14(%0),%7;"
   61|   805k|        "mov    0x18(%0),%8;"
   62|   805k|        "mov    0x1c(%0),%9;"
   63|   805k|        "movdqa %18,%%xmm12;"
   64|   805k|        "movdqa %19,%%xmm10;"
   65|   805k|        "movdqa %20,%%xmm11;"
   66|       |
   67|   805k|        "Lloop0_%=:"
   68|   805k|        "lea    %17,%13;"
   69|   805k|        "movdqu (%1),%%xmm4;"
   70|   805k|        "pshufb %%xmm12,%%xmm4;"
   71|   805k|        "movdqu 0x10(%1),%%xmm5;"
   72|   805k|        "pshufb %%xmm12,%%xmm5;"
   73|   805k|        "movdqu 0x20(%1),%%xmm6;"
   74|   805k|        "pshufb %%xmm12,%%xmm6;"
   75|   805k|        "movdqu 0x30(%1),%%xmm7;"
   76|   805k|        "pshufb %%xmm12,%%xmm7;"
   77|   805k|        "mov    %1,%15;"
   78|   805k|        "mov    $3,%1;"
   79|       |
   80|   805k|        "Lloop1_%=:"
   81|   805k|        "movdqa 0x0(%13),%%xmm9;"
   82|   805k|        "paddd  %%xmm4,%%xmm9;"
   83|   805k|        "movdqa %%xmm9,%16;"
   84|   805k|        "movdqa %%xmm7,%%xmm0;"
   85|   805k|        "mov    %k2,%10;"
   86|   805k|        "ror    $0xe,%10;"
   87|   805k|        "mov    %3,%11;"
   88|   805k|        "palignr $0x4,%%xmm6,%%xmm0;"
   89|   805k|        "ror    $0x9,%11;"
   90|   805k|        "xor    %k2,%10;"
   91|   805k|        "mov    %7,%12;"
   92|   805k|        "ror    $0x5,%10;"
   93|   805k|        "movdqa %%xmm5,%%xmm1;"
   94|   805k|        "xor    %3,%11;"
   95|   805k|        "xor    %8,%12;"
   96|   805k|        "paddd  %%xmm4,%%xmm0;"
   97|   805k|        "xor    %k2,%10;"
   98|   805k|        "and    %k2,%12;"
   99|   805k|        "ror    $0xb,%11;"
  100|   805k|        "palignr $0x4,%%xmm4,%%xmm1;"
  101|   805k|        "xor    %3,%11;"
  102|   805k|        "ror    $0x6,%10;"
  103|   805k|        "xor    %8,%12;"
  104|   805k|        "movdqa %%xmm1,%%xmm2;"
  105|   805k|        "ror    $0x2,%11;"
  106|   805k|        "add    %10,%12;"
  107|   805k|        "add    %16,%12;"
  108|   805k|        "movdqa %%xmm1,%%xmm3;"
  109|   805k|        "mov    %3,%10;"
  110|   805k|        "add    %12,%9;"
  111|   805k|        "mov    %3,%12;"
  112|   805k|        "pslld  $0x19,%%xmm1;"
  113|   805k|        "or     %5,%10;"
  114|   805k|        "add    %9,%6;"
  115|   805k|        "and    %5,%12;"
  116|   805k|        "psrld  $0x7,%%xmm2;"
  117|   805k|        "and    %4,%10;"
  118|   805k|        "add    %11,%9;"
  119|   805k|        "por    %%xmm2,%%xmm1;"
  120|   805k|        "or     %12,%10;"
  121|   805k|        "add    %10,%9;"
  122|   805k|        "movdqa %%xmm3,%%xmm2;"
  123|   805k|        "mov    %6,%10;"
  124|   805k|        "mov    %9,%11;"
  125|   805k|        "movdqa %%xmm3,%%xmm8;"
  126|   805k|        "ror    $0xe,%10;"
  127|   805k|        "xor    %6,%10;"
  128|   805k|        "mov    %k2,%12;"
  129|   805k|        "ror    $0x9,%11;"
  130|   805k|        "pslld  $0xe,%%xmm3;"
  131|   805k|        "xor    %9,%11;"
  132|   805k|        "ror    $0x5,%10;"
  133|   805k|        "xor    %7,%12;"
  134|   805k|        "psrld  $0x12,%%xmm2;"
  135|   805k|        "ror    $0xb,%11;"
  136|   805k|        "xor    %6,%10;"
  137|   805k|        "and    %6,%12;"
  138|   805k|        "ror    $0x6,%10;"
  139|   805k|        "pxor   %%xmm3,%%xmm1;"
  140|   805k|        "xor    %9,%11;"
  141|   805k|        "xor    %7,%12;"
  142|   805k|        "psrld  $0x3,%%xmm8;"
  143|   805k|        "add    %10,%12;"
  144|   805k|        "add    4+%16,%12;"
  145|   805k|        "ror    $0x2,%11;"
  146|   805k|        "pxor   %%xmm2,%%xmm1;"
  147|   805k|        "mov    %9,%10;"
  148|   805k|        "add    %12,%8;"
  149|   805k|        "mov    %9,%12;"
  150|   805k|        "pxor   %%xmm8,%%xmm1;"
  151|   805k|        "or     %4,%10;"
  152|   805k|        "add    %8,%5;"
  153|   805k|        "and    %4,%12;"
  154|   805k|        "pshufd $0xfa,%%xmm7,%%xmm2;"
  155|   805k|        "and    %3,%10;"
  156|   805k|        "add    %11,%8;"
  157|   805k|        "paddd  %%xmm1,%%xmm0;"
  158|   805k|        "or     %12,%10;"
  159|   805k|        "add    %10,%8;"
  160|   805k|        "movdqa %%xmm2,%%xmm3;"
  161|   805k|        "mov    %5,%10;"
  162|   805k|        "mov    %8,%11;"
  163|   805k|        "ror    $0xe,%10;"
  164|   805k|        "movdqa %%xmm2,%%xmm8;"
  165|   805k|        "xor    %5,%10;"
  166|   805k|        "ror    $0x9,%11;"
  167|   805k|        "mov    %6,%12;"
  168|   805k|        "xor    %8,%11;"
  169|   805k|        "ror    $0x5,%10;"
  170|   805k|        "psrlq  $0x11,%%xmm2;"
  171|   805k|        "xor    %k2,%12;"
  172|   805k|        "psrlq  $0x13,%%xmm3;"
  173|   805k|        "xor    %5,%10;"
  174|   805k|        "and    %5,%12;"
  175|   805k|        "psrld  $0xa,%%xmm8;"
  176|   805k|        "ror    $0xb,%11;"
  177|   805k|        "xor    %8,%11;"
  178|   805k|        "xor    %k2,%12;"
  179|   805k|        "ror    $0x6,%10;"
  180|   805k|        "pxor   %%xmm3,%%xmm2;"
  181|   805k|        "add    %10,%12;"
  182|   805k|        "ror    $0x2,%11;"
  183|   805k|        "add    8+%16,%12;"
  184|   805k|        "pxor   %%xmm2,%%xmm8;"
  185|   805k|        "mov    %8,%10;"
  186|   805k|        "add    %12,%7;"
  187|   805k|        "mov    %8,%12;"
  188|   805k|        "pshufb %%xmm10,%%xmm8;"
  189|   805k|        "or     %3,%10;"
  190|   805k|        "add    %7,%4;"
  191|   805k|        "and    %3,%12;"
  192|   805k|        "paddd  %%xmm8,%%xmm0;"
  193|   805k|        "and    %9,%10;"
  194|   805k|        "add    %11,%7;"
  195|   805k|        "pshufd $0x50,%%xmm0,%%xmm2;"
  196|   805k|        "or     %12,%10;"
  197|   805k|        "add    %10,%7;"
  198|   805k|        "movdqa %%xmm2,%%xmm3;"
  199|   805k|        "mov    %4,%10;"
  200|   805k|        "ror    $0xe,%10;"
  201|   805k|        "mov    %7,%11;"
  202|   805k|        "movdqa %%xmm2,%%xmm4;"
  203|   805k|        "ror    $0x9,%11;"
  204|   805k|        "xor    %4,%10;"
  205|   805k|        "mov    %5,%12;"
  206|   805k|        "ror    $0x5,%10;"
  207|   805k|        "psrlq  $0x11,%%xmm2;"
  208|   805k|        "xor    %7,%11;"
  209|   805k|        "xor    %6,%12;"
  210|   805k|        "psrlq  $0x13,%%xmm3;"
  211|   805k|        "xor    %4,%10;"
  212|   805k|        "and    %4,%12;"
  213|   805k|        "ror    $0xb,%11;"
  214|   805k|        "psrld  $0xa,%%xmm4;"
  215|   805k|        "xor    %7,%11;"
  216|   805k|        "ror    $0x6,%10;"
  217|   805k|        "xor    %6,%12;"
  218|   805k|        "pxor   %%xmm3,%%xmm2;"
  219|   805k|        "ror    $0x2,%11;"
  220|   805k|        "add    %10,%12;"
  221|   805k|        "add    12+%16,%12;"
  222|   805k|        "pxor   %%xmm2,%%xmm4;"
  223|   805k|        "mov    %7,%10;"
  224|   805k|        "add    %12,%k2;"
  225|   805k|        "mov    %7,%12;"
  226|   805k|        "pshufb %%xmm11,%%xmm4;"
  227|   805k|        "or     %9,%10;"
  228|   805k|        "add    %k2,%3;"
  229|   805k|        "and    %9,%12;"
  230|   805k|        "paddd  %%xmm0,%%xmm4;"
  231|   805k|        "and    %8,%10;"
  232|   805k|        "add    %11,%k2;"
  233|   805k|        "or     %12,%10;"
  234|   805k|        "add    %10,%k2;"
  235|   805k|        "movdqa 0x10(%13),%%xmm9;"
  236|   805k|        "paddd  %%xmm5,%%xmm9;"
  237|   805k|        "movdqa %%xmm9,%16;"
  238|   805k|        "movdqa %%xmm4,%%xmm0;"
  239|   805k|        "mov    %3,%10;"
  240|   805k|        "ror    $0xe,%10;"
  241|   805k|        "mov    %k2,%11;"
  242|   805k|        "palignr $0x4,%%xmm7,%%xmm0;"
  243|   805k|        "ror    $0x9,%11;"
  244|   805k|        "xor    %3,%10;"
  245|   805k|        "mov    %4,%12;"
  246|   805k|        "ror    $0x5,%10;"
  247|   805k|        "movdqa %%xmm6,%%xmm1;"
  248|   805k|        "xor    %k2,%11;"
  249|   805k|        "xor    %5,%12;"
  250|   805k|        "paddd  %%xmm5,%%xmm0;"
  251|   805k|        "xor    %3,%10;"
  252|   805k|        "and    %3,%12;"
  253|   805k|        "ror    $0xb,%11;"
  254|   805k|        "palignr $0x4,%%xmm5,%%xmm1;"
  255|   805k|        "xor    %k2,%11;"
  256|   805k|        "ror    $0x6,%10;"
  257|   805k|        "xor    %5,%12;"
  258|   805k|        "movdqa %%xmm1,%%xmm2;"
  259|   805k|        "ror    $0x2,%11;"
  260|   805k|        "add    %10,%12;"
  261|   805k|        "add    %16,%12;"
  262|   805k|        "movdqa %%xmm1,%%xmm3;"
  263|   805k|        "mov    %k2,%10;"
  264|   805k|        "add    %12,%6;"
  265|   805k|        "mov    %k2,%12;"
  266|   805k|        "pslld  $0x19,%%xmm1;"
  267|   805k|        "or     %8,%10;"
  268|   805k|        "add    %6,%9;"
  269|   805k|        "and    %8,%12;"
  270|   805k|        "psrld  $0x7,%%xmm2;"
  271|   805k|        "and    %7,%10;"
  272|   805k|        "add    %11,%6;"
  273|   805k|        "por    %%xmm2,%%xmm1;"
  274|   805k|        "or     %12,%10;"
  275|   805k|        "add    %10,%6;"
  276|   805k|        "movdqa %%xmm3,%%xmm2;"
  277|   805k|        "mov    %9,%10;"
  278|   805k|        "mov    %6,%11;"
  279|   805k|        "movdqa %%xmm3,%%xmm8;"
  280|   805k|        "ror    $0xe,%10;"
  281|   805k|        "xor    %9,%10;"
  282|   805k|        "mov    %3,%12;"
  283|   805k|        "ror    $0x9,%11;"
  284|   805k|        "pslld  $0xe,%%xmm3;"
  285|   805k|        "xor    %6,%11;"
  286|   805k|        "ror    $0x5,%10;"
  287|   805k|        "xor    %4,%12;"
  288|   805k|        "psrld  $0x12,%%xmm2;"
  289|   805k|        "ror    $0xb,%11;"
  290|   805k|        "xor    %9,%10;"
  291|   805k|        "and    %9,%12;"
  292|   805k|        "ror    $0x6,%10;"
  293|   805k|        "pxor   %%xmm3,%%xmm1;"
  294|   805k|        "xor    %6,%11;"
  295|   805k|        "xor    %4,%12;"
  296|   805k|        "psrld  $0x3,%%xmm8;"
  297|   805k|        "add    %10,%12;"
  298|   805k|        "add    4+%16,%12;"
  299|   805k|        "ror    $0x2,%11;"
  300|   805k|        "pxor   %%xmm2,%%xmm1;"
  301|   805k|        "mov    %6,%10;"
  302|   805k|        "add    %12,%5;"
  303|   805k|        "mov    %6,%12;"
  304|   805k|        "pxor   %%xmm8,%%xmm1;"
  305|   805k|        "or     %7,%10;"
  306|   805k|        "add    %5,%8;"
  307|   805k|        "and    %7,%12;"
  308|   805k|        "pshufd $0xfa,%%xmm4,%%xmm2;"
  309|   805k|        "and    %k2,%10;"
  310|   805k|        "add    %11,%5;"
  311|   805k|        "paddd  %%xmm1,%%xmm0;"
  312|   805k|        "or     %12,%10;"
  313|   805k|        "add    %10,%5;"
  314|   805k|        "movdqa %%xmm2,%%xmm3;"
  315|   805k|        "mov    %8,%10;"
  316|   805k|        "mov    %5,%11;"
  317|   805k|        "ror    $0xe,%10;"
  318|   805k|        "movdqa %%xmm2,%%xmm8;"
  319|   805k|        "xor    %8,%10;"
  320|   805k|        "ror    $0x9,%11;"
  321|   805k|        "mov    %9,%12;"
  322|   805k|        "xor    %5,%11;"
  323|   805k|        "ror    $0x5,%10;"
  324|   805k|        "psrlq  $0x11,%%xmm2;"
  325|   805k|        "xor    %3,%12;"
  326|   805k|        "psrlq  $0x13,%%xmm3;"
  327|   805k|        "xor    %8,%10;"
  328|   805k|        "and    %8,%12;"
  329|   805k|        "psrld  $0xa,%%xmm8;"
  330|   805k|        "ror    $0xb,%11;"
  331|   805k|        "xor    %5,%11;"
  332|   805k|        "xor    %3,%12;"
  333|   805k|        "ror    $0x6,%10;"
  334|   805k|        "pxor   %%xmm3,%%xmm2;"
  335|   805k|        "add    %10,%12;"
  336|   805k|        "ror    $0x2,%11;"
  337|   805k|        "add    8+%16,%12;"
  338|   805k|        "pxor   %%xmm2,%%xmm8;"
  339|   805k|        "mov    %5,%10;"
  340|   805k|        "add    %12,%4;"
  341|   805k|        "mov    %5,%12;"
  342|   805k|        "pshufb %%xmm10,%%xmm8;"
  343|   805k|        "or     %k2,%10;"
  344|   805k|        "add    %4,%7;"
  345|   805k|        "and    %k2,%12;"
  346|   805k|        "paddd  %%xmm8,%%xmm0;"
  347|   805k|        "and    %6,%10;"
  348|   805k|        "add    %11,%4;"
  349|   805k|        "pshufd $0x50,%%xmm0,%%xmm2;"
  350|   805k|        "or     %12,%10;"
  351|   805k|        "add    %10,%4;"
  352|   805k|        "movdqa %%xmm2,%%xmm3;"
  353|   805k|        "mov    %7,%10;"
  354|   805k|        "ror    $0xe,%10;"
  355|   805k|        "mov    %4,%11;"
  356|   805k|        "movdqa %%xmm2,%%xmm5;"
  357|   805k|        "ror    $0x9,%11;"
  358|   805k|        "xor    %7,%10;"
  359|   805k|        "mov    %8,%12;"
  360|   805k|        "ror    $0x5,%10;"
  361|   805k|        "psrlq  $0x11,%%xmm2;"
  362|   805k|        "xor    %4,%11;"
  363|   805k|        "xor    %9,%12;"
  364|   805k|        "psrlq  $0x13,%%xmm3;"
  365|   805k|        "xor    %7,%10;"
  366|   805k|        "and    %7,%12;"
  367|   805k|        "ror    $0xb,%11;"
  368|   805k|        "psrld  $0xa,%%xmm5;"
  369|   805k|        "xor    %4,%11;"
  370|   805k|        "ror    $0x6,%10;"
  371|   805k|        "xor    %9,%12;"
  372|   805k|        "pxor   %%xmm3,%%xmm2;"
  373|   805k|        "ror    $0x2,%11;"
  374|   805k|        "add    %10,%12;"
  375|   805k|        "add    12+%16,%12;"
  376|   805k|        "pxor   %%xmm2,%%xmm5;"
  377|   805k|        "mov    %4,%10;"
  378|   805k|        "add    %12,%3;"
  379|   805k|        "mov    %4,%12;"
  380|   805k|        "pshufb %%xmm11,%%xmm5;"
  381|   805k|        "or     %6,%10;"
  382|   805k|        "add    %3,%k2;"
  383|   805k|        "and    %6,%12;"
  384|   805k|        "paddd  %%xmm0,%%xmm5;"
  385|   805k|        "and    %5,%10;"
  386|   805k|        "add    %11,%3;"
  387|   805k|        "or     %12,%10;"
  388|   805k|        "add    %10,%3;"
  389|   805k|        "movdqa 0x20(%13),%%xmm9;"
  390|   805k|        "paddd  %%xmm6,%%xmm9;"
  391|   805k|        "movdqa %%xmm9,%16;"
  392|   805k|        "movdqa %%xmm5,%%xmm0;"
  393|   805k|        "mov    %k2,%10;"
  394|   805k|        "ror    $0xe,%10;"
  395|   805k|        "mov    %3,%11;"
  396|   805k|        "palignr $0x4,%%xmm4,%%xmm0;"
  397|   805k|        "ror    $0x9,%11;"
  398|   805k|        "xor    %k2,%10;"
  399|   805k|        "mov    %7,%12;"
  400|   805k|        "ror    $0x5,%10;"
  401|   805k|        "movdqa %%xmm7,%%xmm1;"
  402|   805k|        "xor    %3,%11;"
  403|   805k|        "xor    %8,%12;"
  404|   805k|        "paddd  %%xmm6,%%xmm0;"
  405|   805k|        "xor    %k2,%10;"
  406|   805k|        "and    %k2,%12;"
  407|   805k|        "ror    $0xb,%11;"
  408|   805k|        "palignr $0x4,%%xmm6,%%xmm1;"
  409|   805k|        "xor    %3,%11;"
  410|   805k|        "ror    $0x6,%10;"
  411|   805k|        "xor    %8,%12;"
  412|   805k|        "movdqa %%xmm1,%%xmm2;"
  413|   805k|        "ror    $0x2,%11;"
  414|   805k|        "add    %10,%12;"
  415|   805k|        "add    %16,%12;"
  416|   805k|        "movdqa %%xmm1,%%xmm3;"
  417|   805k|        "mov    %3,%10;"
  418|   805k|        "add    %12,%9;"
  419|   805k|        "mov    %3,%12;"
  420|   805k|        "pslld  $0x19,%%xmm1;"
  421|   805k|        "or     %5,%10;"
  422|   805k|        "add    %9,%6;"
  423|   805k|        "and    %5,%12;"
  424|   805k|        "psrld  $0x7,%%xmm2;"
  425|   805k|        "and    %4,%10;"
  426|   805k|        "add    %11,%9;"
  427|   805k|        "por    %%xmm2,%%xmm1;"
  428|   805k|        "or     %12,%10;"
  429|   805k|        "add    %10,%9;"
  430|   805k|        "movdqa %%xmm3,%%xmm2;"
  431|   805k|        "mov    %6,%10;"
  432|   805k|        "mov    %9,%11;"
  433|   805k|        "movdqa %%xmm3,%%xmm8;"
  434|   805k|        "ror    $0xe,%10;"
  435|   805k|        "xor    %6,%10;"
  436|   805k|        "mov    %k2,%12;"
  437|   805k|        "ror    $0x9,%11;"
  438|   805k|        "pslld  $0xe,%%xmm3;"
  439|   805k|        "xor    %9,%11;"
  440|   805k|        "ror    $0x5,%10;"
  441|   805k|        "xor    %7,%12;"
  442|   805k|        "psrld  $0x12,%%xmm2;"
  443|   805k|        "ror    $0xb,%11;"
  444|   805k|        "xor    %6,%10;"
  445|   805k|        "and    %6,%12;"
  446|   805k|        "ror    $0x6,%10;"
  447|   805k|        "pxor   %%xmm3,%%xmm1;"
  448|   805k|        "xor    %9,%11;"
  449|   805k|        "xor    %7,%12;"
  450|   805k|        "psrld  $0x3,%%xmm8;"
  451|   805k|        "add    %10,%12;"
  452|   805k|        "add    4+%16,%12;"
  453|   805k|        "ror    $0x2,%11;"
  454|   805k|        "pxor   %%xmm2,%%xmm1;"
  455|   805k|        "mov    %9,%10;"
  456|   805k|        "add    %12,%8;"
  457|   805k|        "mov    %9,%12;"
  458|   805k|        "pxor   %%xmm8,%%xmm1;"
  459|   805k|        "or     %4,%10;"
  460|   805k|        "add    %8,%5;"
  461|   805k|        "and    %4,%12;"
  462|   805k|        "pshufd $0xfa,%%xmm5,%%xmm2;"
  463|   805k|        "and    %3,%10;"
  464|   805k|        "add    %11,%8;"
  465|   805k|        "paddd  %%xmm1,%%xmm0;"
  466|   805k|        "or     %12,%10;"
  467|   805k|        "add    %10,%8;"
  468|   805k|        "movdqa %%xmm2,%%xmm3;"
  469|   805k|        "mov    %5,%10;"
  470|   805k|        "mov    %8,%11;"
  471|   805k|        "ror    $0xe,%10;"
  472|   805k|        "movdqa %%xmm2,%%xmm8;"
  473|   805k|        "xor    %5,%10;"
  474|   805k|        "ror    $0x9,%11;"
  475|   805k|        "mov    %6,%12;"
  476|   805k|        "xor    %8,%11;"
  477|   805k|        "ror    $0x5,%10;"
  478|   805k|        "psrlq  $0x11,%%xmm2;"
  479|   805k|        "xor    %k2,%12;"
  480|   805k|        "psrlq  $0x13,%%xmm3;"
  481|   805k|        "xor    %5,%10;"
  482|   805k|        "and    %5,%12;"
  483|   805k|        "psrld  $0xa,%%xmm8;"
  484|   805k|        "ror    $0xb,%11;"
  485|   805k|        "xor    %8,%11;"
  486|   805k|        "xor    %k2,%12;"
  487|   805k|        "ror    $0x6,%10;"
  488|   805k|        "pxor   %%xmm3,%%xmm2;"
  489|   805k|        "add    %10,%12;"
  490|   805k|        "ror    $0x2,%11;"
  491|   805k|        "add    8+%16,%12;"
  492|   805k|        "pxor   %%xmm2,%%xmm8;"
  493|   805k|        "mov    %8,%10;"
  494|   805k|        "add    %12,%7;"
  495|   805k|        "mov    %8,%12;"
  496|   805k|        "pshufb %%xmm10,%%xmm8;"
  497|   805k|        "or     %3,%10;"
  498|   805k|        "add    %7,%4;"
  499|   805k|        "and    %3,%12;"
  500|   805k|        "paddd  %%xmm8,%%xmm0;"
  501|   805k|        "and    %9,%10;"
  502|   805k|        "add    %11,%7;"
  503|   805k|        "pshufd $0x50,%%xmm0,%%xmm2;"
  504|   805k|        "or     %12,%10;"
  505|   805k|        "add    %10,%7;"
  506|   805k|        "movdqa %%xmm2,%%xmm3;"
  507|   805k|        "mov    %4,%10;"
  508|   805k|        "ror    $0xe,%10;"
  509|   805k|        "mov    %7,%11;"
  510|   805k|        "movdqa %%xmm2,%%xmm6;"
  511|   805k|        "ror    $0x9,%11;"
  512|   805k|        "xor    %4,%10;"
  513|   805k|        "mov    %5,%12;"
  514|   805k|        "ror    $0x5,%10;"
  515|   805k|        "psrlq  $0x11,%%xmm2;"
  516|   805k|        "xor    %7,%11;"
  517|   805k|        "xor    %6,%12;"
  518|   805k|        "psrlq  $0x13,%%xmm3;"
  519|   805k|        "xor    %4,%10;"
  520|   805k|        "and    %4,%12;"
  521|   805k|        "ror    $0xb,%11;"
  522|   805k|        "psrld  $0xa,%%xmm6;"
  523|   805k|        "xor    %7,%11;"
  524|   805k|        "ror    $0x6,%10;"
  525|   805k|        "xor    %6,%12;"
  526|   805k|        "pxor   %%xmm3,%%xmm2;"
  527|   805k|        "ror    $0x2,%11;"
  528|   805k|        "add    %10,%12;"
  529|   805k|        "add    12+%16,%12;"
  530|   805k|        "pxor   %%xmm2,%%xmm6;"
  531|   805k|        "mov    %7,%10;"
  532|   805k|        "add    %12,%k2;"
  533|   805k|        "mov    %7,%12;"
  534|   805k|        "pshufb %%xmm11,%%xmm6;"
  535|   805k|        "or     %9,%10;"
  536|   805k|        "add    %k2,%3;"
  537|   805k|        "and    %9,%12;"
  538|   805k|        "paddd  %%xmm0,%%xmm6;"
  539|   805k|        "and    %8,%10;"
  540|   805k|        "add    %11,%k2;"
  541|   805k|        "or     %12,%10;"
  542|   805k|        "add    %10,%k2;"
  543|   805k|        "movdqa 0x30(%13),%%xmm9;"
  544|   805k|        "paddd  %%xmm7,%%xmm9;"
  545|   805k|        "movdqa %%xmm9,%16;"
  546|   805k|        "add    $0x40,%13;"
  547|   805k|        "movdqa %%xmm6,%%xmm0;"
  548|   805k|        "mov    %3,%10;"
  549|   805k|        "ror    $0xe,%10;"
  550|   805k|        "mov    %k2,%11;"
  551|   805k|        "palignr $0x4,%%xmm5,%%xmm0;"
  552|   805k|        "ror    $0x9,%11;"
  553|   805k|        "xor    %3,%10;"
  554|   805k|        "mov    %4,%12;"
  555|   805k|        "ror    $0x5,%10;"
  556|   805k|        "movdqa %%xmm4,%%xmm1;"
  557|   805k|        "xor    %k2,%11;"
  558|   805k|        "xor    %5,%12;"
  559|   805k|        "paddd  %%xmm7,%%xmm0;"
  560|   805k|        "xor    %3,%10;"
  561|   805k|        "and    %3,%12;"
  562|   805k|        "ror    $0xb,%11;"
  563|   805k|        "palignr $0x4,%%xmm7,%%xmm1;"
  564|   805k|        "xor    %k2,%11;"
  565|   805k|        "ror    $0x6,%10;"
  566|   805k|        "xor    %5,%12;"
  567|   805k|        "movdqa %%xmm1,%%xmm2;"
  568|   805k|        "ror    $0x2,%11;"
  569|   805k|        "add    %10,%12;"
  570|   805k|        "add    %16,%12;"
  571|   805k|        "movdqa %%xmm1,%%xmm3;"
  572|   805k|        "mov    %k2,%10;"
  573|   805k|        "add    %12,%6;"
  574|   805k|        "mov    %k2,%12;"
  575|   805k|        "pslld  $0x19,%%xmm1;"
  576|   805k|        "or     %8,%10;"
  577|   805k|        "add    %6,%9;"
  578|   805k|        "and    %8,%12;"
  579|   805k|        "psrld  $0x7,%%xmm2;"
  580|   805k|        "and    %7,%10;"
  581|   805k|        "add    %11,%6;"
  582|   805k|        "por    %%xmm2,%%xmm1;"
  583|   805k|        "or     %12,%10;"
  584|   805k|        "add    %10,%6;"
  585|   805k|        "movdqa %%xmm3,%%xmm2;"
  586|   805k|        "mov    %9,%10;"
  587|   805k|        "mov    %6,%11;"
  588|   805k|        "movdqa %%xmm3,%%xmm8;"
  589|   805k|        "ror    $0xe,%10;"
  590|   805k|        "xor    %9,%10;"
  591|   805k|        "mov    %3,%12;"
  592|   805k|        "ror    $0x9,%11;"
  593|   805k|        "pslld  $0xe,%%xmm3;"
  594|   805k|        "xor    %6,%11;"
  595|   805k|        "ror    $0x5,%10;"
  596|   805k|        "xor    %4,%12;"
  597|   805k|        "psrld  $0x12,%%xmm2;"
  598|   805k|        "ror    $0xb,%11;"
  599|   805k|        "xor    %9,%10;"
  600|   805k|        "and    %9,%12;"
  601|   805k|        "ror    $0x6,%10;"
  602|   805k|        "pxor   %%xmm3,%%xmm1;"
  603|   805k|        "xor    %6,%11;"
  604|   805k|        "xor    %4,%12;"
  605|   805k|        "psrld  $0x3,%%xmm8;"
  606|   805k|        "add    %10,%12;"
  607|   805k|        "add    4+%16,%12;"
  608|   805k|        "ror    $0x2,%11;"
  609|   805k|        "pxor   %%xmm2,%%xmm1;"
  610|   805k|        "mov    %6,%10;"
  611|   805k|        "add    %12,%5;"
  612|   805k|        "mov    %6,%12;"
  613|   805k|        "pxor   %%xmm8,%%xmm1;"
  614|   805k|        "or     %7,%10;"
  615|   805k|        "add    %5,%8;"
  616|   805k|        "and    %7,%12;"
  617|   805k|        "pshufd $0xfa,%%xmm6,%%xmm2;"
  618|   805k|        "and    %k2,%10;"
  619|   805k|        "add    %11,%5;"
  620|   805k|        "paddd  %%xmm1,%%xmm0;"
  621|   805k|        "or     %12,%10;"
  622|   805k|        "add    %10,%5;"
  623|   805k|        "movdqa %%xmm2,%%xmm3;"
  624|   805k|        "mov    %8,%10;"
  625|   805k|        "mov    %5,%11;"
  626|   805k|        "ror    $0xe,%10;"
  627|   805k|        "movdqa %%xmm2,%%xmm8;"
  628|   805k|        "xor    %8,%10;"
  629|   805k|        "ror    $0x9,%11;"
  630|   805k|        "mov    %9,%12;"
  631|   805k|        "xor    %5,%11;"
  632|   805k|        "ror    $0x5,%10;"
  633|   805k|        "psrlq  $0x11,%%xmm2;"
  634|   805k|        "xor    %3,%12;"
  635|   805k|        "psrlq  $0x13,%%xmm3;"
  636|   805k|        "xor    %8,%10;"
  637|   805k|        "and    %8,%12;"
  638|   805k|        "psrld  $0xa,%%xmm8;"
  639|   805k|        "ror    $0xb,%11;"
  640|   805k|        "xor    %5,%11;"
  641|   805k|        "xor    %3,%12;"
  642|   805k|        "ror    $0x6,%10;"
  643|   805k|        "pxor   %%xmm3,%%xmm2;"
  644|   805k|        "add    %10,%12;"
  645|   805k|        "ror    $0x2,%11;"
  646|   805k|        "add    8+%16,%12;"
  647|   805k|        "pxor   %%xmm2,%%xmm8;"
  648|   805k|        "mov    %5,%10;"
  649|   805k|        "add    %12,%4;"
  650|   805k|        "mov    %5,%12;"
  651|   805k|        "pshufb %%xmm10,%%xmm8;"
  652|   805k|        "or     %k2,%10;"
  653|   805k|        "add    %4,%7;"
  654|   805k|        "and    %k2,%12;"
  655|   805k|        "paddd  %%xmm8,%%xmm0;"
  656|   805k|        "and    %6,%10;"
  657|   805k|        "add    %11,%4;"
  658|   805k|        "pshufd $0x50,%%xmm0,%%xmm2;"
  659|   805k|        "or     %12,%10;"
  660|   805k|        "add    %10,%4;"
  661|   805k|        "movdqa %%xmm2,%%xmm3;"
  662|   805k|        "mov    %7,%10;"
  663|   805k|        "ror    $0xe,%10;"
  664|   805k|        "mov    %4,%11;"
  665|   805k|        "movdqa %%xmm2,%%xmm7;"
  666|   805k|        "ror    $0x9,%11;"
  667|   805k|        "xor    %7,%10;"
  668|   805k|        "mov    %8,%12;"
  669|   805k|        "ror    $0x5,%10;"
  670|   805k|        "psrlq  $0x11,%%xmm2;"
  671|   805k|        "xor    %4,%11;"
  672|   805k|        "xor    %9,%12;"
  673|   805k|        "psrlq  $0x13,%%xmm3;"
  674|   805k|        "xor    %7,%10;"
  675|   805k|        "and    %7,%12;"
  676|   805k|        "ror    $0xb,%11;"
  677|   805k|        "psrld  $0xa,%%xmm7;"
  678|   805k|        "xor    %4,%11;"
  679|   805k|        "ror    $0x6,%10;"
  680|   805k|        "xor    %9,%12;"
  681|   805k|        "pxor   %%xmm3,%%xmm2;"
  682|   805k|        "ror    $0x2,%11;"
  683|   805k|        "add    %10,%12;"
  684|   805k|        "add    12+%16,%12;"
  685|   805k|        "pxor   %%xmm2,%%xmm7;"
  686|   805k|        "mov    %4,%10;"
  687|   805k|        "add    %12,%3;"
  688|   805k|        "mov    %4,%12;"
  689|   805k|        "pshufb %%xmm11,%%xmm7;"
  690|   805k|        "or     %6,%10;"
  691|   805k|        "add    %3,%k2;"
  692|   805k|        "and    %6,%12;"
  693|   805k|        "paddd  %%xmm0,%%xmm7;"
  694|   805k|        "and    %5,%10;"
  695|   805k|        "add    %11,%3;"
  696|   805k|        "or     %12,%10;"
  697|   805k|        "add    %10,%3;"
  698|   805k|        "sub    $0x1,%1;"
  699|   805k|        "jne    Lloop1_%=;"
  700|   805k|        "mov    $0x2,%1;"
  701|       |
  702|   805k|        "Lloop2_%=:"
  703|   805k|        "paddd  0x0(%13),%%xmm4;"
  704|   805k|        "movdqa %%xmm4,%16;"
  705|   805k|        "mov    %k2,%10;"
  706|   805k|        "ror    $0xe,%10;"
  707|   805k|        "mov    %3,%11;"
  708|   805k|        "xor    %k2,%10;"
  709|   805k|        "ror    $0x9,%11;"
  710|   805k|        "mov    %7,%12;"
  711|   805k|        "xor    %3,%11;"
  712|   805k|        "ror    $0x5,%10;"
  713|   805k|        "xor    %8,%12;"
  714|   805k|        "xor    %k2,%10;"
  715|   805k|        "ror    $0xb,%11;"
  716|   805k|        "and    %k2,%12;"
  717|   805k|        "xor    %3,%11;"
  718|   805k|        "ror    $0x6,%10;"
  719|   805k|        "xor    %8,%12;"
  720|   805k|        "add    %10,%12;"
  721|   805k|        "ror    $0x2,%11;"
  722|   805k|        "add    %16,%12;"
  723|   805k|        "mov    %3,%10;"
  724|   805k|        "add    %12,%9;"
  725|   805k|        "mov    %3,%12;"
  726|   805k|        "or     %5,%10;"
  727|   805k|        "add    %9,%6;"
  728|   805k|        "and    %5,%12;"
  729|   805k|        "and    %4,%10;"
  730|   805k|        "add    %11,%9;"
  731|   805k|        "or     %12,%10;"
  732|   805k|        "add    %10,%9;"
  733|   805k|        "mov    %6,%10;"
  734|   805k|        "ror    $0xe,%10;"
  735|   805k|        "mov    %9,%11;"
  736|   805k|        "xor    %6,%10;"
  737|   805k|        "ror    $0x9,%11;"
  738|   805k|        "mov    %k2,%12;"
  739|   805k|        "xor    %9,%11;"
  740|   805k|        "ror    $0x5,%10;"
  741|   805k|        "xor    %7,%12;"
  742|   805k|        "xor    %6,%10;"
  743|   805k|        "ror    $0xb,%11;"
  744|   805k|        "and    %6,%12;"
  745|   805k|        "xor    %9,%11;"
  746|   805k|        "ror    $0x6,%10;"
  747|   805k|        "xor    %7,%12;"
  748|   805k|        "add    %10,%12;"
  749|   805k|        "ror    $0x2,%11;"
  750|   805k|        "add    4+%16,%12;"
  751|   805k|        "mov    %9,%10;"
  752|   805k|        "add    %12,%8;"
  753|   805k|        "mov    %9,%12;"
  754|   805k|        "or     %4,%10;"
  755|   805k|        "add    %8,%5;"
  756|   805k|        "and    %4,%12;"
  757|   805k|        "and    %3,%10;"
  758|   805k|        "add    %11,%8;"
  759|   805k|        "or     %12,%10;"
  760|   805k|        "add    %10,%8;"
  761|   805k|        "mov    %5,%10;"
  762|   805k|        "ror    $0xe,%10;"
  763|   805k|        "mov    %8,%11;"
  764|   805k|        "xor    %5,%10;"
  765|   805k|        "ror    $0x9,%11;"
  766|   805k|        "mov    %6,%12;"
  767|   805k|        "xor    %8,%11;"
  768|   805k|        "ror    $0x5,%10;"
  769|   805k|        "xor    %k2,%12;"
  770|   805k|        "xor    %5,%10;"
  771|   805k|        "ror    $0xb,%11;"
  772|   805k|        "and    %5,%12;"
  773|   805k|        "xor    %8,%11;"
  774|   805k|        "ror    $0x6,%10;"
  775|   805k|        "xor    %k2,%12;"
  776|   805k|        "add    %10,%12;"
  777|   805k|        "ror    $0x2,%11;"
  778|   805k|        "add    8+%16,%12;"
  779|   805k|        "mov    %8,%10;"
  780|   805k|        "add    %12,%7;"
  781|   805k|        "mov    %8,%12;"
  782|   805k|        "or     %3,%10;"
  783|   805k|        "add    %7,%4;"
  784|   805k|        "and    %3,%12;"
  785|   805k|        "and    %9,%10;"
  786|   805k|        "add    %11,%7;"
  787|   805k|        "or     %12,%10;"
  788|   805k|        "add    %10,%7;"
  789|   805k|        "mov    %4,%10;"
  790|   805k|        "ror    $0xe,%10;"
  791|   805k|        "mov    %7,%11;"
  792|   805k|        "xor    %4,%10;"
  793|   805k|        "ror    $0x9,%11;"
  794|   805k|        "mov    %5,%12;"
  795|   805k|        "xor    %7,%11;"
  796|   805k|        "ror    $0x5,%10;"
  797|   805k|        "xor    %6,%12;"
  798|   805k|        "xor    %4,%10;"
  799|   805k|        "ror    $0xb,%11;"
  800|   805k|        "and    %4,%12;"
  801|   805k|        "xor    %7,%11;"
  802|   805k|        "ror    $0x6,%10;"
  803|   805k|        "xor    %6,%12;"
  804|   805k|        "add    %10,%12;"
  805|   805k|        "ror    $0x2,%11;"
  806|   805k|        "add    12+%16,%12;"
  807|   805k|        "mov    %7,%10;"
  808|   805k|        "add    %12,%k2;"
  809|   805k|        "mov    %7,%12;"
  810|   805k|        "or     %9,%10;"
  811|   805k|        "add    %k2,%3;"
  812|   805k|        "and    %9,%12;"
  813|   805k|        "and    %8,%10;"
  814|   805k|        "add    %11,%k2;"
  815|   805k|        "or     %12,%10;"
  816|   805k|        "add    %10,%k2;"
  817|   805k|        "paddd  0x10(%13),%%xmm5;"
  818|   805k|        "movdqa %%xmm5,%16;"
  819|   805k|        "add    $0x20,%13;"
  820|   805k|        "mov    %3,%10;"
  821|   805k|        "ror    $0xe,%10;"
  822|   805k|        "mov    %k2,%11;"
  823|   805k|        "xor    %3,%10;"
  824|   805k|        "ror    $0x9,%11;"
  825|   805k|        "mov    %4,%12;"
  826|   805k|        "xor    %k2,%11;"
  827|   805k|        "ror    $0x5,%10;"
  828|   805k|        "xor    %5,%12;"
  829|   805k|        "xor    %3,%10;"
  830|   805k|        "ror    $0xb,%11;"
  831|   805k|        "and    %3,%12;"
  832|   805k|        "xor    %k2,%11;"
  833|   805k|        "ror    $0x6,%10;"
  834|   805k|        "xor    %5,%12;"
  835|   805k|        "add    %10,%12;"
  836|   805k|        "ror    $0x2,%11;"
  837|   805k|        "add    %16,%12;"
  838|   805k|        "mov    %k2,%10;"
  839|   805k|        "add    %12,%6;"
  840|   805k|        "mov    %k2,%12;"
  841|   805k|        "or     %8,%10;"
  842|   805k|        "add    %6,%9;"
  843|   805k|        "and    %8,%12;"
  844|   805k|        "and    %7,%10;"
  845|   805k|        "add    %11,%6;"
  846|   805k|        "or     %12,%10;"
  847|   805k|        "add    %10,%6;"
  848|   805k|        "mov    %9,%10;"
  849|   805k|        "ror    $0xe,%10;"
  850|   805k|        "mov    %6,%11;"
  851|   805k|        "xor    %9,%10;"
  852|   805k|        "ror    $0x9,%11;"
  853|   805k|        "mov    %3,%12;"
  854|   805k|        "xor    %6,%11;"
  855|   805k|        "ror    $0x5,%10;"
  856|   805k|        "xor    %4,%12;"
  857|   805k|        "xor    %9,%10;"
  858|   805k|        "ror    $0xb,%11;"
  859|   805k|        "and    %9,%12;"
  860|   805k|        "xor    %6,%11;"
  861|   805k|        "ror    $0x6,%10;"
  862|   805k|        "xor    %4,%12;"
  863|   805k|        "add    %10,%12;"
  864|   805k|        "ror    $0x2,%11;"
  865|   805k|        "add    4+%16,%12;"
  866|   805k|        "mov    %6,%10;"
  867|   805k|        "add    %12,%5;"
  868|   805k|        "mov    %6,%12;"
  869|   805k|        "or     %7,%10;"
  870|   805k|        "add    %5,%8;"
  871|   805k|        "and    %7,%12;"
  872|   805k|        "and    %k2,%10;"
  873|   805k|        "add    %11,%5;"
  874|   805k|        "or     %12,%10;"
  875|   805k|        "add    %10,%5;"
  876|   805k|        "mov    %8,%10;"
  877|   805k|        "ror    $0xe,%10;"
  878|   805k|        "mov    %5,%11;"
  879|   805k|        "xor    %8,%10;"
  880|   805k|        "ror    $0x9,%11;"
  881|   805k|        "mov    %9,%12;"
  882|   805k|        "xor    %5,%11;"
  883|   805k|        "ror    $0x5,%10;"
  884|   805k|        "xor    %3,%12;"
  885|   805k|        "xor    %8,%10;"
  886|   805k|        "ror    $0xb,%11;"
  887|   805k|        "and    %8,%12;"
  888|   805k|        "xor    %5,%11;"
  889|   805k|        "ror    $0x6,%10;"
  890|   805k|        "xor    %3,%12;"
  891|   805k|        "add    %10,%12;"
  892|   805k|        "ror    $0x2,%11;"
  893|   805k|        "add    8+%16,%12;"
  894|   805k|        "mov    %5,%10;"
  895|   805k|        "add    %12,%4;"
  896|   805k|        "mov    %5,%12;"
  897|   805k|        "or     %k2,%10;"
  898|   805k|        "add    %4,%7;"
  899|   805k|        "and    %k2,%12;"
  900|   805k|        "and    %6,%10;"
  901|   805k|        "add    %11,%4;"
  902|   805k|        "or     %12,%10;"
  903|   805k|        "add    %10,%4;"
  904|   805k|        "mov    %7,%10;"
  905|   805k|        "ror    $0xe,%10;"
  906|   805k|        "mov    %4,%11;"
  907|   805k|        "xor    %7,%10;"
  908|   805k|        "ror    $0x9,%11;"
  909|   805k|        "mov    %8,%12;"
  910|   805k|        "xor    %4,%11;"
  911|   805k|        "ror    $0x5,%10;"
  912|   805k|        "xor    %9,%12;"
  913|   805k|        "xor    %7,%10;"
  914|   805k|        "ror    $0xb,%11;"
  915|   805k|        "and    %7,%12;"
  916|   805k|        "xor    %4,%11;"
  917|   805k|        "ror    $0x6,%10;"
  918|   805k|        "xor    %9,%12;"
  919|   805k|        "add    %10,%12;"
  920|   805k|        "ror    $0x2,%11;"
  921|   805k|        "add    12+%16,%12;"
  922|   805k|        "mov    %4,%10;"
  923|   805k|        "add    %12,%3;"
  924|   805k|        "mov    %4,%12;"
  925|   805k|        "or     %6,%10;"
  926|   805k|        "add    %3,%k2;"
  927|   805k|        "and    %6,%12;"
  928|   805k|        "and    %5,%10;"
  929|   805k|        "add    %11,%3;"
  930|   805k|        "or     %12,%10;"
  931|   805k|        "add    %10,%3;"
  932|   805k|        "movdqa %%xmm6,%%xmm4;"
  933|   805k|        "movdqa %%xmm7,%%xmm5;"
  934|   805k|        "sub    $0x1,%1;"
  935|   805k|        "jne    Lloop2_%=;"
  936|   805k|        "add    (%0),%3;"
  937|   805k|        "mov    %3,(%0);"
  938|   805k|        "add    0x4(%0),%4;"
  939|   805k|        "mov    %4,0x4(%0);"
  940|   805k|        "add    0x8(%0),%5;"
  941|   805k|        "mov    %5,0x8(%0);"
  942|   805k|        "add    0xc(%0),%6;"
  943|   805k|        "mov    %6,0xc(%0);"
  944|   805k|        "add    0x10(%0),%k2;"
  945|   805k|        "mov    %k2,0x10(%0);"
  946|   805k|        "add    0x14(%0),%7;"
  947|   805k|        "mov    %7,0x14(%0);"
  948|   805k|        "add    0x18(%0),%8;"
  949|   805k|        "mov    %8,0x18(%0);"
  950|   805k|        "add    0x1c(%0),%9;"
  951|   805k|        "mov    %9,0x1c(%0);"
  952|   805k|        "mov    %15,%1;"
  953|   805k|        "add    $0x40,%1;"
  954|   805k|        "cmp    %14,%1;"
  955|   805k|        "jne    Lloop0_%=;"
  956|       |
  957|   805k|        "Ldone_hash_%=:"
  958|       |
  959|   805k|        : "+r"(s), "+r"(chunk), "+r"(blocks), "=r"(a), "=r"(b), "=r"(c), "=r"(d), /* e = chunk */ "=r"(f), "=r"(g), "=r"(h), "=r"(y0), "=r"(y1), "=r"(y2), "=r"(tbl), "+m"(inp_end), "+m"(inp), "+m"(xfer)
  960|   805k|        : "m"(K256), "m"(FLIP_MASK), "m"(SHUF_00BA), "m"(SHUF_DC00)
  961|   805k|        : "cc", "memory", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7", "xmm8", "xmm9", "xmm10", "xmm11", "xmm12"
  962|   805k|   );
  963|   805k|}

_Z19SipHashUint256ExtrammRK7uint256j:
  136|  3.67M|{
  137|       |    /* Specialized implementation for efficiency */
  138|  3.67M|    uint64_t d = val.GetUint64(0);
  139|       |
  140|  3.67M|    uint64_t v0 = 0x736f6d6570736575ULL ^ k0;
  141|  3.67M|    uint64_t v1 = 0x646f72616e646f6dULL ^ k1;
  142|  3.67M|    uint64_t v2 = 0x6c7967656e657261ULL ^ k0;
  143|  3.67M|    uint64_t v3 = 0x7465646279746573ULL ^ k1 ^ d;
  144|       |
  145|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  146|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  147|  3.67M|    v0 ^= d;
  148|  3.67M|    d = val.GetUint64(1);
  149|  3.67M|    v3 ^= d;
  150|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  151|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  152|  3.67M|    v0 ^= d;
  153|  3.67M|    d = val.GetUint64(2);
  154|  3.67M|    v3 ^= d;
  155|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  156|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  157|  3.67M|    v0 ^= d;
  158|  3.67M|    d = val.GetUint64(3);
  159|  3.67M|    v3 ^= d;
  160|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  161|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  162|  3.67M|    v0 ^= d;
  163|  3.67M|    d = ((uint64_t{36}) << 56) | extra;
  164|  3.67M|    v3 ^= d;
  165|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  166|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  167|  3.67M|    v0 ^= d;
  168|  3.67M|    v2 ^= 0xFF;
  169|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  170|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  171|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  172|  3.67M|    SIPROUND;
  ------------------
  |  |    9|  3.67M|#define SIPROUND do { \
  |  |   10|  3.67M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  3.67M|    v0 = std::rotl(v0, 32); \
  |  |   12|  3.67M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  3.67M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  3.67M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  3.67M|    v2 = std::rotl(v2, 32); \
  |  |   16|  3.67M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  173|  3.67M|    return v0 ^ v1 ^ v2 ^ v3;
  174|  3.67M|}

_ZN8CHash2568FinalizeE4SpanIhE:
   30|  1.76k|    void Finalize(Span<unsigned char> output) {
   31|  1.76k|        assert(output.size() == OUTPUT_SIZE);
   32|  1.76k|        unsigned char buf[CSHA256::OUTPUT_SIZE];
   33|  1.76k|        sha.Finalize(buf);
   34|  1.76k|        sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
   35|  1.76k|    }
_ZN8CHash2565WriteE4SpanIKhE:
   37|  1.76k|    CHash256& Write(Span<const unsigned char> input) {
   38|  1.76k|        sha.Write(input.data(), input.size());
   39|  1.76k|        return *this;
   40|  1.76k|    }
_ZN8CHash1608FinalizeE4SpanIhE:
   55|    638|    void Finalize(Span<unsigned char> output) {
   56|    638|        assert(output.size() == OUTPUT_SIZE);
   57|    638|        unsigned char buf[CSHA256::OUTPUT_SIZE];
   58|    638|        sha.Finalize(buf);
   59|    638|        CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
   60|    638|    }
_ZN8CHash1605WriteE4SpanIKhE:
   62|    638|    CHash160& Write(Span<const unsigned char> input) {
   63|    638|        sha.Write(input.data(), input.size());
   64|    638|        return *this;
   65|    638|    }
_ZN10HashWriter5writeE4SpanIKSt4byteE:
  107|  10.6M|    {
  108|  10.6M|        ctx.Write(UCharCast(src.data()), src.size());
  109|  10.6M|    }
_ZN10HashWriter7GetHashEv:
  115|  14.4k|    uint256 GetHash() {
  116|  14.4k|        uint256 result;
  117|  14.4k|        ctx.Finalize(result.begin());
  118|  14.4k|        ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin());
  119|  14.4k|        return result;
  120|  14.4k|    }
_ZN10HashWriterlsI13ParamsWrapperI20TransactionSerParamsK12CTransactionEEERS_RKT_:
  142|  14.4k|    {
  143|  14.4k|        ::Serialize(*this, obj);
  144|  14.4k|        return *this;
  145|  14.4k|    }

_ZN10interfaces5ChainD2Ev:
  131|      2|    virtual ~Chain() = default;

_ZN11ECC_ContextD2Ev:
  482|      2|{
  483|      2|    ECC_Stop();
  484|      2|}
key.cpp:_ZL8ECC_Stopv:
  467|      2|static void ECC_Stop() {
  468|      2|    secp256k1_context *ctx = secp256k1_context_sign;
  469|      2|    secp256k1_context_sign = nullptr;
  470|       |
  471|      2|    if (ctx) {
  ------------------
  |  Branch (471:9): [True: 2, False: 0]
  ------------------
  472|      2|        secp256k1_context_destroy(ctx);
  473|      2|    }
  474|      2|}

_Z11LogInstancev:
   25|      2|{
   26|       |/**
   27|       | * NOTE: the logger instances is leaked on exit. This is ugly, but will be
   28|       | * cleaned up by the OS/libc. Defining a logger as a global object doesn't work
   29|       | * since the order of destruction of static/global objects is undefined.
   30|       | * Consider if the logger gets destroyed, and then some later destructor calls
   31|       | * LogPrintf, maybe indirectly, and you get a core dump at shutdown trying to
   32|       | * access the logger. When the shutdown sequence is fully audited and tested,
   33|       | * explicit destruction of these objects can be implemented by changing this
   34|       | * from a raw pointer to a std::unique_ptr.
   35|       | * Since the ~Logger() destructor is never called, the Logger class and all
   36|       | * its subclasses must have implicitly-defined destructors.
   37|       | *
   38|       | * This method of initialization was originally introduced in
   39|       | * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c.
   40|       | */
   41|      2|    static BCLog::Logger* g_logger{new BCLog::Logger()};
   42|      2|    return *g_logger;
   43|      2|}
_ZN5BCLog6Logger20DisconnectTestLoggerEv:
   97|      2|{
   98|      2|    StdLockGuard scoped_lock(m_cs);
   99|      2|    m_buffering = true;
  100|      2|    if (m_fileout != nullptr) fclose(m_fileout);
  ------------------
  |  Branch (100:9): [True: 0, False: 2]
  ------------------
  101|      2|    m_fileout = nullptr;
  102|      2|    m_print_callbacks.clear();
  103|      2|    m_max_buffer_memusage = DEFAULT_MAX_LOG_BUFFER;
  104|      2|    m_cur_buffer_memusage = 0;
  105|      2|    m_buffer_lines_discarded = 0;
  106|      2|    m_msgs_before_open.clear();
  107|      2|}

coins_view.cpp:_ZN8memusageL12DynamicUsageILj28EhjiEEmRK9prevectorIXT_ET0_T1_T2_E:
  108|   118k|{
  109|   118k|    return MallocUsage(v.allocated_memory());
  110|   118k|}
coins_view.cpp:_ZN8memusageL11MallocUsageEm:
   53|   118k|{
   54|       |    // Measured on libc6 2.19 on Linux.
   55|   118k|    if (alloc == 0) {
  ------------------
  |  Branch (55:9): [True: 66.0k, False: 52.3k]
  ------------------
   56|  66.0k|        return 0;
   57|  66.0k|    } else if (sizeof(void*) == 8) {
  ------------------
  |  Branch (57:16): [Folded - Ignored]
  ------------------
   58|  52.3k|        return ((alloc + 31) >> 4) << 4;
   59|  52.3k|    } else if (sizeof(void*) == 4) {
  ------------------
  |  Branch (59:16): [Folded - Ignored]
  ------------------
   60|      0|        return ((alloc + 15) >> 3) << 3;
   61|      0|    } else {
   62|      0|        assert(0);
   63|      0|    }
   64|   118k|}
coins.cpp:_ZN8memusageL12DynamicUsageILj28EhjiEEmRK9prevectorIXT_ET0_T1_T2_E:
  108|  1.26M|{
  109|  1.26M|    return MallocUsage(v.allocated_memory());
  110|  1.26M|}
coins.cpp:_ZN8memusageL11MallocUsageEm:
   53|  1.29M|{
   54|       |    // Measured on libc6 2.19 on Linux.
   55|  1.29M|    if (alloc == 0) {
  ------------------
  |  Branch (55:9): [True: 1.23M, False: 54.0k]
  ------------------
   56|  1.23M|        return 0;
   57|  1.23M|    } else if (sizeof(void*) == 8) {
  ------------------
  |  Branch (57:16): [Folded - Ignored]
  ------------------
   58|  54.0k|        return ((alloc + 31) >> 4) << 4;
   59|  54.0k|    } else if (sizeof(void*) == 4) {
  ------------------
  |  Branch (59:16): [Folded - Ignored]
  ------------------
   60|      0|        return ((alloc + 15) >> 3) << 3;
   61|      0|    } else {
   62|      0|        assert(0);
   63|      0|    }
   64|  1.29M|}
coins.cpp:_ZN8memusageL12DynamicUsageI9COutPoint16CCoinsCacheEntry20SaltedOutpointHasherNSt3__18equal_toIS1_EELm144ELm8EEEmRKNS4_13unordered_mapIT_T0_T1_T2_13PoolAllocatorINS4_4pairIKS8_S9_EEXT3_EXT4_EEEE:
  207|  8.67k|{
  208|  8.67k|    auto* pool_resource = m.get_allocator().resource();
  209|       |
  210|       |    // The allocated chunks are stored in a std::list. Size per node should
  211|       |    // therefore be 3 pointers: next, previous, and a pointer to the chunk.
  212|  8.67k|    size_t estimated_list_node_size = MallocUsage(sizeof(void*) * 3);
  213|  8.67k|    size_t usage_resource = estimated_list_node_size * pool_resource->NumAllocatedChunks();
  214|  8.67k|    size_t usage_chunks = MallocUsage(pool_resource->ChunkSizeBytes()) * pool_resource->NumAllocatedChunks();
  215|  8.67k|    return usage_resource + usage_chunks + MallocUsage(sizeof(void*) * m.bucket_count());
  216|  8.67k|}

_ZN4node11NodeContextD2Ev:
   26|      2|NodeContext::~NodeContext() = default;

_Z17AreInputsStandardRK12CTransactionRK15CCoinsViewCache:
  190|  2.80k|{
  191|  2.80k|    if (tx.IsCoinBase()) {
  ------------------
  |  Branch (191:9): [True: 1, False: 2.80k]
  ------------------
  192|      1|        return true; // Coinbases don't use vin normally
  193|      1|    }
  194|       |
  195|  5.76k|    for (unsigned int i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (195:30): [True: 5.67k, False: 86]
  ------------------
  196|  5.67k|        const CTxOut& prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
  197|       |
  198|  5.67k|        std::vector<std::vector<unsigned char> > vSolutions;
  199|  5.67k|        TxoutType whichType = Solver(prev.scriptPubKey, vSolutions);
  200|  5.67k|        if (whichType == TxoutType::NONSTANDARD || whichType == TxoutType::WITNESS_UNKNOWN) {
  ------------------
  |  Branch (200:13): [True: 1.02k, False: 4.65k]
  |  Branch (200:52): [True: 8, False: 4.64k]
  ------------------
  201|       |            // WITNESS_UNKNOWN failures are typically also caught with a policy
  202|       |            // flag in the script interpreter, but it can be helpful to catch
  203|       |            // this type of NONSTANDARD transaction earlier in transaction
  204|       |            // validation.
  205|  1.03k|            return false;
  206|  4.64k|        } else if (whichType == TxoutType::SCRIPTHASH) {
  ------------------
  |  Branch (206:20): [True: 2.57k, False: 2.07k]
  ------------------
  207|  2.57k|            std::vector<std::vector<unsigned char> > stack;
  208|       |            // convert the scriptSig into a stack, so we can inspect the redeemScript
  209|  2.57k|            if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
  ------------------
  |  Branch (209:17): [True: 1.65k, False: 916]
  ------------------
  210|  1.65k|                return false;
  211|    916|            if (stack.empty())
  ------------------
  |  Branch (211:17): [True: 6, False: 910]
  ------------------
  212|      6|                return false;
  213|    910|            CScript subscript(stack.back().begin(), stack.back().end());
  214|    910|            if (subscript.GetSigOpCount(true) > MAX_P2SH_SIGOPS) {
  ------------------
  |  Branch (214:17): [True: 23, False: 887]
  ------------------
  215|     23|                return false;
  216|     23|            }
  217|    910|        }
  218|  5.67k|    }
  219|       |
  220|     86|    return true;
  221|  2.80k|}
_Z17IsWitnessStandardRK12CTransactionRK15CCoinsViewCache:
  224|    258|{
  225|    258|    if (tx.IsCoinBase())
  ------------------
  |  Branch (225:9): [True: 1, False: 257]
  ------------------
  226|      1|        return true; // Coinbases are skipped
  227|       |
  228|  2.67k|    for (unsigned int i = 0; i < tx.vin.size(); i++)
  ------------------
  |  Branch (228:30): [True: 2.51k, False: 154]
  ------------------
  229|  2.51k|    {
  230|       |        // We don't care if witness for this input is empty, since it must not be bloated.
  231|       |        // If the script is invalid without witness, it would be caught sooner or later during validation.
  232|  2.51k|        if (tx.vin[i].scriptWitness.IsNull())
  ------------------
  |  Branch (232:13): [True: 522, False: 1.99k]
  ------------------
  233|    522|            continue;
  234|       |
  235|  1.99k|        const CTxOut &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
  236|       |
  237|       |        // get the scriptPubKey corresponding to this input:
  238|  1.99k|        CScript prevScript = prev.scriptPubKey;
  239|       |
  240|       |        // witness stuffing detected
  241|  1.99k|        if (prevScript.IsPayToAnchor()) {
  ------------------
  |  Branch (241:13): [True: 1, False: 1.99k]
  ------------------
  242|      1|            return false;
  243|      1|        }
  244|       |
  245|  1.99k|        bool p2sh = false;
  246|  1.99k|        if (prevScript.IsPayToScriptHash()) {
  ------------------
  |  Branch (246:13): [True: 21, False: 1.97k]
  ------------------
  247|     21|            std::vector <std::vector<unsigned char> > stack;
  248|       |            // If the scriptPubKey is P2SH, we try to extract the redeemScript casually by converting the scriptSig
  249|       |            // into a stack. We do not check IsPushOnly nor compare the hash as these will be done later anyway.
  250|       |            // If the check fails at this stage, we know that this txid must be a bad one.
  251|     21|            if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
  ------------------
  |  Branch (251:17): [True: 4, False: 17]
  ------------------
  252|      4|                return false;
  253|     17|            if (stack.empty())
  ------------------
  |  Branch (253:17): [True: 2, False: 15]
  ------------------
  254|      2|                return false;
  255|     15|            prevScript = CScript(stack.back().begin(), stack.back().end());
  256|     15|            p2sh = true;
  257|     15|        }
  258|       |
  259|  1.99k|        int witnessversion = 0;
  260|  1.99k|        std::vector<unsigned char> witnessprogram;
  261|       |
  262|       |        // Non-witness program must not be associated with any witness
  263|  1.99k|        if (!prevScript.IsWitnessProgram(witnessversion, witnessprogram))
  ------------------
  |  Branch (263:13): [True: 81, False: 1.90k]
  ------------------
  264|     81|            return false;
  265|       |
  266|       |        // Check P2WSH standard limits
  267|  1.90k|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
  ------------------
  |  Branch (267:13): [True: 769, False: 1.14k]
  |  Branch (267:36): [True: 549, False: 220]
  ------------------
  268|    549|            if (tx.vin[i].scriptWitness.stack.back().size() > MAX_STANDARD_P2WSH_SCRIPT_SIZE)
  ------------------
  |  Branch (268:17): [True: 2, False: 547]
  ------------------
  269|      2|                return false;
  270|    547|            size_t sizeWitnessStack = tx.vin[i].scriptWitness.stack.size() - 1;
  271|    547|            if (sizeWitnessStack > MAX_STANDARD_P2WSH_STACK_ITEMS)
  ------------------
  |  Branch (271:17): [True: 2, False: 545]
  ------------------
  272|      2|                return false;
  273|  2.20k|            for (unsigned int j = 0; j < sizeWitnessStack; j++) {
  ------------------
  |  Branch (273:38): [True: 1.65k, False: 542]
  ------------------
  274|  1.65k|                if (tx.vin[i].scriptWitness.stack[j].size() > MAX_STANDARD_P2WSH_STACK_ITEM_SIZE)
  ------------------
  |  Branch (274:21): [True: 3, False: 1.65k]
  ------------------
  275|      3|                    return false;
  276|  1.65k|            }
  277|    545|        }
  278|       |
  279|       |        // Check policy limits for Taproot spends:
  280|       |        // - MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE limit for stack item size
  281|       |        // - No annexes
  282|  1.90k|        if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE && !p2sh) {
  ------------------
  |  Branch (282:13): [True: 898, False: 1.00k]
  |  Branch (282:36): [True: 652, False: 246]
  |  Branch (282:88): [True: 652, False: 0]
  ------------------
  283|       |            // Taproot spend (non-P2SH-wrapped, version 1, witness program size 32; see BIP 341)
  284|    652|            Span stack{tx.vin[i].scriptWitness.stack};
  285|    652|            if (stack.size() >= 2 && !stack.back().empty() && stack.back()[0] == ANNEX_TAG) {
  ------------------
  |  Branch (285:17): [True: 262, False: 390]
  |  Branch (285:38): [True: 260, False: 2]
  |  Branch (285:63): [True: 2, False: 258]
  ------------------
  286|       |                // Annexes are nonstandard as long as no semantics are defined for them.
  287|      2|                return false;
  288|      2|            }
  289|    650|            if (stack.size() >= 2) {
  ------------------
  |  Branch (289:17): [True: 260, False: 390]
  ------------------
  290|       |                // Script path spend (2 or more stack elements after removing optional annex)
  291|    260|                const auto& control_block = SpanPopBack(stack);
  292|    260|                SpanPopBack(stack); // Ignore script
  293|    260|                if (control_block.empty()) return false; // Empty control block is invalid
  ------------------
  |  Branch (293:21): [True: 2, False: 258]
  ------------------
  294|    258|                if ((control_block[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT) {
  ------------------
  |  Branch (294:21): [True: 31, False: 227]
  ------------------
  295|       |                    // Leaf version 0xc0 (aka Tapscript, see BIP 342)
  296|    327|                    for (const auto& item : stack) {
  ------------------
  |  Branch (296:43): [True: 327, False: 27]
  ------------------
  297|    327|                        if (item.size() > MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE) return false;
  ------------------
  |  Branch (297:29): [True: 4, False: 323]
  ------------------
  298|    327|                    }
  299|     31|                }
  300|    390|            } else if (stack.size() == 1) {
  ------------------
  |  Branch (300:24): [True: 390, False: 0]
  ------------------
  301|       |                // Key path spend (1 stack element after removing optional annex)
  302|       |                // (no policy rules apply)
  303|    390|            } else {
  304|       |                // 0 stack elements; this is already invalid by consensus rules
  305|      0|                return false;
  306|      0|            }
  307|    650|        }
  308|  1.90k|    }
  309|    154|    return true;
  310|    257|}

_ZN9prevectorILj28EhjiE3endEv:
  304|  3.90M|    iterator end() { return iterator(item_ptr(size())); }
_ZN9prevectorILj28EhjiE8item_ptrEi:
  206|  20.6M|    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (206:47): [True: 9.34M, False: 11.2M]
  ------------------
_ZNK9prevectorILj28EhjiE9is_directEv:
  173|   156M|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj28EhjiE10direct_ptrEi:
  169|  9.52M|    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
_ZN9prevectorILj28EhjiE12indirect_ptrEi:
  171|  11.2M|    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
_ZN9prevectorILj28EhjiE6insertENS0_8iteratorERKh:
  359|  9.17k|    iterator insert(iterator pos, const T& value) {
  360|  9.17k|        size_type p = pos - begin();
  361|  9.17k|        size_type new_size = size() + 1;
  362|  9.17k|        if (capacity() < new_size) {
  ------------------
  |  Branch (362:13): [True: 0, False: 9.17k]
  ------------------
  363|      0|            change_capacity(new_size + (new_size >> 1));
  364|      0|        }
  365|  9.17k|        T* ptr = item_ptr(p);
  366|  9.17k|        T* dst = ptr + 1;
  367|  9.17k|        memmove(dst, ptr, (size() - p) * sizeof(T));
  368|  9.17k|        _size++;
  369|  9.17k|        new(static_cast<void*>(ptr)) T(value);
  370|  9.17k|        return iterator(ptr);
  371|  9.17k|    }
_ZN9prevectorILj28EhjiE5beginEv:
  302|  3.88M|    iterator begin() { return iterator(item_ptr(0)); }
_ZmiN9prevectorILj28EhjiE8iteratorES1_:
   66|  3.88M|        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
_ZNK9prevectorILj28EhjiE8iteratordeEv:
   59|  7.84M|        T& operator*() const { return *ptr; }
_ZNK9prevectorILj28EhjiE8capacityEv:
  312|  4.33M|    size_t capacity() const {
  313|  4.33M|        if (is_direct()) {
  ------------------
  |  Branch (313:13): [True: 644k, False: 3.68M]
  ------------------
  314|   644k|            return N;
  315|  3.68M|        } else {
  316|  3.68M|            return _union.indirect_contents.capacity;
  317|  3.68M|        }
  318|  4.33M|    }
_ZN9prevectorILj28EhjiE15change_capacityEj:
  175|  13.1M|    void change_capacity(size_type new_capacity) {
  176|  13.1M|        if (new_capacity <= N) {
  ------------------
  |  Branch (176:13): [True: 12.9M, False: 216k]
  ------------------
  177|  12.9M|            if (!is_direct()) {
  ------------------
  |  Branch (177:17): [True: 509, False: 12.9M]
  ------------------
  178|    509|                T* indirect = indirect_ptr(0);
  179|    509|                T* src = indirect;
  180|    509|                T* dst = direct_ptr(0);
  181|    509|                memcpy(dst, src, size() * sizeof(T));
  182|    509|                free(indirect);
  183|    509|                _size -= N + 1;
  184|    509|            }
  185|  12.9M|        } else {
  186|   216k|            if (!is_direct()) {
  ------------------
  |  Branch (186:17): [True: 42.2k, False: 174k]
  ------------------
  187|       |                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
  188|       |                    success. These should instead use an allocator or new/delete so that handlers
  189|       |                    are called as necessary, but performance would be slightly degraded by doing so. */
  190|  42.2k|                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
  191|  42.2k|                assert(_union.indirect_contents.indirect);
  192|  42.2k|                _union.indirect_contents.capacity = new_capacity;
  193|   174k|            } else {
  194|   174k|                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
  195|   174k|                assert(new_indirect);
  196|   174k|                T* src = direct_ptr(0);
  197|   174k|                T* dst = reinterpret_cast<T*>(new_indirect);
  198|   174k|                memcpy(dst, src, size() * sizeof(T));
  199|   174k|                _union.indirect_contents.indirect = new_indirect;
  200|   174k|                _union.indirect_contents.capacity = new_capacity;
  201|   174k|                _size += N + 1;
  202|   174k|            }
  203|   216k|        }
  204|  13.1M|    }
_ZN9prevectorILj28EhjiE6insertITkNSt3__114input_iteratorEPKhEEvNS0_8iteratorET_S6_:
  387|    125|    void insert(iterator pos, InputIterator first, InputIterator last) {
  388|    125|        size_type p = pos - begin();
  389|    125|        difference_type count = last - first;
  390|    125|        size_type new_size = size() + count;
  391|    125|        if (capacity() < new_size) {
  ------------------
  |  Branch (391:13): [True: 0, False: 125]
  ------------------
  392|      0|            change_capacity(new_size + (new_size >> 1));
  393|      0|        }
  394|    125|        T* ptr = item_ptr(p);
  395|    125|        T* dst = ptr + count;
  396|    125|        memmove(dst, ptr, (size() - p) * sizeof(T));
  397|    125|        _size += count;
  398|    125|        fill(ptr, first, last);
  399|    125|    }
_ZN9prevectorILj28EhjiE4fillITkNSt3__114input_iteratorEPKhEEvPhT_S6_:
  214|    125|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|    375|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 250, False: 125]
  ------------------
  216|    250|            new(static_cast<void*>(dst)) T(*first);
  217|    250|            ++dst;
  218|    250|            ++first;
  219|    250|        }
  220|    125|    }
_ZN9prevectorILj28EhjiE6insertITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEEvNS0_8iteratorET_S8_:
  387|  8.83k|    void insert(iterator pos, InputIterator first, InputIterator last) {
  388|  8.83k|        size_type p = pos - begin();
  389|  8.83k|        difference_type count = last - first;
  390|  8.83k|        size_type new_size = size() + count;
  391|  8.83k|        if (capacity() < new_size) {
  ------------------
  |  Branch (391:13): [True: 1.20k, False: 7.62k]
  ------------------
  392|  1.20k|            change_capacity(new_size + (new_size >> 1));
  393|  1.20k|        }
  394|  8.83k|        T* ptr = item_ptr(p);
  395|  8.83k|        T* dst = ptr + count;
  396|  8.83k|        memmove(dst, ptr, (size() - p) * sizeof(T));
  397|  8.83k|        _size += count;
  398|  8.83k|        fill(ptr, first, last);
  399|  8.83k|    }
_ZN9prevectorILj28EhjiE4fillITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEEvPhT_S8_:
  214|  9.50k|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|   509k|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 499k, False: 9.50k]
  ------------------
  216|   499k|            new(static_cast<void*>(dst)) T(*first);
  217|   499k|            ++dst;
  218|   499k|            ++first;
  219|   499k|        }
  220|  9.50k|    }
_ZNK9prevectorILj28EhjiE3endEv:
  305|  18.2M|    const_iterator end() const { return const_iterator(item_ptr(size())); }
_ZNK9prevectorILj28EhjiE8item_ptrEi:
  207|  32.4M|    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (207:59): [True: 26.1M, False: 6.29M]
  ------------------
_ZNK9prevectorILj28EhjiE10direct_ptrEi:
  170|  26.1M|    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
_ZNK9prevectorILj28EhjiE12indirect_ptrEi:
  172|  6.29M|    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
_ZNK9prevectorILj28EhjiE4sizeEv:
  294|  69.6M|    size_type size() const {
  295|  69.6M|        return is_direct() ? _size : _size - N - 1;
  ------------------
  |  Branch (295:16): [True: 52.1M, False: 17.4M]
  ------------------
  296|  69.6M|    }
_ZNK9prevectorILj28EhjiE5beginEv:
  303|  13.4M|    const_iterator begin() const { return const_iterator(item_ptr(0)); }
_ZNK9prevectorILj28EhjiE14const_iteratordeEv:
  111|   144M|        const T& operator*() const { return *ptr; }
_ZN9prevectorILj28EhjiE5clearEv:
  355|  7.06M|    void clear() {
  356|  7.06M|        resize(0);
  357|  7.06M|    }
_ZN9prevectorILj28EhjiE6resizeEj:
  328|  7.08M|    void resize(size_type new_size) {
  329|  7.08M|        size_type cur_size = size();
  330|  7.08M|        if (cur_size == new_size) {
  ------------------
  |  Branch (330:13): [True: 7.05M, False: 26.6k]
  ------------------
  331|  7.05M|            return;
  332|  7.05M|        }
  333|  26.6k|        if (cur_size > new_size) {
  ------------------
  |  Branch (333:13): [True: 14.8k, False: 11.8k]
  ------------------
  334|  14.8k|            erase(item_ptr(new_size), end());
  335|  14.8k|            return;
  336|  14.8k|        }
  337|  11.8k|        if (new_size > capacity()) {
  ------------------
  |  Branch (337:13): [True: 5.39k, False: 6.43k]
  ------------------
  338|  5.39k|            change_capacity(new_size);
  339|  5.39k|        }
  340|  11.8k|        ptrdiff_t increase = new_size - cur_size;
  341|  11.8k|        fill(item_ptr(cur_size), increase);
  342|  11.8k|        _size += increase;
  343|  11.8k|    }
_ZN9prevectorILj28EhjiE5eraseENS0_8iteratorES1_:
  420|  14.8k|    iterator erase(iterator first, iterator last) {
  421|       |        // Erase is not allowed to the change the object's capacity. That means
  422|       |        // that when starting with an indirectly allocated prevector with
  423|       |        // size and capacity > N, the result may be a still indirectly allocated
  424|       |        // prevector with size <= N and capacity > N. A shrink_to_fit() call is
  425|       |        // necessary to switch to the (more efficient) directly allocated
  426|       |        // representation (with capacity N and size <= N).
  427|  14.8k|        iterator p = first;
  428|  14.8k|        char* endp = (char*)&(*end());
  429|  14.8k|        _size -= last - p;
  430|  14.8k|        memmove(&(*first), &(*last), endp - ((char*)(&(*last))));
  431|  14.8k|        return first;
  432|  14.8k|    }
_ZN9prevectorILj28EhjiE4fillEPhlRKh:
  209|  11.8k|    void fill(T* dst, ptrdiff_t count, const T& value = T{}) {
  210|  11.8k|        std::fill_n(dst, count, value);
  211|  11.8k|    }
_ZN9prevectorILj28EhjiE13shrink_to_fitEv:
  351|  4.58M|    void shrink_to_fit() {
  352|  4.58M|        change_capacity(size());
  353|  4.58M|    }
_ZN9prevectorILj28EhjiE4fillITkNSt3__114input_iteratorENS0_14const_iteratorEEEvPhT_S5_:
  214|  12.5M|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|   119M|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 106M, False: 12.5M]
  ------------------
  216|   106M|            new(static_cast<void*>(dst)) T(*first);
  217|   106M|            ++dst;
  218|   106M|            ++first;
  219|   106M|        }
  220|  12.5M|    }
_ZNK9prevectorILj28EhjiE14const_iteratorneES1_:
  125|   119M|        bool operator!=(const_iterator x) const { return ptr != x.ptr; }
_ZN9prevectorILj28EhjiE14const_iteratorppEv:
  114|   111M|        const_iterator& operator++() { ptr++; return *this; }
_ZNK9prevectorILj28EhjiEeqERKS0_:
  481|  4.92k|    bool operator==(const prevector<N, T, Size, Diff>& other) const {
  482|  4.92k|        if (other.size() != size()) {
  ------------------
  |  Branch (482:13): [True: 0, False: 4.92k]
  ------------------
  483|      0|            return false;
  484|      0|        }
  485|  4.92k|        const_iterator b1 = begin();
  486|  4.92k|        const_iterator b2 = other.begin();
  487|  4.92k|        const_iterator e1 = end();
  488|   216k|        while (b1 != e1) {
  ------------------
  |  Branch (488:16): [True: 211k, False: 4.92k]
  ------------------
  489|   211k|            if ((*b1) != (*b2)) {
  ------------------
  |  Branch (489:17): [True: 0, False: 211k]
  ------------------
  490|      0|                return false;
  491|      0|            }
  492|   211k|            ++b1;
  493|   211k|            ++b2;
  494|   211k|        }
  495|  4.92k|        return true;
  496|  4.92k|    }
_ZN9prevectorILj33EhjiE4dataEv:
  533|  9.60k|    value_type* data() {
  534|  9.60k|        return item_ptr(0);
  535|  9.60k|    }
_ZN9prevectorILj33EhjiE8item_ptrEi:
  206|  19.2k|    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (206:47): [True: 19.2k, False: 0]
  ------------------
_ZNK9prevectorILj33EhjiE9is_directEv:
  173|  57.5k|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj33EhjiE10direct_ptrEi:
  169|  19.2k|    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
_ZNK9prevectorILj33EhjiE4sizeEv:
  294|  9.60k|    size_type size() const {
  295|  9.60k|        return is_direct() ? _size : _size - N - 1;
  ------------------
  |  Branch (295:16): [True: 9.60k, False: 0]
  ------------------
  296|  9.60k|    }
_ZNK9prevectorILj28EhjiE4dataEv:
  537|   740k|    const value_type* data() const {
  538|   740k|        return item_ptr(0);
  539|   740k|    }
_ZN9prevectorILj28EhjiE4dataEv:
  533|  5.31k|    value_type* data() {
  534|  5.31k|        return item_ptr(0);
  535|  5.31k|    }
_ZNK9prevectorILj28EhjiE16allocated_memoryEv:
  525|  1.38M|    size_t allocated_memory() const {
  526|  1.38M|        if (is_direct()) {
  ------------------
  |  Branch (526:13): [True: 1.30M, False: 80.4k]
  ------------------
  527|  1.30M|            return 0;
  528|  1.30M|        } else {
  529|  80.4k|            return ((size_t)(sizeof(T))) * _union.indirect_contents.capacity;
  530|  80.4k|        }
  531|  1.38M|    }
_ZNK9prevectorILj28EhjiE5emptyEv:
  298|  5.13M|    bool empty() const {
  299|  5.13M|        return size() == 0;
  300|  5.13M|    }
_ZNK9prevectorILj28EhjiEixEj:
  324|  65.8k|    const T& operator[](size_type pos) const {
  325|  65.8k|        return *item_ptr(pos);
  326|  65.8k|    }
_ZN9prevectorILj28EhjiED2Ev:
  474|  13.1M|    ~prevector() {
  475|  13.1M|        if (!is_direct()) {
  ------------------
  |  Branch (475:13): [True: 165k, False: 13.0M]
  ------------------
  476|   165k|            free(_union.indirect_contents.indirect);
  477|   165k|            _union.indirect_contents.indirect = nullptr;
  478|   165k|        }
  479|  13.1M|    }
_ZN9prevectorILj28EhjiEC2EOS0_:
  271|  14.8k|        : _union(std::move(other._union)), _size(other._size)
  272|  14.8k|    {
  273|  14.8k|        other._size = 0;
  274|  14.8k|    }
_ZN9prevectorILj28EhjiEC2Ev:
  243|  4.70M|    prevector() = default;
_ZN9prevectorILj28EhjiE8iteratorC2EPh:
   58|  7.81M|        iterator(T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj28EhjiE20resize_uninitializedEj:
  401|   249k|    inline void resize_uninitialized(size_type new_size) {
  402|       |        // resize_uninitialized changes the size of the prevector but does not initialize it.
  403|       |        // If size < new_size, the added elements must be initialized explicitly.
  404|   249k|        if (capacity() < new_size) {
  ------------------
  |  Branch (404:13): [True: 22.7k, False: 226k]
  ------------------
  405|  22.7k|            change_capacity(new_size);
  406|  22.7k|            _size += new_size - size();
  407|  22.7k|            return;
  408|  22.7k|        }
  409|   226k|        if (new_size < size()) {
  ------------------
  |  Branch (409:13): [True: 0, False: 226k]
  ------------------
  410|      0|            erase(item_ptr(new_size), end());
  411|   226k|        } else {
  412|   226k|            _size += new_size - size();
  413|   226k|        }
  414|   226k|    }
_ZN9prevectorILj28EhjiEixEj:
  320|   280k|    T& operator[](size_type pos) {
  321|   280k|        return *item_ptr(pos);
  322|   280k|    }
_ZN9prevectorILj28EhjiE14const_iteratorC2EPKh:
  109|  32.5M|        const_iterator(const T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj28EhjiEC2ERKS0_:
  263|  8.44M|    prevector(const prevector<N, T, Size, Diff>& other) {
  264|  8.44M|        size_type n = other.size();
  265|  8.44M|        change_capacity(n);
  266|  8.44M|        _size += n;
  267|  8.44M|        fill(item_ptr(0), other.begin(),  other.end());
  268|  8.44M|    }
_ZN9prevectorILj33EhjiEC2EjRKh:
  249|  9.60k|    explicit prevector(size_type n, const T& val) {
  250|  9.60k|        change_capacity(n);
  251|  9.60k|        _size += n;
  252|  9.60k|        fill(item_ptr(0), n, val);
  253|  9.60k|    }
_ZN9prevectorILj33EhjiE15change_capacityEj:
  175|  9.60k|    void change_capacity(size_type new_capacity) {
  176|  9.60k|        if (new_capacity <= N) {
  ------------------
  |  Branch (176:13): [True: 9.60k, False: 0]
  ------------------
  177|  9.60k|            if (!is_direct()) {
  ------------------
  |  Branch (177:17): [True: 0, False: 9.60k]
  ------------------
  178|      0|                T* indirect = indirect_ptr(0);
  179|      0|                T* src = indirect;
  180|      0|                T* dst = direct_ptr(0);
  181|      0|                memcpy(dst, src, size() * sizeof(T));
  182|      0|                free(indirect);
  183|      0|                _size -= N + 1;
  184|      0|            }
  185|  9.60k|        } else {
  186|      0|            if (!is_direct()) {
  ------------------
  |  Branch (186:17): [True: 0, False: 0]
  ------------------
  187|       |                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
  188|       |                    success. These should instead use an allocator or new/delete so that handlers
  189|       |                    are called as necessary, but performance would be slightly degraded by doing so. */
  190|      0|                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
  191|      0|                assert(_union.indirect_contents.indirect);
  192|      0|                _union.indirect_contents.capacity = new_capacity;
  193|      0|            } else {
  194|      0|                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
  195|      0|                assert(new_indirect);
  196|      0|                T* src = direct_ptr(0);
  197|      0|                T* dst = reinterpret_cast<T*>(new_indirect);
  198|      0|                memcpy(dst, src, size() * sizeof(T));
  199|      0|                _union.indirect_contents.indirect = new_indirect;
  200|      0|                _union.indirect_contents.capacity = new_capacity;
  201|      0|                _size += N + 1;
  202|      0|            }
  203|      0|        }
  204|  9.60k|    }
_ZN9prevectorILj33EhjiE4fillEPhlRKh:
  209|  9.60k|    void fill(T* dst, ptrdiff_t count, const T& value = T{}) {
  210|  9.60k|        std::fill_n(dst, count, value);
  211|  9.60k|    }
_ZN9prevectorILj33EhjiED2Ev:
  474|  9.60k|    ~prevector() {
  475|  9.60k|        if (!is_direct()) {
  ------------------
  |  Branch (475:13): [True: 0, False: 9.60k]
  ------------------
  476|      0|            free(_union.indirect_contents.indirect);
  477|      0|            _union.indirect_contents.indirect = nullptr;
  478|      0|        }
  479|  9.60k|    }
_ZN9prevectorILj28EhjiEaSERKS0_:
  276|   206k|    prevector& operator=(const prevector<N, T, Size, Diff>& other) {
  277|   206k|        if (&other == this) {
  ------------------
  |  Branch (277:13): [True: 0, False: 206k]
  ------------------
  278|      0|            return *this;
  279|      0|        }
  280|   206k|        assign(other.begin(), other.end());
  281|   206k|        return *this;
  282|   206k|    }
_ZN9prevectorILj28EhjiE6assignITkNSt3__114input_iteratorENS0_14const_iteratorEEEvT_S4_:
  233|   206k|    void assign(InputIterator first, InputIterator last) {
  234|   206k|        size_type n = last - first;
  235|   206k|        clear();
  236|   206k|        if (capacity() < n) {
  ------------------
  |  Branch (236:13): [True: 54.6k, False: 151k]
  ------------------
  237|  54.6k|            change_capacity(n);
  238|  54.6k|        }
  239|   206k|        _size += n;
  240|   206k|        fill(item_ptr(0), first, last);
  241|   206k|    }
_ZmiN9prevectorILj28EhjiE14const_iteratorES1_:
  118|  16.4M|        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
_ZN9prevectorILj28EhjiEaSEOS0_:
  284|  1.24M|    prevector& operator=(prevector<N, T, Size, Diff>&& other) noexcept {
  285|  1.24M|        if (!is_direct()) {
  ------------------
  |  Branch (285:13): [True: 7.95k, False: 1.23M]
  ------------------
  286|  7.95k|            free(_union.indirect_contents.indirect);
  287|  7.95k|        }
  288|  1.24M|        _union = std::move(other._union);
  289|  1.24M|        _size = other._size;
  290|  1.24M|        other._size = 0;
  291|  1.24M|        return *this;
  292|  1.24M|    }
_ZN9prevectorILj28EhjiEC2ITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEET_S7_:
  256|    664|    prevector(InputIterator first, InputIterator last) {
  257|    664|        size_type n = last - first;
  258|    664|        change_capacity(n);
  259|    664|        _size += n;
  260|    664|        fill(item_ptr(0), first, last);
  261|    664|    }
_ZNK9prevectorILj28EhjiE14const_iteratorptEv:
  112|  13.9M|        const T* operator->() const { return ptr; }
_ZN9prevectorILj28EhjiEC2ITkNSt3__114input_iteratorENS2_11__wrap_iterIPhEEEET_S6_:
  256|  2.44k|    prevector(InputIterator first, InputIterator last) {
  257|  2.44k|        size_type n = last - first;
  258|  2.44k|        change_capacity(n);
  259|  2.44k|        _size += n;
  260|  2.44k|        fill(item_ptr(0), first, last);
  261|  2.44k|    }
_ZN9prevectorILj28EhjiE4fillITkNSt3__114input_iteratorENS2_11__wrap_iterIPhEEEEvS4_T_S6_:
  214|  2.44k|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|  10.4k|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 7.99k, False: 2.44k]
  ------------------
  216|  7.99k|            new(static_cast<void*>(dst)) T(*first);
  217|  7.99k|            ++dst;
  218|  7.99k|            ++first;
  219|  7.99k|        }
  220|  2.44k|    }
_ZNK9prevectorILj28EhjiE14const_iteratorltES1_:
  129|   660k|        bool operator<(const_iterator x) const { return ptr < x.ptr; }
_ZNK9prevectorILj33EhjiE4dataEv:
  537|  9.53k|    const value_type* data() const {
  538|  9.53k|        return item_ptr(0);
  539|  9.53k|    }
_ZNK9prevectorILj33EhjiE8item_ptrEi:
  207|  9.53k|    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (207:59): [True: 9.53k, False: 0]
  ------------------
_ZNK9prevectorILj33EhjiE10direct_ptrEi:
  170|  9.53k|    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
_ZNK9prevectorILj28EhjiE4backEv:
  464|  1.36k|    const T& back() const {
  465|  1.36k|        return *item_ptr(size() - 1);
  466|  1.36k|    }
_ZNK9prevectorILj28EhjiE14const_iteratorplEj:
  119|   922k|        const_iterator operator+(size_type n) const { return const_iterator(ptr + n); }
_ZN9prevectorILj28EhjiE14const_iteratorpLEj:
  121|  1.59M|        const_iterator& operator+=(size_type n) { ptr += n; return *this; }
_ZN9prevectorILj28EhjiE14const_iteratorC2ENS0_8iteratorE:
  110|  26.5k|        const_iterator(iterator x) : ptr(&(*x)) {}
_ZN9prevectorILj28EhjiE6insertITkNSt3__114input_iteratorENS0_14const_iteratorEEEvNS0_8iteratorET_S5_:
  387|  3.84M|    void insert(iterator pos, InputIterator first, InputIterator last) {
  388|  3.84M|        size_type p = pos - begin();
  389|  3.84M|        difference_type count = last - first;
  390|  3.84M|        size_type new_size = size() + count;
  391|  3.84M|        if (capacity() < new_size) {
  ------------------
  |  Branch (391:13): [True: 50.0k, False: 3.79M]
  ------------------
  392|  50.0k|            change_capacity(new_size + (new_size >> 1));
  393|  50.0k|        }
  394|  3.84M|        T* ptr = item_ptr(p);
  395|  3.84M|        T* dst = ptr + count;
  396|  3.84M|        memmove(dst, ptr, (size() - p) * sizeof(T));
  397|  3.84M|        _size += count;
  398|  3.84M|        fill(ptr, first, last);
  399|  3.84M|    }
_ZN9prevectorILj28EhjiEC2ITkNSt3__114input_iteratorENS0_14const_iteratorEEET_S4_:
  256|  8.31k|    prevector(InputIterator first, InputIterator last) {
  257|  8.31k|        size_type n = last - first;
  258|  8.31k|        change_capacity(n);
  259|  8.31k|        _size += n;
  260|  8.31k|        fill(item_ptr(0), first, last);
  261|  8.31k|    }
_ZNK9prevectorILj28EhjiE14const_iteratorixEj:
  113|  8.49k|        const T& operator[](size_type pos) const { return ptr[pos]; }
_ZNK9prevectorILj28EhjiE14const_iteratorgeES1_:
  126|  4.49M|        bool operator>=(const_iterator x) const { return ptr >= x.ptr; }
_ZN9prevectorILj28EhjiE14const_iteratorppEi:
  116|  4.49M|        const_iterator operator++(int) { const_iterator copy(*this); ++(*this); return copy; }

_ZN19CMutableTransactionC2Ev:
   66|  20.4k|CMutableTransaction::CMutableTransaction() : version{CTransaction::CURRENT_VERSION}, nLockTime{0} {}
_ZNK12CTransaction17ComputeHasWitnessEv:
   75|  13.6k|{
   76|  13.6k|    return std::any_of(vin.begin(), vin.end(), [](const auto& input) {
   77|  13.6k|        return !input.scriptWitness.IsNull();
   78|  13.6k|    });
   79|  13.6k|}
_ZNK12CTransaction11ComputeHashEv:
   82|  13.6k|{
   83|  13.6k|    return Txid::FromUint256((HashWriter{} << TX_NO_WITNESS(*this)).GetHash());
   84|  13.6k|}
_ZNK12CTransaction18ComputeWitnessHashEv:
   87|  13.6k|{
   88|  13.6k|    if (!HasWitness()) {
  ------------------
  |  Branch (88:9): [True: 12.7k, False: 881]
  ------------------
   89|  12.7k|        return Wtxid::FromUint256(hash.ToUint256());
   90|  12.7k|    }
   91|       |
   92|    881|    return Wtxid::FromUint256((HashWriter{} << TX_WITH_WITNESS(*this)).GetHash());
   93|  13.6k|}
_ZN12CTransactionC2ERK19CMutableTransaction:
   95|  13.6k|CTransaction::CTransaction(const CMutableTransaction& tx) : vin(tx.vin), vout(tx.vout), version{tx.version}, nLockTime{tx.nLockTime}, m_has_witness{ComputeHasWitness()}, hash{ComputeHash()}, m_witness_hash{ComputeWitnessHash()} {}
_ZNK12CTransaction11GetValueOutEv:
   99|    276|{
  100|    276|    CAmount nValueOut = 0;
  101|  1.00k|    for (const auto& tx_out : vout) {
  ------------------
  |  Branch (101:29): [True: 1.00k, False: 276]
  ------------------
  102|  1.00k|        if (!MoneyRange(tx_out.nValue) || !MoneyRange(nValueOut + tx_out.nValue))
  ------------------
  |  Branch (102:13): [True: 0, False: 1.00k]
  |  Branch (102:13): [True: 0, False: 1.00k]
  |  Branch (102:43): [True: 0, False: 1.00k]
  ------------------
  103|      0|            throw std::runtime_error(std::string(__func__) + ": value out of range");
  104|  1.00k|        nValueOut += tx_out.nValue;
  105|  1.00k|    }
  106|    276|    assert(MoneyRange(nValueOut));
  107|    276|    return nValueOut;
  108|    276|}
transaction.cpp:_ZZNK12CTransaction17ComputeHasWitnessEvENK3$_0clI5CTxInEEDaRKT_:
   76|  91.5k|    return std::any_of(vin.begin(), vin.end(), [](const auto& input) {
   77|  91.5k|        return !input.scriptWitness.IsNull();
   78|  91.5k|    });

_ZN9COutPointC2Ev:
   36|   139k|    COutPoint(): n(NULL_INDEX) { }
_ZN9COutPointC2ERK22transaction_identifierILb0EEj:
   37|  2.18M|    COutPoint(const Txid& hashIn, uint32_t nIn): hash(hashIn), n(nIn) { }
_ZNK9COutPoint6IsNullEv:
   42|   818k|    bool IsNull() const { return (hash.IsNull() && n == NULL_INDEX); }
  ------------------
  |  Branch (42:35): [True: 136k, False: 682k]
  |  Branch (42:52): [True: 135k, False: 478]
  ------------------
_ZltRK9COutPointS1_:
   45|     26|    {
   46|     26|        return std::tie(a.hash, a.n) < std::tie(b.hash, b.n);
   47|     26|    }
_ZeqRK9COutPointS1_:
   50|   207k|    {
   51|   207k|        return (a.hash == b.hash && a.n == b.n);
  ------------------
  |  Branch (51:17): [True: 207k, False: 0]
  |  Branch (51:37): [True: 207k, False: 0]
  ------------------
   52|   207k|    }
_ZN5CTxInC2Ev:
  122|   111k|    {
  123|   111k|        nSequence = SEQUENCE_FINAL;
  124|   111k|    }
_ZN6CTxOutC2Ev:
  156|  4.57M|    {
  157|  4.57M|        SetNull();
  158|  4.57M|    }
_ZN6CTxOut7SetNullEv:
  165|  4.58M|    {
  166|  4.58M|        nValue = -1;
  167|  4.58M|        scriptPubKey.clear();
  168|  4.58M|    }
_ZNK6CTxOut6IsNullEv:
  171|  3.81M|    {
  172|  3.81M|        return (nValue == -1);
  173|  3.81M|    }
_ZeqRK6CTxOutS1_:
  176|  5.39k|    {
  177|  5.39k|        return (a.nValue       == b.nValue &&
  ------------------
  |  Branch (177:17): [True: 4.92k, False: 471]
  ------------------
  178|  5.39k|                a.scriptPubKey == b.scriptPubKey);
  ------------------
  |  Branch (178:17): [True: 4.92k, False: 0]
  ------------------
  179|  5.39k|    }
_ZNK12CTransaction7GetHashEv:
  343|    667|    const Txid& GetHash() const LIFETIMEBOUND { return hash; }
_ZNK12CTransaction10IsCoinBaseEv:
  357|  1.22M|    {
  358|  1.22M|        return (vin.size() == 1 && vin[0].prevout.IsNull());
  ------------------
  |  Branch (358:17): [True: 818k, False: 409k]
  |  Branch (358:36): [True: 135k, False: 683k]
  ------------------
  359|  1.22M|    }
_ZNK12CTransaction10HasWitnessEv:
  373|  14.4k|    bool HasWitness() const { return m_has_witness; }
_ZNK19CMutableTransaction10HasWitnessEv:
  413|  1.96k|    {
  414|  3.74k|        for (size_t i = 0; i < vin.size(); i++) {
  ------------------
  |  Branch (414:28): [True: 3.73k, False: 16]
  ------------------
  415|  3.73k|            if (!vin[i].scriptWitness.IsNull()) {
  ------------------
  |  Branch (415:17): [True: 1.94k, False: 1.78k]
  ------------------
  416|  1.94k|                return true;
  417|  1.94k|            }
  418|  3.73k|        }
  419|     16|        return false;
  420|  1.96k|    }
_ZNK12CTransaction9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  328|    556|    inline void Serialize(Stream& s) const {
  329|    556|        SerializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
  330|    556|    }
_Z20SerializeTransactionI12ParamsStreamIR12SizeComputer20TransactionSerParamsE12CTransactionEvRKT0_RT_RKS3_:
  257|    556|{
  258|    556|    const bool fAllowWitness = params.allow_witness;
  259|       |
  260|    556|    s << tx.version;
  261|    556|    unsigned char flags = 0;
  262|       |    // Consistency check
  263|    556|    if (fAllowWitness) {
  ------------------
  |  Branch (263:9): [True: 0, False: 556]
  ------------------
  264|       |        /* Check whether witnesses need to be serialized. */
  265|      0|        if (tx.HasWitness()) {
  ------------------
  |  Branch (265:13): [True: 0, False: 0]
  ------------------
  266|      0|            flags |= 1;
  267|      0|        }
  268|      0|    }
  269|    556|    if (flags) {
  ------------------
  |  Branch (269:9): [True: 0, False: 556]
  ------------------
  270|       |        /* Use extended format in case witnesses are to be serialized. */
  271|      0|        std::vector<CTxIn> vinDummy;
  272|      0|        s << vinDummy;
  273|      0|        s << flags;
  274|      0|    }
  275|    556|    s << tx.vin;
  276|    556|    s << tx.vout;
  277|    556|    if (flags & 1) {
  ------------------
  |  Branch (277:9): [True: 0, False: 556]
  ------------------
  278|      0|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (278:28): [True: 0, False: 0]
  ------------------
  279|      0|            s << tx.vin[i].scriptWitness.stack;
  280|      0|        }
  281|      0|    }
  282|    556|    s << tx.nLockTime;
  283|    556|}
_ZN5CTxIn16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  129|    963|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  156|    963|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
   39|    963|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  156|    963|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  162|   594k|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  156|   594k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN19CMutableTransaction11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  393|  11.8k|    inline void Unserialize(Stream& s) {
  394|  11.8k|        UnserializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
  395|  11.8k|    }
_Z22UnserializeTransactionI12ParamsStreamIR10DataStream20TransactionSerParamsE19CMutableTransactionEvRT0_RT_RKS3_:
  217|  11.8k|{
  218|  11.8k|    const bool fAllowWitness = params.allow_witness;
  219|       |
  220|  11.8k|    s >> tx.version;
  221|  11.8k|    unsigned char flags = 0;
  222|  11.8k|    tx.vin.clear();
  223|  11.8k|    tx.vout.clear();
  224|       |    /* Try to read the vin. In case the dummy is there, this will be read as an empty vector. */
  225|  11.8k|    s >> tx.vin;
  226|  11.8k|    if (tx.vin.size() == 0 && fAllowWitness) {
  ------------------
  |  Branch (226:9): [True: 4.60k, False: 7.21k]
  |  Branch (226:31): [True: 4.60k, False: 0]
  ------------------
  227|       |        /* We read a dummy or an empty vin. */
  228|  4.60k|        s >> flags;
  229|  4.60k|        if (flags != 0) {
  ------------------
  |  Branch (229:13): [True: 2.25k, False: 2.35k]
  ------------------
  230|  2.25k|            s >> tx.vin;
  231|  2.25k|            s >> tx.vout;
  232|  2.25k|        }
  233|  7.21k|    } else {
  234|       |        /* We read a non-empty vin. Assume a normal vout follows. */
  235|  7.21k|        s >> tx.vout;
  236|  7.21k|    }
  237|  11.8k|    if ((flags & 1) && fAllowWitness) {
  ------------------
  |  Branch (237:9): [True: 2.09k, False: 9.72k]
  |  Branch (237:24): [True: 2.09k, False: 0]
  ------------------
  238|       |        /* The witness flag is present, and we support witnesses. */
  239|  2.09k|        flags ^= 1;
  240|  20.0k|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (240:28): [True: 17.9k, False: 2.09k]
  ------------------
  241|  17.9k|            s >> tx.vin[i].scriptWitness.stack;
  242|  17.9k|        }
  243|  2.09k|        if (!tx.HasWitness()) {
  ------------------
  |  Branch (243:13): [True: 16, False: 2.07k]
  ------------------
  244|       |            /* It's illegal to encode witnesses when all witness stacks are empty. */
  245|     16|            throw std::ios_base::failure("Superfluous witness record");
  246|     16|        }
  247|  2.09k|    }
  248|  11.8k|    if (flags) {
  ------------------
  |  Branch (248:9): [True: 11, False: 11.7k]
  ------------------
  249|       |        /* Unknown flag in the serialization */
  250|     11|        throw std::ios_base::failure("Unknown transaction optional data");
  251|     11|    }
  252|  11.7k|    s >> tx.nLockTime;
  253|  11.7k|}
_ZN5CTxIn16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_:
  129|   111k|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  156|   111k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_:
   39|   111k|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  156|   111k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_:
  162|  2.16M|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  156|  2.16M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
   39|  1.93k|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  156|  1.93k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN5CTxIn16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  129|   120k|    SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
  ------------------
  |  |  156|   120k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN9COutPoint16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
   39|   120k|    SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
  ------------------
  |  |  156|   120k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN6CTxOut16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  162|  4.40M|    SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
  ------------------
  |  |  156|  4.40M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZNK12CTransaction9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  328|  14.4k|    inline void Serialize(Stream& s) const {
  329|  14.4k|        SerializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
  330|  14.4k|    }
_Z20SerializeTransactionI12ParamsStreamIR10HashWriter20TransactionSerParamsE12CTransactionEvRKT0_RT_RKS3_:
  257|  14.4k|{
  258|  14.4k|    const bool fAllowWitness = params.allow_witness;
  259|       |
  260|  14.4k|    s << tx.version;
  261|  14.4k|    unsigned char flags = 0;
  262|       |    // Consistency check
  263|  14.4k|    if (fAllowWitness) {
  ------------------
  |  Branch (263:9): [True: 881, False: 13.6k]
  ------------------
  264|       |        /* Check whether witnesses need to be serialized. */
  265|    881|        if (tx.HasWitness()) {
  ------------------
  |  Branch (265:13): [True: 881, False: 0]
  ------------------
  266|    881|            flags |= 1;
  267|    881|        }
  268|    881|    }
  269|  14.4k|    if (flags) {
  ------------------
  |  Branch (269:9): [True: 881, False: 13.6k]
  ------------------
  270|       |        /* Use extended format in case witnesses are to be serialized. */
  271|    881|        std::vector<CTxIn> vinDummy;
  272|    881|        s << vinDummy;
  273|    881|        s << flags;
  274|    881|    }
  275|  14.4k|    s << tx.vin;
  276|  14.4k|    s << tx.vout;
  277|  14.4k|    if (flags & 1) {
  ------------------
  |  Branch (277:9): [True: 881, False: 13.6k]
  ------------------
  278|  16.2k|        for (size_t i = 0; i < tx.vin.size(); i++) {
  ------------------
  |  Branch (278:28): [True: 15.3k, False: 881]
  ------------------
  279|  15.3k|            s << tx.vin[i].scriptWitness.stack;
  280|  15.3k|        }
  281|    881|    }
  282|  14.4k|    s << tx.nLockTime;
  283|  14.4k|}

_ZN7CPubKey10DecompressEv:
  321|  4.67k|bool CPubKey::Decompress() {
  322|  4.67k|    if (!IsValid())
  ------------------
  |  Branch (322:9): [True: 0, False: 4.67k]
  ------------------
  323|      0|        return false;
  324|  4.67k|    secp256k1_pubkey pubkey;
  325|  4.67k|    if (!secp256k1_ec_pubkey_parse(secp256k1_context_static, &pubkey, vch, size())) {
  ------------------
  |  Branch (325:9): [True: 1.46k, False: 3.21k]
  ------------------
  326|  1.46k|        return false;
  327|  1.46k|    }
  328|  3.21k|    unsigned char pub[SIZE];
  329|  3.21k|    size_t publen = SIZE;
  330|  3.21k|    secp256k1_ec_pubkey_serialize(secp256k1_context_static, pub, &publen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
  ------------------
  |  |  213|  3.21k|#define SECP256K1_EC_UNCOMPRESSED (SECP256K1_FLAGS_TYPE_COMPRESSION)
  |  |  ------------------
  |  |  |  |  193|  3.21k|#define SECP256K1_FLAGS_TYPE_COMPRESSION (1 << 1)
  |  |  ------------------
  ------------------
  331|  3.21k|    Set(pub, pub + publen);
  332|  3.21k|    return true;
  333|  4.67k|}

_ZN7CPubKey6GetLenEh:
   61|  21.6k|    {
   62|  21.6k|        if (chHeader == 2 || chHeader == 3)
  ------------------
  |  Branch (62:13): [True: 2.23k, False: 19.3k]
  |  Branch (62:30): [True: 12.2k, False: 7.14k]
  ------------------
   63|  14.4k|            return COMPRESSED_SIZE;
   64|  7.14k|        if (chHeader == 4 || chHeader == 6 || chHeader == 7)
  ------------------
  |  Branch (64:13): [True: 6.65k, False: 498]
  |  Branch (64:30): [True: 233, False: 265]
  |  Branch (64:47): [True: 205, False: 60]
  ------------------
   65|  7.08k|            return SIZE;
   66|     60|        return 0;
   67|  7.14k|    }
_ZN7CPubKey9ValidSizeERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
   77|  1.16k|    bool static ValidSize(const std::vector<unsigned char> &vch) {
   78|  1.16k|      return vch.size() > 0 && GetLen(vch[0]) == vch.size();
  ------------------
  |  Branch (78:14): [True: 1.15k, False: 14]
  |  Branch (78:32): [True: 1.07k, False: 80]
  ------------------
   79|  1.16k|    }
_ZN7CPubKeyC2E4SpanIKhE:
  107|  4.67k|    {
  108|  4.67k|        Set(_vch.begin(), _vch.end());
  109|  4.67k|    }
_ZNK7CPubKey4sizeEv:
  112|  12.5k|    unsigned int size() const { return GetLen(vch[0]); }
_ZNK7CPubKey5beginEv:
  114|  3.21k|    const unsigned char* begin() const { return vch; }
_ZNK7CPubKey7IsValidEv:
  190|  4.67k|    {
  191|  4.67k|        return size() > 0;
  192|  4.67k|    }
_ZN7CPubKey3SetIPKhEEvT_S3_:
   90|  4.67k|    {
   91|  4.67k|        int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
  ------------------
  |  Branch (91:19): [True: 0, False: 4.67k]
  ------------------
   92|  4.67k|        if (len && len == (pend - pbegin))
  ------------------
  |  Branch (92:13): [True: 4.67k, False: 0]
  |  Branch (92:20): [True: 4.67k, False: 0]
  ------------------
   93|  4.67k|            memcpy(vch, (unsigned char*)&pbegin[0], len);
   94|      0|        else
   95|      0|            Invalidate();
   96|  4.67k|    }
_ZN7CPubKey3SetIPhEEvT_S2_:
   90|  3.21k|    {
   91|  3.21k|        int len = pend == pbegin ? 0 : GetLen(pbegin[0]);
  ------------------
  |  Branch (91:19): [True: 0, False: 3.21k]
  ------------------
   92|  3.21k|        if (len && len == (pend - pbegin))
  ------------------
  |  Branch (92:13): [True: 3.21k, False: 0]
  |  Branch (92:20): [True: 3.21k, False: 0]
  ------------------
   93|  3.21k|            memcpy(vch, (unsigned char*)&pbegin[0], len);
   94|      0|        else
   95|      0|            Invalidate();
   96|  3.21k|    }

_Z10CastToBoolRKNSt3__16vectorIhNS_9allocatorIhEEEE:
   36|  4.97k|{
   37|  7.71k|    for (unsigned int i = 0; i < vch.size(); i++)
  ------------------
  |  Branch (37:30): [True: 6.21k, False: 1.50k]
  ------------------
   38|  6.21k|    {
   39|  6.21k|        if (vch[i] != 0)
  ------------------
  |  Branch (39:13): [True: 3.47k, False: 2.74k]
  ------------------
   40|  3.47k|        {
   41|       |            // Can be negative zero
   42|  3.47k|            if (i == vch.size()-1 && vch[i] == 0x80)
  ------------------
  |  Branch (42:17): [True: 1.93k, False: 1.54k]
  |  Branch (42:38): [True: 381, False: 1.55k]
  ------------------
   43|    381|                return false;
   44|  3.09k|            return true;
   45|  3.47k|        }
   46|  6.21k|    }
   47|  1.50k|    return false;
   48|  4.97k|}
_Z22CheckSignatureEncodingRKNSt3__16vectorIhNS_9allocatorIhEEEEjP13ScriptError_t:
  200|  7.73k|bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, unsigned int flags, ScriptError* serror) {
  201|       |    // Empty signature. Not strictly DER encoded, but allowed to provide a
  202|       |    // compact way to provide an invalid signature for use with CHECK(MULTI)SIG
  203|  7.73k|    if (vchSig.size() == 0) {
  ------------------
  |  Branch (203:9): [True: 3.60k, False: 4.12k]
  ------------------
  204|  3.60k|        return true;
  205|  3.60k|    }
  206|  4.12k|    if ((flags & (SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_STRICTENC)) != 0 && !IsValidSignatureEncoding(vchSig)) {
  ------------------
  |  Branch (206:9): [True: 0, False: 4.12k]
  |  Branch (206:98): [True: 0, False: 0]
  ------------------
  207|      0|        return set_error(serror, SCRIPT_ERR_SIG_DER);
  208|  4.12k|    } else if ((flags & SCRIPT_VERIFY_LOW_S) != 0 && !IsLowDERSignature(vchSig, serror)) {
  ------------------
  |  Branch (208:16): [True: 0, False: 4.12k]
  |  Branch (208:54): [True: 0, False: 0]
  ------------------
  209|       |        // serror is set
  210|      0|        return false;
  211|  4.12k|    } else if ((flags & SCRIPT_VERIFY_STRICTENC) != 0 && !IsDefinedHashtypeSignature(vchSig)) {
  ------------------
  |  Branch (211:16): [True: 0, False: 4.12k]
  |  Branch (211:58): [True: 0, False: 0]
  ------------------
  212|      0|        return set_error(serror, SCRIPT_ERR_SIG_HASHTYPE);
  213|      0|    }
  214|  4.12k|    return true;
  215|  4.12k|}
_Z13FindAndDeleteR7CScriptRKS_:
  229|  8.83k|{
  230|  8.83k|    int nFound = 0;
  231|  8.83k|    if (b.empty())
  ------------------
  |  Branch (231:9): [True: 0, False: 8.83k]
  ------------------
  232|      0|        return nFound;
  233|  8.83k|    CScript result;
  234|  8.83k|    CScript::const_iterator pc = script.begin(), pc2 = script.begin(), end = script.end();
  235|  8.83k|    opcodetype opcode;
  236|  8.83k|    do
  237|  3.84M|    {
  238|  3.84M|        result.insert(result.end(), pc2, pc);
  239|  4.62M|        while (static_cast<size_t>(end - pc) >= b.size() && std::equal(b.begin(), b.end(), pc))
  ------------------
  |  Branch (239:16): [True: 4.58M, False: 48.0k]
  |  Branch (239:61): [True: 786k, False: 3.79M]
  ------------------
  240|   786k|        {
  241|   786k|            pc = pc + b.size();
  242|   786k|            ++nFound;
  243|   786k|        }
  244|  3.84M|        pc2 = pc;
  245|  3.84M|    }
  246|  3.84M|    while (script.GetOp(pc, opcode));
  ------------------
  |  Branch (246:12): [True: 3.83M, False: 8.83k]
  ------------------
  247|       |
  248|  8.83k|    if (nFound > 0) {
  ------------------
  |  Branch (248:9): [True: 5.43k, False: 3.40k]
  ------------------
  249|  5.43k|        result.insert(result.end(), pc2, end);
  250|  5.43k|        script = std::move(result);
  251|  5.43k|    }
  252|       |
  253|  8.83k|    return nFound;
  254|  8.83k|}
_Z10EvalScriptRNSt3__16vectorINS0_IhNS_9allocatorIhEEEENS1_IS3_EEEERK7CScriptjRK20BaseSignatureChecker10SigVersionR19ScriptExecutionDataP13ScriptError_t:
  407|  2.59k|{
  408|  2.59k|    static const CScriptNum bnZero(0);
  409|  2.59k|    static const CScriptNum bnOne(1);
  410|       |    // static const CScriptNum bnFalse(0);
  411|       |    // static const CScriptNum bnTrue(1);
  412|  2.59k|    static const valtype vchFalse(0);
  413|       |    // static const valtype vchZero(0);
  414|  2.59k|    static const valtype vchTrue(1, 1);
  415|       |
  416|       |    // sigversion cannot be TAPROOT here, as it admits no script execution.
  417|  2.59k|    assert(sigversion == SigVersion::BASE || sigversion == SigVersion::WITNESS_V0 || sigversion == SigVersion::TAPSCRIPT);
  418|       |
  419|  2.59k|    CScript::const_iterator pc = script.begin();
  420|  2.59k|    CScript::const_iterator pend = script.end();
  421|  2.59k|    CScript::const_iterator pbegincodehash = script.begin();
  422|  2.59k|    opcodetype opcode;
  423|  2.59k|    valtype vchPushValue;
  424|  2.59k|    ConditionStack vfExec;
  425|  2.59k|    std::vector<valtype> altstack;
  426|  2.59k|    set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR);
  427|  2.59k|    if ((sigversion == SigVersion::BASE || sigversion == SigVersion::WITNESS_V0) && script.size() > MAX_SCRIPT_SIZE) {
  ------------------
  |  Branch (427:10): [True: 2.59k, False: 0]
  |  Branch (427:44): [True: 0, False: 0]
  |  Branch (427:85): [True: 3, False: 2.59k]
  ------------------
  428|      3|        return set_error(serror, SCRIPT_ERR_SCRIPT_SIZE);
  429|      3|    }
  430|  2.59k|    int nOpCount = 0;
  431|  2.59k|    bool fRequireMinimal = (flags & SCRIPT_VERIFY_MINIMALDATA) != 0;
  432|  2.59k|    uint32_t opcode_pos = 0;
  433|  2.59k|    execdata.m_codeseparator_pos = 0xFFFFFFFFUL;
  434|  2.59k|    execdata.m_codeseparator_pos_init = true;
  435|       |
  436|  2.59k|    try
  437|  2.59k|    {
  438|   165k|        for (; pc < pend; ++opcode_pos) {
  ------------------
  |  Branch (438:16): [True: 164k, False: 1.02k]
  ------------------
  439|   164k|            bool fExec = vfExec.all_true();
  440|       |
  441|       |            //
  442|       |            // Read instruction
  443|       |            //
  444|   164k|            if (!script.GetOp(pc, opcode, vchPushValue))
  ------------------
  |  Branch (444:17): [True: 399, False: 163k]
  ------------------
  445|    399|                return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
  446|   163k|            if (vchPushValue.size() > MAX_SCRIPT_ELEMENT_SIZE)
  ------------------
  |  Branch (446:17): [True: 1, False: 163k]
  ------------------
  447|      1|                return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
  448|       |
  449|   163k|            if (sigversion == SigVersion::BASE || sigversion == SigVersion::WITNESS_V0) {
  ------------------
  |  Branch (449:17): [True: 163k, False: 0]
  |  Branch (449:51): [True: 0, False: 0]
  ------------------
  450|       |                // Note how OP_RESERVED does not count towards the opcode limit.
  451|   163k|                if (opcode > OP_16 && ++nOpCount > MAX_OPS_PER_SCRIPT) {
  ------------------
  |  Branch (451:21): [True: 73.4k, False: 90.5k]
  |  Branch (451:39): [True: 29, False: 73.4k]
  ------------------
  452|     29|                    return set_error(serror, SCRIPT_ERR_OP_COUNT);
  453|     29|                }
  454|   163k|            }
  455|       |
  456|   163k|            if (opcode == OP_CAT ||
  ------------------
  |  Branch (456:17): [True: 7, False: 163k]
  ------------------
  457|   163k|                opcode == OP_SUBSTR ||
  ------------------
  |  Branch (457:17): [True: 1, False: 163k]
  ------------------
  458|   163k|                opcode == OP_LEFT ||
  ------------------
  |  Branch (458:17): [True: 13, False: 163k]
  ------------------
  459|   163k|                opcode == OP_RIGHT ||
  ------------------
  |  Branch (459:17): [True: 2, False: 163k]
  ------------------
  460|   163k|                opcode == OP_INVERT ||
  ------------------
  |  Branch (460:17): [True: 6, False: 163k]
  ------------------
  461|   163k|                opcode == OP_AND ||
  ------------------
  |  Branch (461:17): [True: 5, False: 163k]
  ------------------
  462|   163k|                opcode == OP_OR ||
  ------------------
  |  Branch (462:17): [True: 9, False: 163k]
  ------------------
  463|   163k|                opcode == OP_XOR ||
  ------------------
  |  Branch (463:17): [True: 3, False: 163k]
  ------------------
  464|   163k|                opcode == OP_2MUL ||
  ------------------
  |  Branch (464:17): [True: 8, False: 163k]
  ------------------
  465|   163k|                opcode == OP_2DIV ||
  ------------------
  |  Branch (465:17): [True: 10, False: 163k]
  ------------------
  466|   163k|                opcode == OP_MUL ||
  ------------------
  |  Branch (466:17): [True: 6, False: 163k]
  ------------------
  467|   163k|                opcode == OP_DIV ||
  ------------------
  |  Branch (467:17): [True: 4, False: 163k]
  ------------------
  468|   163k|                opcode == OP_MOD ||
  ------------------
  |  Branch (468:17): [True: 6, False: 163k]
  ------------------
  469|   163k|                opcode == OP_LSHIFT ||
  ------------------
  |  Branch (469:17): [True: 7, False: 163k]
  ------------------
  470|   163k|                opcode == OP_RSHIFT)
  ------------------
  |  Branch (470:17): [True: 10, False: 163k]
  ------------------
  471|     97|                return set_error(serror, SCRIPT_ERR_DISABLED_OPCODE); // Disabled opcodes (CVE-2010-5137).
  472|       |
  473|       |            // With SCRIPT_VERIFY_CONST_SCRIPTCODE, OP_CODESEPARATOR in non-segwit script is rejected even in an unexecuted branch
  474|   163k|            if (opcode == OP_CODESEPARATOR && sigversion == SigVersion::BASE && (flags & SCRIPT_VERIFY_CONST_SCRIPTCODE))
  ------------------
  |  Branch (474:17): [True: 517, False: 163k]
  |  Branch (474:47): [True: 517, False: 0]
  |  Branch (474:81): [True: 0, False: 517]
  ------------------
  475|      0|                return set_error(serror, SCRIPT_ERR_OP_CODESEPARATOR);
  476|       |
  477|   163k|            if (fExec && 0 <= opcode && opcode <= OP_PUSHDATA4) {
  ------------------
  |  Branch (477:17): [True: 160k, False: 3.72k]
  |  Branch (477:26): [True: 160k, False: 0]
  |  Branch (477:41): [True: 56.3k, False: 103k]
  ------------------
  478|  56.3k|                if (fRequireMinimal && !CheckMinimalPush(vchPushValue, opcode)) {
  ------------------
  |  Branch (478:21): [True: 0, False: 56.3k]
  |  Branch (478:40): [True: 0, False: 0]
  ------------------
  479|      0|                    return set_error(serror, SCRIPT_ERR_MINIMALDATA);
  480|      0|                }
  481|  56.3k|                stack.push_back(vchPushValue);
  482|   107k|            } else if (fExec || (OP_IF <= opcode && opcode <= OP_ENDIF))
  ------------------
  |  Branch (482:24): [True: 103k, False: 3.72k]
  |  Branch (482:34): [True: 2.44k, False: 1.28k]
  |  Branch (482:53): [True: 1.83k, False: 604]
  ------------------
  483|   105k|            switch (opcode)
  484|   105k|            {
  485|       |                //
  486|       |                // Push value
  487|       |                //
  488|    773|                case OP_1NEGATE:
  ------------------
  |  Branch (488:17): [True: 773, False: 104k]
  ------------------
  489|  1.61k|                case OP_1:
  ------------------
  |  Branch (489:17): [True: 843, False: 104k]
  ------------------
  490|  2.37k|                case OP_2:
  ------------------
  |  Branch (490:17): [True: 763, False: 104k]
  ------------------
  491|  15.2k|                case OP_3:
  ------------------
  |  Branch (491:17): [True: 12.8k, False: 92.7k]
  ------------------
  492|  16.4k|                case OP_4:
  ------------------
  |  Branch (492:17): [True: 1.23k, False: 104k]
  ------------------
  493|  18.2k|                case OP_5:
  ------------------
  |  Branch (493:17): [True: 1.78k, False: 103k]
  ------------------
  494|  19.7k|                case OP_6:
  ------------------
  |  Branch (494:17): [True: 1.51k, False: 104k]
  ------------------
  495|  20.9k|                case OP_7:
  ------------------
  |  Branch (495:17): [True: 1.16k, False: 104k]
  ------------------
  496|  21.3k|                case OP_8:
  ------------------
  |  Branch (496:17): [True: 371, False: 105k]
  ------------------
  497|  22.6k|                case OP_9:
  ------------------
  |  Branch (497:17): [True: 1.36k, False: 104k]
  ------------------
  498|  24.4k|                case OP_10:
  ------------------
  |  Branch (498:17): [True: 1.74k, False: 103k]
  ------------------
  499|  29.1k|                case OP_11:
  ------------------
  |  Branch (499:17): [True: 4.68k, False: 100k]
  ------------------
  500|  29.4k|                case OP_12:
  ------------------
  |  Branch (500:17): [True: 361, False: 105k]
  ------------------
  501|  30.2k|                case OP_13:
  ------------------
  |  Branch (501:17): [True: 724, False: 104k]
  ------------------
  502|  31.6k|                case OP_14:
  ------------------
  |  Branch (502:17): [True: 1.46k, False: 104k]
  ------------------
  503|  32.2k|                case OP_15:
  ------------------
  |  Branch (503:17): [True: 569, False: 105k]
  ------------------
  504|  32.9k|                case OP_16:
  ------------------
  |  Branch (504:17): [True: 737, False: 104k]
  ------------------
  505|  32.9k|                {
  506|       |                    // ( -- value)
  507|  32.9k|                    CScriptNum bn((int)opcode - (int)(OP_1 - 1));
  508|  32.9k|                    stack.push_back(bn.getvch());
  509|       |                    // The result of these opcodes should always be the minimal way to push the data
  510|       |                    // they push, so no need for a CheckMinimalPush here.
  511|  32.9k|                }
  512|  32.9k|                break;
  513|       |
  514|       |
  515|       |                //
  516|       |                // Control
  517|       |                //
  518|    856|                case OP_NOP:
  ------------------
  |  Branch (518:17): [True: 856, False: 104k]
  ------------------
  519|    856|                    break;
  520|       |
  521|    655|                case OP_CHECKLOCKTIMEVERIFY:
  ------------------
  |  Branch (521:17): [True: 655, False: 104k]
  ------------------
  522|    655|                {
  523|    655|                    if (!(flags & SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY)) {
  ------------------
  |  Branch (523:25): [True: 655, False: 0]
  ------------------
  524|       |                        // not enabled; treat as a NOP2
  525|    655|                        break;
  526|    655|                    }
  527|       |
  528|      0|                    if (stack.size() < 1)
  ------------------
  |  Branch (528:25): [True: 0, False: 0]
  ------------------
  529|      0|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  530|       |
  531|       |                    // Note that elsewhere numeric opcodes are limited to
  532|       |                    // operands in the range -2**31+1 to 2**31-1, however it is
  533|       |                    // legal for opcodes to produce results exceeding that
  534|       |                    // range. This limitation is implemented by CScriptNum's
  535|       |                    // default 4-byte limit.
  536|       |                    //
  537|       |                    // If we kept to that limit we'd have a year 2038 problem,
  538|       |                    // even though the nLockTime field in transactions
  539|       |                    // themselves is uint32 which only becomes meaningless
  540|       |                    // after the year 2106.
  541|       |                    //
  542|       |                    // Thus as a special case we tell CScriptNum to accept up
  543|       |                    // to 5-byte bignums, which are good until 2**39-1, well
  544|       |                    // beyond the 2**32-1 limit of the nLockTime field itself.
  545|      0|                    const CScriptNum nLockTime(stacktop(-1), fRequireMinimal, 5);
  ------------------
  |  |   54|      0|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  546|       |
  547|       |                    // In the rare event that the argument may be < 0 due to
  548|       |                    // some arithmetic being done first, you can always use
  549|       |                    // 0 MAX CHECKLOCKTIMEVERIFY.
  550|      0|                    if (nLockTime < 0)
  ------------------
  |  Branch (550:25): [True: 0, False: 0]
  ------------------
  551|      0|                        return set_error(serror, SCRIPT_ERR_NEGATIVE_LOCKTIME);
  552|       |
  553|       |                    // Actually compare the specified lock time with the transaction.
  554|      0|                    if (!checker.CheckLockTime(nLockTime))
  ------------------
  |  Branch (554:25): [True: 0, False: 0]
  ------------------
  555|      0|                        return set_error(serror, SCRIPT_ERR_UNSATISFIED_LOCKTIME);
  556|       |
  557|      0|                    break;
  558|      0|                }
  559|       |
  560|    409|                case OP_CHECKSEQUENCEVERIFY:
  ------------------
  |  Branch (560:17): [True: 409, False: 105k]
  ------------------
  561|    409|                {
  562|    409|                    if (!(flags & SCRIPT_VERIFY_CHECKSEQUENCEVERIFY)) {
  ------------------
  |  Branch (562:25): [True: 409, False: 0]
  ------------------
  563|       |                        // not enabled; treat as a NOP3
  564|    409|                        break;
  565|    409|                    }
  566|       |
  567|      0|                    if (stack.size() < 1)
  ------------------
  |  Branch (567:25): [True: 0, False: 0]
  ------------------
  568|      0|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  569|       |
  570|       |                    // nSequence, like nLockTime, is a 32-bit unsigned integer
  571|       |                    // field. See the comment in CHECKLOCKTIMEVERIFY regarding
  572|       |                    // 5-byte numeric operands.
  573|      0|                    const CScriptNum nSequence(stacktop(-1), fRequireMinimal, 5);
  ------------------
  |  |   54|      0|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  574|       |
  575|       |                    // In the rare event that the argument may be < 0 due to
  576|       |                    // some arithmetic being done first, you can always use
  577|       |                    // 0 MAX CHECKSEQUENCEVERIFY.
  578|      0|                    if (nSequence < 0)
  ------------------
  |  Branch (578:25): [True: 0, False: 0]
  ------------------
  579|      0|                        return set_error(serror, SCRIPT_ERR_NEGATIVE_LOCKTIME);
  580|       |
  581|       |                    // To provide for future soft-fork extensibility, if the
  582|       |                    // operand has the disabled lock-time flag set,
  583|       |                    // CHECKSEQUENCEVERIFY behaves as a NOP.
  584|      0|                    if ((nSequence & CTxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG) != 0)
  ------------------
  |  Branch (584:25): [True: 0, False: 0]
  ------------------
  585|      0|                        break;
  586|       |
  587|       |                    // Compare the specified sequence number with the input.
  588|      0|                    if (!checker.CheckSequence(nSequence))
  ------------------
  |  Branch (588:25): [True: 0, False: 0]
  ------------------
  589|      0|                        return set_error(serror, SCRIPT_ERR_UNSATISFIED_LOCKTIME);
  590|       |
  591|      0|                    break;
  592|      0|                }
  593|       |
  594|  1.48k|                case OP_NOP1: case OP_NOP4: case OP_NOP5:
  ------------------
  |  Branch (594:17): [True: 448, False: 105k]
  |  Branch (594:31): [True: 467, False: 105k]
  |  Branch (594:45): [True: 574, False: 105k]
  ------------------
  595|  3.24k|                case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case OP_NOP10:
  ------------------
  |  Branch (595:17): [True: 383, False: 105k]
  |  Branch (595:31): [True: 337, False: 105k]
  |  Branch (595:45): [True: 391, False: 105k]
  |  Branch (595:59): [True: 347, False: 105k]
  |  Branch (595:73): [True: 294, False: 105k]
  ------------------
  596|  3.24k|                {
  597|  3.24k|                    if (flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
  ------------------
  |  Branch (597:25): [True: 0, False: 3.24k]
  ------------------
  598|      0|                        return set_error(serror, SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS);
  599|  3.24k|                }
  600|  3.24k|                break;
  601|       |
  602|  3.24k|                case OP_IF:
  ------------------
  |  Branch (602:17): [True: 1.42k, False: 104k]
  ------------------
  603|  2.78k|                case OP_NOTIF:
  ------------------
  |  Branch (603:17): [True: 1.36k, False: 104k]
  ------------------
  604|  2.78k|                {
  605|       |                    // <expression> if [statements] [else [statements]] endif
  606|  2.78k|                    bool fValue = false;
  607|  2.78k|                    if (fExec)
  ------------------
  |  Branch (607:25): [True: 1.51k, False: 1.27k]
  ------------------
  608|  1.51k|                    {
  609|  1.51k|                        if (stack.size() < 1)
  ------------------
  |  Branch (609:29): [True: 8, False: 1.50k]
  ------------------
  610|      8|                            return set_error(serror, SCRIPT_ERR_UNBALANCED_CONDITIONAL);
  611|  1.50k|                        valtype& vch = stacktop(-1);
  ------------------
  |  |   54|  1.50k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  612|       |                        // Tapscript requires minimal IF/NOTIF inputs as a consensus rule.
  613|  1.50k|                        if (sigversion == SigVersion::TAPSCRIPT) {
  ------------------
  |  Branch (613:29): [True: 0, False: 1.50k]
  ------------------
  614|       |                            // The input argument to the OP_IF and OP_NOTIF opcodes must be either
  615|       |                            // exactly 0 (the empty vector) or exactly 1 (the one-byte vector with value 1).
  616|      0|                            if (vch.size() > 1 || (vch.size() == 1 && vch[0] != 1)) {
  ------------------
  |  Branch (616:33): [True: 0, False: 0]
  |  Branch (616:52): [True: 0, False: 0]
  |  Branch (616:71): [True: 0, False: 0]
  ------------------
  617|      0|                                return set_error(serror, SCRIPT_ERR_TAPSCRIPT_MINIMALIF);
  618|      0|                            }
  619|      0|                        }
  620|       |                        // Under witness v0 rules it is only a policy rule, enabled through SCRIPT_VERIFY_MINIMALIF.
  621|  1.50k|                        if (sigversion == SigVersion::WITNESS_V0 && (flags & SCRIPT_VERIFY_MINIMALIF)) {
  ------------------
  |  Branch (621:29): [True: 0, False: 1.50k]
  |  Branch (621:69): [True: 0, False: 0]
  ------------------
  622|      0|                            if (vch.size() > 1)
  ------------------
  |  Branch (622:33): [True: 0, False: 0]
  ------------------
  623|      0|                                return set_error(serror, SCRIPT_ERR_MINIMALIF);
  624|      0|                            if (vch.size() == 1 && vch[0] != 1)
  ------------------
  |  Branch (624:33): [True: 0, False: 0]
  |  Branch (624:52): [True: 0, False: 0]
  ------------------
  625|      0|                                return set_error(serror, SCRIPT_ERR_MINIMALIF);
  626|      0|                        }
  627|  1.50k|                        fValue = CastToBool(vch);
  628|  1.50k|                        if (opcode == OP_NOTIF)
  ------------------
  |  Branch (628:29): [True: 821, False: 685]
  ------------------
  629|    821|                            fValue = !fValue;
  630|  1.50k|                        popstack(stack);
  631|  1.50k|                    }
  632|  2.77k|                    vfExec.push_back(fValue);
  633|  2.77k|                }
  634|      0|                break;
  635|       |
  636|    426|                case OP_ELSE:
  ------------------
  |  Branch (636:17): [True: 426, False: 105k]
  ------------------
  637|    426|                {
  638|    426|                    if (vfExec.empty())
  ------------------
  |  Branch (638:25): [True: 5, False: 421]
  ------------------
  639|      5|                        return set_error(serror, SCRIPT_ERR_UNBALANCED_CONDITIONAL);
  640|    421|                    vfExec.toggle_top();
  641|    421|                }
  642|      0|                break;
  643|       |
  644|    311|                case OP_ENDIF:
  ------------------
  |  Branch (644:17): [True: 311, False: 105k]
  ------------------
  645|    311|                {
  646|    311|                    if (vfExec.empty())
  ------------------
  |  Branch (646:25): [True: 5, False: 306]
  ------------------
  647|      5|                        return set_error(serror, SCRIPT_ERR_UNBALANCED_CONDITIONAL);
  648|    306|                    vfExec.pop_back();
  649|    306|                }
  650|      0|                break;
  651|       |
  652|    453|                case OP_VERIFY:
  ------------------
  |  Branch (652:17): [True: 453, False: 105k]
  ------------------
  653|    453|                {
  654|       |                    // (true -- ) or
  655|       |                    // (false -- false) and return
  656|    453|                    if (stack.size() < 1)
  ------------------
  |  Branch (656:25): [True: 8, False: 445]
  ------------------
  657|      8|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  658|    445|                    bool fValue = CastToBool(stacktop(-1));
  ------------------
  |  |   54|    445|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  659|    445|                    if (fValue)
  ------------------
  |  Branch (659:25): [True: 441, False: 4]
  ------------------
  660|    441|                        popstack(stack);
  661|      4|                    else
  662|      4|                        return set_error(serror, SCRIPT_ERR_VERIFY);
  663|    445|                }
  664|    441|                break;
  665|       |
  666|    441|                case OP_RETURN:
  ------------------
  |  Branch (666:17): [True: 4, False: 105k]
  ------------------
  667|      4|                {
  668|      4|                    return set_error(serror, SCRIPT_ERR_OP_RETURN);
  669|    445|                }
  670|      0|                break;
  671|       |
  672|       |
  673|       |                //
  674|       |                // Stack ops
  675|       |                //
  676|    737|                case OP_TOALTSTACK:
  ------------------
  |  Branch (676:17): [True: 737, False: 104k]
  ------------------
  677|    737|                {
  678|    737|                    if (stack.size() < 1)
  ------------------
  |  Branch (678:25): [True: 8, False: 729]
  ------------------
  679|      8|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  680|    729|                    altstack.push_back(stacktop(-1));
  ------------------
  |  |   54|    729|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  681|    729|                    popstack(stack);
  682|    729|                }
  683|      0|                break;
  684|       |
  685|    158|                case OP_FROMALTSTACK:
  ------------------
  |  Branch (685:17): [True: 158, False: 105k]
  ------------------
  686|    158|                {
  687|    158|                    if (altstack.size() < 1)
  ------------------
  |  Branch (687:25): [True: 4, False: 154]
  ------------------
  688|      4|                        return set_error(serror, SCRIPT_ERR_INVALID_ALTSTACK_OPERATION);
  689|    154|                    stack.push_back(altstacktop(-1));
  ------------------
  |  |   55|    154|#define altstacktop(i) (altstack.at(size_t(int64_t(altstack.size()) + int64_t{i})))
  ------------------
  690|    154|                    popstack(altstack);
  691|    154|                }
  692|      0|                break;
  693|       |
  694|    510|                case OP_2DROP:
  ------------------
  |  Branch (694:17): [True: 510, False: 105k]
  ------------------
  695|    510|                {
  696|       |                    // (x1 x2 -- )
  697|    510|                    if (stack.size() < 2)
  ------------------
  |  Branch (697:25): [True: 7, False: 503]
  ------------------
  698|      7|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  699|    503|                    popstack(stack);
  700|    503|                    popstack(stack);
  701|    503|                }
  702|      0|                break;
  703|       |
  704|  3.53k|                case OP_2DUP:
  ------------------
  |  Branch (704:17): [True: 3.53k, False: 102k]
  ------------------
  705|  3.53k|                {
  706|       |                    // (x1 x2 -- x1 x2 x1 x2)
  707|  3.53k|                    if (stack.size() < 2)
  ------------------
  |  Branch (707:25): [True: 2, False: 3.53k]
  ------------------
  708|      2|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  709|  3.53k|                    valtype vch1 = stacktop(-2);
  ------------------
  |  |   54|  3.53k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  710|  3.53k|                    valtype vch2 = stacktop(-1);
  ------------------
  |  |   54|  3.53k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  711|  3.53k|                    stack.push_back(vch1);
  712|  3.53k|                    stack.push_back(vch2);
  713|  3.53k|                }
  714|      0|                break;
  715|       |
  716|  4.57k|                case OP_3DUP:
  ------------------
  |  Branch (716:17): [True: 4.57k, False: 101k]
  ------------------
  717|  4.57k|                {
  718|       |                    // (x1 x2 x3 -- x1 x2 x3 x1 x2 x3)
  719|  4.57k|                    if (stack.size() < 3)
  ------------------
  |  Branch (719:25): [True: 4, False: 4.56k]
  ------------------
  720|      4|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  721|  4.56k|                    valtype vch1 = stacktop(-3);
  ------------------
  |  |   54|  4.56k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  722|  4.56k|                    valtype vch2 = stacktop(-2);
  ------------------
  |  |   54|  4.56k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  723|  4.56k|                    valtype vch3 = stacktop(-1);
  ------------------
  |  |   54|  4.56k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  724|  4.56k|                    stack.push_back(vch1);
  725|  4.56k|                    stack.push_back(vch2);
  726|  4.56k|                    stack.push_back(vch3);
  727|  4.56k|                }
  728|      0|                break;
  729|       |
  730|  2.19k|                case OP_2OVER:
  ------------------
  |  Branch (730:17): [True: 2.19k, False: 103k]
  ------------------
  731|  2.19k|                {
  732|       |                    // (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2)
  733|  2.19k|                    if (stack.size() < 4)
  ------------------
  |  Branch (733:25): [True: 4, False: 2.18k]
  ------------------
  734|      4|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  735|  2.18k|                    valtype vch1 = stacktop(-4);
  ------------------
  |  |   54|  2.18k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  736|  2.18k|                    valtype vch2 = stacktop(-3);
  ------------------
  |  |   54|  2.18k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  737|  2.18k|                    stack.push_back(vch1);
  738|  2.18k|                    stack.push_back(vch2);
  739|  2.18k|                }
  740|      0|                break;
  741|       |
  742|  1.18k|                case OP_2ROT:
  ------------------
  |  Branch (742:17): [True: 1.18k, False: 104k]
  ------------------
  743|  1.18k|                {
  744|       |                    // (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2)
  745|  1.18k|                    if (stack.size() < 6)
  ------------------
  |  Branch (745:25): [True: 4, False: 1.17k]
  ------------------
  746|      4|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  747|  1.17k|                    valtype vch1 = stacktop(-6);
  ------------------
  |  |   54|  1.17k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  748|  1.17k|                    valtype vch2 = stacktop(-5);
  ------------------
  |  |   54|  1.17k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  749|  1.17k|                    stack.erase(stack.end()-6, stack.end()-4);
  750|  1.17k|                    stack.push_back(vch1);
  751|  1.17k|                    stack.push_back(vch2);
  752|  1.17k|                }
  753|      0|                break;
  754|       |
  755|    374|                case OP_2SWAP:
  ------------------
  |  Branch (755:17): [True: 374, False: 105k]
  ------------------
  756|    374|                {
  757|       |                    // (x1 x2 x3 x4 -- x3 x4 x1 x2)
  758|    374|                    if (stack.size() < 4)
  ------------------
  |  Branch (758:25): [True: 5, False: 369]
  ------------------
  759|      5|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  760|    369|                    swap(stacktop(-4), stacktop(-2));
  ------------------
  |  |   54|    369|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
                                  swap(stacktop(-4), stacktop(-2));
  ------------------
  |  |   54|    369|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  761|    369|                    swap(stacktop(-3), stacktop(-1));
  ------------------
  |  |   54|    369|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
                                  swap(stacktop(-3), stacktop(-1));
  ------------------
  |  |   54|    369|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  762|    369|                }
  763|      0|                break;
  764|       |
  765|  2.77k|                case OP_IFDUP:
  ------------------
  |  Branch (765:17): [True: 2.77k, False: 102k]
  ------------------
  766|  2.77k|                {
  767|       |                    // (x - 0 | x x)
  768|  2.77k|                    if (stack.size() < 1)
  ------------------
  |  Branch (768:25): [True: 2, False: 2.77k]
  ------------------
  769|      2|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  770|  2.77k|                    valtype vch = stacktop(-1);
  ------------------
  |  |   54|  2.77k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  771|  2.77k|                    if (CastToBool(vch))
  ------------------
  |  Branch (771:25): [True: 1.78k, False: 988]
  ------------------
  772|  1.78k|                        stack.push_back(vch);
  773|  2.77k|                }
  774|      0|                break;
  775|       |
  776|    619|                case OP_DEPTH:
  ------------------
  |  Branch (776:17): [True: 619, False: 105k]
  ------------------
  777|    619|                {
  778|       |                    // -- stacksize
  779|    619|                    CScriptNum bn(stack.size());
  780|    619|                    stack.push_back(bn.getvch());
  781|    619|                }
  782|    619|                break;
  783|       |
  784|    326|                case OP_DROP:
  ------------------
  |  Branch (784:17): [True: 326, False: 105k]
  ------------------
  785|    326|                {
  786|       |                    // (x -- )
  787|    326|                    if (stack.size() < 1)
  ------------------
  |  Branch (787:25): [True: 5, False: 321]
  ------------------
  788|      5|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  789|    321|                    popstack(stack);
  790|    321|                }
  791|      0|                break;
  792|       |
  793|    872|                case OP_DUP:
  ------------------
  |  Branch (793:17): [True: 872, False: 104k]
  ------------------
  794|    872|                {
  795|       |                    // (x -- x x)
  796|    872|                    if (stack.size() < 1)
  ------------------
  |  Branch (796:25): [True: 1, False: 871]
  ------------------
  797|      1|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  798|    871|                    valtype vch = stacktop(-1);
  ------------------
  |  |   54|    871|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  799|    871|                    stack.push_back(vch);
  800|    871|                }
  801|      0|                break;
  802|       |
  803|  1.14k|                case OP_NIP:
  ------------------
  |  Branch (803:17): [True: 1.14k, False: 104k]
  ------------------
  804|  1.14k|                {
  805|       |                    // (x1 x2 -- x2)
  806|  1.14k|                    if (stack.size() < 2)
  ------------------
  |  Branch (806:25): [True: 4, False: 1.13k]
  ------------------
  807|      4|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  808|  1.13k|                    stack.erase(stack.end() - 2);
  809|  1.13k|                }
  810|      0|                break;
  811|       |
  812|    931|                case OP_OVER:
  ------------------
  |  Branch (812:17): [True: 931, False: 104k]
  ------------------
  813|    931|                {
  814|       |                    // (x1 x2 -- x1 x2 x1)
  815|    931|                    if (stack.size() < 2)
  ------------------
  |  Branch (815:25): [True: 3, False: 928]
  ------------------
  816|      3|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  817|    928|                    valtype vch = stacktop(-2);
  ------------------
  |  |   54|    928|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  818|    928|                    stack.push_back(vch);
  819|    928|                }
  820|      0|                break;
  821|       |
  822|    413|                case OP_PICK:
  ------------------
  |  Branch (822:17): [True: 413, False: 105k]
  ------------------
  823|  1.16k|                case OP_ROLL:
  ------------------
  |  Branch (823:17): [True: 752, False: 104k]
  ------------------
  824|  1.16k|                {
  825|       |                    // (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn)
  826|       |                    // (xn ... x2 x1 x0 n - ... x2 x1 x0 xn)
  827|  1.16k|                    if (stack.size() < 2)
  ------------------
  |  Branch (827:25): [True: 5, False: 1.16k]
  ------------------
  828|      5|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  829|  1.16k|                    int n = CScriptNum(stacktop(-1), fRequireMinimal).getint();
  ------------------
  |  |   54|  1.16k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  830|  1.16k|                    popstack(stack);
  831|  1.16k|                    if (n < 0 || n >= (int)stack.size())
  ------------------
  |  Branch (831:25): [True: 58, False: 1.10k]
  |  Branch (831:34): [True: 70, False: 1.03k]
  ------------------
  832|    122|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  833|  1.03k|                    valtype vch = stacktop(-n-1);
  ------------------
  |  |   54|  1.03k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  834|  1.03k|                    if (opcode == OP_ROLL)
  ------------------
  |  Branch (834:25): [True: 661, False: 377]
  ------------------
  835|    661|                        stack.erase(stack.end()-n-1);
  836|  1.03k|                    stack.push_back(vch);
  837|  1.03k|                }
  838|      0|                break;
  839|       |
  840|    371|                case OP_ROT:
  ------------------
  |  Branch (840:17): [True: 371, False: 105k]
  ------------------
  841|    371|                {
  842|       |                    // (x1 x2 x3 -- x2 x3 x1)
  843|       |                    //  x2 x1 x3  after first swap
  844|       |                    //  x2 x3 x1  after second swap
  845|    371|                    if (stack.size() < 3)
  ------------------
  |  Branch (845:25): [True: 1, False: 370]
  ------------------
  846|      1|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  847|    370|                    swap(stacktop(-3), stacktop(-2));
  ------------------
  |  |   54|    370|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
                                  swap(stacktop(-3), stacktop(-2));
  ------------------
  |  |   54|    370|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  848|    370|                    swap(stacktop(-2), stacktop(-1));
  ------------------
  |  |   54|    370|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
                                  swap(stacktop(-2), stacktop(-1));
  ------------------
  |  |   54|    370|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  849|    370|                }
  850|      0|                break;
  851|       |
  852|    397|                case OP_SWAP:
  ------------------
  |  Branch (852:17): [True: 397, False: 105k]
  ------------------
  853|    397|                {
  854|       |                    // (x1 x2 -- x2 x1)
  855|    397|                    if (stack.size() < 2)
  ------------------
  |  Branch (855:25): [True: 1, False: 396]
  ------------------
  856|      1|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  857|    396|                    swap(stacktop(-2), stacktop(-1));
  ------------------
  |  |   54|    396|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
                                  swap(stacktop(-2), stacktop(-1));
  ------------------
  |  |   54|    396|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  858|    396|                }
  859|      0|                break;
  860|       |
  861|  3.70k|                case OP_TUCK:
  ------------------
  |  Branch (861:17): [True: 3.70k, False: 101k]
  ------------------
  862|  3.70k|                {
  863|       |                    // (x1 x2 -- x2 x1 x2)
  864|  3.70k|                    if (stack.size() < 2)
  ------------------
  |  Branch (864:25): [True: 2, False: 3.70k]
  ------------------
  865|      2|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  866|  3.70k|                    valtype vch = stacktop(-1);
  ------------------
  |  |   54|  3.70k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  867|  3.70k|                    stack.insert(stack.end()-2, vch);
  868|  3.70k|                }
  869|      0|                break;
  870|       |
  871|       |
  872|    675|                case OP_SIZE:
  ------------------
  |  Branch (872:17): [True: 675, False: 104k]
  ------------------
  873|    675|                {
  874|       |                    // (in -- in size)
  875|    675|                    if (stack.size() < 1)
  ------------------
  |  Branch (875:25): [True: 1, False: 674]
  ------------------
  876|      1|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  877|    674|                    CScriptNum bn(stacktop(-1).size());
  ------------------
  |  |   54|    674|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  878|    674|                    stack.push_back(bn.getvch());
  879|    674|                }
  880|      0|                break;
  881|       |
  882|       |
  883|       |                //
  884|       |                // Bitwise logic
  885|       |                //
  886|  2.63k|                case OP_EQUAL:
  ------------------
  |  Branch (886:17): [True: 2.63k, False: 102k]
  ------------------
  887|  2.87k|                case OP_EQUALVERIFY:
  ------------------
  |  Branch (887:17): [True: 239, False: 105k]
  ------------------
  888|       |                //case OP_NOTEQUAL: // use OP_NUMNOTEQUAL
  889|  2.87k|                {
  890|       |                    // (x1 x2 - bool)
  891|  2.87k|                    if (stack.size() < 2)
  ------------------
  |  Branch (891:25): [True: 12, False: 2.86k]
  ------------------
  892|     12|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  893|  2.86k|                    valtype& vch1 = stacktop(-2);
  ------------------
  |  |   54|  2.86k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  894|  2.86k|                    valtype& vch2 = stacktop(-1);
  ------------------
  |  |   54|  2.86k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  895|  2.86k|                    bool fEqual = (vch1 == vch2);
  896|       |                    // OP_NOTEQUAL is disabled because it would be too easy to say
  897|       |                    // something like n != 1 and have some wiseguy pass in 1 with extra
  898|       |                    // zero bytes after it (numerically, 0x01 == 0x0001 == 0x000001)
  899|       |                    //if (opcode == OP_NOTEQUAL)
  900|       |                    //    fEqual = !fEqual;
  901|  2.86k|                    popstack(stack);
  902|  2.86k|                    popstack(stack);
  903|  2.86k|                    stack.push_back(fEqual ? vchTrue : vchFalse);
  ------------------
  |  Branch (903:37): [True: 1.03k, False: 1.83k]
  ------------------
  904|  2.86k|                    if (opcode == OP_EQUALVERIFY)
  ------------------
  |  Branch (904:25): [True: 233, False: 2.62k]
  ------------------
  905|    233|                    {
  906|    233|                        if (fEqual)
  ------------------
  |  Branch (906:29): [True: 218, False: 15]
  ------------------
  907|    218|                            popstack(stack);
  908|     15|                        else
  909|     15|                            return set_error(serror, SCRIPT_ERR_EQUALVERIFY);
  910|    233|                    }
  911|  2.86k|                }
  912|  2.84k|                break;
  913|       |
  914|       |
  915|       |                //
  916|       |                // Numeric
  917|       |                //
  918|  2.84k|                case OP_1ADD:
  ------------------
  |  Branch (918:17): [True: 809, False: 104k]
  ------------------
  919|  2.60k|                case OP_1SUB:
  ------------------
  |  Branch (919:17): [True: 1.79k, False: 103k]
  ------------------
  920|  4.03k|                case OP_NEGATE:
  ------------------
  |  Branch (920:17): [True: 1.42k, False: 104k]
  ------------------
  921|  5.53k|                case OP_ABS:
  ------------------
  |  Branch (921:17): [True: 1.50k, False: 104k]
  ------------------
  922|  6.28k|                case OP_NOT:
  ------------------
  |  Branch (922:17): [True: 749, False: 104k]
  ------------------
  923|  6.85k|                case OP_0NOTEQUAL:
  ------------------
  |  Branch (923:17): [True: 577, False: 105k]
  ------------------
  924|  6.85k|                {
  925|       |                    // (in -- out)
  926|  6.85k|                    if (stack.size() < 1)
  ------------------
  |  Branch (926:25): [True: 2, False: 6.85k]
  ------------------
  927|      2|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  928|  6.85k|                    CScriptNum bn(stacktop(-1), fRequireMinimal);
  ------------------
  |  |   54|  6.85k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  929|  6.85k|                    switch (opcode)
  930|  6.85k|                    {
  931|    809|                    case OP_1ADD:       bn += bnOne; break;
  ------------------
  |  Branch (931:21): [True: 809, False: 6.04k]
  ------------------
  932|  1.79k|                    case OP_1SUB:       bn -= bnOne; break;
  ------------------
  |  Branch (932:21): [True: 1.79k, False: 5.06k]
  ------------------
  933|  1.42k|                    case OP_NEGATE:     bn = -bn; break;
  ------------------
  |  Branch (933:21): [True: 1.42k, False: 5.43k]
  ------------------
  934|  1.50k|                    case OP_ABS:        if (bn < bnZero) bn = -bn; break;
  ------------------
  |  Branch (934:21): [True: 1.50k, False: 5.35k]
  |  Branch (934:45): [True: 168, False: 1.33k]
  ------------------
  935|    745|                    case OP_NOT:        bn = (bn == bnZero); break;
  ------------------
  |  Branch (935:21): [True: 745, False: 6.11k]
  ------------------
  936|    577|                    case OP_0NOTEQUAL:  bn = (bn != bnZero); break;
  ------------------
  |  Branch (936:21): [True: 577, False: 6.27k]
  ------------------
  937|      0|                    default:            assert(!"invalid opcode"); break;
  ------------------
  |  Branch (937:21): [True: 0, False: 6.85k]
  ------------------
  938|  6.85k|                    }
  939|  6.84k|                    popstack(stack);
  940|  6.84k|                    stack.push_back(bn.getvch());
  941|  6.84k|                }
  942|      0|                break;
  943|       |
  944|  1.04k|                case OP_ADD:
  ------------------
  |  Branch (944:17): [True: 1.04k, False: 104k]
  ------------------
  945|  1.90k|                case OP_SUB:
  ------------------
  |  Branch (945:17): [True: 864, False: 104k]
  ------------------
  946|  2.94k|                case OP_BOOLAND:
  ------------------
  |  Branch (946:17): [True: 1.03k, False: 104k]
  ------------------
  947|  3.85k|                case OP_BOOLOR:
  ------------------
  |  Branch (947:17): [True: 907, False: 104k]
  ------------------
  948|  4.45k|                case OP_NUMEQUAL:
  ------------------
  |  Branch (948:17): [True: 600, False: 105k]
  ------------------
  949|  4.70k|                case OP_NUMEQUALVERIFY:
  ------------------
  |  Branch (949:17): [True: 257, False: 105k]
  ------------------
  950|  5.28k|                case OP_NUMNOTEQUAL:
  ------------------
  |  Branch (950:17): [True: 579, False: 105k]
  ------------------
  951|  6.20k|                case OP_LESSTHAN:
  ------------------
  |  Branch (951:17): [True: 914, False: 104k]
  ------------------
  952|  6.86k|                case OP_GREATERTHAN:
  ------------------
  |  Branch (952:17): [True: 665, False: 104k]
  ------------------
  953|  7.44k|                case OP_LESSTHANOREQUAL:
  ------------------
  |  Branch (953:17): [True: 574, False: 105k]
  ------------------
  954|  8.05k|                case OP_GREATERTHANOREQUAL:
  ------------------
  |  Branch (954:17): [True: 611, False: 105k]
  ------------------
  955|  8.97k|                case OP_MIN:
  ------------------
  |  Branch (955:17): [True: 918, False: 104k]
  ------------------
  956|  10.1k|                case OP_MAX:
  ------------------
  |  Branch (956:17): [True: 1.22k, False: 104k]
  ------------------
  957|  10.1k|                {
  958|       |                    // (x1 x2 -- out)
  959|  10.1k|                    if (stack.size() < 2)
  ------------------
  |  Branch (959:25): [True: 78, False: 10.1k]
  ------------------
  960|     78|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  961|  10.1k|                    CScriptNum bn1(stacktop(-2), fRequireMinimal);
  ------------------
  |  |   54|  10.1k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  962|  10.1k|                    CScriptNum bn2(stacktop(-1), fRequireMinimal);
  ------------------
  |  |   54|  10.1k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  963|  10.1k|                    CScriptNum bn(0);
  964|  10.1k|                    switch (opcode)
  965|  10.1k|                    {
  966|  1.03k|                    case OP_ADD:
  ------------------
  |  Branch (966:21): [True: 1.03k, False: 9.08k]
  ------------------
  967|  1.03k|                        bn = bn1 + bn2;
  968|  1.03k|                        break;
  969|       |
  970|    857|                    case OP_SUB:
  ------------------
  |  Branch (970:21): [True: 857, False: 9.25k]
  ------------------
  971|    857|                        bn = bn1 - bn2;
  972|    857|                        break;
  973|       |
  974|  1.03k|                    case OP_BOOLAND:             bn = (bn1 != bnZero && bn2 != bnZero); break;
  ------------------
  |  Branch (974:21): [True: 1.03k, False: 9.08k]
  |  Branch (974:56): [True: 620, False: 411]
  |  Branch (974:73): [True: 416, False: 204]
  ------------------
  975|    898|                    case OP_BOOLOR:              bn = (bn1 != bnZero || bn2 != bnZero); break;
  ------------------
  |  Branch (975:21): [True: 898, False: 9.21k]
  |  Branch (975:56): [True: 410, False: 488]
  |  Branch (975:73): [True: 257, False: 231]
  ------------------
  976|    593|                    case OP_NUMEQUAL:            bn = (bn1 == bn2); break;
  ------------------
  |  Branch (976:21): [True: 593, False: 9.52k]
  ------------------
  977|    254|                    case OP_NUMEQUALVERIFY:      bn = (bn1 == bn2); break;
  ------------------
  |  Branch (977:21): [True: 254, False: 9.86k]
  ------------------
  978|    564|                    case OP_NUMNOTEQUAL:         bn = (bn1 != bn2); break;
  ------------------
  |  Branch (978:21): [True: 564, False: 9.55k]
  ------------------
  979|    901|                    case OP_LESSTHAN:            bn = (bn1 < bn2); break;
  ------------------
  |  Branch (979:21): [True: 901, False: 9.21k]
  ------------------
  980|    651|                    case OP_GREATERTHAN:         bn = (bn1 > bn2); break;
  ------------------
  |  Branch (980:21): [True: 651, False: 9.46k]
  ------------------
  981|    566|                    case OP_LESSTHANOREQUAL:     bn = (bn1 <= bn2); break;
  ------------------
  |  Branch (981:21): [True: 566, False: 9.54k]
  ------------------
  982|    603|                    case OP_GREATERTHANOREQUAL:  bn = (bn1 >= bn2); break;
  ------------------
  |  Branch (982:21): [True: 603, False: 9.51k]
  ------------------
  983|    908|                    case OP_MIN:                 bn = (bn1 < bn2 ? bn1 : bn2); break;
  ------------------
  |  Branch (983:21): [True: 908, False: 9.20k]
  |  Branch (983:56): [True: 251, False: 657]
  ------------------
  984|  1.21k|                    case OP_MAX:                 bn = (bn1 > bn2 ? bn1 : bn2); break;
  ------------------
  |  Branch (984:21): [True: 1.21k, False: 8.90k]
  |  Branch (984:56): [True: 324, False: 886]
  ------------------
  985|      0|                    default:                     assert(!"invalid opcode"); break;
  ------------------
  |  Branch (985:21): [True: 0, False: 10.1k]
  ------------------
  986|  10.1k|                    }
  987|  10.0k|                    popstack(stack);
  988|  10.0k|                    popstack(stack);
  989|  10.0k|                    stack.push_back(bn.getvch());
  990|       |
  991|  10.0k|                    if (opcode == OP_NUMEQUALVERIFY)
  ------------------
  |  Branch (991:25): [True: 254, False: 9.81k]
  ------------------
  992|    254|                    {
  993|    254|                        if (CastToBool(stacktop(-1)))
  ------------------
  |  |   54|    254|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  |  Branch (993:29): [True: 228, False: 26]
  ------------------
  994|    228|                            popstack(stack);
  995|     26|                        else
  996|     26|                            return set_error(serror, SCRIPT_ERR_NUMEQUALVERIFY);
  997|    254|                    }
  998|  10.0k|                }
  999|  10.0k|                break;
 1000|       |
 1001|  10.0k|                case OP_WITHIN:
  ------------------
  |  Branch (1001:17): [True: 1.42k, False: 104k]
  ------------------
 1002|  1.42k|                {
 1003|       |                    // (x min max -- out)
 1004|  1.42k|                    if (stack.size() < 3)
  ------------------
  |  Branch (1004:25): [True: 35, False: 1.38k]
  ------------------
 1005|     35|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
 1006|  1.38k|                    CScriptNum bn1(stacktop(-3), fRequireMinimal);
  ------------------
  |  |   54|  1.38k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1007|  1.38k|                    CScriptNum bn2(stacktop(-2), fRequireMinimal);
  ------------------
  |  |   54|  1.38k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1008|  1.38k|                    CScriptNum bn3(stacktop(-1), fRequireMinimal);
  ------------------
  |  |   54|  1.38k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1009|  1.38k|                    bool fValue = (bn2 <= bn1 && bn1 < bn3);
  ------------------
  |  Branch (1009:36): [True: 1.04k, False: 341]
  |  Branch (1009:50): [True: 346, False: 698]
  ------------------
 1010|  1.38k|                    popstack(stack);
 1011|  1.38k|                    popstack(stack);
 1012|  1.38k|                    popstack(stack);
 1013|  1.38k|                    stack.push_back(fValue ? vchTrue : vchFalse);
  ------------------
  |  Branch (1013:37): [True: 346, False: 1.03k]
  ------------------
 1014|  1.38k|                }
 1015|      0|                break;
 1016|       |
 1017|       |
 1018|       |                //
 1019|       |                // Crypto
 1020|       |                //
 1021|  1.47k|                case OP_RIPEMD160:
  ------------------
  |  Branch (1021:17): [True: 1.47k, False: 104k]
  ------------------
 1022|  3.62k|                case OP_SHA1:
  ------------------
  |  Branch (1022:17): [True: 2.15k, False: 103k]
  ------------------
 1023|  4.21k|                case OP_SHA256:
  ------------------
  |  Branch (1023:17): [True: 588, False: 105k]
  ------------------
 1024|  4.84k|                case OP_HASH160:
  ------------------
  |  Branch (1024:17): [True: 638, False: 104k]
  ------------------
 1025|  6.61k|                case OP_HASH256:
  ------------------
  |  Branch (1025:17): [True: 1.76k, False: 103k]
  ------------------
 1026|  6.61k|                {
 1027|       |                    // (in -- hash)
 1028|  6.61k|                    if (stack.size() < 1)
  ------------------
  |  Branch (1028:25): [True: 2, False: 6.61k]
  ------------------
 1029|      2|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
 1030|  6.61k|                    valtype& vch = stacktop(-1);
  ------------------
  |  |   54|  6.61k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1031|  6.61k|                    valtype vchHash((opcode == OP_RIPEMD160 || opcode == OP_SHA1 || opcode == OP_HASH160) ? 20 : 32);
  ------------------
  |  Branch (1031:38): [True: 1.47k, False: 5.14k]
  |  Branch (1031:64): [True: 2.15k, False: 2.98k]
  |  Branch (1031:85): [True: 638, False: 2.35k]
  ------------------
 1032|  6.61k|                    if (opcode == OP_RIPEMD160)
  ------------------
  |  Branch (1032:25): [True: 1.47k, False: 5.14k]
  ------------------
 1033|  1.47k|                        CRIPEMD160().Write(vch.data(), vch.size()).Finalize(vchHash.data());
 1034|  5.14k|                    else if (opcode == OP_SHA1)
  ------------------
  |  Branch (1034:30): [True: 2.15k, False: 2.98k]
  ------------------
 1035|  2.15k|                        CSHA1().Write(vch.data(), vch.size()).Finalize(vchHash.data());
 1036|  2.98k|                    else if (opcode == OP_SHA256)
  ------------------
  |  Branch (1036:30): [True: 588, False: 2.40k]
  ------------------
 1037|    588|                        CSHA256().Write(vch.data(), vch.size()).Finalize(vchHash.data());
 1038|  2.40k|                    else if (opcode == OP_HASH160)
  ------------------
  |  Branch (1038:30): [True: 638, False: 1.76k]
  ------------------
 1039|    638|                        CHash160().Write(vch).Finalize(vchHash);
 1040|  1.76k|                    else if (opcode == OP_HASH256)
  ------------------
  |  Branch (1040:30): [True: 1.76k, False: 0]
  ------------------
 1041|  1.76k|                        CHash256().Write(vch).Finalize(vchHash);
 1042|  6.61k|                    popstack(stack);
 1043|  6.61k|                    stack.push_back(vchHash);
 1044|  6.61k|                }
 1045|      0|                break;
 1046|       |
 1047|    487|                case OP_CODESEPARATOR:
  ------------------
  |  Branch (1047:17): [True: 487, False: 105k]
  ------------------
 1048|    487|                {
 1049|       |                    // If SCRIPT_VERIFY_CONST_SCRIPTCODE flag is set, use of OP_CODESEPARATOR is rejected in pre-segwit
 1050|       |                    // script, even in an unexecuted branch (this is checked above the opcode case statement).
 1051|       |
 1052|       |                    // Hash starts after the code separator
 1053|    487|                    pbegincodehash = pc;
 1054|    487|                    execdata.m_codeseparator_pos = opcode_pos;
 1055|    487|                }
 1056|    487|                break;
 1057|       |
 1058|  7.13k|                case OP_CHECKSIG:
  ------------------
  |  Branch (1058:17): [True: 7.13k, False: 98.5k]
  ------------------
 1059|  7.14k|                case OP_CHECKSIGVERIFY:
  ------------------
  |  Branch (1059:17): [True: 14, False: 105k]
  ------------------
 1060|  7.14k|                {
 1061|       |                    // (sig pubkey -- bool)
 1062|  7.14k|                    if (stack.size() < 2)
  ------------------
  |  Branch (1062:25): [True: 32, False: 7.11k]
  ------------------
 1063|     32|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
 1064|       |
 1065|  7.11k|                    valtype& vchSig    = stacktop(-2);
  ------------------
  |  |   54|  7.11k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1066|  7.11k|                    valtype& vchPubKey = stacktop(-1);
  ------------------
  |  |   54|  7.11k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1067|       |
 1068|  7.11k|                    bool fSuccess = true;
 1069|  7.11k|                    if (!EvalChecksig(vchSig, vchPubKey, pbegincodehash, pend, execdata, flags, checker, sigversion, serror, fSuccess)) return false;
  ------------------
  |  Branch (1069:25): [True: 0, False: 7.11k]
  ------------------
 1070|  7.11k|                    popstack(stack);
 1071|  7.11k|                    popstack(stack);
 1072|  7.11k|                    stack.push_back(fSuccess ? vchTrue : vchFalse);
  ------------------
  |  Branch (1072:37): [True: 0, False: 7.11k]
  ------------------
 1073|  7.11k|                    if (opcode == OP_CHECKSIGVERIFY)
  ------------------
  |  Branch (1073:25): [True: 14, False: 7.10k]
  ------------------
 1074|     14|                    {
 1075|     14|                        if (fSuccess)
  ------------------
  |  Branch (1075:29): [True: 0, False: 14]
  ------------------
 1076|      0|                            popstack(stack);
 1077|     14|                        else
 1078|     14|                            return set_error(serror, SCRIPT_ERR_CHECKSIGVERIFY);
 1079|     14|                    }
 1080|  7.11k|                }
 1081|  7.10k|                break;
 1082|       |
 1083|  7.10k|                case OP_CHECKSIGADD:
  ------------------
  |  Branch (1083:17): [True: 4, False: 105k]
  ------------------
 1084|      4|                {
 1085|       |                    // OP_CHECKSIGADD is only available in Tapscript
 1086|      4|                    if (sigversion == SigVersion::BASE || sigversion == SigVersion::WITNESS_V0) return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
  ------------------
  |  Branch (1086:25): [True: 4, False: 0]
  |  Branch (1086:59): [True: 0, False: 0]
  ------------------
 1087|       |
 1088|       |                    // (sig num pubkey -- num)
 1089|      0|                    if (stack.size() < 3) return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
  ------------------
  |  Branch (1089:25): [True: 0, False: 0]
  ------------------
 1090|       |
 1091|      0|                    const valtype& sig = stacktop(-3);
  ------------------
  |  |   54|      0|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1092|      0|                    const CScriptNum num(stacktop(-2), fRequireMinimal);
  ------------------
  |  |   54|      0|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1093|      0|                    const valtype& pubkey = stacktop(-1);
  ------------------
  |  |   54|      0|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1094|       |
 1095|      0|                    bool success = true;
 1096|      0|                    if (!EvalChecksig(sig, pubkey, pbegincodehash, pend, execdata, flags, checker, sigversion, serror, success)) return false;
  ------------------
  |  Branch (1096:25): [True: 0, False: 0]
  ------------------
 1097|      0|                    popstack(stack);
 1098|      0|                    popstack(stack);
 1099|      0|                    popstack(stack);
 1100|      0|                    stack.push_back((num + (success ? 1 : 0)).getvch());
  ------------------
  |  Branch (1100:45): [True: 0, False: 0]
  ------------------
 1101|      0|                }
 1102|      0|                break;
 1103|       |
 1104|    880|                case OP_CHECKMULTISIG:
  ------------------
  |  Branch (1104:17): [True: 880, False: 104k]
  ------------------
 1105|  1.47k|                case OP_CHECKMULTISIGVERIFY:
  ------------------
  |  Branch (1105:17): [True: 599, False: 105k]
  ------------------
 1106|  1.47k|                {
 1107|  1.47k|                    if (sigversion == SigVersion::TAPSCRIPT) return set_error(serror, SCRIPT_ERR_TAPSCRIPT_CHECKMULTISIG);
  ------------------
  |  Branch (1107:25): [True: 0, False: 1.47k]
  ------------------
 1108|       |
 1109|       |                    // ([sig ...] num_of_signatures [pubkey ...] num_of_pubkeys -- bool)
 1110|       |
 1111|  1.47k|                    int i = 1;
 1112|  1.47k|                    if ((int)stack.size() < i)
  ------------------
  |  Branch (1112:25): [True: 1, False: 1.47k]
  ------------------
 1113|      1|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
 1114|       |
 1115|  1.47k|                    int nKeysCount = CScriptNum(stacktop(-i), fRequireMinimal).getint();
  ------------------
  |  |   54|  1.47k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1116|  1.47k|                    if (nKeysCount < 0 || nKeysCount > MAX_PUBKEYS_PER_MULTISIG)
  ------------------
  |  Branch (1116:25): [True: 57, False: 1.42k]
  |  Branch (1116:43): [True: 56, False: 1.36k]
  ------------------
 1117|    108|                        return set_error(serror, SCRIPT_ERR_PUBKEY_COUNT);
 1118|  1.37k|                    nOpCount += nKeysCount;
 1119|  1.37k|                    if (nOpCount > MAX_OPS_PER_SCRIPT)
  ------------------
  |  Branch (1119:25): [True: 2, False: 1.36k]
  ------------------
 1120|      2|                        return set_error(serror, SCRIPT_ERR_OP_COUNT);
 1121|  1.36k|                    int ikey = ++i;
 1122|       |                    // ikey2 is the position of last non-signature item in the stack. Top stack item = 1.
 1123|       |                    // With SCRIPT_VERIFY_NULLFAIL, this is used for cleanup if operation fails.
 1124|  1.36k|                    int ikey2 = nKeysCount + 2;
 1125|  1.36k|                    i += nKeysCount;
 1126|  1.36k|                    if ((int)stack.size() < i)
  ------------------
  |  Branch (1126:25): [True: 16, False: 1.35k]
  ------------------
 1127|     16|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
 1128|       |
 1129|  1.35k|                    int nSigsCount = CScriptNum(stacktop(-i), fRequireMinimal).getint();
  ------------------
  |  |   54|  1.35k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1130|  1.35k|                    if (nSigsCount < 0 || nSigsCount > nKeysCount)
  ------------------
  |  Branch (1130:25): [True: 69, False: 1.28k]
  |  Branch (1130:43): [True: 79, False: 1.20k]
  ------------------
 1131|    135|                        return set_error(serror, SCRIPT_ERR_SIG_COUNT);
 1132|  1.21k|                    int isig = ++i;
 1133|  1.21k|                    i += nSigsCount;
 1134|  1.21k|                    if ((int)stack.size() < i)
  ------------------
  |  Branch (1134:25): [True: 7, False: 1.21k]
  ------------------
 1135|      7|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
 1136|       |
 1137|       |                    // Subset of script starting at the most recent codeseparator
 1138|  1.21k|                    CScript scriptCode(pbegincodehash, pend);
 1139|       |
 1140|       |                    // Drop the signature in pre-segwit scripts but not segwit scripts
 1141|  2.93k|                    for (int k = 0; k < nSigsCount; k++)
  ------------------
  |  Branch (1141:37): [True: 1.72k, False: 1.21k]
  ------------------
 1142|  1.72k|                    {
 1143|  1.72k|                        valtype& vchSig = stacktop(-isig-k);
  ------------------
  |  |   54|  1.72k|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1144|  1.72k|                        if (sigversion == SigVersion::BASE) {
  ------------------
  |  Branch (1144:29): [True: 1.72k, False: 0]
  ------------------
 1145|  1.72k|                            int found = FindAndDelete(scriptCode, CScript() << vchSig);
 1146|  1.72k|                            if (found > 0 && (flags & SCRIPT_VERIFY_CONST_SCRIPTCODE))
  ------------------
  |  Branch (1146:33): [True: 267, False: 1.45k]
  |  Branch (1146:46): [True: 0, False: 267]
  ------------------
 1147|      0|                                return set_error(serror, SCRIPT_ERR_SIG_FINDANDDELETE);
 1148|  1.72k|                        }
 1149|  1.72k|                    }
 1150|       |
 1151|  1.21k|                    bool fSuccess = true;
 1152|  1.83k|                    while (fSuccess && nSigsCount > 0)
  ------------------
  |  Branch (1152:28): [True: 1.56k, False: 268]
  |  Branch (1152:40): [True: 622, False: 942]
  ------------------
 1153|    622|                    {
 1154|    622|                        valtype& vchSig    = stacktop(-isig);
  ------------------
  |  |   54|    622|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1155|    622|                        valtype& vchPubKey = stacktop(-ikey);
  ------------------
  |  |   54|    622|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
 1156|       |
 1157|       |                        // Note how this makes the exact order of pubkey/signature evaluation
 1158|       |                        // distinguishable by CHECKMULTISIG NOT if the STRICTENC flag is set.
 1159|       |                        // See the script_(in)valid tests for details.
 1160|    622|                        if (!CheckSignatureEncoding(vchSig, flags, serror) || !CheckPubKeyEncoding(vchPubKey, flags, sigversion, serror)) {
  ------------------
  |  Branch (1160:29): [True: 0, False: 622]
  |  Branch (1160:79): [True: 0, False: 622]
  ------------------
 1161|       |                            // serror is set
 1162|      0|                            return false;
 1163|      0|                        }
 1164|       |
 1165|       |                        // Check signature
 1166|    622|                        bool fOk = checker.CheckECDSASignature(vchSig, vchPubKey, scriptCode, sigversion);
 1167|       |
 1168|    622|                        if (fOk) {
  ------------------
  |  Branch (1168:29): [True: 0, False: 622]
  ------------------
 1169|      0|                            isig++;
 1170|      0|                            nSigsCount--;
 1171|      0|                        }
 1172|    622|                        ikey++;
 1173|    622|                        nKeysCount--;
 1174|       |
 1175|       |                        // If there are more signatures left than keys left,
 1176|       |                        // then too many signatures have failed. Exit early,
 1177|       |                        // without checking any further signatures.
 1178|    622|                        if (nSigsCount > nKeysCount)
  ------------------
  |  Branch (1178:29): [True: 255, False: 367]
  ------------------
 1179|    255|                            fSuccess = false;
 1180|    622|                    }
 1181|       |
 1182|       |                    // Clean up stack of actual arguments
 1183|  8.09k|                    while (i-- > 1) {
  ------------------
  |  Branch (1183:28): [True: 6.88k, False: 1.21k]
  ------------------
 1184|       |                        // If the operation failed, we require that all signatures must be empty vector
 1185|  6.88k|                        if (!fSuccess && (flags & SCRIPT_VERIFY_NULLFAIL) && !ikey2 && stacktop(-1).size())
  ------------------
  |  |   54|      0|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  |  Branch (1185:29): [True: 4.32k, False: 2.55k]
  |  Branch (1185:42): [True: 0, False: 4.32k]
  |  Branch (1185:78): [True: 0, False: 0]
  |  Branch (1185:88): [True: 0, False: 0]
  ------------------
 1186|      0|                            return set_error(serror, SCRIPT_ERR_SIG_NULLFAIL);
 1187|  6.88k|                        if (ikey2 > 0)
  ------------------
  |  Branch (1187:29): [True: 5.15k, False: 1.72k]
  ------------------
 1188|  5.15k|                            ikey2--;
 1189|  6.88k|                        popstack(stack);
 1190|  6.88k|                    }
 1191|       |
 1192|       |                    // A bug causes CHECKMULTISIG to consume one extra argument
 1193|       |                    // whose contents were not checked in any way.
 1194|       |                    //
 1195|       |                    // Unfortunately this is a potential source of mutability,
 1196|       |                    // so optionally verify it is exactly equal to zero prior
 1197|       |                    // to removing it from the stack.
 1198|  1.21k|                    if (stack.size() < 1)
  ------------------
  |  Branch (1198:25): [True: 0, False: 1.21k]
  ------------------
 1199|      0|                        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);
 1200|  1.21k|                    if ((flags & SCRIPT_VERIFY_NULLDUMMY) && stacktop(-1).size())
  ------------------
  |  |   54|      0|#define stacktop(i) (stack.at(size_t(int64_t(stack.size()) + int64_t{i})))
  ------------------
  |  Branch (1200:25): [True: 0, False: 1.21k]
  |  Branch (1200:62): [True: 0, False: 0]
  ------------------
 1201|      0|                        return set_error(serror, SCRIPT_ERR_SIG_NULLDUMMY);
 1202|  1.21k|                    popstack(stack);
 1203|       |
 1204|  1.21k|                    stack.push_back(fSuccess ? vchTrue : vchFalse);
  ------------------
  |  Branch (1204:37): [True: 942, False: 268]
  ------------------
 1205|       |
 1206|  1.21k|                    if (opcode == OP_CHECKMULTISIGVERIFY)
  ------------------
  |  Branch (1206:25): [True: 473, False: 737]
  ------------------
 1207|    473|                    {
 1208|    473|                        if (fSuccess)
  ------------------
  |  Branch (1208:29): [True: 446, False: 27]
  ------------------
 1209|    446|                            popstack(stack);
 1210|     27|                        else
 1211|     27|                            return set_error(serror, SCRIPT_ERR_CHECKMULTISIGVERIFY);
 1212|    473|                    }
 1213|  1.21k|                }
 1214|  1.18k|                break;
 1215|       |
 1216|  1.18k|                default:
  ------------------
  |  Branch (1216:17): [True: 208, False: 105k]
  ------------------
 1217|    208|                    return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
 1218|   105k|            }
 1219|       |
 1220|       |            // Size limits
 1221|   162k|            if (stack.size() + altstack.size() > MAX_STACK_SIZE)
  ------------------
  |  Branch (1221:17): [True: 3, False: 162k]
  ------------------
 1222|      3|                return set_error(serror, SCRIPT_ERR_STACK_SIZE);
 1223|   162k|        }
 1224|  2.59k|    }
 1225|  2.59k|    catch (...)
 1226|  2.59k|    {
 1227|     93|        return set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR);
 1228|     93|    }
 1229|       |
 1230|  1.02k|    if (!vfExec.empty())
  ------------------
  |  Branch (1230:9): [True: 95, False: 933]
  ------------------
 1231|     95|        return set_error(serror, SCRIPT_ERR_UNBALANCED_CONDITIONAL);
 1232|       |
 1233|    933|    return set_success(serror);
 1234|  1.02k|}
_Z10EvalScriptRNSt3__16vectorINS0_IhNS_9allocatorIhEEEENS1_IS3_EEEERK7CScriptjRK20BaseSignatureChecker10SigVersionP13ScriptError_t:
 1237|  2.59k|{
 1238|  2.59k|    ScriptExecutionData execdata;
 1239|  2.59k|    return EvalScript(stack, script, flags, checker, sigversion, execdata, serror);
 1240|  2.59k|}
_Z18CountWitnessSigOpsRK7CScriptS1_PK14CScriptWitnessj:
 2096|  5.63k|{
 2097|  5.63k|    static const CScriptWitness witnessEmpty;
 2098|       |
 2099|  5.63k|    if ((flags & SCRIPT_VERIFY_WITNESS) == 0) {
  ------------------
  |  Branch (2099:9): [True: 372, False: 5.26k]
  ------------------
 2100|    372|        return 0;
 2101|    372|    }
 2102|  5.26k|    assert((flags & SCRIPT_VERIFY_P2SH) != 0);
 2103|       |
 2104|  5.26k|    int witnessversion;
 2105|  5.26k|    std::vector<unsigned char> witnessprogram;
 2106|  5.26k|    if (scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
  ------------------
  |  Branch (2106:9): [True: 1.79k, False: 3.46k]
  ------------------
 2107|  1.79k|        return WitnessSigOps(witnessversion, witnessprogram, witness ? *witness : witnessEmpty);
  ------------------
  |  Branch (2107:62): [True: 1.79k, False: 0]
  ------------------
 2108|  1.79k|    }
 2109|       |
 2110|  3.46k|    if (scriptPubKey.IsPayToScriptHash() && scriptSig.IsPushOnly()) {
  ------------------
  |  Branch (2110:9): [True: 2.45k, False: 1.01k]
  |  Branch (2110:45): [True: 723, False: 1.72k]
  ------------------
 2111|    723|        CScript::const_iterator pc = scriptSig.begin();
 2112|    723|        std::vector<unsigned char> data;
 2113|  12.8k|        while (pc < scriptSig.end()) {
  ------------------
  |  Branch (2113:16): [True: 12.1k, False: 723]
  ------------------
 2114|  12.1k|            opcodetype opcode;
 2115|  12.1k|            scriptSig.GetOp(pc, opcode, data);
 2116|  12.1k|        }
 2117|    723|        CScript subscript(data.begin(), data.end());
 2118|    723|        if (subscript.IsWitnessProgram(witnessversion, witnessprogram)) {
  ------------------
  |  Branch (2118:13): [True: 7, False: 716]
  ------------------
 2119|      7|            return WitnessSigOps(witnessversion, witnessprogram, witness ? *witness : witnessEmpty);
  ------------------
  |  Branch (2119:66): [True: 7, False: 0]
  ------------------
 2120|      7|        }
 2121|    723|    }
 2122|       |
 2123|  3.46k|    return 0;
 2124|  3.46k|}
interpreter.cpp:_ZN12_GLOBAL__N_19set_errorEP13ScriptError_tS0_:
   27|  4.25k|{
   28|  4.25k|    if (ret)
  ------------------
  |  Branch (28:9): [True: 0, False: 4.25k]
  ------------------
   29|      0|        *ret = serror;
   30|  4.25k|    return false;
   31|  4.25k|}
interpreter.cpp:_ZNK12_GLOBAL__N_114ConditionStack8all_trueEv:
  284|   164k|    bool all_true() const { return m_first_false_pos == NO_FALSE; }
interpreter.cpp:_ZL8popstackRNSt3__16vectorINS0_IhNS_9allocatorIhEEEENS1_IS3_EEEE:
   57|  71.9k|{
   58|  71.9k|    if (stack.empty())
  ------------------
  |  Branch (58:9): [True: 0, False: 71.9k]
  ------------------
   59|      0|        throw std::runtime_error("popstack(): stack empty");
   60|  71.9k|    stack.pop_back();
   61|  71.9k|}
interpreter.cpp:_ZN12_GLOBAL__N_114ConditionStack9push_backEb:
  286|  2.77k|    {
  287|  2.77k|        if (m_first_false_pos == NO_FALSE && !f) {
  ------------------
  |  Branch (287:13): [True: 1.50k, False: 1.27k]
  |  Branch (287:46): [True: 161, False: 1.34k]
  ------------------
  288|       |            // The stack consists of all true values, and a false is added.
  289|       |            // The first false value will appear at the current size.
  290|    161|            m_first_false_pos = m_stack_size;
  291|    161|        }
  292|  2.77k|        ++m_stack_size;
  293|  2.77k|    }
interpreter.cpp:_ZNK12_GLOBAL__N_114ConditionStack5emptyEv:
  283|  1.76k|    bool empty() const { return m_stack_size == 0; }
interpreter.cpp:_ZN12_GLOBAL__N_114ConditionStack10toggle_topEv:
  304|    421|    {
  305|    421|        assert(m_stack_size > 0);
  306|    421|        if (m_first_false_pos == NO_FALSE) {
  ------------------
  |  Branch (306:13): [True: 81, False: 340]
  ------------------
  307|       |            // The current stack is all true values; the first false will be the top.
  308|     81|            m_first_false_pos = m_stack_size - 1;
  309|    340|        } else if (m_first_false_pos == m_stack_size - 1) {
  ------------------
  |  Branch (309:20): [True: 92, False: 248]
  ------------------
  310|       |            // The top is the first false value; toggling it will make everything true.
  311|     92|            m_first_false_pos = NO_FALSE;
  312|    248|        } else {
  313|       |            // There is a false value, but not on top. No action is needed as toggling
  314|       |            // anything but the first false value is unobservable.
  315|    248|        }
  316|    421|    }
interpreter.cpp:_ZN12_GLOBAL__N_114ConditionStack8pop_backEv:
  295|    306|    {
  296|    306|        assert(m_stack_size > 0);
  297|    306|        --m_stack_size;
  298|    306|        if (m_first_false_pos == m_stack_size) {
  ------------------
  |  Branch (298:13): [True: 53, False: 253]
  ------------------
  299|       |            // When popping off the first false value, everything becomes true.
  300|     53|            m_first_false_pos = NO_FALSE;
  301|     53|        }
  302|    306|    }
interpreter.cpp:_ZL12EvalChecksigRKNSt3__16vectorIhNS_9allocatorIhEEEES5_N9prevectorILj28EhjiE14const_iteratorES8_R19ScriptExecutionDatajRK20BaseSignatureChecker10SigVersionP13ScriptError_tRb:
  392|  7.11k|{
  393|  7.11k|    switch (sigversion) {
  ------------------
  |  Branch (393:13): [True: 0, False: 7.11k]
  ------------------
  394|  7.11k|    case SigVersion::BASE:
  ------------------
  |  Branch (394:5): [True: 7.11k, False: 0]
  ------------------
  395|  7.11k|    case SigVersion::WITNESS_V0:
  ------------------
  |  Branch (395:5): [True: 0, False: 7.11k]
  ------------------
  396|  7.11k|        return EvalChecksigPreTapscript(sig, pubkey, pbegincodehash, pend, flags, checker, sigversion, serror, success);
  397|      0|    case SigVersion::TAPSCRIPT:
  ------------------
  |  Branch (397:5): [True: 0, False: 7.11k]
  ------------------
  398|      0|        return EvalChecksigTapscript(sig, pubkey, execdata, flags, checker, sigversion, serror, success);
  399|      0|    case SigVersion::TAPROOT:
  ------------------
  |  Branch (399:5): [True: 0, False: 7.11k]
  ------------------
  400|       |        // Key path spending in Taproot has no script, so this is unreachable.
  401|      0|        break;
  402|  7.11k|    }
  403|      0|    assert(false);
  404|      0|}
interpreter.cpp:_ZL24EvalChecksigPreTapscriptRKNSt3__16vectorIhNS_9allocatorIhEEEES5_N9prevectorILj28EhjiE14const_iteratorES8_jRK20BaseSignatureChecker10SigVersionP13ScriptError_tRb:
  321|  7.11k|{
  322|  7.11k|    assert(sigversion == SigVersion::BASE || sigversion == SigVersion::WITNESS_V0);
  323|       |
  324|       |    // Subset of script starting at the most recent codeseparator
  325|  7.11k|    CScript scriptCode(pbegincodehash, pend);
  326|       |
  327|       |    // Drop the signature in pre-segwit scripts but not segwit scripts
  328|  7.11k|    if (sigversion == SigVersion::BASE) {
  ------------------
  |  Branch (328:9): [True: 7.11k, False: 0]
  ------------------
  329|  7.11k|        int found = FindAndDelete(scriptCode, CScript() << vchSig);
  330|  7.11k|        if (found > 0 && (flags & SCRIPT_VERIFY_CONST_SCRIPTCODE))
  ------------------
  |  Branch (330:13): [True: 5.16k, False: 1.95k]
  |  Branch (330:26): [True: 0, False: 5.16k]
  ------------------
  331|      0|            return set_error(serror, SCRIPT_ERR_SIG_FINDANDDELETE);
  332|  7.11k|    }
  333|       |
  334|  7.11k|    if (!CheckSignatureEncoding(vchSig, flags, serror) || !CheckPubKeyEncoding(vchPubKey, flags, sigversion, serror)) {
  ------------------
  |  Branch (334:9): [True: 0, False: 7.11k]
  |  Branch (334:59): [True: 0, False: 7.11k]
  ------------------
  335|       |        //serror is set
  336|      0|        return false;
  337|      0|    }
  338|  7.11k|    fSuccess = checker.CheckECDSASignature(vchSig, vchPubKey, scriptCode, sigversion);
  339|       |
  340|  7.11k|    if (!fSuccess && (flags & SCRIPT_VERIFY_NULLFAIL) && vchSig.size())
  ------------------
  |  Branch (340:9): [True: 7.11k, False: 0]
  |  Branch (340:22): [True: 0, False: 7.11k]
  |  Branch (340:58): [True: 0, False: 0]
  ------------------
  341|      0|        return set_error(serror, SCRIPT_ERR_SIG_NULLFAIL);
  342|       |
  343|  7.11k|    return true;
  344|  7.11k|}
interpreter.cpp:_ZL19CheckPubKeyEncodingRKNSt3__16vectorIhNS_9allocatorIhEEEEjRK10SigVersionP13ScriptError_t:
  217|  7.73k|bool static CheckPubKeyEncoding(const valtype &vchPubKey, unsigned int flags, const SigVersion &sigversion, ScriptError* serror) {
  218|  7.73k|    if ((flags & SCRIPT_VERIFY_STRICTENC) != 0 && !IsCompressedOrUncompressedPubKey(vchPubKey)) {
  ------------------
  |  Branch (218:9): [True: 0, False: 7.73k]
  |  Branch (218:51): [True: 0, False: 0]
  ------------------
  219|      0|        return set_error(serror, SCRIPT_ERR_PUBKEYTYPE);
  220|      0|    }
  221|       |    // Only compressed keys are accepted in segwit
  222|  7.73k|    if ((flags & SCRIPT_VERIFY_WITNESS_PUBKEYTYPE) != 0 && sigversion == SigVersion::WITNESS_V0 && !IsCompressedPubKey(vchPubKey)) {
  ------------------
  |  Branch (222:9): [True: 0, False: 7.73k]
  |  Branch (222:60): [True: 0, False: 0]
  |  Branch (222:100): [True: 0, False: 0]
  ------------------
  223|      0|        return set_error(serror, SCRIPT_ERR_WITNESS_PUBKEYTYPE);
  224|      0|    }
  225|  7.73k|    return true;
  226|  7.73k|}
interpreter.cpp:_ZN12_GLOBAL__N_111set_successEP13ScriptError_t:
   20|    933|{
   21|    933|    if (ret)
  ------------------
  |  Branch (21:9): [True: 0, False: 933]
  ------------------
   22|      0|        *ret = SCRIPT_ERR_OK;
   23|    933|    return true;
   24|    933|}
interpreter.cpp:_ZL13WitnessSigOpsiRKNSt3__16vectorIhNS_9allocatorIhEEEERK14CScriptWitness:
 2080|  1.80k|{
 2081|  1.80k|    if (witversion == 0) {
  ------------------
  |  Branch (2081:9): [True: 1.53k, False: 262]
  ------------------
 2082|  1.53k|        if (witprogram.size() == WITNESS_V0_KEYHASH_SIZE)
  ------------------
  |  Branch (2082:13): [True: 118, False: 1.42k]
  ------------------
 2083|    118|            return 1;
 2084|       |
 2085|  1.42k|        if (witprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE && witness.stack.size() > 0) {
  ------------------
  |  Branch (2085:13): [True: 1.15k, False: 265]
  |  Branch (2085:64): [True: 664, False: 492]
  ------------------
 2086|    664|            CScript subscript(witness.stack.back().begin(), witness.stack.back().end());
 2087|    664|            return subscript.GetSigOpCount(true);
 2088|    664|        }
 2089|  1.42k|    }
 2090|       |
 2091|       |    // Future flags may be implemented here.
 2092|  1.01k|    return 0;
 2093|  1.80k|}

_ZNK20BaseSignatureChecker19CheckECDSASignatureERKNSt3__16vectorIhNS0_9allocatorIhEEEES6_RK7CScript10SigVersion:
  249|  7.73k|    {
  250|  7.73k|        return false;
  251|  7.73k|    }
_ZN20BaseSignatureCheckerD2Ev:
  268|  2.59k|    virtual ~BaseSignatureChecker() = default;

_ZNK7CScript13GetSigOpCountEb:
  160|  11.2k|{
  161|  11.2k|    unsigned int n = 0;
  162|  11.2k|    const_iterator pc = begin();
  163|  11.2k|    opcodetype lastOpcode = OP_INVALIDOPCODE;
  164|   432k|    while (pc < end())
  ------------------
  |  Branch (164:12): [True: 427k, False: 4.29k]
  ------------------
  165|   427k|    {
  166|   427k|        opcodetype opcode;
  167|   427k|        if (!GetOp(pc, opcode))
  ------------------
  |  Branch (167:13): [True: 6.98k, False: 420k]
  ------------------
  168|  6.98k|            break;
  169|   420k|        if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
  ------------------
  |  Branch (169:13): [True: 462, False: 420k]
  |  Branch (169:38): [True: 239, False: 420k]
  ------------------
  170|    701|            n++;
  171|   420k|        else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
  ------------------
  |  Branch (171:18): [True: 682, False: 419k]
  |  Branch (171:48): [True: 4.31k, False: 415k]
  ------------------
  172|  4.99k|        {
  173|  4.99k|            if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)
  ------------------
  |  Branch (173:17): [True: 4.26k, False: 733]
  |  Branch (173:30): [True: 4.15k, False: 111]
  |  Branch (173:52): [True: 248, False: 3.90k]
  ------------------
  174|    248|                n += DecodeOP_N(lastOpcode);
  175|  4.74k|            else
  176|  4.74k|                n += MAX_PUBKEYS_PER_MULTISIG;
  177|  4.99k|        }
  178|   420k|        lastOpcode = opcode;
  179|   420k|    }
  180|  11.2k|    return n;
  181|  11.2k|}
_ZNK7CScript13GetSigOpCountERKS_:
  184|  2.61k|{
  185|  2.61k|    if (!IsPayToScriptHash())
  ------------------
  |  Branch (185:9): [True: 0, False: 2.61k]
  ------------------
  186|      0|        return GetSigOpCount(true);
  187|       |
  188|       |    // This is a pay-to-script-hash scriptPubKey;
  189|       |    // get the last item that the scriptSig
  190|       |    // pushes onto the stack:
  191|  2.61k|    const_iterator pc = scriptSig.begin();
  192|  2.61k|    std::vector<unsigned char> vData;
  193|  27.2k|    while (pc < scriptSig.end())
  ------------------
  |  Branch (193:12): [True: 26.4k, False: 794]
  ------------------
  194|  26.4k|    {
  195|  26.4k|        opcodetype opcode;
  196|  26.4k|        if (!scriptSig.GetOp(pc, opcode, vData))
  ------------------
  |  Branch (196:13): [True: 1.65k, False: 24.7k]
  ------------------
  197|  1.65k|            return 0;
  198|  24.7k|        if (opcode > OP_16)
  ------------------
  |  Branch (198:13): [True: 162, False: 24.6k]
  ------------------
  199|    162|            return 0;
  200|  24.7k|    }
  201|       |
  202|       |    /// ... and return its opcount:
  203|    794|    CScript subscript(vData.begin(), vData.end());
  204|    794|    return subscript.GetSigOpCount(true);
  205|  2.61k|}
_ZNK7CScript13IsPayToAnchorEv:
  208|  2.26k|{
  209|  2.26k|    return (this->size() == 4 &&
  ------------------
  |  Branch (209:13): [True: 751, False: 1.51k]
  ------------------
  210|  2.26k|        (*this)[0] == OP_1 &&
  ------------------
  |  Branch (210:9): [True: 502, False: 249]
  ------------------
  211|  2.26k|        (*this)[1] == 0x02 &&
  ------------------
  |  Branch (211:9): [True: 498, False: 4]
  ------------------
  212|  2.26k|        (*this)[2] == 0x4e &&
  ------------------
  |  Branch (212:9): [True: 254, False: 244]
  ------------------
  213|  2.26k|        (*this)[3] == 0x73);
  ------------------
  |  Branch (213:9): [True: 254, False: 0]
  ------------------
  214|  2.26k|}
_ZNK7CScript17IsPayToScriptHashEv:
  225|  19.4k|{
  226|       |    // Extra-fast test for pay-to-script-hash CScripts:
  227|  19.4k|    return (this->size() == 23 &&
  ------------------
  |  Branch (227:13): [True: 10.7k, False: 8.68k]
  ------------------
  228|  19.4k|            (*this)[0] == OP_HASH160 &&
  ------------------
  |  Branch (228:13): [True: 10.5k, False: 238]
  ------------------
  229|  19.4k|            (*this)[1] == 0x14 &&
  ------------------
  |  Branch (229:13): [True: 10.2k, False: 263]
  ------------------
  230|  19.4k|            (*this)[22] == OP_EQUAL);
  ------------------
  |  Branch (230:13): [True: 10.2k, False: 0]
  ------------------
  231|  19.4k|}
_ZNK7CScript16IsWitnessProgramERiRNSt3__16vectorIhNS1_9allocatorIhEEEE:
  244|  11.0k|{
  245|  11.0k|    if (this->size() < 4 || this->size() > 42) {
  ------------------
  |  Branch (245:9): [True: 1.79k, False: 9.28k]
  |  Branch (245:29): [True: 817, False: 8.46k]
  ------------------
  246|  2.61k|        return false;
  247|  2.61k|    }
  248|  8.46k|    if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {
  ------------------
  |  Branch (248:9): [True: 5.57k, False: 2.89k]
  |  Branch (248:32): [True: 669, False: 4.90k]
  |  Branch (248:53): [True: 2.88k, False: 2.01k]
  ------------------
  249|  3.55k|        return false;
  250|  3.55k|    }
  251|  4.90k|    if ((size_t)((*this)[1] + 2) == this->size()) {
  ------------------
  |  Branch (251:9): [True: 4.48k, False: 425]
  ------------------
  252|  4.48k|        version = DecodeOP_N((opcodetype)(*this)[0]);
  253|  4.48k|        program = std::vector<unsigned char>(this->begin() + 2, this->end());
  254|  4.48k|        return true;
  255|  4.48k|    }
  256|    425|    return false;
  257|  4.90k|}
_ZNK7CScript10IsPushOnlyEN9prevectorILj28EhjiE14const_iteratorE:
  260|  2.50k|{
  261|  22.8k|    while (pc < end())
  ------------------
  |  Branch (261:12): [True: 22.0k, False: 734]
  ------------------
  262|  22.0k|    {
  263|  22.0k|        opcodetype opcode;
  264|  22.0k|        if (!GetOp(pc, opcode))
  ------------------
  |  Branch (264:13): [True: 1.63k, False: 20.4k]
  ------------------
  265|  1.63k|            return false;
  266|       |        // Note that IsPushOnly() *does* consider OP_RESERVED to be a
  267|       |        // push-type opcode, however execution of OP_RESERVED fails, so
  268|       |        // it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to
  269|       |        // the P2SH special validation code being executed.
  270|  20.4k|        if (opcode > OP_16)
  ------------------
  |  Branch (270:13): [True: 130, False: 20.3k]
  ------------------
  271|    130|            return false;
  272|  20.4k|    }
  273|    734|    return true;
  274|  2.50k|}
_ZNK7CScript10IsPushOnlyEv:
  277|  2.45k|{
  278|  2.45k|    return this->IsPushOnly(begin());
  279|  2.45k|}
_Z11GetScriptOpRN9prevectorILj28EhjiE14const_iteratorES1_R10opcodetypePNSt3__16vectorIhNS5_9allocatorIhEEEE:
  307|  4.49M|{
  308|  4.49M|    opcodeRet = OP_INVALIDOPCODE;
  309|  4.49M|    if (pvchRet)
  ------------------
  |  Branch (309:9): [True: 203k, False: 4.29M]
  ------------------
  310|   203k|        pvchRet->clear();
  311|  4.49M|    if (pc >= end)
  ------------------
  |  Branch (311:9): [True: 3.98k, False: 4.49M]
  ------------------
  312|  3.98k|        return false;
  313|       |
  314|       |    // Read instruction
  315|  4.49M|    if (end - pc < 1)
  ------------------
  |  Branch (315:9): [True: 0, False: 4.49M]
  ------------------
  316|      0|        return false;
  317|  4.49M|    unsigned int opcode = *pc++;
  318|       |
  319|       |    // Immediate operand
  320|  4.49M|    if (opcode <= OP_PUSHDATA4)
  ------------------
  |  Branch (320:9): [True: 1.59M, False: 2.89M]
  ------------------
  321|  1.59M|    {
  322|  1.59M|        unsigned int nSize = 0;
  323|  1.59M|        if (opcode < OP_PUSHDATA1)
  ------------------
  |  Branch (323:13): [True: 1.57M, False: 12.9k]
  ------------------
  324|  1.57M|        {
  325|  1.57M|            nSize = opcode;
  326|  1.57M|        }
  327|  12.9k|        else if (opcode == OP_PUSHDATA1)
  ------------------
  |  Branch (327:18): [True: 3.31k, False: 9.67k]
  ------------------
  328|  3.31k|        {
  329|  3.31k|            if (end - pc < 1)
  ------------------
  |  Branch (329:17): [True: 545, False: 2.76k]
  ------------------
  330|    545|                return false;
  331|  2.76k|            nSize = *pc++;
  332|  2.76k|        }
  333|  9.67k|        else if (opcode == OP_PUSHDATA2)
  ------------------
  |  Branch (333:18): [True: 6.66k, False: 3.00k]
  ------------------
  334|  6.66k|        {
  335|  6.66k|            if (end - pc < 2)
  ------------------
  |  Branch (335:17): [True: 616, False: 6.05k]
  ------------------
  336|    616|                return false;
  337|  6.05k|            nSize = ReadLE16(&pc[0]);
  338|  6.05k|            pc += 2;
  339|  6.05k|        }
  340|  3.00k|        else if (opcode == OP_PUSHDATA4)
  ------------------
  |  Branch (340:18): [True: 3.00k, False: 0]
  ------------------
  341|  3.00k|        {
  342|  3.00k|            if (end - pc < 4)
  ------------------
  |  Branch (342:17): [True: 561, False: 2.44k]
  ------------------
  343|    561|                return false;
  344|  2.44k|            nSize = ReadLE32(&pc[0]);
  345|  2.44k|            pc += 4;
  346|  2.44k|        }
  347|  1.59M|        if (end - pc < 0 || (unsigned int)(end - pc) < nSize)
  ------------------
  |  Branch (347:13): [True: 0, False: 1.59M]
  |  Branch (347:29): [True: 13.8k, False: 1.57M]
  ------------------
  348|  13.8k|            return false;
  349|  1.57M|        if (pvchRet)
  ------------------
  |  Branch (349:13): [True: 63.7k, False: 1.51M]
  ------------------
  350|  63.7k|            pvchRet->assign(pc, pc + nSize);
  351|  1.57M|        pc += nSize;
  352|  1.57M|    }
  353|       |
  354|  4.47M|    opcodeRet = static_cast<opcodetype>(opcode);
  355|  4.47M|    return true;
  356|  4.49M|}
_Z16CheckMinimalPushRKNSt3__16vectorIhNS_9allocatorIhEEEE10opcodetype:
  366|    141|bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode) {
  367|       |    // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal
  368|    141|    assert(0 <= opcode && opcode <= OP_PUSHDATA4);
  369|    141|    if (data.size() == 0) {
  ------------------
  |  Branch (369:9): [True: 2, False: 139]
  ------------------
  370|       |        // Should have used OP_0.
  371|      2|        return opcode == OP_0;
  372|    139|    } else if (data.size() == 1 && data[0] >= 1 && data[0] <= 16) {
  ------------------
  |  Branch (372:16): [True: 34, False: 105]
  |  Branch (372:36): [True: 33, False: 1]
  |  Branch (372:52): [True: 8, False: 25]
  ------------------
  373|       |        // Should have used OP_1 .. OP_16.
  374|      8|        return false;
  375|    131|    } else if (data.size() == 1 && data[0] == 0x81) {
  ------------------
  |  Branch (375:16): [True: 26, False: 105]
  |  Branch (375:36): [True: 1, False: 25]
  ------------------
  376|       |        // Should have used OP_1NEGATE.
  377|      1|        return false;
  378|    130|    } else if (data.size() <= 75) {
  ------------------
  |  Branch (378:16): [True: 128, False: 2]
  ------------------
  379|       |        // Must have used a direct push (opcode indicating number of bytes pushed + those bytes).
  380|    128|        return opcode == data.size();
  381|    128|    } else if (data.size() <= 255) {
  ------------------
  |  Branch (381:16): [True: 2, False: 0]
  ------------------
  382|       |        // Must have used OP_PUSHDATA.
  383|      2|        return opcode == OP_PUSHDATA1;
  384|      2|    } else if (data.size() <= 65535) {
  ------------------
  |  Branch (384:16): [True: 0, False: 0]
  ------------------
  385|       |        // Must have used OP_PUSHDATA2.
  386|      0|        return opcode == OP_PUSHDATA2;
  387|      0|    }
  388|      0|    return true;
  389|    141|}

_ZN15scriptnum_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  223|    112|    explicit scriptnum_error(const std::string& str) : std::runtime_error(str) {}
_ZN10CScriptNumC2ERKl:
  239|  47.8k|    {
  240|  47.8k|        m_value = n;
  241|  47.8k|    }
_ZN10CScriptNumC2ERKNSt3__16vectorIhNS0_9allocatorIhEEEEbm:
  247|  35.3k|    {
  248|  35.3k|        if (vch.size() > nMaxNumSize) {
  ------------------
  |  Branch (248:13): [True: 109, False: 35.2k]
  ------------------
  249|    109|            throw scriptnum_error("script number overflow");
  250|    109|        }
  251|  35.2k|        if (fRequireMinimal && vch.size() > 0) {
  ------------------
  |  Branch (251:13): [True: 112, False: 35.0k]
  |  Branch (251:32): [True: 112, False: 0]
  ------------------
  252|       |            // Check that the number is encoded with the minimum possible
  253|       |            // number of bytes.
  254|       |            //
  255|       |            // If the most-significant-byte - excluding the sign bit - is zero
  256|       |            // then we're not minimal. Note how this test also rejects the
  257|       |            // negative-zero encoding, 0x80.
  258|    112|            if ((vch.back() & 0x7f) == 0) {
  ------------------
  |  Branch (258:17): [True: 11, False: 101]
  ------------------
  259|       |                // One exception: if there's more than one byte and the most
  260|       |                // significant bit of the second-most-significant-byte is set
  261|       |                // it would conflict with the sign bit. An example of this case
  262|       |                // is +-255, which encode to 0xff00 and 0xff80 respectively.
  263|       |                // (big-endian).
  264|     11|                if (vch.size() <= 1 || (vch[vch.size() - 2] & 0x80) == 0) {
  ------------------
  |  Branch (264:21): [True: 1, False: 10]
  |  Branch (264:40): [True: 2, False: 8]
  ------------------
  265|      3|                    throw scriptnum_error("non-minimally encoded script number");
  266|      3|                }
  267|     11|            }
  268|    112|        }
  269|  35.2k|        m_value = set_vch(vch);
  270|  35.2k|    }
_ZNK10CScriptNumeqERKl:
  272|  1.59k|    inline bool operator==(const int64_t& rhs) const    { return m_value == rhs; }
_ZNK10CScriptNumneERKl:
  273|  4.17k|    inline bool operator!=(const int64_t& rhs) const    { return m_value != rhs; }
_ZNK10CScriptNumleERKl:
  274|  1.92k|    inline bool operator<=(const int64_t& rhs) const    { return m_value <= rhs; }
_ZNK10CScriptNumltERKl:
  275|  4.35k|    inline bool operator< (const int64_t& rhs) const    { return m_value <  rhs; }
_ZNK10CScriptNumgeERKl:
  276|    603|    inline bool operator>=(const int64_t& rhs) const    { return m_value >= rhs; }
_ZNK10CScriptNumgtERKl:
  277|  1.86k|    inline bool operator> (const int64_t& rhs) const    { return m_value >  rhs; }
_ZNK10CScriptNumeqERKS_:
  279|  1.59k|    inline bool operator==(const CScriptNum& rhs) const { return operator==(rhs.m_value); }
_ZNK10CScriptNumneERKS_:
  280|  4.17k|    inline bool operator!=(const CScriptNum& rhs) const { return operator!=(rhs.m_value); }
_ZNK10CScriptNumleERKS_:
  281|  1.92k|    inline bool operator<=(const CScriptNum& rhs) const { return operator<=(rhs.m_value); }
_ZNK10CScriptNumltERKS_:
  282|  4.35k|    inline bool operator< (const CScriptNum& rhs) const { return operator< (rhs.m_value); }
_ZNK10CScriptNumgeERKS_:
  283|    603|    inline bool operator>=(const CScriptNum& rhs) const { return operator>=(rhs.m_value); }
_ZNK10CScriptNumgtERKS_:
  284|  1.86k|    inline bool operator> (const CScriptNum& rhs) const { return operator> (rhs.m_value); }
_ZNK10CScriptNumplERKl:
  286|  1.03k|    inline CScriptNum operator+(   const int64_t& rhs)    const { return CScriptNum(m_value + rhs);}
_ZNK10CScriptNummiERKl:
  287|    857|    inline CScriptNum operator-(   const int64_t& rhs)    const { return CScriptNum(m_value - rhs);}
_ZNK10CScriptNumplERKS_:
  288|  1.03k|    inline CScriptNum operator+(   const CScriptNum& rhs) const { return operator+(rhs.m_value);   }
_ZNK10CScriptNummiERKS_:
  289|    857|    inline CScriptNum operator-(   const CScriptNum& rhs) const { return operator-(rhs.m_value);   }
_ZN10CScriptNumpLERKS_:
  291|    809|    inline CScriptNum& operator+=( const CScriptNum& rhs)       { return operator+=(rhs.m_value);  }
_ZN10CScriptNummIERKS_:
  292|  1.79k|    inline CScriptNum& operator-=( const CScriptNum& rhs)       { return operator-=(rhs.m_value);  }
_ZNK10CScriptNumngEv:
  300|  1.59k|    {
  301|  1.59k|        assert(m_value != std::numeric_limits<int64_t>::min());
  302|  1.59k|        return CScriptNum(-m_value);
  303|  1.59k|    }
_ZN10CScriptNumaSERKl:
  306|  7.38k|    {
  307|  7.38k|        m_value = rhs;
  308|  7.38k|        return *this;
  309|  7.38k|    }
_ZN10CScriptNumpLERKl:
  312|    809|    {
  313|    809|        assert(rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) ||
  314|    809|                           (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs));
  315|    809|        m_value += rhs;
  316|    809|        return *this;
  317|    809|    }
_ZN10CScriptNummIERKl:
  320|  1.79k|    {
  321|  1.79k|        assert(rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) ||
  322|  1.79k|                           (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs));
  323|  1.79k|        m_value -= rhs;
  324|  1.79k|        return *this;
  325|  1.79k|    }
_ZNK10CScriptNum6getintEv:
  334|  4.07k|    {
  335|  4.07k|        if (m_value > std::numeric_limits<int>::max())
  ------------------
  |  Branch (335:13): [True: 0, False: 4.07k]
  ------------------
  336|      0|            return std::numeric_limits<int>::max();
  337|  4.07k|        else if (m_value < std::numeric_limits<int>::min())
  ------------------
  |  Branch (337:18): [True: 0, False: 4.07k]
  ------------------
  338|      0|            return std::numeric_limits<int>::min();
  339|  4.07k|        return m_value;
  340|  4.07k|    }
_ZNK10CScriptNum6getvchEv:
  345|  51.1k|    {
  346|  51.1k|        return serialize(m_value);
  347|  51.1k|    }
_ZN10CScriptNum9serializeERKl:
  350|  51.1k|    {
  351|  51.1k|        if(value == 0)
  ------------------
  |  Branch (351:12): [True: 5.87k, False: 45.3k]
  ------------------
  352|  5.87k|            return std::vector<unsigned char>();
  353|       |
  354|  45.3k|        std::vector<unsigned char> result;
  355|  45.3k|        const bool neg = value < 0;
  356|  45.3k|        uint64_t absvalue = neg ? ~static_cast<uint64_t>(value) + 1 : static_cast<uint64_t>(value);
  ------------------
  |  Branch (356:29): [True: 3.41k, False: 41.8k]
  ------------------
  357|       |
  358|   100k|        while(absvalue)
  ------------------
  |  Branch (358:15): [True: 55.2k, False: 45.3k]
  ------------------
  359|  55.2k|        {
  360|  55.2k|            result.push_back(absvalue & 0xff);
  361|  55.2k|            absvalue >>= 8;
  362|  55.2k|        }
  363|       |
  364|       |//    - If the most significant byte is >= 0x80 and the value is positive, push a
  365|       |//    new zero-byte to make the significant byte < 0x80 again.
  366|       |
  367|       |//    - If the most significant byte is >= 0x80 and the value is negative, push a
  368|       |//    new 0x80 byte that will be popped off when converting to an integral.
  369|       |
  370|       |//    - If the most significant byte is < 0x80 and the value is negative, add
  371|       |//    0x80 to it, since it will be subtracted and interpreted as a negative when
  372|       |//    converting to an integral.
  373|       |
  374|  45.3k|        if (result.back() & 0x80)
  ------------------
  |  Branch (374:13): [True: 1.06k, False: 44.2k]
  ------------------
  375|  1.06k|            result.push_back(neg ? 0x80 : 0);
  ------------------
  |  Branch (375:30): [True: 150, False: 916]
  ------------------
  376|  44.2k|        else if (neg)
  ------------------
  |  Branch (376:18): [True: 3.26k, False: 40.9k]
  ------------------
  377|  3.26k|            result.back() |= 0x80;
  378|       |
  379|  45.3k|        return result;
  380|  51.1k|    }
_ZN10CScriptNum7set_vchERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  384|  35.2k|    {
  385|  35.2k|      if (vch.empty())
  ------------------
  |  Branch (385:11): [True: 16.1k, False: 19.0k]
  ------------------
  386|  16.1k|          return 0;
  387|       |
  388|  19.0k|      int64_t result = 0;
  389|  57.0k|      for (size_t i = 0; i != vch.size(); ++i)
  ------------------
  |  Branch (389:26): [True: 38.0k, False: 19.0k]
  ------------------
  390|  38.0k|          result |= static_cast<int64_t>(vch[i]) << 8*i;
  391|       |
  392|       |      // If the input vector's most significant byte is 0x80, remove it from
  393|       |      // the result's msb and return a negative.
  394|  19.0k|      if (vch.back() & 0x80)
  ------------------
  |  Branch (394:11): [True: 4.47k, False: 14.5k]
  ------------------
  395|  4.47k|          return -((int64_t)(result & ~(0x80ULL << (8 * (vch.size() - 1)))));
  396|       |
  397|  14.5k|      return result;
  398|  19.0k|    }
_ZN7CScript14AppendDataSizeEj:
  418|  8.83k|    {
  419|  8.83k|        if (size < OP_PUSHDATA1) {
  ------------------
  |  Branch (419:13): [True: 8.58k, False: 248]
  ------------------
  420|  8.58k|            insert(end(), static_cast<value_type>(size));
  421|  8.58k|        } else if (size <= 0xff) {
  ------------------
  |  Branch (421:20): [True: 123, False: 125]
  ------------------
  422|    123|            insert(end(), OP_PUSHDATA1);
  423|    123|            insert(end(), static_cast<value_type>(size));
  424|    125|        } else if (size <= 0xffff) {
  ------------------
  |  Branch (424:20): [True: 125, False: 0]
  ------------------
  425|    125|            insert(end(), OP_PUSHDATA2);
  426|    125|            value_type data[2];
  427|    125|            WriteLE16(data, size);
  428|    125|            insert(end(), std::cbegin(data), std::cend(data));
  429|    125|        } else {
  430|      0|            insert(end(), OP_PUSHDATA4);
  431|      0|            value_type data[4];
  432|      0|            WriteLE32(data, size);
  433|      0|            insert(end(), std::cbegin(data), std::cend(data));
  434|      0|        }
  435|  8.83k|    }
_ZN7CScript10AppendDataENSt3__14spanIKhLm18446744073709551615EEE:
  438|  8.83k|    {
  439|  8.83k|        insert(end(), data.begin(), data.end());
  440|  8.83k|    }
_ZN7CScriptlsE10opcodetype:
  480|    213|    {
  481|    213|        if (opcode < 0 || opcode > 0xff)
  ------------------
  |  Branch (481:13): [True: 0, False: 213]
  |  Branch (481:27): [True: 0, False: 213]
  ------------------
  482|      0|            throw std::runtime_error("CScript::operator<<(): invalid opcode");
  483|    213|        insert(end(), (unsigned char)opcode);
  484|    213|        return *this;
  485|    213|    }
_ZN7CScriptlsENSt3__14spanIKSt4byteLm18446744073709551615EEE:
  494|  8.83k|    {
  495|  8.83k|        AppendDataSize(b.size());
  496|  8.83k|        AppendData({reinterpret_cast<const value_type*>(b.data()), b.size()});
  497|  8.83k|        return *this;
  498|  8.83k|    }
_ZN7CScriptlsENSt3__14spanIKhLm18446744073709551615EEE:
  502|  8.83k|    {
  503|  8.83k|        return *this << std::as_bytes(b);
  504|  8.83k|    }
_ZNK7CScript5GetOpERN9prevectorILj28EhjiE14const_iteratorER10opcodetypeRNSt3__16vectorIhNS6_9allocatorIhEEEE:
  507|   203k|    {
  508|   203k|        return GetScriptOp(pc, end(), opcodeRet, &vchRet);
  509|   203k|    }
_ZNK7CScript5GetOpERN9prevectorILj28EhjiE14const_iteratorER10opcodetype:
  512|  4.29M|    {
  513|  4.29M|        return GetScriptOp(pc, end(), opcodeRet, nullptr);
  514|  4.29M|    }
_ZN7CScript10DecodeOP_NE10opcodetype:
  518|  4.81k|    {
  519|  4.81k|        if (opcode == OP_0)
  ------------------
  |  Branch (519:13): [True: 2.59k, False: 2.21k]
  ------------------
  520|  2.59k|            return 0;
  521|  2.21k|        assert(opcode >= OP_1 && opcode <= OP_16);
  522|  2.21k|        return (int)opcode - (int)(OP_1 - 1);
  523|  2.21k|    }
_ZNK7CScript13IsUnspendableEv:
  572|  1.24M|    {
  573|  1.24M|        return (size() > 0 && *begin() == OP_RETURN) || (size() > MAX_SCRIPT_SIZE);
  ------------------
  |  Branch (573:17): [True: 120k, False: 1.12M]
  |  Branch (573:31): [True: 646, False: 119k]
  |  Branch (573:57): [True: 49, False: 1.24M]
  ------------------
  574|  1.24M|    }
_ZN7CScript5clearEv:
  577|  4.58M|    {
  578|       |        // The default prevector::clear() does not release memory
  579|  4.58M|        CScriptBase::clear();
  580|  4.58M|        shrink_to_fit();
  581|  4.58M|    }
_ZNK14CScriptWitness6IsNullEv:
  593|  97.8k|    bool IsNull() const { return stack.empty(); }
_ZN7CScript16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  465|   595k|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|   595k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN7CScriptC2Ev:
  461|  4.70M|    CScript() = default;
_ZN14CScriptWitnessC2Ev:
  591|   111k|    CScriptWitness() = default;
_ZN7CScript16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_:
  465|  2.28M|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|  2.28M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN7CScriptC2ITkNSt3__114input_iteratorENS1_11__wrap_iterIPKhEEEET_S6_:
  463|    664|    CScript(InputIterator first, InputIterator last) : CScriptBase{first, last} { }
_ZN7CScriptC2ITkNSt3__114input_iteratorENS1_11__wrap_iterIPhEEEET_S5_:
  463|  2.44k|    CScript(InputIterator first, InputIterator last) : CScriptBase{first, last} { }
_ZN7CScript16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_:
  465|  4.53M|    SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
  ------------------
  |  |  156|  4.53M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN7CScriptC2ITkNSt3__114input_iteratorEN9prevectorILj28EhjiE14const_iteratorEEET_S5_:
  463|  8.31k|    CScript(InputIterator first, InputIterator last) : CScriptBase{first, last} { }

_Z6SolverRK7CScriptRNSt3__16vectorINS3_IhNS2_9allocatorIhEEEENS4_IS6_EEEE:
  142|  5.67k|{
  143|  5.67k|    vSolutionsRet.clear();
  144|       |
  145|       |    // Shortcut for pay-to-script-hash, which are more constrained than the other types:
  146|       |    // it is always OP_HASH160 20 [20 byte hash] OP_EQUAL
  147|  5.67k|    if (scriptPubKey.IsPayToScriptHash())
  ------------------
  |  Branch (147:9): [True: 2.57k, False: 3.10k]
  ------------------
  148|  2.57k|    {
  149|  2.57k|        std::vector<unsigned char> hashBytes(scriptPubKey.begin()+2, scriptPubKey.begin()+22);
  150|  2.57k|        vSolutionsRet.push_back(hashBytes);
  151|  2.57k|        return TxoutType::SCRIPTHASH;
  152|  2.57k|    }
  153|       |
  154|  3.10k|    int witnessversion;
  155|  3.10k|    std::vector<unsigned char> witnessprogram;
  156|  3.10k|    if (scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
  ------------------
  |  Branch (156:9): [True: 774, False: 2.33k]
  ------------------
  157|    774|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_KEYHASH_SIZE) {
  ------------------
  |  Branch (157:13): [True: 289, False: 485]
  |  Branch (157:36): [True: 87, False: 202]
  ------------------
  158|     87|            vSolutionsRet.push_back(std::move(witnessprogram));
  159|     87|            return TxoutType::WITNESS_V0_KEYHASH;
  160|     87|        }
  161|    687|        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
  ------------------
  |  Branch (161:13): [True: 202, False: 485]
  |  Branch (161:36): [True: 196, False: 6]
  ------------------
  162|    196|            vSolutionsRet.push_back(std::move(witnessprogram));
  163|    196|            return TxoutType::WITNESS_V0_SCRIPTHASH;
  164|    196|        }
  165|    491|        if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE) {
  ------------------
  |  Branch (165:13): [True: 481, False: 10]
  |  Branch (165:36): [True: 224, False: 257]
  ------------------
  166|    224|            vSolutionsRet.push_back(std::move(witnessprogram));
  167|    224|            return TxoutType::WITNESS_V1_TAPROOT;
  168|    224|        }
  169|    267|        if (scriptPubKey.IsPayToAnchor()) {
  ------------------
  |  Branch (169:13): [True: 253, False: 14]
  ------------------
  170|    253|            return TxoutType::ANCHOR;
  171|    253|        }
  172|     14|        if (witnessversion != 0) {
  ------------------
  |  Branch (172:13): [True: 8, False: 6]
  ------------------
  173|      8|            vSolutionsRet.push_back(std::vector<unsigned char>{(unsigned char)witnessversion});
  174|      8|            vSolutionsRet.push_back(std::move(witnessprogram));
  175|      8|            return TxoutType::WITNESS_UNKNOWN;
  176|      8|        }
  177|      6|        return TxoutType::NONSTANDARD;
  178|     14|    }
  179|       |
  180|       |    // Provably prunable, data-carrying output
  181|       |    //
  182|       |    // So long as script passes the IsUnspendable() test and all but the first
  183|       |    // byte passes the IsPushOnly() test we don't care what exactly is in the
  184|       |    // script.
  185|  2.33k|    if (scriptPubKey.size() >= 1 && scriptPubKey[0] == OP_RETURN && scriptPubKey.IsPushOnly(scriptPubKey.begin()+1)) {
  ------------------
  |  Branch (185:9): [True: 1.58k, False: 747]
  |  Branch (185:9): [True: 11, False: 2.31k]
  |  Branch (185:37): [True: 51, False: 1.53k]
  |  Branch (185:69): [True: 11, False: 40]
  ------------------
  186|     11|        return TxoutType::NULL_DATA;
  187|     11|    }
  188|       |
  189|  2.31k|    std::vector<unsigned char> data;
  190|  2.31k|    if (MatchPayToPubkey(scriptPubKey, data)) {
  ------------------
  |  Branch (190:9): [True: 1.06k, False: 1.25k]
  ------------------
  191|  1.06k|        vSolutionsRet.push_back(std::move(data));
  192|  1.06k|        return TxoutType::PUBKEY;
  193|  1.06k|    }
  194|       |
  195|  1.25k|    if (MatchPayToPubkeyHash(scriptPubKey, data)) {
  ------------------
  |  Branch (195:9): [True: 235, False: 1.01k]
  ------------------
  196|    235|        vSolutionsRet.push_back(std::move(data));
  197|    235|        return TxoutType::PUBKEYHASH;
  198|    235|    }
  199|       |
  200|  1.01k|    int required;
  201|  1.01k|    std::vector<std::vector<unsigned char>> keys;
  202|  1.01k|    if (MatchMultisig(scriptPubKey, required, keys)) {
  ------------------
  |  Branch (202:9): [True: 0, False: 1.01k]
  ------------------
  203|      0|        vSolutionsRet.push_back({static_cast<unsigned char>(required)}); // safe as required is in range 1..20
  204|      0|        vSolutionsRet.insert(vSolutionsRet.end(), keys.begin(), keys.end());
  205|      0|        vSolutionsRet.push_back({static_cast<unsigned char>(keys.size())}); // safe as size is in range 1..20
  206|      0|        return TxoutType::MULTISIG;
  207|      0|    }
  208|       |
  209|  1.01k|    vSolutionsRet.clear();
  210|  1.01k|    return TxoutType::NONSTANDARD;
  211|  1.01k|}
solver.cpp:_ZL15GetScriptNumber10opcodetypeNSt3__16vectorIhNS0_9allocatorIhEEEEii:
   67|    248|{
   68|    248|    int count;
   69|    248|    if (IsSmallInteger(opcode)) {
  ------------------
  |  Branch (69:9): [True: 80, False: 168]
  ------------------
   70|     80|        count = CScript::DecodeOP_N(opcode);
   71|    168|    } else if (IsPushdataOp(opcode)) {
  ------------------
  |  Branch (71:16): [True: 141, False: 27]
  ------------------
   72|    141|        if (!CheckMinimalPush(data, opcode)) return {};
  ------------------
  |  Branch (72:13): [True: 13, False: 128]
  ------------------
   73|    128|        try {
   74|    128|            count = CScriptNum(data, /* fRequireMinimal = */ true).getint();
   75|    128|        } catch (const scriptnum_error&) {
   76|     19|            return {};
   77|     19|        }
   78|    128|    } else {
   79|     27|        return {};
   80|     27|    }
   81|    189|    if (count < min || count > max) return {};
  ------------------
  |  Branch (81:9): [True: 39, False: 150]
  |  Branch (81:24): [True: 64, False: 86]
  ------------------
   82|     86|    return count;
   83|    189|}
solver.cpp:_ZL14IsSmallInteger10opcodetype:
   60|    248|{
   61|    248|    return opcode >= OP_1 && opcode <= OP_16;
  ------------------
  |  Branch (61:12): [True: 101, False: 147]
  |  Branch (61:30): [True: 80, False: 21]
  ------------------
   62|    248|}
solver.cpp:_ZL16MatchPayToPubkeyRK7CScriptRNSt3__16vectorIhNS2_9allocatorIhEEEE:
   37|  2.31k|{
   38|  2.31k|    if (script.size() == CPubKey::SIZE + 2 && script[0] == CPubKey::SIZE && script.back() == OP_CHECKSIG) {
  ------------------
  |  Branch (38:9): [True: 679, False: 1.64k]
  |  Branch (38:47): [True: 670, False: 9]
  |  Branch (38:77): [True: 662, False: 8]
  ------------------
   39|    662|        pubkey = valtype(script.begin() + 1, script.begin() + CPubKey::SIZE + 1);
   40|    662|        return CPubKey::ValidSize(pubkey);
   41|    662|    }
   42|  1.65k|    if (script.size() == CPubKey::COMPRESSED_SIZE + 2 && script[0] == CPubKey::COMPRESSED_SIZE && script.back() == OP_CHECKSIG) {
  ------------------
  |  Branch (42:9): [True: 440, False: 1.21k]
  |  Branch (42:58): [True: 429, False: 11]
  |  Branch (42:99): [True: 419, False: 10]
  ------------------
   43|    419|        pubkey = valtype(script.begin() + 1, script.begin() + CPubKey::COMPRESSED_SIZE + 1);
   44|    419|        return CPubKey::ValidSize(pubkey);
   45|    419|    }
   46|  1.23k|    return false;
   47|  1.65k|}
solver.cpp:_ZL20MatchPayToPubkeyHashRK7CScriptRNSt3__16vectorIhNS2_9allocatorIhEEEE:
   50|  1.25k|{
   51|  1.25k|    if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160 && script[2] == 20 && script[23] == OP_EQUALVERIFY && script[24] == OP_CHECKSIG) {
  ------------------
  |  Branch (51:9): [True: 251, False: 1.00k]
  |  Branch (51:32): [True: 246, False: 5]
  |  Branch (51:55): [True: 243, False: 3]
  |  Branch (51:82): [True: 240, False: 3]
  |  Branch (51:101): [True: 236, False: 4]
  |  Branch (51:133): [True: 235, False: 1]
  ------------------
   52|    235|        pubkeyhash = valtype(script.begin () + 3, script.begin() + 23);
   53|    235|        return true;
   54|    235|    }
   55|  1.01k|    return false;
   56|  1.25k|}
solver.cpp:_ZL13MatchMultisigRK7CScriptRiRNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEE:
   86|  1.01k|{
   87|  1.01k|    opcodetype opcode;
   88|  1.01k|    valtype data;
   89|       |
   90|  1.01k|    CScript::const_iterator it = script.begin();
   91|  1.01k|    if (script.size() < 1 || script.back() != OP_CHECKMULTISIG) return false;
  ------------------
  |  Branch (91:9): [True: 747, False: 270]
  |  Branch (91:30): [True: 103, False: 167]
  ------------------
   92|       |
   93|    167|    if (!script.GetOp(it, opcode, data)) return false;
  ------------------
  |  Branch (93:9): [True: 3, False: 164]
  ------------------
   94|    164|    auto req_sigs = GetScriptNumber(opcode, data, 1, MAX_PUBKEYS_PER_MULTISIG);
   95|    164|    if (!req_sigs) return false;
  ------------------
  |  Branch (95:9): [True: 80, False: 84]
  ------------------
   96|     84|    required_sigs = *req_sigs;
   97|     90|    while (script.GetOp(it, opcode, data) && CPubKey::ValidSize(data)) {
  ------------------
  |  Branch (97:12): [True: 86, False: 4]
  |  Branch (97:46): [True: 6, False: 80]
  ------------------
   98|      6|        pubkeys.emplace_back(std::move(data));
   99|      6|    }
  100|     84|    auto num_keys = GetScriptNumber(opcode, data, required_sigs, MAX_PUBKEYS_PER_MULTISIG);
  101|     84|    if (!num_keys) return false;
  ------------------
  |  Branch (101:9): [True: 82, False: 2]
  ------------------
  102|      2|    if (pubkeys.size() != static_cast<unsigned long>(*num_keys)) return false;
  ------------------
  |  Branch (102:9): [True: 2, False: 0]
  ------------------
  103|       |
  104|      0|    return (it + 1 == script.end());
  105|      2|}

_Z12IsPushdataOp10opcodetype:
   41|    168|{
   42|    168|    return opcode > OP_FALSE && opcode <= OP_PUSHDATA4;
  ------------------
  |  Branch (42:12): [True: 163, False: 5]
  |  Branch (42:33): [True: 141, False: 22]
  ------------------
   43|    168|}

secp256k1.c:secp256k1_eckey_pubkey_parse:
   17|  4.67k|static int secp256k1_eckey_pubkey_parse(secp256k1_ge *elem, const unsigned char *pub, size_t size) {
   18|  4.67k|    if (size == 33 && (pub[0] == SECP256K1_TAG_PUBKEY_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_ODD)) {
  ------------------
  |  |  216|  9.35k|#define SECP256K1_TAG_PUBKEY_EVEN 0x02
  ------------------
                  if (size == 33 && (pub[0] == SECP256K1_TAG_PUBKEY_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_ODD)) {
  ------------------
  |  |  217|  4.00k|#define SECP256K1_TAG_PUBKEY_ODD 0x03
  ------------------
  |  Branch (18:9): [True: 4.67k, False: 0]
  |  Branch (18:24): [True: 676, False: 4.00k]
  |  Branch (18:63): [True: 4.00k, False: 0]
  ------------------
   19|  4.67k|        secp256k1_fe x;
   20|  4.67k|        return secp256k1_fe_set_b32_limit(&x, pub+1) && secp256k1_ge_set_xo_var(elem, &x, pub[0] == SECP256K1_TAG_PUBKEY_ODD);
  ------------------
  |  |   88|  4.67k|#  define secp256k1_fe_set_b32_limit secp256k1_fe_impl_set_b32_limit
  ------------------
                      return secp256k1_fe_set_b32_limit(&x, pub+1) && secp256k1_ge_set_xo_var(elem, &x, pub[0] == SECP256K1_TAG_PUBKEY_ODD);
  ------------------
  |  |  217|  4.45k|#define SECP256K1_TAG_PUBKEY_ODD 0x03
  ------------------
  |  Branch (20:16): [True: 4.45k, False: 227]
  |  Branch (20:57): [True: 3.21k, False: 1.24k]
  ------------------
   21|  4.67k|    } else if (size == 65 && (pub[0] == SECP256K1_TAG_PUBKEY_UNCOMPRESSED || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD)) {
  ------------------
  |  |  218|      0|#define SECP256K1_TAG_PUBKEY_UNCOMPRESSED 0x04
  ------------------
                  } else if (size == 65 && (pub[0] == SECP256K1_TAG_PUBKEY_UNCOMPRESSED || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD)) {
  ------------------
  |  |  219|      0|#define SECP256K1_TAG_PUBKEY_HYBRID_EVEN 0x06
  ------------------
                  } else if (size == 65 && (pub[0] == SECP256K1_TAG_PUBKEY_UNCOMPRESSED || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD)) {
  ------------------
  |  |  220|      0|#define SECP256K1_TAG_PUBKEY_HYBRID_ODD 0x07
  ------------------
  |  Branch (21:16): [True: 0, False: 0]
  |  Branch (21:31): [True: 0, False: 0]
  |  Branch (21:78): [True: 0, False: 0]
  |  Branch (21:124): [True: 0, False: 0]
  ------------------
   22|      0|        secp256k1_fe x, y;
   23|      0|        if (!secp256k1_fe_set_b32_limit(&x, pub+1) || !secp256k1_fe_set_b32_limit(&y, pub+33)) {
  ------------------
  |  |   88|      0|#  define secp256k1_fe_set_b32_limit secp256k1_fe_impl_set_b32_limit
  ------------------
                      if (!secp256k1_fe_set_b32_limit(&x, pub+1) || !secp256k1_fe_set_b32_limit(&y, pub+33)) {
  ------------------
  |  |   88|      0|#  define secp256k1_fe_set_b32_limit secp256k1_fe_impl_set_b32_limit
  ------------------
  |  Branch (23:13): [True: 0, False: 0]
  |  Branch (23:55): [True: 0, False: 0]
  ------------------
   24|      0|            return 0;
   25|      0|        }
   26|      0|        secp256k1_ge_set_xy(elem, &x, &y);
   27|      0|        if ((pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD) &&
  ------------------
  |  |  219|      0|#define SECP256K1_TAG_PUBKEY_HYBRID_EVEN 0x06
  ------------------
                      if ((pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_EVEN || pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD) &&
  ------------------
  |  |  220|      0|#define SECP256K1_TAG_PUBKEY_HYBRID_ODD 0x07
  ------------------
  |  Branch (27:14): [True: 0, False: 0]
  |  Branch (27:60): [True: 0, False: 0]
  ------------------
   28|      0|            secp256k1_fe_is_odd(&y) != (pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD)) {
  ------------------
  |  |   85|      0|#  define secp256k1_fe_is_odd secp256k1_fe_impl_is_odd
  ------------------
                          secp256k1_fe_is_odd(&y) != (pub[0] == SECP256K1_TAG_PUBKEY_HYBRID_ODD)) {
  ------------------
  |  |  220|      0|#define SECP256K1_TAG_PUBKEY_HYBRID_ODD 0x07
  ------------------
  |  Branch (28:13): [True: 0, False: 0]
  ------------------
   29|      0|            return 0;
   30|      0|        }
   31|      0|        return secp256k1_ge_is_valid_var(elem);
   32|      0|    } else {
   33|      0|        return 0;
   34|      0|    }
   35|  4.67k|}
secp256k1.c:secp256k1_eckey_pubkey_serialize:
   37|  3.21k|static int secp256k1_eckey_pubkey_serialize(secp256k1_ge *elem, unsigned char *pub, size_t *size, int compressed) {
   38|  3.21k|    if (secp256k1_ge_is_infinity(elem)) {
  ------------------
  |  Branch (38:9): [True: 0, False: 3.21k]
  ------------------
   39|      0|        return 0;
   40|      0|    }
   41|  3.21k|    secp256k1_fe_normalize_var(&elem->x);
  ------------------
  |  |   80|  3.21k|#  define secp256k1_fe_normalize_var secp256k1_fe_impl_normalize_var
  ------------------
   42|  3.21k|    secp256k1_fe_normalize_var(&elem->y);
  ------------------
  |  |   80|  3.21k|#  define secp256k1_fe_normalize_var secp256k1_fe_impl_normalize_var
  ------------------
   43|  3.21k|    secp256k1_fe_get_b32(&pub[1], &elem->x);
  ------------------
  |  |   89|  3.21k|#  define secp256k1_fe_get_b32 secp256k1_fe_impl_get_b32
  ------------------
   44|  3.21k|    if (compressed) {
  ------------------
  |  Branch (44:9): [True: 0, False: 3.21k]
  ------------------
   45|      0|        *size = 33;
   46|      0|        pub[0] = secp256k1_fe_is_odd(&elem->y) ? SECP256K1_TAG_PUBKEY_ODD : SECP256K1_TAG_PUBKEY_EVEN;
  ------------------
  |  |   85|      0|#  define secp256k1_fe_is_odd secp256k1_fe_impl_is_odd
  ------------------
                      pub[0] = secp256k1_fe_is_odd(&elem->y) ? SECP256K1_TAG_PUBKEY_ODD : SECP256K1_TAG_PUBKEY_EVEN;
  ------------------
  |  |  217|      0|#define SECP256K1_TAG_PUBKEY_ODD 0x03
  ------------------
                      pub[0] = secp256k1_fe_is_odd(&elem->y) ? SECP256K1_TAG_PUBKEY_ODD : SECP256K1_TAG_PUBKEY_EVEN;
  ------------------
  |  |  216|      0|#define SECP256K1_TAG_PUBKEY_EVEN 0x02
  ------------------
  |  Branch (46:18): [True: 0, False: 0]
  ------------------
   47|  3.21k|    } else {
   48|  3.21k|        *size = 65;
   49|  3.21k|        pub[0] = SECP256K1_TAG_PUBKEY_UNCOMPRESSED;
  ------------------
  |  |  218|  3.21k|#define SECP256K1_TAG_PUBKEY_UNCOMPRESSED 0x04
  ------------------
   50|  3.21k|        secp256k1_fe_get_b32(&pub[33], &elem->y);
  ------------------
  |  |   89|  3.21k|#  define secp256k1_fe_get_b32 secp256k1_fe_impl_get_b32
  ------------------
   51|  3.21k|    }
   52|  3.21k|    return 1;
   53|  3.21k|}

secp256k1.c:secp256k1_ecmult_gen_context_clear:
   26|      2|static void secp256k1_ecmult_gen_context_clear(secp256k1_ecmult_gen_context *ctx) {
   27|      2|    ctx->built = 0;
   28|      2|    secp256k1_scalar_clear(&ctx->scalar_offset);
   29|      2|    secp256k1_ge_clear(&ctx->ge_offset);
   30|      2|    secp256k1_fe_clear(&ctx->proj_blind);
   31|      2|}
secp256k1.c:secp256k1_ecmult_gen_context_is_built:
   22|      4|static int secp256k1_ecmult_gen_context_is_built(const secp256k1_ecmult_gen_context* ctx) {
   23|      4|    return ctx->built;
   24|      4|}

secp256k1.c:secp256k1_fe_impl_sqr:
  345|  1.13M|SECP256K1_INLINE static void secp256k1_fe_impl_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
  346|  1.13M|    secp256k1_fe_sqr_inner(r->n, a->n);
  347|  1.13M|}
secp256k1.c:secp256k1_fe_impl_mul:
  341|  62.3k|SECP256K1_INLINE static void secp256k1_fe_impl_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b) {
  342|  62.3k|    secp256k1_fe_mul_inner(r->n, a->n, b->n);
  343|  62.3k|}
secp256k1.c:secp256k1_fe_impl_add_int:
  329|  4.45k|SECP256K1_INLINE static void secp256k1_fe_impl_add_int(secp256k1_fe *r, int a) {
  330|  4.45k|    r->n[0] += a;
  331|  4.45k|}
secp256k1.c:secp256k1_fe_impl_to_storage:
  428|  6.42k|static void secp256k1_fe_impl_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a) {
  429|  6.42k|    r->n[0] = a->n[0] | a->n[1] << 52;
  430|  6.42k|    r->n[1] = a->n[1] >> 12 | a->n[2] << 40;
  431|  6.42k|    r->n[2] = a->n[2] >> 24 | a->n[3] << 28;
  432|  6.42k|    r->n[3] = a->n[3] >> 36 | a->n[4] << 16;
  433|  6.42k|}
secp256k1.c:secp256k1_fe_impl_from_storage:
  435|  6.42k|static SECP256K1_INLINE void secp256k1_fe_impl_from_storage(secp256k1_fe *r, const secp256k1_fe_storage *a) {
  436|  6.42k|    r->n[0] = a->n[0] & 0xFFFFFFFFFFFFFULL;
  437|  6.42k|    r->n[1] = a->n[0] >> 52 | ((a->n[1] << 12) & 0xFFFFFFFFFFFFFULL);
  438|  6.42k|    r->n[2] = a->n[1] >> 40 | ((a->n[2] << 24) & 0xFFFFFFFFFFFFFULL);
  439|  6.42k|    r->n[3] = a->n[2] >> 28 | ((a->n[3] << 36) & 0xFFFFFFFFFFFFFULL);
  440|  6.42k|    r->n[4] = a->n[3] >> 16;
  441|  6.42k|}
secp256k1.c:secp256k1_fe_impl_is_zero:
  206|  3.21k|SECP256K1_INLINE static int secp256k1_fe_impl_is_zero(const secp256k1_fe *a) {
  207|  3.21k|    const uint64_t *t = a->n;
  208|  3.21k|    return (t[0] | t[1] | t[2] | t[3] | t[4]) == 0;
  209|  3.21k|}
secp256k1.c:secp256k1_fe_impl_add:
  333|  4.45k|SECP256K1_INLINE static void secp256k1_fe_impl_add(secp256k1_fe *r, const secp256k1_fe *a) {
  334|  4.45k|    r->n[0] += a->n[0];
  335|  4.45k|    r->n[1] += a->n[1];
  336|  4.45k|    r->n[2] += a->n[2];
  337|  4.45k|    r->n[3] += a->n[3];
  338|  4.45k|    r->n[4] += a->n[4];
  339|  4.45k|}
secp256k1.c:secp256k1_fe_impl_negate_unchecked:
  306|  6.48k|SECP256K1_INLINE static void secp256k1_fe_impl_negate_unchecked(secp256k1_fe *r, const secp256k1_fe *a, int m) {
  307|       |    /* For all legal values of m (0..31), the following properties hold: */
  308|  6.48k|    VERIFY_CHECK(0xFFFFEFFFFFC2FULL * 2 * (m + 1) >= 0xFFFFFFFFFFFFFULL * 2 * m);
  309|  6.48k|    VERIFY_CHECK(0xFFFFFFFFFFFFFULL * 2 * (m + 1) >= 0xFFFFFFFFFFFFFULL * 2 * m);
  310|  6.48k|    VERIFY_CHECK(0x0FFFFFFFFFFFFULL * 2 * (m + 1) >= 0x0FFFFFFFFFFFFULL * 2 * m);
  311|       |
  312|       |    /* Due to the properties above, the left hand in the subtractions below is never less than
  313|       |     * the right hand. */
  314|  6.48k|    r->n[0] = 0xFFFFEFFFFFC2FULL * 2 * (m + 1) - a->n[0];
  315|  6.48k|    r->n[1] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[1];
  316|  6.48k|    r->n[2] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[2];
  317|  6.48k|    r->n[3] = 0xFFFFFFFFFFFFFULL * 2 * (m + 1) - a->n[3];
  318|  6.48k|    r->n[4] = 0x0FFFFFFFFFFFFULL * 2 * (m + 1) - a->n[4];
  319|  6.48k|}
secp256k1.c:secp256k1_fe_impl_normalizes_to_zero:
  137|  4.45k|static int secp256k1_fe_impl_normalizes_to_zero(const secp256k1_fe *r) {
  138|  4.45k|    uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
  139|       |
  140|       |    /* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
  141|  4.45k|    uint64_t z0, z1;
  142|       |
  143|       |    /* Reduce t4 at the start so there will be at most a single carry from the first pass */
  144|  4.45k|    uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
  145|       |
  146|       |    /* The first pass ensures the magnitude is 1, ... */
  147|  4.45k|    t0 += x * 0x1000003D1ULL;
  148|  4.45k|    t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL; z0  = t0; z1  = t0 ^ 0x1000003D0ULL;
  149|  4.45k|    t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; z0 |= t1; z1 &= t1;
  150|  4.45k|    t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; z0 |= t2; z1 &= t2;
  151|  4.45k|    t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; z0 |= t3; z1 &= t3;
  152|  4.45k|                                                z0 |= t4; z1 &= t4 ^ 0xF000000000000ULL;
  153|       |
  154|       |    /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
  155|  4.45k|    VERIFY_CHECK(t4 >> 49 == 0);
  156|       |
  157|  4.45k|    return (z0 == 0) | (z1 == 0xFFFFFFFFFFFFFULL);
  158|  4.45k|}
secp256k1.c:secp256k1_fe_impl_set_b32_limit:
  265|  4.67k|static int secp256k1_fe_impl_set_b32_limit(secp256k1_fe *r, const unsigned char *a) {
  266|  4.67k|    secp256k1_fe_impl_set_b32_mod(r, a);
  267|  4.67k|    return !((r->n[4] == 0x0FFFFFFFFFFFFULL) & ((r->n[3] & r->n[2] & r->n[1]) == 0xFFFFFFFFFFFFFULL) & (r->n[0] >= 0xFFFFEFFFFFC2FULL));
  268|  4.67k|}
secp256k1.c:secp256k1_fe_impl_get_b32:
  271|  6.42k|static void secp256k1_fe_impl_get_b32(unsigned char *r, const secp256k1_fe *a) {
  272|  6.42k|    r[0] = (a->n[4] >> 40) & 0xFF;
  273|  6.42k|    r[1] = (a->n[4] >> 32) & 0xFF;
  274|  6.42k|    r[2] = (a->n[4] >> 24) & 0xFF;
  275|  6.42k|    r[3] = (a->n[4] >> 16) & 0xFF;
  276|  6.42k|    r[4] = (a->n[4] >> 8) & 0xFF;
  277|  6.42k|    r[5] = a->n[4] & 0xFF;
  278|  6.42k|    r[6] = (a->n[3] >> 44) & 0xFF;
  279|  6.42k|    r[7] = (a->n[3] >> 36) & 0xFF;
  280|  6.42k|    r[8] = (a->n[3] >> 28) & 0xFF;
  281|  6.42k|    r[9] = (a->n[3] >> 20) & 0xFF;
  282|  6.42k|    r[10] = (a->n[3] >> 12) & 0xFF;
  283|  6.42k|    r[11] = (a->n[3] >> 4) & 0xFF;
  284|  6.42k|    r[12] = ((a->n[2] >> 48) & 0xF) | ((a->n[3] & 0xF) << 4);
  285|  6.42k|    r[13] = (a->n[2] >> 40) & 0xFF;
  286|  6.42k|    r[14] = (a->n[2] >> 32) & 0xFF;
  287|  6.42k|    r[15] = (a->n[2] >> 24) & 0xFF;
  288|  6.42k|    r[16] = (a->n[2] >> 16) & 0xFF;
  289|  6.42k|    r[17] = (a->n[2] >> 8) & 0xFF;
  290|  6.42k|    r[18] = a->n[2] & 0xFF;
  291|  6.42k|    r[19] = (a->n[1] >> 44) & 0xFF;
  292|  6.42k|    r[20] = (a->n[1] >> 36) & 0xFF;
  293|  6.42k|    r[21] = (a->n[1] >> 28) & 0xFF;
  294|  6.42k|    r[22] = (a->n[1] >> 20) & 0xFF;
  295|  6.42k|    r[23] = (a->n[1] >> 12) & 0xFF;
  296|  6.42k|    r[24] = (a->n[1] >> 4) & 0xFF;
  297|  6.42k|    r[25] = ((a->n[0] >> 48) & 0xF) | ((a->n[1] & 0xF) << 4);
  298|  6.42k|    r[26] = (a->n[0] >> 40) & 0xFF;
  299|  6.42k|    r[27] = (a->n[0] >> 32) & 0xFF;
  300|  6.42k|    r[28] = (a->n[0] >> 24) & 0xFF;
  301|  6.42k|    r[29] = (a->n[0] >> 16) & 0xFF;
  302|  6.42k|    r[30] = (a->n[0] >> 8) & 0xFF;
  303|  6.42k|    r[31] = a->n[0] & 0xFF;
  304|  6.42k|}
secp256k1.c:secp256k1_fe_impl_normalize_var:
   99|  10.8k|static void secp256k1_fe_impl_normalize_var(secp256k1_fe *r) {
  100|  10.8k|    uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
  101|       |
  102|       |    /* Reduce t4 at the start so there will be at most a single carry from the first pass */
  103|  10.8k|    uint64_t m;
  104|  10.8k|    uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
  105|       |
  106|       |    /* The first pass ensures the magnitude is 1, ... */
  107|  10.8k|    t0 += x * 0x1000003D1ULL;
  108|  10.8k|    t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
  109|  10.8k|    t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; m = t1;
  110|  10.8k|    t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; m &= t2;
  111|  10.8k|    t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; m &= t3;
  112|       |
  113|       |    /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
  114|  10.8k|    VERIFY_CHECK(t4 >> 49 == 0);
  115|       |
  116|       |    /* At most a single final reduction is needed; check if the value is >= the field characteristic */
  117|  10.8k|    x = (t4 >> 48) | ((t4 == 0x0FFFFFFFFFFFFULL) & (m == 0xFFFFFFFFFFFFFULL)
  118|  10.8k|        & (t0 >= 0xFFFFEFFFFFC2FULL));
  119|       |
  120|  10.8k|    if (x) {
  ------------------
  |  Branch (120:9): [True: 1, False: 10.8k]
  ------------------
  121|      1|        t0 += 0x1000003D1ULL;
  122|      1|        t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
  123|      1|        t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL;
  124|      1|        t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL;
  125|      1|        t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL;
  126|       |
  127|       |        /* If t4 didn't carry to bit 48 already, then it should have after any final reduction */
  128|      1|        VERIFY_CHECK(t4 >> 48 == x);
  129|       |
  130|       |        /* Mask off the possible multiple of 2^256 from the final reduction */
  131|      1|        t4 &= 0x0FFFFFFFFFFFFULL;
  132|      1|    }
  133|       |
  134|  10.8k|    r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
  135|  10.8k|}
secp256k1.c:secp256k1_fe_impl_is_odd:
  211|  4.45k|SECP256K1_INLINE static int secp256k1_fe_impl_is_odd(const secp256k1_fe *a) {
  212|  4.45k|    return a->n[0] & 1;
  213|  4.45k|}
secp256k1.c:secp256k1_fe_impl_set_b32_mod:
  228|  4.67k|static void secp256k1_fe_impl_set_b32_mod(secp256k1_fe *r, const unsigned char *a) {
  229|  4.67k|    r->n[0] = (uint64_t)a[31]
  230|  4.67k|            | ((uint64_t)a[30] << 8)
  231|  4.67k|            | ((uint64_t)a[29] << 16)
  232|  4.67k|            | ((uint64_t)a[28] << 24)
  233|  4.67k|            | ((uint64_t)a[27] << 32)
  234|  4.67k|            | ((uint64_t)a[26] << 40)
  235|  4.67k|            | ((uint64_t)(a[25] & 0xF)  << 48);
  236|  4.67k|    r->n[1] = (uint64_t)((a[25] >> 4) & 0xF)
  237|  4.67k|            | ((uint64_t)a[24] << 4)
  238|  4.67k|            | ((uint64_t)a[23] << 12)
  239|  4.67k|            | ((uint64_t)a[22] << 20)
  240|  4.67k|            | ((uint64_t)a[21] << 28)
  241|  4.67k|            | ((uint64_t)a[20] << 36)
  242|  4.67k|            | ((uint64_t)a[19] << 44);
  243|  4.67k|    r->n[2] = (uint64_t)a[18]
  244|  4.67k|            | ((uint64_t)a[17] << 8)
  245|  4.67k|            | ((uint64_t)a[16] << 16)
  246|  4.67k|            | ((uint64_t)a[15] << 24)
  247|  4.67k|            | ((uint64_t)a[14] << 32)
  248|  4.67k|            | ((uint64_t)a[13] << 40)
  249|  4.67k|            | ((uint64_t)(a[12] & 0xF) << 48);
  250|  4.67k|    r->n[3] = (uint64_t)((a[12] >> 4) & 0xF)
  251|  4.67k|            | ((uint64_t)a[11] << 4)
  252|  4.67k|            | ((uint64_t)a[10] << 12)
  253|  4.67k|            | ((uint64_t)a[9]  << 20)
  254|  4.67k|            | ((uint64_t)a[8]  << 28)
  255|  4.67k|            | ((uint64_t)a[7]  << 36)
  256|  4.67k|            | ((uint64_t)a[6]  << 44);
  257|  4.67k|    r->n[4] = (uint64_t)a[5]
  258|  4.67k|            | ((uint64_t)a[4] << 8)
  259|  4.67k|            | ((uint64_t)a[3] << 16)
  260|  4.67k|            | ((uint64_t)a[2] << 24)
  261|  4.67k|            | ((uint64_t)a[1] << 32)
  262|  4.67k|            | ((uint64_t)a[0] << 40);
  263|  4.67k|}
secp256k1.c:secp256k1_fe_impl_normalize:
   43|  6.42k|static void secp256k1_fe_impl_normalize(secp256k1_fe *r) {
   44|  6.42k|    uint64_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4];
   45|       |
   46|       |    /* Reduce t4 at the start so there will be at most a single carry from the first pass */
   47|  6.42k|    uint64_t m;
   48|  6.42k|    uint64_t x = t4 >> 48; t4 &= 0x0FFFFFFFFFFFFULL;
   49|       |
   50|       |    /* The first pass ensures the magnitude is 1, ... */
   51|  6.42k|    t0 += x * 0x1000003D1ULL;
   52|  6.42k|    t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
   53|  6.42k|    t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL; m = t1;
   54|  6.42k|    t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL; m &= t2;
   55|  6.42k|    t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL; m &= t3;
   56|       |
   57|       |    /* ... except for a possible carry at bit 48 of t4 (i.e. bit 256 of the field element) */
   58|  6.42k|    VERIFY_CHECK(t4 >> 49 == 0);
   59|       |
   60|       |    /* At most a single final reduction is needed; check if the value is >= the field characteristic */
   61|  6.42k|    x = (t4 >> 48) | ((t4 == 0x0FFFFFFFFFFFFULL) & (m == 0xFFFFFFFFFFFFFULL)
   62|  6.42k|        & (t0 >= 0xFFFFEFFFFFC2FULL));
   63|       |
   64|       |    /* Apply the final reduction (for constant-time behaviour, we do it always) */
   65|  6.42k|    t0 += x * 0x1000003D1ULL;
   66|  6.42k|    t1 += (t0 >> 52); t0 &= 0xFFFFFFFFFFFFFULL;
   67|  6.42k|    t2 += (t1 >> 52); t1 &= 0xFFFFFFFFFFFFFULL;
   68|  6.42k|    t3 += (t2 >> 52); t2 &= 0xFFFFFFFFFFFFFULL;
   69|  6.42k|    t4 += (t3 >> 52); t3 &= 0xFFFFFFFFFFFFFULL;
   70|       |
   71|       |    /* If t4 didn't carry to bit 48 already, then it should have after any final reduction */
   72|  6.42k|    VERIFY_CHECK(t4 >> 48 == x);
   73|       |
   74|       |    /* Mask off the possible multiple of 2^256 from the final reduction */
   75|  6.42k|    t4 &= 0x0FFFFFFFFFFFFULL;
   76|       |
   77|  6.42k|    r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
   78|  6.42k|}

secp256k1.c:secp256k1_fe_sqr_inner:
  154|  1.13M|SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const uint64_t *a) {
  155|  1.13M|    secp256k1_uint128 c, d;
  156|  1.13M|    uint64_t a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4];
  157|  1.13M|    uint64_t t3, t4, tx, u0;
  158|  1.13M|    const uint64_t M = 0xFFFFFFFFFFFFFULL, R = 0x1000003D10ULL;
  159|       |
  160|  1.13M|    VERIFY_BITS(a[0], 56);
  161|  1.13M|    VERIFY_BITS(a[1], 56);
  162|  1.13M|    VERIFY_BITS(a[2], 56);
  163|  1.13M|    VERIFY_BITS(a[3], 56);
  164|  1.13M|    VERIFY_BITS(a[4], 52);
  165|       |
  166|       |    /**  [... a b c] is a shorthand for ... + a<<104 + b<<52 + c<<0 mod n.
  167|       |     *  px is a shorthand for sum(a[i]*a[x-i], i=0..x).
  168|       |     *  Note that [x 0 0 0 0 0] = [x*R].
  169|       |     */
  170|       |
  171|  1.13M|    secp256k1_u128_mul(&d, a0*2, a3);
  172|  1.13M|    secp256k1_u128_accum_mul(&d, a1*2, a2);
  173|  1.13M|    VERIFY_BITS_128(&d, 114);
  174|       |    /* [d 0 0 0] = [p3 0 0 0] */
  175|  1.13M|    secp256k1_u128_mul(&c, a4, a4);
  176|  1.13M|    VERIFY_BITS_128(&c, 112);
  177|       |    /* [c 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
  178|  1.13M|    secp256k1_u128_accum_mul(&d, R, secp256k1_u128_to_u64(&c)); secp256k1_u128_rshift(&c, 64);
  179|  1.13M|    VERIFY_BITS_128(&d, 115);
  180|  1.13M|    VERIFY_BITS_128(&c, 48);
  181|       |    /* [(c<<12) 0 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
  182|  1.13M|    t3 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
  183|  1.13M|    VERIFY_BITS(t3, 52);
  184|  1.13M|    VERIFY_BITS_128(&d, 63);
  185|       |    /* [(c<<12) 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
  186|       |
  187|  1.13M|    a4 *= 2;
  188|  1.13M|    secp256k1_u128_accum_mul(&d, a0, a4);
  189|  1.13M|    secp256k1_u128_accum_mul(&d, a1*2, a3);
  190|  1.13M|    secp256k1_u128_accum_mul(&d, a2, a2);
  191|  1.13M|    VERIFY_BITS_128(&d, 115);
  192|       |    /* [(c<<12) 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
  193|  1.13M|    secp256k1_u128_accum_mul(&d, R << 12, secp256k1_u128_to_u64(&c));
  194|  1.13M|    VERIFY_BITS_128(&d, 116);
  195|       |    /* [d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
  196|  1.13M|    t4 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
  197|  1.13M|    VERIFY_BITS(t4, 52);
  198|  1.13M|    VERIFY_BITS_128(&d, 64);
  199|       |    /* [d t4 t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
  200|  1.13M|    tx = (t4 >> 48); t4 &= (M >> 4);
  201|  1.13M|    VERIFY_BITS(tx, 4);
  202|  1.13M|    VERIFY_BITS(t4, 48);
  203|       |    /* [d t4+(tx<<48) t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
  204|       |
  205|  1.13M|    secp256k1_u128_mul(&c, a0, a0);
  206|  1.13M|    VERIFY_BITS_128(&c, 112);
  207|       |    /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 0 p4 p3 0 0 p0] */
  208|  1.13M|    secp256k1_u128_accum_mul(&d, a1, a4);
  209|  1.13M|    secp256k1_u128_accum_mul(&d, a2*2, a3);
  210|  1.13M|    VERIFY_BITS_128(&d, 114);
  211|       |    /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  212|  1.13M|    u0 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
  213|  1.13M|    VERIFY_BITS(u0, 52);
  214|  1.13M|    VERIFY_BITS_128(&d, 62);
  215|       |    /* [d u0 t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  216|       |    /* [d 0 t4+(tx<<48)+(u0<<52) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  217|  1.13M|    u0 = (u0 << 4) | tx;
  218|  1.13M|    VERIFY_BITS(u0, 56);
  219|       |    /* [d 0 t4+(u0<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  220|  1.13M|    secp256k1_u128_accum_mul(&c, u0, R >> 4);
  221|  1.13M|    VERIFY_BITS_128(&c, 113);
  222|       |    /* [d 0 t4 t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  223|  1.13M|    r[0] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  224|  1.13M|    VERIFY_BITS(r[0], 52);
  225|  1.13M|    VERIFY_BITS_128(&c, 61);
  226|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 0 p0] */
  227|       |
  228|  1.13M|    a0 *= 2;
  229|  1.13M|    secp256k1_u128_accum_mul(&c, a0, a1);
  230|  1.13M|    VERIFY_BITS_128(&c, 114);
  231|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 p1 p0] */
  232|  1.13M|    secp256k1_u128_accum_mul(&d, a2, a4);
  233|  1.13M|    secp256k1_u128_accum_mul(&d, a3, a3);
  234|  1.13M|    VERIFY_BITS_128(&d, 114);
  235|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  236|  1.13M|    secp256k1_u128_accum_mul(&c, secp256k1_u128_to_u64(&d) & M, R); secp256k1_u128_rshift(&d, 52);
  237|  1.13M|    VERIFY_BITS_128(&c, 115);
  238|  1.13M|    VERIFY_BITS_128(&d, 62);
  239|       |    /* [d 0 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  240|  1.13M|    r[1] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  241|  1.13M|    VERIFY_BITS(r[1], 52);
  242|  1.13M|    VERIFY_BITS_128(&c, 63);
  243|       |    /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  244|       |
  245|  1.13M|    secp256k1_u128_accum_mul(&c, a0, a2);
  246|  1.13M|    secp256k1_u128_accum_mul(&c, a1, a1);
  247|  1.13M|    VERIFY_BITS_128(&c, 114);
  248|       |    /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 p2 p1 p0] */
  249|  1.13M|    secp256k1_u128_accum_mul(&d, a3, a4);
  250|  1.13M|    VERIFY_BITS_128(&d, 114);
  251|       |    /* [d 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  252|  1.13M|    secp256k1_u128_accum_mul(&c, R, secp256k1_u128_to_u64(&d)); secp256k1_u128_rshift(&d, 64);
  253|  1.13M|    VERIFY_BITS_128(&c, 115);
  254|  1.13M|    VERIFY_BITS_128(&d, 50);
  255|       |    /* [(d<<12) 0 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  256|  1.13M|    r[2] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  257|  1.13M|    VERIFY_BITS(r[2], 52);
  258|  1.13M|    VERIFY_BITS_128(&c, 63);
  259|       |    /* [(d<<12) 0 0 0 t4 t3+c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  260|       |
  261|  1.13M|    secp256k1_u128_accum_mul(&c, R << 12, secp256k1_u128_to_u64(&d));
  262|  1.13M|    secp256k1_u128_accum_u64(&c, t3);
  263|  1.13M|    VERIFY_BITS_128(&c, 100);
  264|       |    /* [t4 c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  265|  1.13M|    r[3] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  266|  1.13M|    VERIFY_BITS(r[3], 52);
  267|  1.13M|    VERIFY_BITS_128(&c, 48);
  268|       |    /* [t4+c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  269|  1.13M|    r[4] = secp256k1_u128_to_u64(&c) + t4;
  270|  1.13M|    VERIFY_BITS(r[4], 49);
  271|       |    /* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  272|  1.13M|}
secp256k1.c:secp256k1_fe_mul_inner:
   18|  62.3k|SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const uint64_t *a, const uint64_t * SECP256K1_RESTRICT b) {
   19|  62.3k|    secp256k1_uint128 c, d;
   20|  62.3k|    uint64_t t3, t4, tx, u0;
   21|  62.3k|    uint64_t a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4];
   22|  62.3k|    const uint64_t M = 0xFFFFFFFFFFFFFULL, R = 0x1000003D10ULL;
   23|       |
   24|  62.3k|    VERIFY_BITS(a[0], 56);
   25|  62.3k|    VERIFY_BITS(a[1], 56);
   26|  62.3k|    VERIFY_BITS(a[2], 56);
   27|  62.3k|    VERIFY_BITS(a[3], 56);
   28|  62.3k|    VERIFY_BITS(a[4], 52);
   29|  62.3k|    VERIFY_BITS(b[0], 56);
   30|  62.3k|    VERIFY_BITS(b[1], 56);
   31|  62.3k|    VERIFY_BITS(b[2], 56);
   32|  62.3k|    VERIFY_BITS(b[3], 56);
   33|  62.3k|    VERIFY_BITS(b[4], 52);
   34|  62.3k|    VERIFY_CHECK(r != b);
   35|  62.3k|    VERIFY_CHECK(a != b);
   36|       |
   37|       |    /*  [... a b c] is a shorthand for ... + a<<104 + b<<52 + c<<0 mod n.
   38|       |     *  for 0 <= x <= 4, px is a shorthand for sum(a[i]*b[x-i], i=0..x).
   39|       |     *  for 4 <= x <= 8, px is a shorthand for sum(a[i]*b[x-i], i=(x-4)..4)
   40|       |     *  Note that [x 0 0 0 0 0] = [x*R].
   41|       |     */
   42|       |
   43|  62.3k|    secp256k1_u128_mul(&d, a0, b[3]);
   44|  62.3k|    secp256k1_u128_accum_mul(&d, a1, b[2]);
   45|  62.3k|    secp256k1_u128_accum_mul(&d, a2, b[1]);
   46|  62.3k|    secp256k1_u128_accum_mul(&d, a3, b[0]);
   47|  62.3k|    VERIFY_BITS_128(&d, 114);
   48|       |    /* [d 0 0 0] = [p3 0 0 0] */
   49|  62.3k|    secp256k1_u128_mul(&c, a4, b[4]);
   50|  62.3k|    VERIFY_BITS_128(&c, 112);
   51|       |    /* [c 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
   52|  62.3k|    secp256k1_u128_accum_mul(&d, R, secp256k1_u128_to_u64(&c)); secp256k1_u128_rshift(&c, 64);
   53|  62.3k|    VERIFY_BITS_128(&d, 115);
   54|  62.3k|    VERIFY_BITS_128(&c, 48);
   55|       |    /* [(c<<12) 0 0 0 0 0 d 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
   56|  62.3k|    t3 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
   57|  62.3k|    VERIFY_BITS(t3, 52);
   58|  62.3k|    VERIFY_BITS_128(&d, 63);
   59|       |    /* [(c<<12) 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 0 p3 0 0 0] */
   60|       |
   61|  62.3k|    secp256k1_u128_accum_mul(&d, a0, b[4]);
   62|  62.3k|    secp256k1_u128_accum_mul(&d, a1, b[3]);
   63|  62.3k|    secp256k1_u128_accum_mul(&d, a2, b[2]);
   64|  62.3k|    secp256k1_u128_accum_mul(&d, a3, b[1]);
   65|  62.3k|    secp256k1_u128_accum_mul(&d, a4, b[0]);
   66|  62.3k|    VERIFY_BITS_128(&d, 115);
   67|       |    /* [(c<<12) 0 0 0 0 d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
   68|  62.3k|    secp256k1_u128_accum_mul(&d, R << 12, secp256k1_u128_to_u64(&c));
   69|  62.3k|    VERIFY_BITS_128(&d, 116);
   70|       |    /* [d t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
   71|  62.3k|    t4 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
   72|  62.3k|    VERIFY_BITS(t4, 52);
   73|  62.3k|    VERIFY_BITS_128(&d, 64);
   74|       |    /* [d t4 t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
   75|  62.3k|    tx = (t4 >> 48); t4 &= (M >> 4);
   76|  62.3k|    VERIFY_BITS(tx, 4);
   77|  62.3k|    VERIFY_BITS(t4, 48);
   78|       |    /* [d t4+(tx<<48) t3 0 0 0] = [p8 0 0 0 p4 p3 0 0 0] */
   79|       |
   80|  62.3k|    secp256k1_u128_mul(&c, a0, b[0]);
   81|  62.3k|    VERIFY_BITS_128(&c, 112);
   82|       |    /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 0 p4 p3 0 0 p0] */
   83|  62.3k|    secp256k1_u128_accum_mul(&d, a1, b[4]);
   84|  62.3k|    secp256k1_u128_accum_mul(&d, a2, b[3]);
   85|  62.3k|    secp256k1_u128_accum_mul(&d, a3, b[2]);
   86|  62.3k|    secp256k1_u128_accum_mul(&d, a4, b[1]);
   87|  62.3k|    VERIFY_BITS_128(&d, 114);
   88|       |    /* [d t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
   89|  62.3k|    u0 = secp256k1_u128_to_u64(&d) & M; secp256k1_u128_rshift(&d, 52);
   90|  62.3k|    VERIFY_BITS(u0, 52);
   91|  62.3k|    VERIFY_BITS_128(&d, 62);
   92|       |    /* [d u0 t4+(tx<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
   93|       |    /* [d 0 t4+(tx<<48)+(u0<<52) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
   94|  62.3k|    u0 = (u0 << 4) | tx;
   95|  62.3k|    VERIFY_BITS(u0, 56);
   96|       |    /* [d 0 t4+(u0<<48) t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
   97|  62.3k|    secp256k1_u128_accum_mul(&c, u0, R >> 4);
   98|  62.3k|    VERIFY_BITS_128(&c, 113);
   99|       |    /* [d 0 t4 t3 0 0 c] = [p8 0 0 p5 p4 p3 0 0 p0] */
  100|  62.3k|    r[0] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  101|  62.3k|    VERIFY_BITS(r[0], 52);
  102|  62.3k|    VERIFY_BITS_128(&c, 61);
  103|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 0 p0] */
  104|       |
  105|  62.3k|    secp256k1_u128_accum_mul(&c, a0, b[1]);
  106|  62.3k|    secp256k1_u128_accum_mul(&c, a1, b[0]);
  107|  62.3k|    VERIFY_BITS_128(&c, 114);
  108|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 0 p5 p4 p3 0 p1 p0] */
  109|  62.3k|    secp256k1_u128_accum_mul(&d, a2, b[4]);
  110|  62.3k|    secp256k1_u128_accum_mul(&d, a3, b[3]);
  111|  62.3k|    secp256k1_u128_accum_mul(&d, a4, b[2]);
  112|  62.3k|    VERIFY_BITS_128(&d, 114);
  113|       |    /* [d 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  114|  62.3k|    secp256k1_u128_accum_mul(&c, secp256k1_u128_to_u64(&d) & M, R); secp256k1_u128_rshift(&d, 52);
  115|  62.3k|    VERIFY_BITS_128(&c, 115);
  116|  62.3k|    VERIFY_BITS_128(&d, 62);
  117|       |    /* [d 0 0 t4 t3 0 c r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  118|  62.3k|    r[1] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  119|  62.3k|    VERIFY_BITS(r[1], 52);
  120|  62.3k|    VERIFY_BITS_128(&c, 63);
  121|       |    /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 0 p1 p0] */
  122|       |
  123|  62.3k|    secp256k1_u128_accum_mul(&c, a0, b[2]);
  124|  62.3k|    secp256k1_u128_accum_mul(&c, a1, b[1]);
  125|  62.3k|    secp256k1_u128_accum_mul(&c, a2, b[0]);
  126|  62.3k|    VERIFY_BITS_128(&c, 114);
  127|       |    /* [d 0 0 t4 t3 c r1 r0] = [p8 0 p6 p5 p4 p3 p2 p1 p0] */
  128|  62.3k|    secp256k1_u128_accum_mul(&d, a3, b[4]);
  129|  62.3k|    secp256k1_u128_accum_mul(&d, a4, b[3]);
  130|  62.3k|    VERIFY_BITS_128(&d, 114);
  131|       |    /* [d 0 0 t4 t3 c t1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  132|  62.3k|    secp256k1_u128_accum_mul(&c, R, secp256k1_u128_to_u64(&d)); secp256k1_u128_rshift(&d, 64);
  133|  62.3k|    VERIFY_BITS_128(&c, 115);
  134|  62.3k|    VERIFY_BITS_128(&d, 50);
  135|       |    /* [(d<<12) 0 0 0 t4 t3 c r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  136|       |
  137|  62.3k|    r[2] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  138|  62.3k|    VERIFY_BITS(r[2], 52);
  139|  62.3k|    VERIFY_BITS_128(&c, 63);
  140|       |    /* [(d<<12) 0 0 0 t4 t3+c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  141|  62.3k|    secp256k1_u128_accum_mul(&c, R << 12, secp256k1_u128_to_u64(&d));
  142|  62.3k|    secp256k1_u128_accum_u64(&c, t3);
  143|  62.3k|    VERIFY_BITS_128(&c, 100);
  144|       |    /* [t4 c r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  145|  62.3k|    r[3] = secp256k1_u128_to_u64(&c) & M; secp256k1_u128_rshift(&c, 52);
  146|  62.3k|    VERIFY_BITS(r[3], 52);
  147|  62.3k|    VERIFY_BITS_128(&c, 48);
  148|       |    /* [t4+c r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  149|  62.3k|    r[4] = secp256k1_u128_to_u64(&c) + t4;
  150|  62.3k|    VERIFY_BITS(r[4], 49);
  151|       |    /* [r4 r3 r2 r1 r0] = [p8 p7 p6 p5 p4 p3 p2 p1 p0] */
  152|  62.3k|}

secp256k1.c:secp256k1_fe_verify:
  149|  52.3k|static void secp256k1_fe_verify(const secp256k1_fe *a) { (void)a; }
secp256k1.c:secp256k1_fe_verify_magnitude:
  150|  47.9k|static void secp256k1_fe_verify_magnitude(const secp256k1_fe *a, int m) { (void)a; (void)m; }
secp256k1.c:secp256k1_fe_sqrt:
   37|  4.45k|static int secp256k1_fe_sqrt(secp256k1_fe * SECP256K1_RESTRICT r, const secp256k1_fe * SECP256K1_RESTRICT a) {
   38|       |    /** Given that p is congruent to 3 mod 4, we can compute the square root of
   39|       |     *  a mod p as the (p+1)/4'th power of a.
   40|       |     *
   41|       |     *  As (p+1)/4 is an even number, it will have the same result for a and for
   42|       |     *  (-a). Only one of these two numbers actually has a square root however,
   43|       |     *  so we test at the end by squaring and comparing to the input.
   44|       |     *  Also because (p+1)/4 is an even number, the computed square root is
   45|       |     *  itself always a square (a ** ((p+1)/4) is the square of a ** ((p+1)/8)).
   46|       |     */
   47|  4.45k|    secp256k1_fe x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
   48|  4.45k|    int j, ret;
   49|       |
   50|  4.45k|    VERIFY_CHECK(r != a);
   51|  4.45k|    SECP256K1_FE_VERIFY(a);
  ------------------
  |  |  344|  4.45k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   52|  4.45k|    SECP256K1_FE_VERIFY_MAGNITUDE(a, 8);
  ------------------
  |  |  348|  4.45k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   53|       |
   54|       |    /** The binary representation of (p + 1)/4 has 3 blocks of 1s, with lengths in
   55|       |     *  { 2, 22, 223 }. Use an addition chain to calculate 2^n - 1 for each block:
   56|       |     *  1, [2], 3, 6, 9, 11, [22], 44, 88, 176, 220, [223]
   57|       |     */
   58|       |
   59|  4.45k|    secp256k1_fe_sqr(&x2, a);
  ------------------
  |  |   94|  4.45k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   60|  4.45k|    secp256k1_fe_mul(&x2, &x2, a);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   61|       |
   62|  4.45k|    secp256k1_fe_sqr(&x3, &x2);
  ------------------
  |  |   94|  4.45k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   63|  4.45k|    secp256k1_fe_mul(&x3, &x3, a);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   64|       |
   65|  4.45k|    x6 = x3;
   66|  17.8k|    for (j=0; j<3; j++) {
  ------------------
  |  Branch (66:15): [True: 13.3k, False: 4.45k]
  ------------------
   67|  13.3k|        secp256k1_fe_sqr(&x6, &x6);
  ------------------
  |  |   94|  13.3k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   68|  13.3k|    }
   69|  4.45k|    secp256k1_fe_mul(&x6, &x6, &x3);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   70|       |
   71|  4.45k|    x9 = x6;
   72|  17.8k|    for (j=0; j<3; j++) {
  ------------------
  |  Branch (72:15): [True: 13.3k, False: 4.45k]
  ------------------
   73|  13.3k|        secp256k1_fe_sqr(&x9, &x9);
  ------------------
  |  |   94|  13.3k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   74|  13.3k|    }
   75|  4.45k|    secp256k1_fe_mul(&x9, &x9, &x3);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   76|       |
   77|  4.45k|    x11 = x9;
   78|  13.3k|    for (j=0; j<2; j++) {
  ------------------
  |  Branch (78:15): [True: 8.90k, False: 4.45k]
  ------------------
   79|  8.90k|        secp256k1_fe_sqr(&x11, &x11);
  ------------------
  |  |   94|  8.90k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   80|  8.90k|    }
   81|  4.45k|    secp256k1_fe_mul(&x11, &x11, &x2);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   82|       |
   83|  4.45k|    x22 = x11;
   84|  53.4k|    for (j=0; j<11; j++) {
  ------------------
  |  Branch (84:15): [True: 48.9k, False: 4.45k]
  ------------------
   85|  48.9k|        secp256k1_fe_sqr(&x22, &x22);
  ------------------
  |  |   94|  48.9k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   86|  48.9k|    }
   87|  4.45k|    secp256k1_fe_mul(&x22, &x22, &x11);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   88|       |
   89|  4.45k|    x44 = x22;
   90|   102k|    for (j=0; j<22; j++) {
  ------------------
  |  Branch (90:15): [True: 97.9k, False: 4.45k]
  ------------------
   91|  97.9k|        secp256k1_fe_sqr(&x44, &x44);
  ------------------
  |  |   94|  97.9k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   92|  97.9k|    }
   93|  4.45k|    secp256k1_fe_mul(&x44, &x44, &x22);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
   94|       |
   95|  4.45k|    x88 = x44;
   96|   200k|    for (j=0; j<44; j++) {
  ------------------
  |  Branch (96:15): [True: 195k, False: 4.45k]
  ------------------
   97|   195k|        secp256k1_fe_sqr(&x88, &x88);
  ------------------
  |  |   94|   195k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
   98|   195k|    }
   99|  4.45k|    secp256k1_fe_mul(&x88, &x88, &x44);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  100|       |
  101|  4.45k|    x176 = x88;
  102|   396k|    for (j=0; j<88; j++) {
  ------------------
  |  Branch (102:15): [True: 391k, False: 4.45k]
  ------------------
  103|   391k|        secp256k1_fe_sqr(&x176, &x176);
  ------------------
  |  |   94|   391k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  104|   391k|    }
  105|  4.45k|    secp256k1_fe_mul(&x176, &x176, &x88);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  106|       |
  107|  4.45k|    x220 = x176;
  108|   200k|    for (j=0; j<44; j++) {
  ------------------
  |  Branch (108:15): [True: 195k, False: 4.45k]
  ------------------
  109|   195k|        secp256k1_fe_sqr(&x220, &x220);
  ------------------
  |  |   94|   195k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  110|   195k|    }
  111|  4.45k|    secp256k1_fe_mul(&x220, &x220, &x44);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  112|       |
  113|  4.45k|    x223 = x220;
  114|  17.8k|    for (j=0; j<3; j++) {
  ------------------
  |  Branch (114:15): [True: 13.3k, False: 4.45k]
  ------------------
  115|  13.3k|        secp256k1_fe_sqr(&x223, &x223);
  ------------------
  |  |   94|  13.3k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  116|  13.3k|    }
  117|  4.45k|    secp256k1_fe_mul(&x223, &x223, &x3);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  118|       |
  119|       |    /* The final result is then assembled using a sliding window over the blocks. */
  120|       |
  121|  4.45k|    t1 = x223;
  122|   106k|    for (j=0; j<23; j++) {
  ------------------
  |  Branch (122:15): [True: 102k, False: 4.45k]
  ------------------
  123|   102k|        secp256k1_fe_sqr(&t1, &t1);
  ------------------
  |  |   94|   102k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  124|   102k|    }
  125|  4.45k|    secp256k1_fe_mul(&t1, &t1, &x22);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  126|  31.1k|    for (j=0; j<6; j++) {
  ------------------
  |  Branch (126:15): [True: 26.7k, False: 4.45k]
  ------------------
  127|  26.7k|        secp256k1_fe_sqr(&t1, &t1);
  ------------------
  |  |   94|  26.7k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  128|  26.7k|    }
  129|  4.45k|    secp256k1_fe_mul(&t1, &t1, &x2);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  130|  4.45k|    secp256k1_fe_sqr(&t1, &t1);
  ------------------
  |  |   94|  4.45k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  131|  4.45k|    secp256k1_fe_sqr(r, &t1);
  ------------------
  |  |   94|  4.45k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  132|       |
  133|       |    /* Check that a square root was actually calculated */
  134|       |
  135|  4.45k|    secp256k1_fe_sqr(&t1, r);
  ------------------
  |  |   94|  4.45k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  136|  4.45k|    ret = secp256k1_fe_equal(&t1, a);
  137|       |
  138|       |#ifdef VERIFY
  139|       |    if (!ret) {
  140|       |        secp256k1_fe_negate(&t1, &t1, 1);
  141|       |        secp256k1_fe_normalize_var(&t1);
  142|       |        VERIFY_CHECK(secp256k1_fe_equal(&t1, a));
  143|       |    }
  144|       |#endif
  145|  4.45k|    return ret;
  146|  4.45k|}
secp256k1.c:secp256k1_fe_equal:
   25|  4.45k|SECP256K1_INLINE static int secp256k1_fe_equal(const secp256k1_fe *a, const secp256k1_fe *b) {
   26|  4.45k|    secp256k1_fe na;
   27|  4.45k|    SECP256K1_FE_VERIFY(a);
  ------------------
  |  |  344|  4.45k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   28|  4.45k|    SECP256K1_FE_VERIFY(b);
  ------------------
  |  |  344|  4.45k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   29|  4.45k|    SECP256K1_FE_VERIFY_MAGNITUDE(a, 1);
  ------------------
  |  |  348|  4.45k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   30|  4.45k|    SECP256K1_FE_VERIFY_MAGNITUDE(b, 31);
  ------------------
  |  |  348|  4.45k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   31|       |
   32|  4.45k|    secp256k1_fe_negate(&na, a, 1);
  ------------------
  |  |  211|  4.45k|#define secp256k1_fe_negate(r, a, m) ASSERT_INT_CONST_AND_DO(m, secp256k1_fe_negate_unchecked(r, a, m))
  |  |  ------------------
  |  |  |  |   77|  4.45k|#define ASSERT_INT_CONST_AND_DO(expr, stmt) do { \
  |  |  |  |   78|  4.45k|    switch(42) { \
  |  |  |  |   79|      0|        /* C allows only integer constant expressions as case labels. */ \
  |  |  |  |   80|      0|        case /* ERROR: integer argument is not constant */ (expr): \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:9): [True: 0, False: 4.45k]
  |  |  |  |  ------------------
  |  |  |  |   81|      0|            break; \
  |  |  |  |   82|  4.45k|        default: ; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:9): [True: 4.45k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   83|  4.45k|    } \
  |  |  |  |   84|  4.45k|    stmt; \
  |  |  |  |   85|  4.45k|} while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:9): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   33|  4.45k|    secp256k1_fe_add(&na, b);
  ------------------
  |  |   92|  4.45k|#  define secp256k1_fe_add secp256k1_fe_impl_add
  ------------------
   34|  4.45k|    return secp256k1_fe_normalizes_to_zero(&na);
  ------------------
  |  |   81|  4.45k|#  define secp256k1_fe_normalizes_to_zero secp256k1_fe_impl_normalizes_to_zero
  ------------------
   35|  4.45k|}
secp256k1.c:secp256k1_fe_clear:
   21|      2|SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) {
   22|      2|    secp256k1_memclear(a, sizeof(secp256k1_fe));
   23|      2|}

secp256k1.c:secp256k1_ge_verify:
   78|  17.2k|static void secp256k1_ge_verify(const secp256k1_ge *a) {
   79|  17.2k|    SECP256K1_FE_VERIFY(&a->x);
  ------------------
  |  |  344|  17.2k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   80|  17.2k|    SECP256K1_FE_VERIFY(&a->y);
  ------------------
  |  |  344|  17.2k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
   81|  17.2k|    SECP256K1_FE_VERIFY_MAGNITUDE(&a->x, SECP256K1_GE_X_MAGNITUDE_MAX);
  ------------------
  |  |  348|  17.2k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   82|  17.2k|    SECP256K1_FE_VERIFY_MAGNITUDE(&a->y, SECP256K1_GE_Y_MAGNITUDE_MAX);
  ------------------
  |  |  348|  17.2k|#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
  ------------------
   83|  17.2k|    VERIFY_CHECK(a->infinity == 0 || a->infinity == 1);
   84|  17.2k|    (void)a;
   85|  17.2k|}
secp256k1.c:secp256k1_ge_is_in_correct_subgroup:
  886|  3.21k|static int secp256k1_ge_is_in_correct_subgroup(const secp256k1_ge* ge) {
  887|       |#ifdef EXHAUSTIVE_TEST_ORDER
  888|       |    secp256k1_gej out;
  889|       |    int i;
  890|       |    SECP256K1_GE_VERIFY(ge);
  891|       |
  892|       |    /* A very simple EC multiplication ladder that avoids a dependency on ecmult. */
  893|       |    secp256k1_gej_set_infinity(&out);
  894|       |    for (i = 0; i < 32; ++i) {
  895|       |        secp256k1_gej_double_var(&out, &out, NULL);
  896|       |        if ((((uint32_t)EXHAUSTIVE_TEST_ORDER) >> (31 - i)) & 1) {
  897|       |            secp256k1_gej_add_ge_var(&out, &out, ge, NULL);
  898|       |        }
  899|       |    }
  900|       |    return secp256k1_gej_is_infinity(&out);
  901|       |#else
  902|  3.21k|    SECP256K1_GE_VERIFY(ge);
  ------------------
  |  |  206|  3.21k|#define SECP256K1_GE_VERIFY(a) secp256k1_ge_verify(a)
  ------------------
  903|       |
  904|  3.21k|    (void)ge;
  905|       |    /* The real secp256k1 group has cofactor 1, so the subgroup is the entire curve. */
  906|  3.21k|    return 1;
  907|  3.21k|#endif
  908|  3.21k|}
secp256k1.c:secp256k1_ge_to_bytes:
  937|  3.21k|static void secp256k1_ge_to_bytes(unsigned char *buf, const secp256k1_ge *a) {
  938|  3.21k|    secp256k1_ge_storage s;
  939|       |
  940|       |    /* We require that the secp256k1_ge_storage type is exactly 64 bytes.
  941|       |     * This is formally not guaranteed by the C standard, but should hold on any
  942|       |     * sane compiler in the real world. */
  943|  3.21k|    STATIC_ASSERT(sizeof(secp256k1_ge_storage) == 64);
  ------------------
  |  |   64|  3.21k|#define STATIC_ASSERT(expr) do { \
  |  |   65|  3.21k|    switch(0) { \
  |  |  ------------------
  |  |  |  Branch (65:12): [Folded - Ignored]
  |  |  ------------------
  |  |   66|  3.21k|        case 0: \
  |  |  ------------------
  |  |  |  Branch (66:9): [True: 3.21k, False: 0]
  |  |  ------------------
  |  |   67|  3.21k|        /* If expr evaluates to 0, we have two case labels "0", which is illegal. */ \
  |  |   68|  3.21k|        case /* ERROR: static assertion failed */ (expr): \
  |  |  ------------------
  |  |  |  Branch (68:9): [True: 0, False: 3.21k]
  |  |  ------------------
  |  |   69|  3.21k|        ; \
  |  |   70|  3.21k|    } \
  |  |   71|  3.21k|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  944|  3.21k|    VERIFY_CHECK(!secp256k1_ge_is_infinity(a));
  945|  3.21k|    secp256k1_ge_to_storage(&s, a);
  946|  3.21k|    memcpy(buf, &s, 64);
  947|  3.21k|}
secp256k1.c:secp256k1_ge_to_storage:
  839|  3.21k|static void secp256k1_ge_to_storage(secp256k1_ge_storage *r, const secp256k1_ge *a) {
  840|  3.21k|    secp256k1_fe x, y;
  841|  3.21k|    SECP256K1_GE_VERIFY(a);
  ------------------
  |  |  206|  3.21k|#define SECP256K1_GE_VERIFY(a) secp256k1_ge_verify(a)
  ------------------
  842|  3.21k|    VERIFY_CHECK(!a->infinity);
  843|       |
  844|  3.21k|    x = a->x;
  845|  3.21k|    secp256k1_fe_normalize(&x);
  ------------------
  |  |   78|  3.21k|#  define secp256k1_fe_normalize secp256k1_fe_impl_normalize
  ------------------
  846|  3.21k|    y = a->y;
  847|  3.21k|    secp256k1_fe_normalize(&y);
  ------------------
  |  |   78|  3.21k|#  define secp256k1_fe_normalize secp256k1_fe_impl_normalize
  ------------------
  848|  3.21k|    secp256k1_fe_to_storage(&r->x, &x);
  ------------------
  |  |   96|  3.21k|#  define secp256k1_fe_to_storage secp256k1_fe_impl_to_storage
  ------------------
  849|  3.21k|    secp256k1_fe_to_storage(&r->y, &y);
  ------------------
  |  |   96|  3.21k|#  define secp256k1_fe_to_storage secp256k1_fe_impl_to_storage
  ------------------
  850|  3.21k|}
secp256k1.c:secp256k1_ge_clear:
  305|  3.21k|static void secp256k1_ge_clear(secp256k1_ge *r) {
  306|  3.21k|    secp256k1_memclear(r, sizeof(secp256k1_ge));
  307|  3.21k|}
secp256k1.c:secp256k1_ge_from_bytes:
  949|  3.21k|static void secp256k1_ge_from_bytes(secp256k1_ge *r, const unsigned char *buf) {
  950|  3.21k|    secp256k1_ge_storage s;
  951|       |
  952|  3.21k|    STATIC_ASSERT(sizeof(secp256k1_ge_storage) == 64);
  ------------------
  |  |   64|  3.21k|#define STATIC_ASSERT(expr) do { \
  |  |   65|  3.21k|    switch(0) { \
  |  |  ------------------
  |  |  |  Branch (65:12): [Folded - Ignored]
  |  |  ------------------
  |  |   66|  3.21k|        case 0: \
  |  |  ------------------
  |  |  |  Branch (66:9): [True: 3.21k, False: 0]
  |  |  ------------------
  |  |   67|  3.21k|        /* If expr evaluates to 0, we have two case labels "0", which is illegal. */ \
  |  |   68|  3.21k|        case /* ERROR: static assertion failed */ (expr): \
  |  |  ------------------
  |  |  |  Branch (68:9): [True: 0, False: 3.21k]
  |  |  ------------------
  |  |   69|  3.21k|        ; \
  |  |   70|  3.21k|    } \
  |  |   71|  3.21k|} while(0)
  |  |  ------------------
  |  |  |  Branch (71:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  953|  3.21k|    memcpy(&s, buf, 64);
  954|  3.21k|    secp256k1_ge_from_storage(r, &s);
  955|  3.21k|}
secp256k1.c:secp256k1_ge_from_storage:
  852|  3.21k|static void secp256k1_ge_from_storage(secp256k1_ge *r, const secp256k1_ge_storage *a) {
  853|  3.21k|    secp256k1_fe_from_storage(&r->x, &a->x);
  ------------------
  |  |   97|  3.21k|#  define secp256k1_fe_from_storage secp256k1_fe_impl_from_storage
  ------------------
  854|  3.21k|    secp256k1_fe_from_storage(&r->y, &a->y);
  ------------------
  |  |   97|  3.21k|#  define secp256k1_fe_from_storage secp256k1_fe_impl_from_storage
  ------------------
  855|  3.21k|    r->infinity = 0;
  856|       |
  857|  3.21k|    SECP256K1_GE_VERIFY(r);
  ------------------
  |  |  206|  3.21k|#define SECP256K1_GE_VERIFY(a) secp256k1_ge_verify(a)
  ------------------
  858|  3.21k|}
secp256k1.c:secp256k1_ge_set_xo_var:
  309|  4.45k|static int secp256k1_ge_set_xo_var(secp256k1_ge *r, const secp256k1_fe *x, int odd) {
  310|  4.45k|    secp256k1_fe x2, x3;
  311|  4.45k|    int ret;
  312|  4.45k|    SECP256K1_FE_VERIFY(x);
  ------------------
  |  |  344|  4.45k|#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
  ------------------
  313|       |
  314|  4.45k|    r->x = *x;
  315|  4.45k|    secp256k1_fe_sqr(&x2, x);
  ------------------
  |  |   94|  4.45k|#  define secp256k1_fe_sqr secp256k1_fe_impl_sqr
  ------------------
  316|  4.45k|    secp256k1_fe_mul(&x3, x, &x2);
  ------------------
  |  |   93|  4.45k|#  define secp256k1_fe_mul secp256k1_fe_impl_mul
  ------------------
  317|  4.45k|    r->infinity = 0;
  318|  4.45k|    secp256k1_fe_add_int(&x3, SECP256K1_B);
  ------------------
  |  |  102|  4.45k|#  define secp256k1_fe_add_int secp256k1_fe_impl_add_int
  ------------------
                  secp256k1_fe_add_int(&x3, SECP256K1_B);
  ------------------
  |  |   73|  4.45k|#define SECP256K1_B 7
  ------------------
  319|  4.45k|    ret = secp256k1_fe_sqrt(&r->y, &x3);
  320|  4.45k|    secp256k1_fe_normalize_var(&r->y);
  ------------------
  |  |   80|  4.45k|#  define secp256k1_fe_normalize_var secp256k1_fe_impl_normalize_var
  ------------------
  321|  4.45k|    if (secp256k1_fe_is_odd(&r->y) != odd) {
  ------------------
  |  |   85|  4.45k|#  define secp256k1_fe_is_odd secp256k1_fe_impl_is_odd
  ------------------
  |  Branch (321:9): [True: 2.03k, False: 2.42k]
  ------------------
  322|  2.03k|        secp256k1_fe_negate(&r->y, &r->y, 1);
  ------------------
  |  |  211|  2.03k|#define secp256k1_fe_negate(r, a, m) ASSERT_INT_CONST_AND_DO(m, secp256k1_fe_negate_unchecked(r, a, m))
  |  |  ------------------
  |  |  |  |   77|  2.03k|#define ASSERT_INT_CONST_AND_DO(expr, stmt) do { \
  |  |  |  |   78|  2.03k|    switch(42) { \
  |  |  |  |   79|      0|        /* C allows only integer constant expressions as case labels. */ \
  |  |  |  |   80|      0|        case /* ERROR: integer argument is not constant */ (expr): \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:9): [True: 0, False: 2.03k]
  |  |  |  |  ------------------
  |  |  |  |   81|      0|            break; \
  |  |  |  |   82|  2.03k|        default: ; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:9): [True: 2.03k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   83|  2.03k|    } \
  |  |  |  |   84|  2.03k|    stmt; \
  |  |  |  |   85|  2.03k|} while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:9): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  323|  2.03k|    }
  324|       |
  325|  4.45k|    SECP256K1_GE_VERIFY(r);
  ------------------
  |  |  206|  4.45k|#define SECP256K1_GE_VERIFY(a) secp256k1_ge_verify(a)
  ------------------
  326|  4.45k|    return ret;
  327|  4.45k|}
secp256k1.c:secp256k1_ge_is_infinity:
  143|  3.21k|static int secp256k1_ge_is_infinity(const secp256k1_ge *a) {
  144|  3.21k|    SECP256K1_GE_VERIFY(a);
  ------------------
  |  |  206|  3.21k|#define SECP256K1_GE_VERIFY(a) secp256k1_ge_verify(a)
  ------------------
  145|       |
  146|  3.21k|    return a->infinity;
  147|  3.21k|}

secp256k1.c:secp256k1_u128_mul:
   11|  3.59M|static SECP256K1_INLINE void secp256k1_u128_mul(secp256k1_uint128 *r, uint64_t a, uint64_t b) {
   12|  3.59M|   *r = (uint128_t)a * b;
   13|  3.59M|}
secp256k1.c:secp256k1_u128_accum_mul:
   15|  22.1M|static SECP256K1_INLINE void secp256k1_u128_accum_mul(secp256k1_uint128 *r, uint64_t a, uint64_t b) {
   16|  22.1M|   *r += (uint128_t)a * b;
   17|  22.1M|}
secp256k1.c:secp256k1_u128_to_u64:
   28|  15.5M|static SECP256K1_INLINE uint64_t secp256k1_u128_to_u64(const secp256k1_uint128 *a) {
   29|  15.5M|   return (uint64_t)(*a);
   30|  15.5M|}
secp256k1.c:secp256k1_u128_rshift:
   23|  11.9M|static SECP256K1_INLINE void secp256k1_u128_rshift(secp256k1_uint128 *r, unsigned int n) {
   24|  11.9M|   VERIFY_CHECK(n < 128);
   25|  11.9M|   *r >>= n;
   26|  11.9M|}
secp256k1.c:secp256k1_u128_accum_u64:
   19|  1.19M|static SECP256K1_INLINE void secp256k1_u128_accum_u64(secp256k1_uint128 *r, uint64_t a) {
   20|  1.19M|   *r += a;
   21|  1.19M|}

secp256k1.c:secp256k1_scalar_clear:
   30|      2|SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) {
   31|      2|    secp256k1_memclear(r, sizeof(secp256k1_scalar));
   32|      2|}

secp256k1_context_preallocated_destroy:
  176|      2|void secp256k1_context_preallocated_destroy(secp256k1_context* ctx) {
  177|      2|    ARG_CHECK_VOID(ctx == NULL || secp256k1_context_is_proper(ctx));
  ------------------
  |  |   52|      2|#define ARG_CHECK_VOID(cond) do { \
  |  |   53|      2|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|      4|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 2]
  |  |  |  |  |  Branch (136:39): [True: 0, False: 2]
  |  |  |  |  |  Branch (136:39): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   55|      0|        return; \
  |  |   56|      0|    } \
  |  |   57|      2|} while(0)
  |  |  ------------------
  |  |  |  Branch (57:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  178|       |
  179|       |    /* Defined as noop */
  180|      2|    if (ctx == NULL) {
  ------------------
  |  Branch (180:9): [True: 0, False: 2]
  ------------------
  181|      0|        return;
  182|      0|    }
  183|       |
  184|      2|    secp256k1_ecmult_gen_context_clear(&ctx->ecmult_gen_ctx);
  185|      2|}
secp256k1_context_destroy:
  187|      2|void secp256k1_context_destroy(secp256k1_context* ctx) {
  188|      2|    ARG_CHECK_VOID(ctx == NULL || secp256k1_context_is_proper(ctx));
  ------------------
  |  |   52|      2|#define ARG_CHECK_VOID(cond) do { \
  |  |   53|      2|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|      4|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 2]
  |  |  |  |  |  Branch (136:39): [True: 0, False: 2]
  |  |  |  |  |  Branch (136:39): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   55|      0|        return; \
  |  |   56|      0|    } \
  |  |   57|      2|} while(0)
  |  |  ------------------
  |  |  |  Branch (57:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  189|       |
  190|       |    /* Defined as noop */
  191|      2|    if (ctx == NULL) {
  ------------------
  |  Branch (191:9): [True: 0, False: 2]
  ------------------
  192|      0|        return;
  193|      0|    }
  194|       |
  195|      2|    secp256k1_context_preallocated_destroy(ctx);
  196|      2|    free(ctx);
  197|      2|}
secp256k1_ec_pubkey_parse:
  250|  4.67k|int secp256k1_ec_pubkey_parse(const secp256k1_context* ctx, secp256k1_pubkey* pubkey, const unsigned char *input, size_t inputlen) {
  251|  4.67k|    secp256k1_ge Q;
  252|       |
  253|  4.67k|    VERIFY_CHECK(ctx != NULL);
  254|  4.67k|    ARG_CHECK(pubkey != NULL);
  ------------------
  |  |   45|  4.67k|#define ARG_CHECK(cond) do { \
  |  |   46|  4.67k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|  4.67k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 4.67k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   48|      0|        return 0; \
  |  |   49|      0|    } \
  |  |   50|  4.67k|} while(0)
  |  |  ------------------
  |  |  |  Branch (50:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  255|  4.67k|    memset(pubkey, 0, sizeof(*pubkey));
  256|  4.67k|    ARG_CHECK(input != NULL);
  ------------------
  |  |   45|  4.67k|#define ARG_CHECK(cond) do { \
  |  |   46|  4.67k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|  4.67k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 4.67k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   48|      0|        return 0; \
  |  |   49|      0|    } \
  |  |   50|  4.67k|} while(0)
  |  |  ------------------
  |  |  |  Branch (50:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  257|  4.67k|    if (!secp256k1_eckey_pubkey_parse(&Q, input, inputlen)) {
  ------------------
  |  Branch (257:9): [True: 1.46k, False: 3.21k]
  ------------------
  258|  1.46k|        return 0;
  259|  1.46k|    }
  260|  3.21k|    if (!secp256k1_ge_is_in_correct_subgroup(&Q)) {
  ------------------
  |  Branch (260:9): [True: 0, False: 3.21k]
  ------------------
  261|      0|        return 0;
  262|      0|    }
  263|  3.21k|    secp256k1_pubkey_save(pubkey, &Q);
  264|  3.21k|    secp256k1_ge_clear(&Q);
  265|  3.21k|    return 1;
  266|  3.21k|}
secp256k1_ec_pubkey_serialize:
  268|  3.21k|int secp256k1_ec_pubkey_serialize(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_pubkey* pubkey, unsigned int flags) {
  269|  3.21k|    secp256k1_ge Q;
  270|  3.21k|    size_t len;
  271|  3.21k|    int ret = 0;
  272|       |
  273|  3.21k|    VERIFY_CHECK(ctx != NULL);
  274|  3.21k|    ARG_CHECK(outputlen != NULL);
  ------------------
  |  |   45|  3.21k|#define ARG_CHECK(cond) do { \
  |  |   46|  3.21k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|  3.21k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 3.21k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   48|      0|        return 0; \
  |  |   49|      0|    } \
  |  |   50|  3.21k|} while(0)
  |  |  ------------------
  |  |  |  Branch (50:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  275|  3.21k|    ARG_CHECK(*outputlen >= ((flags & SECP256K1_FLAGS_BIT_COMPRESSION) ? 33u : 65u));
  ------------------
  |  |   45|  3.21k|#define ARG_CHECK(cond) do { \
  |  |   46|  3.21k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|  6.42k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 3.21k]
  |  |  |  |  |  Branch (136:39): [True: 0, False: 3.21k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   48|      0|        return 0; \
  |  |   49|      0|    } \
  |  |   50|  3.21k|} while(0)
  |  |  ------------------
  |  |  |  Branch (50:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  276|  3.21k|    len = *outputlen;
  277|  3.21k|    *outputlen = 0;
  278|  3.21k|    ARG_CHECK(output != NULL);
  ------------------
  |  |   45|  3.21k|#define ARG_CHECK(cond) do { \
  |  |   46|  3.21k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|  3.21k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 3.21k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   48|      0|        return 0; \
  |  |   49|      0|    } \
  |  |   50|  3.21k|} while(0)
  |  |  ------------------
  |  |  |  Branch (50:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  279|  3.21k|    memset(output, 0, len);
  280|  3.21k|    ARG_CHECK(pubkey != NULL);
  ------------------
  |  |   45|  3.21k|#define ARG_CHECK(cond) do { \
  |  |   46|  3.21k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|  3.21k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 3.21k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   48|      0|        return 0; \
  |  |   49|      0|    } \
  |  |   50|  3.21k|} while(0)
  |  |  ------------------
  |  |  |  Branch (50:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  281|  3.21k|    ARG_CHECK((flags & SECP256K1_FLAGS_TYPE_MASK) == SECP256K1_FLAGS_TYPE_COMPRESSION);
  ------------------
  |  |   45|  3.21k|#define ARG_CHECK(cond) do { \
  |  |   46|  3.21k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|  3.21k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 3.21k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   48|      0|        return 0; \
  |  |   49|      0|    } \
  |  |   50|  3.21k|} while(0)
  |  |  ------------------
  |  |  |  Branch (50:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  282|  3.21k|    if (secp256k1_pubkey_load(ctx, &Q, pubkey)) {
  ------------------
  |  Branch (282:9): [True: 3.21k, False: 0]
  ------------------
  283|  3.21k|        ret = secp256k1_eckey_pubkey_serialize(&Q, output, &len, flags & SECP256K1_FLAGS_BIT_COMPRESSION);
  ------------------
  |  |  198|  3.21k|#define SECP256K1_FLAGS_BIT_COMPRESSION (1 << 8)
  ------------------
  284|  3.21k|        if (ret) {
  ------------------
  |  Branch (284:13): [True: 3.21k, False: 0]
  ------------------
  285|  3.21k|            *outputlen = len;
  286|  3.21k|        }
  287|  3.21k|    }
  288|  3.21k|    return ret;
  289|  3.21k|}
secp256k1.c:secp256k1_context_is_proper:
   82|      4|static int secp256k1_context_is_proper(const secp256k1_context* ctx) {
   83|      4|    return secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx);
   84|      4|}
secp256k1.c:secp256k1_pubkey_save:
  246|  3.21k|static void secp256k1_pubkey_save(secp256k1_pubkey* pubkey, secp256k1_ge* ge) {
  247|  3.21k|    secp256k1_ge_to_bytes(pubkey->data, ge);
  248|  3.21k|}
secp256k1.c:secp256k1_pubkey_load:
  240|  3.21k|static int secp256k1_pubkey_load(const secp256k1_context* ctx, secp256k1_ge* ge, const secp256k1_pubkey* pubkey) {
  241|  3.21k|    secp256k1_ge_from_bytes(ge, pubkey->data);
  242|  3.21k|    ARG_CHECK(!secp256k1_fe_is_zero(&ge->x));
  ------------------
  |  |   45|  3.21k|#define ARG_CHECK(cond) do { \
  |  |   46|  3.21k|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|  3.21k|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 3.21k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   47|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   48|      0|        return 0; \
  |  |   49|      0|    } \
  |  |   50|  3.21k|} while(0)
  |  |  ------------------
  |  |  |  Branch (50:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  243|  3.21k|    return 1;
  244|  3.21k|}

secp256k1.c:secp256k1_memclear:
  223|  3.21k|static SECP256K1_INLINE void secp256k1_memclear(void *ptr, size_t len) {
  224|       |#if defined(_MSC_VER)
  225|       |    /* SecureZeroMemory is guaranteed not to be optimized out by MSVC. */
  226|       |    SecureZeroMemory(ptr, len);
  227|       |#elif defined(__GNUC__)
  228|       |    /* We use a memory barrier that scares the compiler away from optimizing out the memset.
  229|       |     *
  230|       |     * Quoting Adam Langley <agl@google.com> in commit ad1907fe73334d6c696c8539646c21b11178f20f
  231|       |     * in BoringSSL (ISC License):
  232|       |     *    As best as we can tell, this is sufficient to break any optimisations that
  233|       |     *    might try to eliminate "superfluous" memsets.
  234|       |     * This method is used in memzero_explicit() the Linux kernel, too. Its advantage is that it
  235|       |     * is pretty efficient, because the compiler can still implement the memset() efficently,
  236|       |     * just not remove it entirely. See "Dead Store Elimination (Still) Considered Harmful" by
  237|       |     * Yang et al. (USENIX Security 2017) for more background.
  238|       |     */
  239|  3.21k|    memset(ptr, 0, len);
  240|  3.21k|    __asm__ __volatile__("" : : "r"(ptr) : "memory");
  241|       |#else
  242|       |    void *(*volatile const volatile_memset)(void *, int, size_t) = memset;
  243|       |    volatile_memset(ptr, 0, len);
  244|       |#endif
  245|       |#ifdef VERIFY
  246|       |    SECP256K1_CHECKMEM_UNDEFINE(ptr, len);
  247|       |#endif
  248|  3.21k|}

_ZN12SizeComputer5writeE4SpanIKSt4byteE:
 1069|  1.29M|    {
 1070|  1.29M|        this->nSize += src.size();
 1071|  1.29M|    }
_ZNK12SizeComputer4sizeEv:
 1086|    556|    size_t size() const {
 1087|    556|        return nSize;
 1088|    556|    }
_ZNK20TransactionSerParamsclIRK12CTransactionEEDaOT_:
 1228|  15.0k|    {                                                                                    \
 1229|  15.0k|        return ParamsWrapper{*this, t};                                                  \
 1230|  15.0k|    }
_Z16GetSerializeSizeI13ParamsWrapperI20TransactionSerParamsK12CTransactionEEmRKT_:
 1104|    556|{
 1105|    556|    return (SizeComputer() << t).size();
 1106|    556|}
_ZN12SizeComputerlsI13ParamsWrapperI20TransactionSerParamsK12CTransactionEEERS_RKT_:
 1081|    556|    {
 1082|    556|        ::Serialize(*this, obj);
 1083|    556|        return (*this);
 1084|    556|    }
_Z9SerializeI12SizeComputer13ParamsWrapperI20TransactionSerParamsK12CTransactionEQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|    556|{
  754|    556|    a.Serialize(os);
  755|    556|}
_ZNK13ParamsWrapperI20TransactionSerParamsK12CTransactionE9SerializeI12SizeComputerEEvRT_:
 1199|    556|    {
 1200|    556|        ParamsStream ss{s, m_params};
 1201|    556|        ::Serialize(ss, m_object);
 1202|    556|    }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE12CTransactionQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|    556|{
  754|    556|    a.Serialize(os);
  755|    556|}
_ZNK12ParamsStreamIR12SizeComputer20TransactionSerParamsE9GetParamsIS2_EERKDav:
 1144|    556|    {
 1145|    556|        if constexpr (std::is_convertible_v<Params, P>) {
 1146|    556|            return m_params;
 1147|       |        } else {
 1148|       |            return m_substream.template GetParams<P>();
 1149|       |        }
 1150|    556|    }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsIjEERS3_RKT_:
 1133|  1.11k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_j:
  262|  3.03k|template<typename Stream> inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); }
_Z15ser_writedata32I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_j:
   69|  3.05k|{
   70|  3.05k|    obj = htole32_internal(obj);
   71|  3.05k|    s.write(AsBytes(Span{&obj, 1}));
   72|  3.05k|}
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsE9GetStreamEv:
 1154|  1.29M|    {
 1155|       |        if constexpr (ContainsStream<SubStream>) {
 1156|       |            return m_substream.GetStream();
 1157|  1.29M|        } else {
 1158|  1.29M|            return m_substream;
 1159|  1.29M|        }
 1160|  1.29M|    }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsE5writeE4SpanIKSt4byteE:
 1135|  1.29M|    void write(Span<const std::byte> src) { GetStream().write(src); }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsINSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1133|    556|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  846|    556|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|    556|    } else {
  859|    556|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|    556|    }
  861|    556|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  753|    556|{
  754|    556|    a.Serialize(os);
  755|    556|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  482|    556|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  662|    556|    {
  663|    556|        Formatter formatter;
  664|    556|        WriteCompactSize(s, v.size());
  665|    963|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 963, False: 556]
  ------------------
  666|    963|            formatter.Ser(s, elem);
  667|    963|        }
  668|    556|    }
_Z16WriteCompactSizeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_m:
  309|   596k|{
  310|   596k|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 596k, False: 302]
  ------------------
  311|   596k|    {
  312|   596k|        ser_writedata8(os, nSize);
  313|   596k|    }
  314|    302|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 281, False: 21]
  ------------------
  315|    281|    {
  316|    281|        ser_writedata8(os, 253);
  317|    281|        ser_writedata16(os, nSize);
  318|    281|    }
  319|     21|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 21, False: 0]
  ------------------
  320|     21|    {
  321|     21|        ser_writedata8(os, 254);
  322|     21|        ser_writedata32(os, nSize);
  323|     21|    }
  324|      0|    else
  325|      0|    {
  326|      0|        ser_writedata8(os, 255);
  327|      0|        ser_writedata64(os, nSize);
  328|      0|    }
  329|   596k|    return;
  330|   596k|}
_Z14ser_writedata8I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_h:
   55|   596k|{
   56|   596k|    s.write(AsBytes(Span{&obj, 1}));
   57|   596k|}
_Z15ser_writedata16I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_t:
   59|    281|{
   60|    281|    obj = htole16_internal(obj);
   61|    281|    s.write(AsBytes(Span{&obj, 1}));
   62|    281|}
_Z15ser_writedata64I12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_m:
   79|   594k|{
   80|   594k|    obj = htole64_internal(obj);
   81|   594k|    s.write(AsBytes(Span{&obj, 1}));
   82|   594k|}
_ZN16DefaultFormatter3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsE5CTxInEEvRT_RKT0_:
  774|    963|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE5CTxInQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|    963|{
  754|    963|    a.Serialize(os);
  755|    963|}
_ZNK5CTxIn9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  222|    963|    {                                                                                               \
  223|    963|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|    963|        Ser(s, *this);                                                                              \
  225|    963|    }                                                                                               \
_ZN5CTxIn3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  178|    963|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9COutPoint7CScriptjEEEvRT_DpRKT0_:
 1013|    963|    {
 1014|    963|        ::SerializeMany(s, args...);
 1015|    963|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9COutPoint7CScriptjEEvRT_DpRKT0_:
  995|    963|{
  996|    963|    (::Serialize(s, args), ...);
  997|    963|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE7CScriptQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|   595k|{
  754|   595k|    a.Serialize(os);
  755|   595k|}
_ZNK7CScript9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  222|   595k|    {                                                                                               \
  223|   595k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|   595k|        Ser(s, *this);                                                                              \
  225|   595k|    }                                                                                               \
_ZN7CScript3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  178|   595k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_Z6AsBaseI9prevectorILj28EhjiE7CScriptERKT_RKT0_:
  151|  5.12M|{
  152|  5.12M|    static_assert(std::is_base_of_v<Out, In>);
  153|  5.12M|    return x;
  154|  5.12M|}
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9prevectorILj28EhjiEEEEvRT_DpRKT0_:
 1013|   595k|    {
 1014|   595k|        ::SerializeMany(s, args...);
 1015|   595k|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ9prevectorILj28EhjiEEEvRT_DpRKT0_:
  995|   595k|{
  996|   595k|    (::Serialize(s, args), ...);
  997|   595k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsELj28EhEvRT_RK9prevectorIXT0_ET1_jiE:
  811|   595k|{
  812|   595k|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  813|   595k|        WriteCompactSize(os, v.size());
  814|   595k|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (814:13): [True: 100k, False: 494k]
  ------------------
  815|       |    } else {
  816|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  817|       |    }
  818|   595k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE9COutPointQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|    963|{
  754|    963|    a.Serialize(os);
  755|    963|}
_ZNK9COutPoint9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  222|    963|    {                                                                                               \
  223|    963|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|    963|        Ser(s, *this);                                                                              \
  225|    963|    }                                                                                               \
_ZN9COutPoint3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  178|    963|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ22transaction_identifierILb0EEjEEEvRT_DpRKT0_:
 1013|    963|    {
 1014|    963|        ::SerializeMany(s, args...);
 1015|    963|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJ22transaction_identifierILb0EEjEEvRT_DpRKT0_:
  995|    963|{
  996|    963|    (::Serialize(s, args), ...);
  997|    963|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE22transaction_identifierILb0EEQ12SerializableIT0_T_EEvRS8_RKS7_:
  753|    963|{
  754|    963|    a.Serialize(os);
  755|    963|}
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsI4SpanIKhEEERS3_RKT_:
 1133|    963|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsETk9BasicByteKhEvRT_4SpanIT0_E:
  268|    963|template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsElsINSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1133|    556|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  846|    556|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|    556|    } else {
  859|    556|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|    556|    }
  861|    556|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  753|    556|{
  754|    556|    a.Serialize(os);
  755|    556|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  482|    556|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  662|    556|    {
  663|    556|        Formatter formatter;
  664|    556|        WriteCompactSize(s, v.size());
  665|   594k|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 594k, False: 556]
  ------------------
  666|   594k|            formatter.Ser(s, elem);
  667|   594k|        }
  668|    556|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsE6CTxOutEEvRT_RKT0_:
  774|   594k|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsE6CTxOutQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|   594k|{
  754|   594k|    a.Serialize(os);
  755|   594k|}
_ZNK6CTxOut9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  222|   594k|    {                                                                                               \
  223|   594k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|   594k|        Ser(s, *this);                                                                              \
  225|   594k|    }                                                                                               \
_ZN6CTxOut3SerI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_RKS_:
  178|   594k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJl7CScriptEEEvRT_DpRKT0_:
 1013|   594k|    {
 1014|   594k|        ::SerializeMany(s, args...);
 1015|   594k|    }
_Z13SerializeManyI12ParamsStreamIR12SizeComputer20TransactionSerParamsEJl7CScriptEEvRT_DpRKT0_:
  995|   594k|{
  996|   594k|    (::Serialize(s, args), ...);
  997|   594k|}
_Z9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEvRT_l:
  263|   594k|template<typename Stream> inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); }
_ZNK20TransactionSerParamsclIR19CMutableTransactionEEDaOT_:
 1228|  11.8k|    {                                                                                    \
 1229|  11.8k|        return ParamsWrapper{*this, t};                                                  \
 1230|  11.8k|    }
_ZN12SizeComputerC2Ev:
 1066|    556|    SizeComputer() = default;
_ZN12ParamsStreamIR12SizeComputer20TransactionSerParamsEC2ES1_RKS2_:
 1127|    556|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  497|    556|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEEC2ESA_:
  481|  15.9k|    explicit Wrapper(T obj) : m_object(obj) {}
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  497|    556|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEEC2ESA_:
  481|  15.0k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEEC2ESB_:
  481|  15.3k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsEC2ES1_RKS2_:
 1127|  11.8k|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_Z14ser_readdata32I12ParamsStreamIR10DataStream20TransactionSerParamsEEjRT_:
  102|   245k|{
  103|   245k|    uint32_t obj;
  104|   245k|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|   245k|    return le32toh_internal(obj);
  106|   245k|}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsE4readE4SpanISt4byteE:
 1136|  9.18M|    void read(Span<std::byte> dst) { GetStream().read(dst); }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsE9GetStreamEv:
 1154|  9.18M|    {
 1155|       |        if constexpr (ContainsStream<SubStream>) {
 1156|       |            return m_substream.GetStream();
 1157|  9.18M|        } else {
 1158|  9.18M|            return m_substream;
 1159|  9.18M|        }
 1160|  9.18M|    }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_Rj:
  277|   245k|template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); }
_Z15ReadCompactSizeI12ParamsStreamIR10DataStream20TransactionSerParamsEEmRT_b:
  340|  6.36M|{
  341|  6.36M|    uint8_t chSize = ser_readdata8(is);
  342|  6.36M|    uint64_t nSizeRet = 0;
  343|  6.36M|    if (chSize < 253)
  ------------------
  |  Branch (343:9): [True: 6.36M, False: 1.78k]
  ------------------
  344|  6.36M|    {
  345|  6.36M|        nSizeRet = chSize;
  346|  6.36M|    }
  347|  1.78k|    else if (chSize == 253)
  ------------------
  |  Branch (347:14): [True: 1.32k, False: 452]
  ------------------
  348|  1.32k|    {
  349|  1.32k|        nSizeRet = ser_readdata16(is);
  350|  1.32k|        if (nSizeRet < 253)
  ------------------
  |  Branch (350:13): [True: 7, False: 1.32k]
  ------------------
  351|      7|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|  1.32k|    }
  353|    452|    else if (chSize == 254)
  ------------------
  |  Branch (353:14): [True: 270, False: 182]
  ------------------
  354|    270|    {
  355|    270|        nSizeRet = ser_readdata32(is);
  356|    270|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (356:13): [True: 17, False: 253]
  ------------------
  357|     17|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|    270|    }
  359|    182|    else
  360|    182|    {
  361|    182|        nSizeRet = ser_readdata64(is);
  362|    182|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (362:13): [True: 34, False: 148]
  ------------------
  363|     34|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  364|    182|    }
  365|  6.36M|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (365:9): [True: 6.36M, False: 74]
  |  Branch (365:24): [True: 94, False: 6.36M]
  ------------------
  366|     94|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  367|     94|    }
  368|  6.36M|    return nSizeRet;
  369|  6.36M|}
_Z13ser_readdata8I12ParamsStreamIR10DataStream20TransactionSerParamsEEhRT_:
   84|  6.36M|{
   85|  6.36M|    uint8_t obj;
   86|  6.36M|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|  6.36M|    return obj;
   88|  6.36M|}
_Z14ser_readdata16I12ParamsStreamIR10DataStream20TransactionSerParamsEEtRT_:
   90|  1.32k|{
   91|  1.32k|    uint16_t obj;
   92|  1.32k|    s.read(AsWritableBytes(Span{&obj, 1}));
   93|  1.32k|    return le16toh_internal(obj);
   94|  1.32k|}
_Z14ser_readdata64I12ParamsStreamIR10DataStream20TransactionSerParamsEEmRT_:
  114|  2.16M|{
  115|  2.16M|    uint64_t obj;
  116|  2.16M|    s.read(AsWritableBytes(Span{&obj, 1}));
  117|  2.16M|    return le64toh_internal(obj);
  118|  2.16M|}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRjEERS3_OT_:
 1134|  22.9k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRNSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_OT_:
 1134|  14.0k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RNS6_6vectorIT0_T1_EE:
  866|  14.0k|{
  867|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  868|       |        // Limit size per read so bogus size value won't cause out of memory
  869|       |        v.clear();
  870|       |        unsigned int nSize = ReadCompactSize(is);
  871|       |        unsigned int i = 0;
  872|       |        while (i < nSize) {
  873|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  874|       |            v.resize(i + blk);
  875|       |            is.read(AsWritableBytes(Span{&v[i], blk}));
  876|       |            i += blk;
  877|       |        }
  878|  14.0k|    } else {
  879|  14.0k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|  14.0k|    }
  881|  14.0k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ14UnserializableIT0_T_EEvRSI_OSH_:
  762|  14.0k|{
  763|  14.0k|    a.Unserialize(is);
  764|  14.0k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  483|  14.0k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RT0_:
  672|  14.0k|    {
  673|  14.0k|        Formatter formatter;
  674|  14.0k|        v.clear();
  675|  14.0k|        size_t size = ReadCompactSize(s);
  676|  14.0k|        size_t allocated = 0;
  677|  23.2k|        while (allocated < size) {
  ------------------
  |  Branch (677:16): [True: 9.15k, False: 14.0k]
  ------------------
  678|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  679|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  680|       |            // X MiB of data to make us allocate X+5 Mib.
  681|  9.15k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  682|  9.15k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  683|  9.15k|            v.reserve(allocated);
  684|   120k|            while (v.size() < allocated) {
  ------------------
  |  Branch (684:20): [True: 111k, False: 9.15k]
  ------------------
  685|   111k|                v.emplace_back();
  686|   111k|                formatter.Unser(s, v.back());
  687|   111k|            }
  688|  9.15k|        }
  689|  14.0k|    };
_ZN16DefaultFormatter5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInEEvRT_RT0_:
  777|   111k|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER5CTxInQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|   111k|{
  763|   111k|    a.Unserialize(is);
  764|   111k|}
_ZN5CTxIn11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  228|   111k|    {                                                                                               \
  229|   111k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   111k|        Unser(s, *this);                                                                            \
  231|   111k|    }
_ZN5CTxIn5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RS_:
  180|   111k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR9COutPointR7CScriptRjEEEvRT_DpOT0_:
 1033|   111k|    {
 1034|   111k|        ::UnserializeMany(s, args...);
 1035|   111k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR9COutPointR7CScriptRjEEvRT_DpOT0_:
 1001|   111k|{
 1002|   111k|    (::Unserialize(s, args), ...);
 1003|   111k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER9COutPointQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|   111k|{
  763|   111k|    a.Unserialize(is);
  764|   111k|}
_ZN9COutPoint11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  228|   111k|    {                                                                                               \
  229|   111k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   111k|        Unser(s, *this);                                                                            \
  231|   111k|    }
_ZN9COutPoint5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RS_:
  180|   111k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR22transaction_identifierILb0EERjEEEvRT_DpOT0_:
 1033|   111k|    {
 1034|   111k|        ::UnserializeMany(s, args...);
 1035|   111k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR22transaction_identifierILb0EERjEEvRT_DpOT0_:
 1001|   111k|{
 1002|   111k|    (::Unserialize(s, args), ...);
 1003|   111k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER22transaction_identifierILb0EEQ14UnserializableIT0_T_EEvRS9_OS8_:
  762|   111k|{
  763|   111k|    a.Unserialize(is);
  764|   111k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER7CScriptQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|  2.28M|{
  763|  2.28M|    a.Unserialize(is);
  764|  2.28M|}
_ZN7CScript11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  228|  2.28M|    {                                                                                               \
  229|  2.28M|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|  2.28M|        Unser(s, *this);                                                                            \
  231|  2.28M|    }
_ZN7CScript5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RS_:
  180|  2.28M|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR9prevectorILj28EhjiEEEEvRT_DpOT0_:
 1033|  2.28M|    {
 1034|  2.28M|        ::UnserializeMany(s, args...);
 1035|  2.28M|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR9prevectorILj28EhjiEEEvRT_DpOT0_:
 1001|  2.28M|{
 1002|  2.28M|    (::Unserialize(s, args), ...);
 1003|  2.28M|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsELj28EhEvRT_R9prevectorIXT0_ET1_jiE:
  823|  2.28M|{
  824|  2.28M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  825|       |        // Limit size per read so bogus size value won't cause out of memory
  826|  2.28M|        v.clear();
  827|  2.28M|        unsigned int nSize = ReadCompactSize(is);
  828|  2.28M|        unsigned int i = 0;
  829|  2.52M|        while (i < nSize) {
  ------------------
  |  Branch (829:16): [True: 249k, False: 2.28M]
  ------------------
  830|   249k|            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  831|   249k|            v.resize_uninitialized(i + blk);
  832|   249k|            is.read(AsWritableBytes(Span{&v[i], blk}));
  833|   249k|            i += blk;
  834|   249k|        }
  835|       |    } else {
  836|       |        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  837|       |    }
  838|  2.28M|}
_Z6AsBaseI9prevectorILj28EhjiE7CScriptERT_RT0_:
  145|  2.28M|{
  146|  2.28M|    static_assert(std::is_base_of_v<Out, In>);
  147|  2.28M|    return x;
  148|  2.28M|}
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_:
  497|  14.0k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEEC2ES9_:
  481|  14.0k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRhEERS3_OT_:
 1134|  4.60k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_Rh:
  273|  4.60k|template<typename Stream> inline void Unserialize(Stream& s, uint8_t& a ) { a = ser_readdata8(s); }
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRNSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_OT_:
 1134|  9.08k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RNS6_6vectorIT0_T1_EE:
  866|  9.08k|{
  867|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  868|       |        // Limit size per read so bogus size value won't cause out of memory
  869|       |        v.clear();
  870|       |        unsigned int nSize = ReadCompactSize(is);
  871|       |        unsigned int i = 0;
  872|       |        while (i < nSize) {
  873|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  874|       |            v.resize(i + blk);
  875|       |            is.read(AsWritableBytes(Span{&v[i], blk}));
  876|       |            i += blk;
  877|       |        }
  878|  9.08k|    } else {
  879|  9.08k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|  9.08k|    }
  881|  9.08k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ14UnserializableIT0_T_EEvRSI_OSH_:
  762|  9.08k|{
  763|  9.08k|    a.Unserialize(is);
  764|  9.08k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  483|  9.08k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RT0_:
  672|  9.08k|    {
  673|  9.08k|        Formatter formatter;
  674|  9.08k|        v.clear();
  675|  9.08k|        size_t size = ReadCompactSize(s);
  676|  9.08k|        size_t allocated = 0;
  677|  12.8k|        while (allocated < size) {
  ------------------
  |  Branch (677:16): [True: 3.74k, False: 9.08k]
  ------------------
  678|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  679|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  680|       |            // X MiB of data to make us allocate X+5 Mib.
  681|  3.74k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  682|  3.74k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  683|  3.74k|            v.reserve(allocated);
  684|  2.17M|            while (v.size() < allocated) {
  ------------------
  |  Branch (684:20): [True: 2.16M, False: 3.74k]
  ------------------
  685|  2.16M|                v.emplace_back();
  686|  2.16M|                formatter.Unser(s, v.back());
  687|  2.16M|            }
  688|  3.74k|        }
  689|  9.08k|    };
_ZN16DefaultFormatter5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutEEvRT_RT0_:
  777|  2.16M|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER6CTxOutQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|  2.16M|{
  763|  2.16M|    a.Unserialize(is);
  764|  2.16M|}
_ZN6CTxOut11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  228|  2.16M|    {                                                                                               \
  229|  2.16M|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|  2.16M|        Unser(s, *this);                                                                            \
  231|  2.16M|    }
_ZN6CTxOut5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RS_:
  180|  2.16M|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJRlR7CScriptEEEvRT_DpOT0_:
 1033|  2.16M|    {
 1034|  2.16M|        ::UnserializeMany(s, args...);
 1035|  2.16M|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJRlR7CScriptEEvRT_DpOT0_:
 1001|  2.16M|{
 1002|  2.16M|    (::Unserialize(s, args), ...);
 1003|  2.16M|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_Rl:
  278|  2.16M|template<typename Stream> inline void Unserialize(Stream& s, int64_t& a ) { a = ser_readdata64(s); }
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_:
  497|  9.08k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEEC2ES9_:
  481|  9.08k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRNSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_OT_:
 1134|  17.9k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RNS6_IT0_T1_EE:
  866|  17.9k|{
  867|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  868|       |        // Limit size per read so bogus size value won't cause out of memory
  869|       |        v.clear();
  870|       |        unsigned int nSize = ReadCompactSize(is);
  871|       |        unsigned int i = 0;
  872|       |        while (i < nSize) {
  873|       |            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  874|       |            v.resize(i + blk);
  875|       |            is.read(AsWritableBytes(Span{&v[i], blk}));
  876|       |            i += blk;
  877|       |        }
  878|  17.9k|    } else {
  879|  17.9k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|  17.9k|    }
  881|  17.9k|}
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ14UnserializableIT0_T_EEvRSJ_OSI_:
  762|  17.9k|{
  763|  17.9k|    a.Unserialize(is);
  764|  17.9k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  483|  17.9k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RT0_:
  672|  17.9k|    {
  673|  17.9k|        Formatter formatter;
  674|  17.9k|        v.clear();
  675|  17.9k|        size_t size = ReadCompactSize(s);
  676|  17.9k|        size_t allocated = 0;
  677|  31.4k|        while (allocated < size) {
  ------------------
  |  Branch (677:16): [True: 13.5k, False: 17.9k]
  ------------------
  678|       |            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
  679|       |            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
  680|       |            // X MiB of data to make us allocate X+5 Mib.
  681|  13.5k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  682|  13.5k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  683|  13.5k|            v.reserve(allocated);
  684|  4.05M|            while (v.size() < allocated) {
  ------------------
  |  Branch (684:20): [True: 4.04M, False: 13.5k]
  ------------------
  685|  4.04M|                v.emplace_back();
  686|  4.04M|                formatter.Unser(s, v.back());
  687|  4.04M|            }
  688|  13.5k|        }
  689|  17.9k|    };
_ZN16DefaultFormatter5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RT0_:
  777|  4.04M|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RNS5_6vectorIT0_T1_EE:
  866|  4.04M|{
  867|  4.04M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  868|       |        // Limit size per read so bogus size value won't cause out of memory
  869|  4.04M|        v.clear();
  870|  4.04M|        unsigned int nSize = ReadCompactSize(is);
  871|  4.04M|        unsigned int i = 0;
  872|  4.08M|        while (i < nSize) {
  ------------------
  |  Branch (872:16): [True: 39.2k, False: 4.04M]
  ------------------
  873|  39.2k|            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
  874|  39.2k|            v.resize(i + blk);
  875|  39.2k|            is.read(AsWritableBytes(Span{&v[i], blk}));
  876|  39.2k|            i += blk;
  877|  39.2k|        }
  878|       |    } else {
  879|       |        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|       |    }
  881|  4.04M|}
block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSD_:
  497|  17.9k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEEC2ESA_:
  481|  17.9k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZNK12ParamsStreamIR10DataStream20TransactionSerParamsE9GetParamsIS2_EERKDav:
 1144|  11.8k|    {
 1145|  11.8k|        if constexpr (std::is_convertible_v<Params, P>) {
 1146|  11.8k|            return m_params;
 1147|       |        } else {
 1148|       |            return m_substream.template GetParams<P>();
 1149|       |        }
 1150|  11.8k|    }
_Z14ser_readdata32I10DataStreamEjRT_:
  102|  1.89k|{
  103|  1.89k|    uint32_t obj;
  104|  1.89k|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|  1.89k|    return le32toh_internal(obj);
  106|  1.89k|}
_Z11UnserializeI10DataStreamEvRT_Rj:
  277|  1.89k|template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); }
_Z13ser_readdata8I10DataStreamEhRT_:
   84|  62.4k|{
   85|  62.4k|    uint8_t obj;
   86|  62.4k|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|  62.4k|    return obj;
   88|  62.4k|}
_Z11UnserializeI10DataStreamR7WrapperI15VarIntFormatterIL10VarIntMode0EERjEQ14UnserializableIT0_T_EEvRS9_OS8_:
  762|  15.2k|{
  763|  15.2k|    a.Unserialize(is);
  764|  15.2k|}
_ZN7WrapperI15VarIntFormatterIL10VarIntMode0EERjE11UnserializeI10DataStreamEEvRT_:
  483|  30.9k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VarIntFormatterIL10VarIntMode0EE5UnserI10DataStreamjEEvRT_RT0_:
  514|  30.9k|    {
  515|  30.9k|        v = ReadVarInt<Stream,Mode,typename std::remove_cv<I>::type>(s);
  516|  30.9k|    }
_Z10ReadVarIntI10DataStreamL10VarIntMode0EjET1_RT_:
  453|  30.9k|{
  454|  30.9k|    CheckVarIntMode<Mode, I>();
  455|  30.9k|    I n = 0;
  456|  38.7k|    while(true) {
  ------------------
  |  Branch (456:11): [Folded - Ignored]
  ------------------
  457|  38.7k|        unsigned char chData = ser_readdata8(is);
  458|  38.7k|        if (n > (std::numeric_limits<I>::max() >> 7)) {
  ------------------
  |  Branch (458:13): [True: 42, False: 38.6k]
  ------------------
  459|     42|           throw std::ios_base::failure("ReadVarInt(): size too large");
  460|     42|        }
  461|  38.6k|        n = (n << 7) | (chData & 0x7F);
  462|  38.6k|        if (chData & 0x80) {
  ------------------
  |  Branch (462:13): [True: 7.82k, False: 30.8k]
  ------------------
  463|  7.82k|            if (n == std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (463:17): [True: 1, False: 7.82k]
  ------------------
  464|      1|                throw std::ios_base::failure("ReadVarInt(): size too large");
  465|      1|            }
  466|  7.82k|            n++;
  467|  30.8k|        } else {
  468|  30.8k|            return n;
  469|  30.8k|        }
  470|  38.6k|    }
  471|  30.9k|}
_ZN15CheckVarIntModeIL10VarIntMode0EjEC2Ev:
  410|  30.9k|    {
  411|  30.9k|        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned<I>::value, "Unsigned type required with mode DEFAULT.");
  412|  30.9k|        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed<I>::value, "Signed type required with mode NONNEGATIVE_SIGNED.");
  413|  30.9k|    }
_ZN7WrapperI15VarIntFormatterIL10VarIntMode0EERjEC2ES3_:
  481|  30.9k|    explicit Wrapper(T obj) : m_object(obj) {}
_Z11UnserializeI10DataStreamR7WrapperI15VarIntFormatterIL10VarIntMode0EERmEQ14UnserializableIT0_T_EEvRS9_OS8_:
  762|  15.4k|{
  763|  15.4k|    a.Unserialize(is);
  764|  15.4k|}
_ZN7WrapperI15VarIntFormatterIL10VarIntMode0EERmE11UnserializeI10DataStreamEEvRT_:
  483|  15.4k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VarIntFormatterIL10VarIntMode0EE5UnserI10DataStreammEEvRT_RT0_:
  514|  15.4k|    {
  515|  15.4k|        v = ReadVarInt<Stream,Mode,typename std::remove_cv<I>::type>(s);
  516|  15.4k|    }
_Z10ReadVarIntI10DataStreamL10VarIntMode0EmET1_RT_:
  453|  15.4k|{
  454|  15.4k|    CheckVarIntMode<Mode, I>();
  455|  15.4k|    I n = 0;
  456|  23.6k|    while(true) {
  ------------------
  |  Branch (456:11): [Folded - Ignored]
  ------------------
  457|  23.6k|        unsigned char chData = ser_readdata8(is);
  458|  23.6k|        if (n > (std::numeric_limits<I>::max() >> 7)) {
  ------------------
  |  Branch (458:13): [True: 13, False: 23.6k]
  ------------------
  459|     13|           throw std::ios_base::failure("ReadVarInt(): size too large");
  460|     13|        }
  461|  23.6k|        n = (n << 7) | (chData & 0x7F);
  462|  23.6k|        if (chData & 0x80) {
  ------------------
  |  Branch (462:13): [True: 8.23k, False: 15.4k]
  ------------------
  463|  8.23k|            if (n == std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (463:17): [True: 1, False: 8.23k]
  ------------------
  464|      1|                throw std::ios_base::failure("ReadVarInt(): size too large");
  465|      1|            }
  466|  8.23k|            n++;
  467|  15.4k|        } else {
  468|  15.4k|            return n;
  469|  15.4k|        }
  470|  23.6k|    }
  471|  15.4k|}
_ZN15CheckVarIntModeIL10VarIntMode0EmEC2Ev:
  410|  15.4k|    {
  411|  15.4k|        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned<I>::value, "Unsigned type required with mode DEFAULT.");
  412|  15.4k|        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed<I>::value, "Signed type required with mode NONNEGATIVE_SIGNED.");
  413|  15.4k|    }
_ZN7WrapperI15VarIntFormatterIL10VarIntMode0EERmEC2ES3_:
  481|  15.4k|    explicit Wrapper(T obj) : m_object(obj) {}
_Z11UnserializeI10DataStreamR9COutPointQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|  1.93k|{
  763|  1.93k|    a.Unserialize(is);
  764|  1.93k|}
_ZN9COutPoint11UnserializeI10DataStreamEEvRT_:
  228|  1.93k|    {                                                                                               \
  229|  1.93k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|  1.93k|        Unser(s, *this);                                                                            \
  231|  1.93k|    }
_ZN9COutPoint5UnserI10DataStreamEEvRT_RS_:
  180|  1.93k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJR22transaction_identifierILb0EERjEEEvRT_DpOT0_:
 1033|  1.93k|    {
 1034|  1.93k|        ::UnserializeMany(s, args...);
 1035|  1.93k|    }
_Z15UnserializeManyI10DataStreamJR22transaction_identifierILb0EERjEEvRT_DpOT0_:
 1001|  1.93k|{
 1002|  1.93k|    (::Unserialize(s, args), ...);
 1003|  1.93k|}
_Z11UnserializeI10DataStreamR22transaction_identifierILb0EEQ14UnserializableIT0_T_EEvRS5_OS4_:
  762|  1.93k|{
  763|  1.93k|    a.Unserialize(is);
  764|  1.93k|}
_Z11UnserializeI10DataStreamR13ParamsWrapperI20TransactionSerParams19CMutableTransactionEQ14UnserializableIT0_T_EEvRS7_OS6_:
  762|  11.8k|{
  763|  11.8k|    a.Unserialize(is);
  764|  11.8k|}
_ZN13ParamsWrapperI20TransactionSerParams19CMutableTransactionE11UnserializeI10DataStreamEEvRT_:
 1205|  11.8k|    {
 1206|  11.8k|        ParamsStream ss{s, m_params};
 1207|  11.8k|        ::Unserialize(ss, m_object);
 1208|  11.8k|    }
_Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER19CMutableTransactionQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|  11.8k|{
  763|  11.8k|    a.Unserialize(is);
  764|  11.8k|}
_ZN13ParamsWrapperI20TransactionSerParams19CMutableTransactionEC2ERKS0_RS1_:
 1195|  11.8k|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_Z11UnserializeI10DataStreamR4CoinQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|  15.6k|{
  763|  15.6k|    a.Unserialize(is);
  764|  15.6k|}
_Z11UnserializeI10DataStream7WrapperI15VarIntFormatterIL10VarIntMode0EERjEQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|  15.6k|{
  763|  15.6k|    a.Unserialize(is);
  764|  15.6k|}
coins_view.cpp:_ZL5UsingI15VarIntFormatterIL10VarIntMode0EERjE7WrapperIT_RT0_EOS6_:
  497|  30.9k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z11UnserializeI10DataStream7WrapperI16TxOutCompressionR6CTxOutEQ14UnserializableIT0_T_EEvRS7_OS6_:
  762|  15.4k|{
  763|  15.4k|    a.Unserialize(is);
  764|  15.4k|}
_ZN7WrapperI16TxOutCompressionR6CTxOutE11UnserializeI10DataStreamEEvRT_:
  483|  15.4k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN16TxOutCompression5UnserI10DataStreamEEvRT_R6CTxOut:
  180|  15.4k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJ7WrapperI17AmountCompressionRlES2_I17ScriptCompressionR7CScriptEEEEvRT_DpOT0_:
 1033|  15.4k|    {
 1034|  15.4k|        ::UnserializeMany(s, args...);
 1035|  15.4k|    }
_Z15UnserializeManyI10DataStreamJR7WrapperI17AmountCompressionRlERS1_I17ScriptCompressionR7CScriptEEEvRT_DpOT0_:
 1001|  15.4k|{
 1002|  15.4k|    (::Unserialize(s, args), ...);
 1003|  15.4k|}
_Z11UnserializeI10DataStreamR7WrapperI17AmountCompressionRlEQ14UnserializableIT0_T_EEvRS7_OS6_:
  762|  15.4k|{
  763|  15.4k|    a.Unserialize(is);
  764|  15.4k|}
_ZN7WrapperI17AmountCompressionRlE11UnserializeI10DataStreamEEvRT_:
  483|  15.4k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
coins_view.cpp:_ZL5UsingI15VarIntFormatterIL10VarIntMode0EERmE7WrapperIT_RT0_EOS6_:
  497|  15.4k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z11UnserializeI10DataStreamR7WrapperI17ScriptCompressionR7CScriptEQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|  15.2k|{
  763|  15.2k|    a.Unserialize(is);
  764|  15.2k|}
_ZN7WrapperI17ScriptCompressionR7CScriptE11UnserializeI10DataStreamEEvRT_:
  483|  15.2k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_Z11UnserializeI10DataStreamTk9BasicBytehEvRT_4SpanIT0_E:
  283|  14.9k|template <typename Stream, BasicByte B> void Unserialize(Stream& s, Span<B> span) { s.read(AsWritableBytes(span)); }
coins_view.cpp:_ZL5UsingI17AmountCompressionRlE7WrapperIT_RT0_EOS4_:
  497|  15.4k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI17AmountCompressionRlEC2ES1_:
  481|  15.4k|    explicit Wrapper(T obj) : m_object(obj) {}
coins_view.cpp:_ZL5UsingI17ScriptCompressionR7CScriptE7WrapperIT_RT0_EOS5_:
  497|  15.4k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI17ScriptCompressionR7CScriptEC2ES2_:
  481|  15.4k|    explicit Wrapper(T obj) : m_object(obj) {}
coins_view.cpp:_ZL5UsingI16TxOutCompressionR6CTxOutE7WrapperIT_RT0_EOS5_:
  497|  15.4k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI16TxOutCompressionR6CTxOutEC2ES2_:
  481|  15.4k|    explicit Wrapper(T obj) : m_object(obj) {}
transaction.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  497|  15.3k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
transaction.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_:
  497|  14.4k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
transaction.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSE_:
  497|  15.3k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN13ParamsWrapperI20TransactionSerParamsK12CTransactionEC2ERKS0_RS2_:
 1195|  15.0k|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsEC2ES1_RKS2_:
 1127|  14.4k|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsIjEERS3_RKT_:
 1133|  28.9k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_j:
  262|   270k|template<typename Stream> inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); }
_Z15ser_writedata32I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_j:
   69|   270k|{
   70|   270k|    obj = htole32_internal(obj);
   71|   270k|    s.write(AsBytes(Span{&obj, 1}));
   72|   270k|}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsE5writeE4SpanIKSt4byteE:
 1135|  10.6M|    void write(Span<const std::byte> src) { GetStream().write(src); }
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsE9GetStreamEv:
 1154|  10.6M|    {
 1155|       |        if constexpr (ContainsStream<SubStream>) {
 1156|       |            return m_substream.GetStream();
 1157|  10.6M|        } else {
 1158|  10.6M|            return m_substream;
 1159|  10.6M|        }
 1160|  10.6M|    }
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1133|  15.3k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  846|  15.3k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|  15.3k|    } else {
  859|  15.3k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|  15.3k|    }
  861|  15.3k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  753|  15.3k|{
  754|  15.3k|    a.Serialize(os);
  755|  15.3k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  482|  15.3k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  662|  15.3k|    {
  663|  15.3k|        Formatter formatter;
  664|  15.3k|        WriteCompactSize(s, v.size());
  665|   120k|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 120k, False: 15.3k]
  ------------------
  666|   120k|            formatter.Ser(s, elem);
  667|   120k|        }
  668|  15.3k|    }
_Z16WriteCompactSizeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_m:
  309|  5.20M|{
  310|  5.20M|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 5.20M, False: 1.80k]
  ------------------
  311|  5.20M|    {
  312|  5.20M|        ser_writedata8(os, nSize);
  313|  5.20M|    }
  314|  1.80k|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 1.67k, False: 129]
  ------------------
  315|  1.67k|    {
  316|  1.67k|        ser_writedata8(os, 253);
  317|  1.67k|        ser_writedata16(os, nSize);
  318|  1.67k|    }
  319|    129|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 129, False: 0]
  ------------------
  320|    129|    {
  321|    129|        ser_writedata8(os, 254);
  322|    129|        ser_writedata32(os, nSize);
  323|    129|    }
  324|      0|    else
  325|      0|    {
  326|      0|        ser_writedata8(os, 255);
  327|      0|        ser_writedata64(os, nSize);
  328|      0|    }
  329|  5.20M|    return;
  330|  5.20M|}
_Z14ser_writedata8I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_h:
   55|  5.20M|{
   56|  5.20M|    s.write(AsBytes(Span{&obj, 1}));
   57|  5.20M|}
_Z15ser_writedata16I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_t:
   59|  1.67k|{
   60|  1.67k|    obj = htole16_internal(obj);
   61|  1.67k|    s.write(AsBytes(Span{&obj, 1}));
   62|  1.67k|}
_Z15ser_writedata64I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_m:
   79|  4.40M|{
   80|  4.40M|    obj = htole64_internal(obj);
   81|  4.40M|    s.write(AsBytes(Span{&obj, 1}));
   82|  4.40M|}
_ZN16DefaultFormatter3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsE5CTxInEEvRT_RKT0_:
  774|   120k|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE5CTxInQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|   120k|{
  754|   120k|    a.Serialize(os);
  755|   120k|}
_ZNK5CTxIn9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  222|   120k|    {                                                                                               \
  223|   120k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|   120k|        Ser(s, *this);                                                                              \
  225|   120k|    }                                                                                               \
_ZN5CTxIn3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_:
  178|   120k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9COutPoint7CScriptjEEEvRT_DpRKT0_:
 1013|   120k|    {
 1014|   120k|        ::SerializeMany(s, args...);
 1015|   120k|    }
_Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9COutPoint7CScriptjEEvRT_DpRKT0_:
  995|   120k|{
  996|   120k|    (::Serialize(s, args), ...);
  997|   120k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE9COutPointQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|   120k|{
  754|   120k|    a.Serialize(os);
  755|   120k|}
_ZNK9COutPoint9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  222|   120k|    {                                                                                               \
  223|   120k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|   120k|        Ser(s, *this);                                                                              \
  225|   120k|    }                                                                                               \
_ZN9COutPoint3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_:
  178|   120k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ22transaction_identifierILb0EEjEEEvRT_DpRKT0_:
 1013|   120k|    {
 1014|   120k|        ::SerializeMany(s, args...);
 1015|   120k|    }
_Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ22transaction_identifierILb0EEjEEvRT_DpRKT0_:
  995|   120k|{
  996|   120k|    (::Serialize(s, args), ...);
  997|   120k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE22transaction_identifierILb0EEQ12SerializableIT0_T_EEvRS8_RKS7_:
  753|   120k|{
  754|   120k|    a.Serialize(os);
  755|   120k|}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsI4SpanIKhEEERS3_RKT_:
 1133|   120k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsETk9BasicByteKhEvRT_4SpanIT0_E:
  268|   120k|template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7CScriptQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  4.53M|{
  754|  4.53M|    a.Serialize(os);
  755|  4.53M|}
_ZNK7CScript9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  222|  4.53M|    {                                                                                               \
  223|  4.53M|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  4.53M|        Ser(s, *this);                                                                              \
  225|  4.53M|    }                                                                                               \
_ZN7CScript3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_:
  178|  4.53M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9prevectorILj28EhjiEEEEvRT_DpRKT0_:
 1013|  4.53M|    {
 1014|  4.53M|        ::SerializeMany(s, args...);
 1015|  4.53M|    }
_Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9prevectorILj28EhjiEEEvRT_DpRKT0_:
  995|  4.53M|{
  996|  4.53M|    (::Serialize(s, args), ...);
  997|  4.53M|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsELj28EhEvRT_RK9prevectorIXT0_ET1_jiE:
  811|  4.53M|{
  812|  4.53M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  813|  4.53M|        WriteCompactSize(os, v.size());
  814|  4.53M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (814:13): [True: 639k, False: 3.89M]
  ------------------
  815|       |    } else {
  816|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  817|       |    }
  818|  4.53M|}
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsIhEERS3_RKT_:
 1133|    881|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_h:
  258|    881|template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_RKT_:
 1133|  14.4k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE:
  846|  14.4k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|  14.4k|    } else {
  859|  14.4k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|  14.4k|    }
  861|  14.4k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_:
  753|  14.4k|{
  754|  14.4k|    a.Serialize(os);
  755|  14.4k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  482|  14.4k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RKT0_:
  662|  14.4k|    {
  663|  14.4k|        Formatter formatter;
  664|  14.4k|        WriteCompactSize(s, v.size());
  665|  4.40M|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 4.40M, False: 14.4k]
  ------------------
  666|  4.40M|            formatter.Ser(s, elem);
  667|  4.40M|        }
  668|  14.4k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsE6CTxOutEEvRT_RKT0_:
  774|  4.40M|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE6CTxOutQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  4.40M|{
  754|  4.40M|    a.Serialize(os);
  755|  4.40M|}
_ZNK6CTxOut9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  222|  4.40M|    {                                                                                               \
  223|  4.40M|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  4.40M|        Ser(s, *this);                                                                              \
  225|  4.40M|    }                                                                                               \
_ZN6CTxOut3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_:
  178|  4.40M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJl7CScriptEEEvRT_DpRKT0_:
 1013|  4.40M|    {
 1014|  4.40M|        ::SerializeMany(s, args...);
 1015|  4.40M|    }
_Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJl7CScriptEEvRT_DpRKT0_:
  995|  4.40M|{
  996|  4.40M|    (::Serialize(s, args), ...);
  997|  4.40M|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_l:
  263|  4.40M|template<typename Stream> inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); }
_ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_RKT_:
 1133|  15.3k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RKNS6_IT0_T1_EE:
  846|  15.3k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|  15.3k|    } else {
  859|  15.3k|        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|  15.3k|    }
  861|  15.3k|}
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ12SerializableIT0_T_EEvRSK_RKSJ_:
  753|  15.3k|{
  754|  15.3k|    a.Serialize(os);
  755|  15.3k|}
_ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  482|  15.3k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RKT0_:
  662|  15.3k|    {
  663|  15.3k|        Formatter formatter;
  664|  15.3k|        WriteCompactSize(s, v.size());
  665|   629k|        for (const typename V::value_type& elem : v) {
  ------------------
  |  Branch (665:49): [True: 629k, False: 15.3k]
  ------------------
  666|   629k|            formatter.Ser(s, elem);
  667|   629k|        }
  668|  15.3k|    }
_ZN16DefaultFormatter3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RKT0_:
  774|   629k|    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RKNS5_6vectorIT0_T1_EE:
  846|   629k|{
  847|   629k|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|   629k|        WriteCompactSize(os, v.size());
  849|   629k|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (849:13): [True: 32.2k, False: 597k]
  ------------------
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|       |    } else {
  859|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|       |    }
  861|   629k|}
_ZNK12ParamsStreamIR10HashWriter20TransactionSerParamsE9GetParamsIS2_EERKDav:
 1144|  14.4k|    {
 1145|  14.4k|        if constexpr (std::is_convertible_v<Params, P>) {
 1146|  14.4k|            return m_params;
 1147|       |        } else {
 1148|       |            return m_substream.template GetParams<P>();
 1149|       |        }
 1150|  14.4k|    }
_Z9SerializeI10HashWriter13ParamsWrapperI20TransactionSerParamsK12CTransactionEQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  14.4k|{
  754|  14.4k|    a.Serialize(os);
  755|  14.4k|}
_ZNK13ParamsWrapperI20TransactionSerParamsK12CTransactionE9SerializeI10HashWriterEEvRT_:
 1199|  14.4k|    {
 1200|  14.4k|        ParamsStream ss{s, m_params};
 1201|  14.4k|        ::Serialize(ss, m_object);
 1202|  14.4k|    }
_Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE12CTransactionQ12SerializableIT0_T_EEvRS7_RKS6_:
  753|  14.4k|{
  754|  14.4k|    a.Serialize(os);
  755|  14.4k|}

_Z9UCharCastPKSt4byte:
  287|  10.6M|inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast<const unsigned char*>(c); }
_ZNK4SpanIKSt4byteE4sizeEv:
  187|  12.0M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKSt4byteE4dataEv:
  174|  10.7M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4sizeEv:
  187|  11.2k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKhE5beginEv:
  175|  13.5k|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKhE3endEv:
  176|  13.5k|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIhE4sizeEv:
  187|  2.40k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIhE4dataEv:
  174|  12.6M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4dataEv:
  174|   926k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanISt4byteE4sizeEv:
  187|  27.7M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanISt4byteE4dataEv:
  174|  9.26M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE10size_bytesEv:
  188|   923k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIKhE4SpanIKSt4byteES1_IT_E:
  259|   923k|{
  260|   923k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|   923k|}
_Z12MakeByteSpanIRKNSt3__16vectorIhNS0_9allocatorIhEEEEE4SpanIKSt4byteEOT_:
  270|  32.2k|{
  271|  32.2k|    return AsBytes(Span{std::forward<V>(v)});
  272|  32.2k|}
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalISA_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISA_EE4sizeEEmEE5valueEDnE4typeE:
  172|  70.4k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m:
  119|  12.0M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE:
  165|  2.40k|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIjE4dataEv:
  174|   521k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIjE10size_bytesEv:
  188|   521k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIjE4SpanIKSt4byteES0_IT_E:
  259|   273k|{
  260|   273k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|   273k|}
_ZNK4SpanIhE10size_bytesEv:
  188|  12.6M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIhE4SpanIKSt4byteES0_IT_E:
  259|  5.80M|{
  260|  5.80M|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  5.80M|}
_ZNK4SpanItE4dataEv:
  174|  3.28k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanItE10size_bytesEv:
  188|  3.28k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesItE4SpanIKSt4byteES0_IT_E:
  259|  1.95k|{
  260|  1.95k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  1.95k|}
_ZNK4SpanImE4dataEv:
  174|  7.17M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanImE10size_bytesEv:
  188|  7.17M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesImE4SpanIKSt4byteES0_IT_E:
  259|  5.00M|{
  260|  5.00M|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  5.00M|}
_Z12MakeByteSpanIRK9prevectorILj28EhjiEE4SpanIKSt4byteEOT_:
  270|   740k|{
  271|   740k|    return AsBytes(Span{std::forward<V>(v)});
  272|   740k|}
_ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  9.26M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E:
  264|  6.84M|{
  265|  6.84M|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  6.84M|}
_ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m:
  119|  12.5M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesItE4SpanISt4byteES0_IT_E:
  264|  1.32k|{
  265|  1.32k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  1.32k|}
_ZN4SpanItEC2ItTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_tEE5valueEiE4typeELi0EEEPS4_m:
  119|  3.28k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIjE4SpanISt4byteES0_IT_E:
  264|   247k|{
  265|   247k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|   247k|}
_ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m:
  119|   521k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesImE4SpanISt4byteES0_IT_E:
  264|  2.16M|{
  265|  2.16M|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  2.16M|}
_ZN4SpanImEC2ImTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_mEE5valueEiE4typeELi0EEEPS4_m:
  119|  7.17M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanIKhEC2INSt3__15arrayIhLm32EEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE:
  172|   121k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2I9prevectorILj28EhjiEEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS8_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  172|   740k|        : m_data(other.data()), m_size(other.size()){}
_Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEE4SpanISt4byteEOT_:
  275|   113k|{
  276|   113k|    return AsWritableBytes(Span{std::forward<V>(v)});
  277|   113k|}
_ZN4SpanIhEC2INSt3__15arrayIhLm32EEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  165|   113k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIhEC2I9prevectorILj33EhjiEEERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS6_14remove_pointerIDTcldtclsr3stdE7declvalIS5_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS5_EE4sizeEEmEE5valueEDnE4typeE:
  165|  9.60k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIhEC2I7CScriptEERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS3_EE5valuesr3std14is_convertibleIPA_NS5_14remove_pointerIDTcldtclsr3stdE7declvalIS4_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS4_EE4sizeEEmEE5valueEDnE4typeE:
  165|  5.31k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIhEC2INSt3__16vectorIhNS2_9allocatorIhEEEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS7_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE:
  165|  2.40k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2ILi33EEERAT__S0_:
  151|  4.67k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZN4SpanIKNSt3__16vectorIhNS0_9allocatorIhEEEEEC2INS1_IS4_NS2_IS4_EEEEEERKT_NS0_9enable_ifIXaaaantsr7is_SpanISA_EE5valuesr3std14is_convertibleIPA_NS0_14remove_pointerIDTcldtclsr3stdE7declvalISC_EE4dataEEE4typeEPA_S5_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISC_EE4sizeEEmEE5valueEDnE4typeE:
  172|    652|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIKNSt3__16vectorIhNS0_9allocatorIhEEEEE4sizeEv:
  187|  2.21k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKNSt3__16vectorIhNS0_9allocatorIhEEEEE4backEv:
  183|  1.04k|    {
  184|  1.04k|        ASSERT_IF_DEBUG(size() > 0);
  185|  1.04k|        return m_data[m_size - 1];
  186|  1.04k|    }
_ZNK4SpanIKNSt3__16vectorIhNS0_9allocatorIhEEEEE5beginEv:
  175|     31|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKNSt3__16vectorIhNS0_9allocatorIhEEEEE3endEv:
  176|     31|    constexpr C* end() const noexcept { return m_data + m_size; }
_Z11SpanPopBackIKNSt3__16vectorIhNS0_9allocatorIhEEEEERT_R4SpanIS6_E:
  249|    520|{
  250|    520|    size_t size = span.size();
  251|    520|    T& back = span.back();
  252|    520|    span = span.first(size - 1);
  253|    520|    return back;
  254|    520|}
_ZNK4SpanIKNSt3__16vectorIhNS0_9allocatorIhEEEEE5firstEm:
  206|    520|    {
  207|    520|        ASSERT_IF_DEBUG(size() >= count);
  208|    520|        return Span<C>(m_data, count);
  209|    520|    }
_ZN4SpanIKNSt3__16vectorIhNS0_9allocatorIhEEEEEC2IS5_TnNS0_9enable_ifIXsr3std14is_convertibleIPA_T_PA_S5_EE5valueEiE4typeELi0EEEPS9_m:
  119|    520|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}

_ZN10DataStreamC2E4SpanIKhE:
  165|  29.3k|    explicit DataStream(Span<const uint8_t> sp) : DataStream{AsBytes(sp)} {}
_ZN10DataStreamC2E4SpanIKSt4byteE:
  166|  29.3k|    explicit DataStream(Span<const value_type> sp) : vch(sp.data(), sp.data() + sp.size()) {}
_ZN10DataStream4readE4SpanISt4byteE:
  219|  9.26M|    {
  220|  9.26M|        if (dst.size() == 0) return;
  ------------------
  |  Branch (220:13): [True: 1.56k, False: 9.26M]
  ------------------
  221|       |
  222|       |        // Read from the beginning of the buffer
  223|  9.26M|        auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
  224|  9.26M|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (224:13): [True: 0, False: 9.26M]
  |  Branch (224:43): [True: 1.16k, False: 9.26M]
  ------------------
  225|  1.16k|            throw std::ios_base::failure("DataStream::read(): end of data");
  226|  1.16k|        }
  227|  9.26M|        memcpy(dst.data(), &vch[m_read_pos], dst.size());
  228|  9.26M|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (228:13): [True: 11.5k, False: 9.25M]
  ------------------
  229|  11.5k|            m_read_pos = 0;
  230|  11.5k|            vch.clear();
  231|  11.5k|            return;
  232|  11.5k|        }
  233|  9.25M|        m_read_pos = next_read_pos.value();
  234|  9.25M|    }
_ZN10DataStream6ignoreEm:
  237|    213|    {
  238|       |        // Ignore from the beginning of the buffer
  239|    213|        auto next_read_pos{CheckedAdd(m_read_pos, num_ignore)};
  240|    213|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (240:13): [True: 0, False: 213]
  |  Branch (240:43): [True: 118, False: 95]
  ------------------
  241|    118|            throw std::ios_base::failure("DataStream::ignore(): end of data");
  242|    118|        }
  243|     95|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (243:13): [True: 12, False: 83]
  ------------------
  244|     12|            m_read_pos = 0;
  245|     12|            vch.clear();
  246|     12|            return;
  247|     12|        }
  248|     83|        m_read_pos = next_read_pos.value();
  249|     83|    }
_ZN10DataStreamrsIR9COutPointEERS_OT_:
  266|  1.93k|    {
  267|  1.93k|        ::Unserialize(*this, obj);
  268|  1.93k|        return (*this);
  269|  1.93k|    }
_ZN10DataStreamrsI13ParamsWrapperI20TransactionSerParams19CMutableTransactionEEERS_OT_:
  266|  11.8k|    {
  267|  11.8k|        ::Unserialize(*this, obj);
  268|  11.8k|        return (*this);
  269|  11.8k|    }
_ZN10DataStreamrsIR4CoinEERS_OT_:
  266|  15.6k|    {
  267|  15.6k|        ::Unserialize(*this, obj);
  268|  15.6k|        return (*this);
  269|  15.6k|    }
_ZN10DataStreamrsI7WrapperI15VarIntFormatterIL10VarIntMode0EERmEEERS_OT_:
  266|  15.4k|    {
  267|  15.4k|        ::Unserialize(*this, obj);
  268|  15.4k|        return (*this);
  269|  15.4k|    }
_ZN10DataStreamrsI7WrapperI15VarIntFormatterIL10VarIntMode0EERjEEERS_OT_:
  266|  15.2k|    {
  267|  15.2k|        ::Unserialize(*this, obj);
  268|  15.2k|        return (*this);
  269|  15.2k|    }
_ZN10DataStreamrsI4SpanIhEEERS_OT_:
  266|  14.9k|    {
  267|  14.9k|        ::Unserialize(*this, obj);
  268|  14.9k|        return (*this);
  269|  14.9k|    }

_ZN13PoolAllocatorINSt3__111__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEELm144ELm8EE10deallocateEPS7_m:
  325|  2.24M|    {
  326|  2.24M|        m_resource->Deallocate(p, n * sizeof(T), alignof(T));
  327|  2.24M|    }
_ZN12PoolResourceILm144ELm8EE16IsFreeListUsableEmm:
  135|  4.51M|    {
  136|  4.51M|        return alignment <= ELEM_ALIGN_BYTES && bytes <= MAX_BLOCK_SIZE_BYTES;
  ------------------
  |  Branch (136:16): [True: 4.51M, False: 0]
  |  Branch (136:49): [True: 4.51M, False: 2.27k]
  ------------------
  137|  4.51M|    }
_ZN12PoolResourceILm144ELm8EE17NumElemAlignBytesEm:
  127|  4.53M|    {
  128|  4.53M|        return (bytes + ELEM_ALIGN_BYTES - 1) / ELEM_ALIGN_BYTES + (bytes == 0);
  129|  4.53M|    }
_ZN12PoolResourceILm144ELm8EE10DeallocateEPvmm:
  242|  2.25M|    {
  243|  2.25M|        if (IsFreeListUsable(bytes, alignment)) {
  ------------------
  |  Branch (243:13): [True: 2.25M, False: 1.13k]
  ------------------
  244|  2.25M|            const std::size_t num_alignments = NumElemAlignBytes(bytes);
  245|       |            // put the memory block into the linked list. We can placement construct the FreeList
  246|       |            // into the memory since we can be sure the alignment is correct.
  247|  2.25M|            PlacementAddToList(p, m_free_lists[num_alignments]);
  248|  2.25M|        } else {
  249|       |            // Can't use the pool => forward deallocation to ::operator delete().
  250|  1.13k|            ::operator delete (p, std::align_val_t{alignment});
  251|  1.13k|        }
  252|  2.25M|    }
_ZN12PoolResourceILm144ELm8EE18PlacementAddToListEPvRPNS0_8ListNodeE:
  143|  2.25M|    {
  144|  2.25M|        node = new (p) ListNode{node};
  145|  2.25M|    }
_ZN13PoolAllocatorIPNSt3__116__hash_node_baseIPNS0_11__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEEEELm144ELm8EE10deallocateEPSB_m:
  325|  17.9k|    {
  326|  17.9k|        m_resource->Deallocate(p, n * sizeof(T), alignof(T));
  327|  17.9k|    }
_ZN12PoolResourceILm144ELm8EE8ListNodeC2EPS1_:
   81|  2.25M|        explicit ListNode(ListNode* next) : m_next(next) {}
_ZN12PoolResourceILm144ELm8EED2Ev:
  201|  17.8k|    {
  202|  18.3k|        for (std::byte* chunk : m_allocated_chunks) {
  ------------------
  |  Branch (202:31): [True: 18.3k, False: 17.8k]
  ------------------
  203|  18.3k|            std::destroy(chunk, chunk + m_chunk_size_bytes);
  204|  18.3k|            ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES});
  205|  18.3k|        }
  206|  17.8k|    }
_ZN12PoolResourceILm144ELm8EEC2Ev:
  187|  17.8k|    PoolResource() : PoolResource(262144) {}
_ZN12PoolResourceILm144ELm8EEC2Em:
  178|  17.8k|        : m_chunk_size_bytes(NumElemAlignBytes(chunk_size_bytes) * ELEM_ALIGN_BYTES)
  179|  17.8k|    {
  180|  17.8k|        assert(m_chunk_size_bytes >= MAX_BLOCK_SIZE_BYTES);
  181|  17.8k|        AllocateChunk();
  182|  17.8k|    }
_ZN12PoolResourceILm144ELm8EE13AllocateChunkEv:
  154|  18.3k|    {
  155|       |        // if there is still any available memory left, put it into the freelist.
  156|  18.3k|        size_t remaining_available_bytes = std::distance(m_available_memory_it, m_available_memory_end);
  157|  18.3k|        if (0 != remaining_available_bytes) {
  ------------------
  |  Branch (157:13): [True: 67, False: 18.2k]
  ------------------
  158|     67|            PlacementAddToList(m_available_memory_it, m_free_lists[remaining_available_bytes / ELEM_ALIGN_BYTES]);
  159|     67|        }
  160|       |
  161|  18.3k|        void* storage = ::operator new (m_chunk_size_bytes, std::align_val_t{ELEM_ALIGN_BYTES});
  162|  18.3k|        m_available_memory_it = new (storage) std::byte[m_chunk_size_bytes];
  163|  18.3k|        m_available_memory_end = m_available_memory_it + m_chunk_size_bytes;
  164|  18.3k|        m_allocated_chunks.emplace_back(m_available_memory_it);
  165|  18.3k|    }
_ZN13PoolAllocatorINSt3__14pairIK9COutPoint16CCoinsCacheEntryEELm144ELm8EEC2EP12PoolResourceILm144ELm8EE:
  291|  17.8k|        : m_resource(resource)
  292|  17.8k|    {
  293|  17.8k|    }
_ZN13PoolAllocatorINSt3__117__hash_value_typeI9COutPoint16CCoinsCacheEntryEELm144ELm8EEC2INS0_4pairIKS2_S3_EEEERKS_IT_Lm144ELm8EE:
  300|  17.8k|        : m_resource(other.resource())
  301|  17.8k|    {
  302|  17.8k|    }
_ZNK13PoolAllocatorINSt3__14pairIK9COutPoint16CCoinsCacheEntryEELm144ELm8EE8resourceEv:
  330|  26.4k|    {
  331|  26.4k|        return m_resource;
  332|  26.4k|    }
_ZN13PoolAllocatorIPNSt3__116__hash_node_baseIPNS0_11__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEEEELm144ELm8EEC2IS6_EERKS_IT_Lm144ELm8EE:
  300|  17.8k|        : m_resource(other.resource())
  301|  17.8k|    {
  302|  17.8k|    }
_ZNK13PoolAllocatorINSt3__117__hash_value_typeI9COutPoint16CCoinsCacheEntryEELm144ELm8EE8resourceEv:
  330|  35.6k|    {
  331|  35.6k|        return m_resource;
  332|  35.6k|    }
_ZN13PoolAllocatorINSt3__111__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEELm144ELm8EEC2IS5_EERKS_IT_Lm144ELm8EE:
  300|  17.8k|        : m_resource(other.resource())
  301|  17.8k|    {
  302|  17.8k|    }
_ZN13PoolAllocatorIPNSt3__116__hash_node_baseIPNS0_11__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEEEELm144ELm8EE8allocateEm:
  317|  17.9k|    {
  318|  17.9k|        return static_cast<T*>(m_resource->Allocate(n * sizeof(T), alignof(T)));
  319|  17.9k|    }
_ZN12PoolResourceILm144ELm8EE8AllocateEmm:
  213|  2.25M|    {
  214|  2.25M|        if (IsFreeListUsable(bytes, alignment)) {
  ------------------
  |  Branch (214:13): [True: 2.25M, False: 1.13k]
  ------------------
  215|  2.25M|            const std::size_t num_alignments = NumElemAlignBytes(bytes);
  216|  2.25M|            if (nullptr != m_free_lists[num_alignments]) {
  ------------------
  |  Branch (216:17): [True: 1.00M, False: 1.24M]
  ------------------
  217|       |                // we've already got data in the pool's freelist, unlink one element and return the pointer
  218|       |                // to the unlinked memory. Since FreeList is trivially destructible we can just treat it as
  219|       |                // uninitialized memory.
  220|  1.00M|                return std::exchange(m_free_lists[num_alignments], m_free_lists[num_alignments]->m_next);
  221|  1.00M|            }
  222|       |
  223|       |            // freelist is empty: get one allocation from allocated chunk memory.
  224|  1.24M|            const std::ptrdiff_t round_bytes = static_cast<std::ptrdiff_t>(num_alignments * ELEM_ALIGN_BYTES);
  225|  1.24M|            if (round_bytes > m_available_memory_end - m_available_memory_it) {
  ------------------
  |  Branch (225:17): [True: 545, False: 1.24M]
  ------------------
  226|       |                // slow path, only happens when a new chunk needs to be allocated
  227|    545|                AllocateChunk();
  228|    545|            }
  229|       |
  230|       |            // Make sure we use the right amount of bytes for that freelist (might be rounded up),
  231|  1.24M|            return std::exchange(m_available_memory_it, m_available_memory_it + round_bytes);
  232|  2.25M|        }
  233|       |
  234|       |        // Can't use the pool => use operator new()
  235|  1.13k|        return ::operator new (bytes, std::align_val_t{alignment});
  236|  2.25M|    }
_ZN13PoolAllocatorINSt3__111__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEELm144ELm8EE8allocateEm:
  317|  2.24M|    {
  318|  2.24M|        return static_cast<T*>(m_resource->Allocate(n * sizeof(T), alignof(T)));
  319|  2.24M|    }
_ZN13PoolAllocatorINSt3__14pairIK9COutPoint16CCoinsCacheEntryEELm144ELm8EEC2INS0_11__hash_nodeINS0_17__hash_value_typeIS2_S4_EEPvEEEERKS_IT_Lm144ELm8EE:
  300|  8.67k|        : m_resource(other.resource())
  301|  8.67k|    {
  302|  8.67k|    }
_ZNK13PoolAllocatorINSt3__111__hash_nodeINS0_17__hash_value_typeI9COutPoint16CCoinsCacheEntryEEPvEELm144ELm8EE8resourceEv:
  330|  8.67k|    {
  331|  8.67k|        return m_resource;
  332|  8.67k|    }
_ZNK12PoolResourceILm144ELm8EE18NumAllocatedChunksEv:
  258|  17.3k|    {
  259|  17.3k|        return m_allocated_chunks.size();
  260|  17.3k|    }
_ZNK12PoolResourceILm144ELm8EE14ChunkSizeBytesEv:
  266|  8.67k|    {
  267|  8.67k|        return m_chunk_size_bytes;
  268|  8.67k|    }

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

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

_Z13LeaveCriticalv:
   76|      2|inline void LeaveCritical() {}
_Z10DeleteLockPv:
   82|      4|inline void DeleteLock(void* cs) {}
_Z17MaybeCheckNotHeldI14AnnotatedMixinINSt3__115recursive_mutexEEERT_S5_:
  253|      2|inline MutexType& MaybeCheckNotHeld(MutexType& m) LOCKS_EXCLUDED(m) LOCK_RETURNED(m) { return m; }
_Z13EnterCriticalINSt3__115recursive_mutexEEvPKcS3_iPT_b:
   75|      2|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEE5EnterEPKcS6_i:
  157|      2|    {
  158|      2|        EnterCritical(pszName, pszFile, nLine, Base::mutex());
  159|       |#ifdef DEBUG_LOCKCONTENTION
  160|       |        if (Base::try_lock()) return;
  161|       |        LOG_TIME_MICROS_WITH_CATEGORY(strprintf("lock contention %s, %s:%d", pszName, pszFile, nLine), BCLog::LOCK);
  162|       |#endif
  163|      2|        Base::lock();
  164|      2|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEEC2ERS3_PKcS7_ib:
  177|      2|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  178|      2|    {
  179|      2|        if (fTry)
  ------------------
  |  Branch (179:13): [True: 0, False: 2]
  ------------------
  180|      0|            TryEnter(pszName, pszFile, nLine);
  181|      2|        else
  182|      2|            Enter(pszName, pszFile, nLine);
  183|      2|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEED2Ev:
  197|      2|    {
  198|      2|        if (Base::owns_lock())
  ------------------
  |  Branch (198:13): [True: 2, False: 0]
  ------------------
  199|      2|            LeaveCritical();
  200|      2|    }
_ZN14AnnotatedMixinINSt3__15mutexEED2Ev:
   94|      2|    ~AnnotatedMixin() {
   95|      2|        DeleteLock((void*)this);
   96|      2|    }
_ZN14AnnotatedMixinINSt3__115recursive_mutexEED2Ev:
   94|      2|    ~AnnotatedMixin() {
   95|      2|        DeleteLock((void*)this);
   96|      2|    }

_ZN18FuzzedDataProviderC2EPKhm:
   37|  8.67k|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_:
  205|   153k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|   153k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|   153k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|   153k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 153k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|   153k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|   153k|  uint64_t result = 0;
  215|   153k|  size_t offset = 0;
  216|       |
  217|   305k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 305k, False: 0]
  |  Branch (217:43): [True: 153k, False: 152k]
  ------------------
  218|   305k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 152k, False: 735]
  ------------------
  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|   152k|    --remaining_bytes_;
  226|   152k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|   152k|    offset += CHAR_BIT;
  228|   152k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|   153k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 153k, False: 0]
  ------------------
  232|   153k|    result = result % (range + 1);
  233|       |
  234|   153k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|   153k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_:
  205|    390|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|    390|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|    390|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|    390|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 390]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|    390|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|    390|  uint64_t result = 0;
  215|    390|  size_t offset = 0;
  216|       |
  217|  1.09k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 1.02k, False: 65]
  |  Branch (217:43): [True: 1.02k, False: 0]
  ------------------
  218|  1.09k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 700, False: 325]
  ------------------
  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|    700|    --remaining_bytes_;
  226|    700|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    700|    offset += CHAR_BIT;
  228|    700|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|    390|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 390, False: 0]
  ------------------
  232|    390|    result = result % (range + 1);
  233|       |
  234|    390|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|    390|}
_ZN18FuzzedDataProvider15ConsumeIntegralIjEET_v:
  195|  1.16k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  1.16k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  1.16k|                                std::numeric_limits<T>::max());
  198|  1.16k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_:
  205|  1.16k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.16k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  1.16k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.16k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.16k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.16k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.16k|  uint64_t result = 0;
  215|  1.16k|  size_t offset = 0;
  216|       |
  217|  3.77k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 3.25k, False: 528]
  |  Branch (217:43): [True: 3.25k, False: 0]
  ------------------
  218|  3.77k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 2.61k, False: 640]
  ------------------
  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|  2.61k|    --remaining_bytes_;
  226|  2.61k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  2.61k|    offset += CHAR_BIT;
  228|  2.61k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.16k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 1.16k, False: 0]
  ------------------
  232|  1.16k|    result = result % (range + 1);
  233|       |
  234|  1.16k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.16k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v:
  195|   708k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|   708k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|   708k|                                std::numeric_limits<T>::max());
  198|   708k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_:
  205|   708k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|   708k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|   708k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|   708k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 708k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|   708k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|   708k|  uint64_t result = 0;
  215|   708k|  size_t offset = 0;
  216|       |
  217|  1.40M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 708k, False: 701k]
  |  Branch (217:43): [True: 708k, False: 0]
  ------------------
  218|  1.40M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 701k, False: 7.88k]
  ------------------
  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|   701k|    --remaining_bytes_;
  226|   701k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|   701k|    offset += CHAR_BIT;
  228|   701k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|   708k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 708k, False: 0]
  ------------------
  232|   708k|    result = result % (range + 1);
  233|       |
  234|   708k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|   708k|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm:
  153|  29.3k|FuzzedDataProvider::ConsumeRandomLengthString(size_t max_length) {
  154|       |  // Reads bytes from the start of |data_ptr_|. Maps "\\" to "\", and maps "\"
  155|       |  // followed by anything else to the end of the string. As a result of this
  156|       |  // logic, a fuzzer can insert characters into the string, and the string
  157|       |  // will be lengthened to include those new characters, resulting in a more
  158|       |  // stable fuzzer than picking the length of a string independently from
  159|       |  // picking its contents.
  160|  29.3k|  std::string result;
  161|       |
  162|       |  // Reserve the anticipated capacity to prevent several reallocations.
  163|  29.3k|  result.reserve(std::min(max_length, remaining_bytes_));
  164|  72.0M|  for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) {
  ------------------
  |  Branch (164:22): [True: 72.0M, False: 2.52k]
  |  Branch (164:40): [True: 72.0M, False: 23]
  ------------------
  165|  72.0M|    char next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  166|  72.0M|    Advance(1);
  167|  72.0M|    if (next == '\\' && remaining_bytes_ != 0) {
  ------------------
  |  Branch (167:9): [True: 32.0k, False: 72.0M]
  |  Branch (167:25): [True: 32.0k, False: 40]
  ------------------
  168|  32.0k|      next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  169|  32.0k|      Advance(1);
  170|  32.0k|      if (next != '\\')
  ------------------
  |  Branch (170:11): [True: 26.8k, False: 5.21k]
  ------------------
  171|  26.8k|        break;
  172|  32.0k|    }
  173|  72.0M|    result += next;
  174|  72.0M|  }
  175|       |
  176|  29.3k|  result.shrink_to_fit();
  177|  29.3k|  return result;
  178|  29.3k|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEv:
  181|  29.3k|inline std::string FuzzedDataProvider::ConsumeRandomLengthString() {
  182|  29.3k|  return ConsumeRandomLengthString(remaining_bytes_);
  183|  29.3k|}
_ZN18FuzzedDataProvider11ConsumeBoolEv:
  289|   708k|inline bool FuzzedDataProvider::ConsumeBool() {
  290|   708k|  return 1 & ConsumeIntegral<uint8_t>();
  291|   708k|}
_ZN18FuzzedDataProvider14CopyAndAdvanceEPvm:
  339|  8.90k|                                               size_t num_bytes) {
  340|  8.90k|  std::memcpy(destination, data_ptr_, num_bytes);
  341|  8.90k|  Advance(num_bytes);
  342|  8.90k|}
_ZN18FuzzedDataProvider7AdvanceEm:
  344|  72.1M|inline void FuzzedDataProvider::Advance(size_t num_bytes) {
  345|  72.1M|  if (num_bytes > remaining_bytes_)
  ------------------
  |  Branch (345:7): [True: 0, False: 72.1M]
  ------------------
  346|      0|    abort();
  347|       |
  348|  72.1M|  data_ptr_ += num_bytes;
  349|  72.1M|  remaining_bytes_ -= num_bytes;
  350|  72.1M|}
_ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_:
  379|  72.1M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) {
  380|  72.1M|  static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types.");
  381|  72.1M|  static_assert(!std::numeric_limits<TU>::is_signed,
  382|  72.1M|                "Source type must be unsigned.");
  383|       |
  384|       |  // TODO(Dor1s): change to `if constexpr` once C++17 becomes mainstream.
  385|  72.1M|  if (std::numeric_limits<TS>::is_modulo)
  ------------------
  |  Branch (385:7): [Folded - Ignored]
  ------------------
  386|      0|    return static_cast<TS>(value);
  387|       |
  388|       |  // Avoid using implementation-defined unsigned to signed conversions.
  389|       |  // To learn more, see https://stackoverflow.com/questions/13150449.
  390|  72.1M|  if (value <= std::numeric_limits<TS>::max()) {
  ------------------
  |  Branch (390:7): [True: 53.6M, False: 18.4M]
  ------------------
  391|  53.6M|    return static_cast<TS>(value);
  392|  53.6M|  } else {
  393|  18.4M|    constexpr auto TS_min = std::numeric_limits<TS>::min();
  394|  18.4M|    return TS_min + static_cast<TS>(value - TS_min);
  395|  18.4M|  }
  396|  72.1M|}
_ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEm:
  109|  8.93k|std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t num_bytes) {
  110|  8.93k|  num_bytes = std::min(num_bytes, remaining_bytes_);
  111|  8.93k|  return ConsumeBytes<T>(num_bytes, num_bytes);
  112|  8.93k|}
_ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEmm:
  353|  8.93k|std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t size, size_t num_bytes) {
  354|  8.93k|  static_assert(sizeof(T) == sizeof(uint8_t), "Incompatible data type.");
  355|       |
  356|       |  // The point of using the size-based constructor below is to increase the
  357|       |  // odds of having a vector object with capacity being equal to the length.
  358|       |  // That part is always implementation specific, but at least both libc++ and
  359|       |  // libstdc++ allocate the requested number of bytes in that constructor,
  360|       |  // which seems to be a natural choice for other implementations as well.
  361|       |  // To increase the odds even more, we also call |shrink_to_fit| below.
  362|  8.93k|  std::vector<T> result(size);
  363|  8.93k|  if (size == 0) {
  ------------------
  |  Branch (363:7): [True: 32, False: 8.90k]
  ------------------
  364|     32|    if (num_bytes != 0)
  ------------------
  |  Branch (364:9): [True: 0, False: 32]
  ------------------
  365|      0|      abort();
  366|     32|    return result;
  367|     32|  }
  368|       |
  369|  8.90k|  CopyAndAdvance(result.data(), num_bytes);
  370|       |
  371|       |  // Even though |shrink_to_fit| is also implementation specific, we expect it
  372|       |  // to provide an additional assurance in case vector's constructor allocated
  373|       |  // a buffer which is larger than the actual amount of data we put inside it.
  374|  8.90k|  result.shrink_to_fit();
  375|  8.90k|  return result;
  376|  8.93k|}

_Z22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   45|  8.67k|{
   46|  8.67k|    FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
   47|  8.67k|    bool good_data{true};
   48|       |
   49|  8.67k|    CCoinsView backend_coins_view;
   50|  8.67k|    CCoinsViewCache coins_view_cache{&backend_coins_view, /*deterministic=*/true};
   51|  8.67k|    COutPoint random_out_point;
   52|  8.67k|    Coin random_coin;
   53|  8.67k|    CMutableTransaction random_mutable_transaction;
   54|  8.67k|    LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 10'000)
  ------------------
  |  |   23|   312k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:35): [True: 155k, False: 1.52k]
  |  |  |  Branch (23:35): [True: 148k, False: 7.15k]
  |  |  |  Branch (23:49): [True: 148k, False: 2]
  |  |  ------------------
  ------------------
   55|   148k|    {
   56|   148k|        CallOneOf(
   57|   148k|            fuzzed_data_provider,
   58|   148k|            [&] {
   59|   148k|                if (random_coin.IsSpent()) {
   60|   148k|                    return;
   61|   148k|                }
   62|   148k|                Coin coin = random_coin;
   63|   148k|                bool expected_code_path = false;
   64|   148k|                const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
   65|   148k|                try {
   66|   148k|                    coins_view_cache.AddCoin(random_out_point, std::move(coin), possible_overwrite);
   67|   148k|                    expected_code_path = true;
   68|   148k|                } catch (const std::logic_error& e) {
   69|   148k|                    if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
   70|   148k|                        assert(!possible_overwrite);
   71|   148k|                        expected_code_path = true;
   72|   148k|                    }
   73|   148k|                }
   74|   148k|                assert(expected_code_path);
   75|   148k|            },
   76|   148k|            [&] {
   77|   148k|                (void)coins_view_cache.Flush();
   78|   148k|            },
   79|   148k|            [&] {
   80|   148k|                (void)coins_view_cache.Sync();
   81|   148k|            },
   82|   148k|            [&] {
   83|   148k|                coins_view_cache.SetBestBlock(ConsumeUInt256(fuzzed_data_provider));
   84|   148k|            },
   85|   148k|            [&] {
   86|   148k|                Coin move_to;
   87|   148k|                (void)coins_view_cache.SpendCoin(random_out_point, fuzzed_data_provider.ConsumeBool() ? &move_to : nullptr);
   88|   148k|            },
   89|   148k|            [&] {
   90|   148k|                coins_view_cache.Uncache(random_out_point);
   91|   148k|            },
   92|   148k|            [&] {
   93|   148k|                if (fuzzed_data_provider.ConsumeBool()) {
   94|   148k|                    backend_coins_view = CCoinsView{};
   95|   148k|                }
   96|   148k|                coins_view_cache.SetBackend(backend_coins_view);
   97|   148k|            },
   98|   148k|            [&] {
   99|   148k|                const std::optional<COutPoint> opt_out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
  100|   148k|                if (!opt_out_point) {
  101|   148k|                    good_data = false;
  102|   148k|                    return;
  103|   148k|                }
  104|   148k|                random_out_point = *opt_out_point;
  105|   148k|            },
  106|   148k|            [&] {
  107|   148k|                const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
  108|   148k|                if (!opt_coin) {
  109|   148k|                    good_data = false;
  110|   148k|                    return;
  111|   148k|                }
  112|   148k|                random_coin = *opt_coin;
  113|   148k|            },
  114|   148k|            [&] {
  115|   148k|                const std::optional<CMutableTransaction> opt_mutable_transaction = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider, TX_WITH_WITNESS);
  116|   148k|                if (!opt_mutable_transaction) {
  117|   148k|                    good_data = false;
  118|   148k|                    return;
  119|   148k|                }
  120|   148k|                random_mutable_transaction = *opt_mutable_transaction;
  121|   148k|            },
  122|   148k|            [&] {
  123|   148k|                CoinsCachePair sentinel{};
  124|   148k|                sentinel.second.SelfRef(sentinel);
  125|   148k|                size_t usage{0};
  126|   148k|                CCoinsMapMemoryResource resource;
  127|   148k|                CCoinsMap coins_map{0, SaltedOutpointHasher{/*deterministic=*/true}, CCoinsMap::key_equal{}, &resource};
  128|   148k|                LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 10'000)
  129|   148k|                {
  130|   148k|                    CCoinsCacheEntry coins_cache_entry;
  131|   148k|                    const auto dirty{fuzzed_data_provider.ConsumeBool()};
  132|   148k|                    const auto fresh{fuzzed_data_provider.ConsumeBool()};
  133|   148k|                    if (fuzzed_data_provider.ConsumeBool()) {
  134|   148k|                        coins_cache_entry.coin = random_coin;
  135|   148k|                    } else {
  136|   148k|                        const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
  137|   148k|                        if (!opt_coin) {
  138|   148k|                            good_data = false;
  139|   148k|                            return;
  140|   148k|                        }
  141|   148k|                        coins_cache_entry.coin = *opt_coin;
  142|   148k|                    }
  143|   148k|                    auto it{coins_map.emplace(random_out_point, std::move(coins_cache_entry)).first};
  144|   148k|                    if (dirty) CCoinsCacheEntry::SetDirty(*it, sentinel);
  145|   148k|                    if (fresh) CCoinsCacheEntry::SetFresh(*it, sentinel);
  146|   148k|                    usage += it->second.coin.DynamicMemoryUsage();
  147|   148k|                }
  148|   148k|                bool expected_code_path = false;
  149|   148k|                try {
  150|   148k|                    auto cursor{CoinsViewCacheCursor(usage, sentinel, coins_map, /*will_erase=*/true)};
  151|   148k|                    coins_view_cache.BatchWrite(cursor, fuzzed_data_provider.ConsumeBool() ? ConsumeUInt256(fuzzed_data_provider) : coins_view_cache.GetBestBlock());
  152|   148k|                    expected_code_path = true;
  153|   148k|                } catch (const std::logic_error& e) {
  154|   148k|                    if (e.what() == std::string{"FRESH flag misapplied to coin that exists in parent cache"}) {
  155|   148k|                        expected_code_path = true;
  156|   148k|                    }
  157|   148k|                }
  158|   148k|                assert(expected_code_path);
  159|   148k|            });
  160|   148k|    }
  161|       |
  162|  8.67k|    {
  163|  8.67k|        const Coin& coin_using_access_coin = coins_view_cache.AccessCoin(random_out_point);
  164|  8.67k|        const bool exists_using_access_coin = !(coin_using_access_coin == EMPTY_COIN);
  165|  8.67k|        const bool exists_using_have_coin = coins_view_cache.HaveCoin(random_out_point);
  166|  8.67k|        const bool exists_using_have_coin_in_cache = coins_view_cache.HaveCoinInCache(random_out_point);
  167|  8.67k|        if (auto coin{coins_view_cache.GetCoin(random_out_point)}) {
  ------------------
  |  Branch (167:18): [True: 4.92k, False: 3.75k]
  ------------------
  168|  4.92k|            assert(*coin == coin_using_access_coin);
  169|  4.92k|            assert(exists_using_access_coin && exists_using_have_coin_in_cache && exists_using_have_coin);
  170|  4.92k|        } else {
  171|  3.75k|            assert(!exists_using_access_coin && !exists_using_have_coin_in_cache && !exists_using_have_coin);
  172|  3.75k|        }
  173|       |        // If HaveCoin on the backend is true, it must also be on the cache if the coin wasn't spent.
  174|  8.67k|        const bool exists_using_have_coin_in_backend = backend_coins_view.HaveCoin(random_out_point);
  175|  8.67k|        if (!coin_using_access_coin.IsSpent() && exists_using_have_coin_in_backend) {
  ------------------
  |  Branch (175:13): [True: 4.92k, False: 3.75k]
  |  Branch (175:50): [True: 0, False: 4.92k]
  ------------------
  176|      0|            assert(exists_using_have_coin);
  177|      0|        }
  178|  8.67k|        if (auto coin{backend_coins_view.GetCoin(random_out_point)}) {
  ------------------
  |  Branch (178:18): [True: 0, False: 8.67k]
  ------------------
  179|      0|            assert(exists_using_have_coin_in_backend);
  180|       |            // Note we can't assert that `coin_using_get_coin == *coin` because the coin in
  181|       |            // the cache may have been modified but not yet flushed.
  182|  8.67k|        } else {
  183|  8.67k|            assert(!exists_using_have_coin_in_backend);
  184|  8.67k|        }
  185|  8.67k|    }
  186|       |
  187|  8.67k|    {
  188|  8.67k|        bool expected_code_path = false;
  189|  8.67k|        try {
  190|  8.67k|            (void)coins_view_cache.Cursor();
  191|  8.67k|        } catch (const std::logic_error&) {
  192|  8.67k|            expected_code_path = true;
  193|  8.67k|        }
  194|  8.67k|        assert(expected_code_path);
  195|  8.67k|        (void)coins_view_cache.DynamicMemoryUsage();
  196|  8.67k|        (void)coins_view_cache.EstimateSize();
  197|  8.67k|        (void)coins_view_cache.GetBestBlock();
  198|  8.67k|        (void)coins_view_cache.GetCacheSize();
  199|  8.67k|        (void)coins_view_cache.GetHeadBlocks();
  200|  8.67k|        (void)coins_view_cache.HaveInputs(CTransaction{random_mutable_transaction});
  201|  8.67k|    }
  202|       |
  203|      0|    {
  204|  8.67k|        std::unique_ptr<CCoinsViewCursor> coins_view_cursor = backend_coins_view.Cursor();
  205|  8.67k|        assert(!coins_view_cursor);
  206|  8.67k|        (void)backend_coins_view.EstimateSize();
  207|  8.67k|        (void)backend_coins_view.GetBestBlock();
  208|  8.67k|        (void)backend_coins_view.GetHeadBlocks();
  209|  8.67k|    }
  210|       |
  211|  8.67k|    if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (211:9): [True: 4.93k, False: 3.74k]
  ------------------
  212|  4.93k|        CallOneOf(
  213|  4.93k|            fuzzed_data_provider,
  214|  4.93k|            [&] {
  215|  4.93k|                const CTransaction transaction{random_mutable_transaction};
  216|  4.93k|                bool is_spent = false;
  217|  4.93k|                for (const CTxOut& tx_out : transaction.vout) {
  218|  4.93k|                    if (Coin{tx_out, 0, transaction.IsCoinBase()}.IsSpent()) {
  219|  4.93k|                        is_spent = true;
  220|  4.93k|                    }
  221|  4.93k|                }
  222|  4.93k|                if (is_spent) {
  223|       |                    // Avoid:
  224|       |                    // coins.cpp:69: void CCoinsViewCache::AddCoin(const COutPoint &, Coin &&, bool): Assertion `!coin.IsSpent()' failed.
  225|  4.93k|                    return;
  226|  4.93k|                }
  227|  4.93k|                bool expected_code_path = false;
  228|  4.93k|                const int height{int(fuzzed_data_provider.ConsumeIntegral<uint32_t>() >> 1)};
  229|  4.93k|                const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
  230|  4.93k|                try {
  231|  4.93k|                    AddCoins(coins_view_cache, transaction, height, possible_overwrite);
  232|  4.93k|                    expected_code_path = true;
  233|  4.93k|                } catch (const std::logic_error& e) {
  234|  4.93k|                    if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
  235|  4.93k|                        assert(!possible_overwrite);
  236|  4.93k|                        expected_code_path = true;
  237|  4.93k|                    }
  238|  4.93k|                }
  239|  4.93k|                assert(expected_code_path);
  240|  4.93k|            },
  241|  4.93k|            [&] {
  242|  4.93k|                (void)AreInputsStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
  243|  4.93k|            },
  244|  4.93k|            [&] {
  245|  4.93k|                TxValidationState state;
  246|  4.93k|                CAmount tx_fee_out;
  247|  4.93k|                const CTransaction transaction{random_mutable_transaction};
  248|  4.93k|                if (ContainsSpentInput(transaction, coins_view_cache)) {
  249|       |                    // Avoid:
  250|       |                    // consensus/tx_verify.cpp:171: bool Consensus::CheckTxInputs(const CTransaction &, TxValidationState &, const CCoinsViewCache &, int, CAmount &): Assertion `!coin.IsSpent()' failed.
  251|  4.93k|                    return;
  252|  4.93k|                }
  253|  4.93k|                TxValidationState dummy;
  254|  4.93k|                if (!CheckTransaction(transaction, dummy)) {
  255|       |                    // It is not allowed to call CheckTxInputs if CheckTransaction failed
  256|  4.93k|                    return;
  257|  4.93k|                }
  258|  4.93k|                if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out)) {
  259|  4.93k|                    assert(MoneyRange(tx_fee_out));
  260|  4.93k|                }
  261|  4.93k|            },
  262|  4.93k|            [&] {
  263|  4.93k|                const CTransaction transaction{random_mutable_transaction};
  264|  4.93k|                if (ContainsSpentInput(transaction, coins_view_cache)) {
  265|       |                    // Avoid:
  266|       |                    // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
  267|  4.93k|                    return;
  268|  4.93k|                }
  269|  4.93k|                (void)GetP2SHSigOpCount(transaction, coins_view_cache);
  270|  4.93k|            },
  271|  4.93k|            [&] {
  272|  4.93k|                const CTransaction transaction{random_mutable_transaction};
  273|  4.93k|                if (ContainsSpentInput(transaction, coins_view_cache)) {
  274|       |                    // Avoid:
  275|       |                    // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
  276|  4.93k|                    return;
  277|  4.93k|                }
  278|  4.93k|                const auto flags{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
  279|  4.93k|                if (!transaction.vin.empty() && (flags & SCRIPT_VERIFY_WITNESS) != 0 && (flags & SCRIPT_VERIFY_P2SH) == 0) {
  280|       |                    // Avoid:
  281|       |                    // script/interpreter.cpp:1705: size_t CountWitnessSigOps(const CScript &, const CScript &, const CScriptWitness *, unsigned int): Assertion `(flags & SCRIPT_VERIFY_P2SH) != 0' failed.
  282|  4.93k|                    return;
  283|  4.93k|                }
  284|  4.93k|                (void)GetTransactionSigOpCost(transaction, coins_view_cache, flags);
  285|  4.93k|            },
  286|  4.93k|            [&] {
  287|  4.93k|                (void)IsWitnessStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
  288|  4.93k|            });
  289|  4.93k|    }
  290|  8.67k|}
coins_view.cpp:_ZN12_GLOBAL__N_1eqERK4CoinS2_:
   33|  13.5k|{
   34|  13.5k|    if (a.IsSpent() && b.IsSpent()) return true;
  ------------------
  |  Branch (34:9): [True: 3.75k, False: 9.84k]
  |  Branch (34:24): [True: 3.75k, False: 0]
  ------------------
   35|  9.84k|    return a.fCoinBase == b.fCoinBase && a.nHeight == b.nHeight && a.out == b.out;
  ------------------
  |  Branch (35:12): [True: 7.74k, False: 2.10k]
  |  Branch (35:42): [True: 5.39k, False: 2.34k]
  |  Branch (35:68): [True: 4.92k, False: 471]
  ------------------
   36|  13.5k|}
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv:
   58|  45.6k|            [&] {
   59|  45.6k|                if (random_coin.IsSpent()) {
  ------------------
  |  Branch (59:21): [True: 15.6k, False: 30.0k]
  ------------------
   60|  15.6k|                    return;
   61|  15.6k|                }
   62|  30.0k|                Coin coin = random_coin;
   63|  30.0k|                bool expected_code_path = false;
   64|  30.0k|                const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
   65|  30.0k|                try {
   66|  30.0k|                    coins_view_cache.AddCoin(random_out_point, std::move(coin), possible_overwrite);
   67|  30.0k|                    expected_code_path = true;
   68|  30.0k|                } catch (const std::logic_error& e) {
   69|  15.0k|                    if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
  ------------------
  |  Branch (69:25): [True: 15.0k, False: 0]
  ------------------
   70|  15.0k|                        assert(!possible_overwrite);
   71|  15.0k|                        expected_code_path = true;
   72|  15.0k|                    }
   73|  15.0k|                }
   74|  30.0k|                assert(expected_code_path);
   75|  30.0k|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_1clEv:
   76|  5.14k|            [&] {
   77|  5.14k|                (void)coins_view_cache.Flush();
   78|  5.14k|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_2clEv:
   79|  26.3k|            [&] {
   80|  26.3k|                (void)coins_view_cache.Sync();
   81|  26.3k|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_3clEv:
   82|  6.72k|            [&] {
   83|  6.72k|                coins_view_cache.SetBestBlock(ConsumeUInt256(fuzzed_data_provider));
   84|  6.72k|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_4clEv:
   85|  12.8k|            [&] {
   86|  12.8k|                Coin move_to;
   87|  12.8k|                (void)coins_view_cache.SpendCoin(random_out_point, fuzzed_data_provider.ConsumeBool() ? &move_to : nullptr);
  ------------------
  |  Branch (87:68): [True: 7.66k, False: 5.15k]
  ------------------
   88|  12.8k|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_5clEv:
   89|  5.59k|            [&] {
   90|  5.59k|                coins_view_cache.Uncache(random_out_point);
   91|  5.59k|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_6clEv:
   92|  9.30k|            [&] {
   93|  9.30k|                if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (93:21): [True: 9.03k, False: 274]
  ------------------
   94|  9.03k|                    backend_coins_view = CCoinsView{};
   95|  9.03k|                }
   96|  9.30k|                coins_view_cache.SetBackend(backend_coins_view);
   97|  9.30k|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_7clEv:
   98|  1.93k|            [&] {
   99|  1.93k|                const std::optional<COutPoint> opt_out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
  100|  1.93k|                if (!opt_out_point) {
  ------------------
  |  Branch (100:21): [True: 36, False: 1.89k]
  ------------------
  101|     36|                    good_data = false;
  102|     36|                    return;
  103|     36|                }
  104|  1.89k|                random_out_point = *opt_out_point;
  105|  1.89k|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_8clEv:
  106|  13.8k|            [&] {
  107|  13.8k|                const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
  108|  13.8k|                if (!opt_coin) {
  ------------------
  |  Branch (108:21): [True: 704, False: 13.1k]
  ------------------
  109|    704|                    good_data = false;
  110|    704|                    return;
  111|    704|                }
  112|  13.1k|                random_coin = *opt_coin;
  113|  13.1k|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_9clEv:
  114|  11.8k|            [&] {
  115|  11.8k|                const std::optional<CMutableTransaction> opt_mutable_transaction = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider, TX_WITH_WITNESS);
  116|  11.8k|                if (!opt_mutable_transaction) {
  ------------------
  |  Branch (116:21): [True: 728, False: 11.0k]
  ------------------
  117|    728|                    good_data = false;
  118|    728|                    return;
  119|    728|                }
  120|  11.0k|                random_mutable_transaction = *opt_mutable_transaction;
  121|  11.0k|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_10clEv:
  122|  9.14k|            [&] {
  123|  9.14k|                CoinsCachePair sentinel{};
  124|  9.14k|                sentinel.second.SelfRef(sentinel);
  125|  9.14k|                size_t usage{0};
  126|  9.14k|                CCoinsMapMemoryResource resource;
  127|  9.14k|                CCoinsMap coins_map{0, SaltedOutpointHasher{/*deterministic=*/true}, CCoinsMap::key_equal{}, &resource};
  128|  9.14k|                LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 10'000)
  ------------------
  |  |   23|   255k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:35): [True: 127k, False: 0]
  |  |  |  Branch (23:35): [True: 118k, False: 9.08k]
  |  |  |  Branch (23:49): [True: 118k, False: 3]
  |  |  ------------------
  ------------------
  129|   118k|                {
  130|   118k|                    CCoinsCacheEntry coins_cache_entry;
  131|   118k|                    const auto dirty{fuzzed_data_provider.ConsumeBool()};
  132|   118k|                    const auto fresh{fuzzed_data_provider.ConsumeBool()};
  133|   118k|                    if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (133:25): [True: 116k, False: 1.71k]
  ------------------
  134|   116k|                        coins_cache_entry.coin = random_coin;
  135|   116k|                    } else {
  136|  1.71k|                        const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
  137|  1.71k|                        if (!opt_coin) {
  ------------------
  |  Branch (137:29): [True: 53, False: 1.66k]
  ------------------
  138|     53|                            good_data = false;
  139|     53|                            return;
  140|     53|                        }
  141|  1.66k|                        coins_cache_entry.coin = *opt_coin;
  142|  1.66k|                    }
  143|   118k|                    auto it{coins_map.emplace(random_out_point, std::move(coins_cache_entry)).first};
  144|   118k|                    if (dirty) CCoinsCacheEntry::SetDirty(*it, sentinel);
  ------------------
  |  Branch (144:25): [True: 114k, False: 3.62k]
  ------------------
  145|   118k|                    if (fresh) CCoinsCacheEntry::SetFresh(*it, sentinel);
  ------------------
  |  Branch (145:25): [True: 112k, False: 5.52k]
  ------------------
  146|   118k|                    usage += it->second.coin.DynamicMemoryUsage();
  147|   118k|                }
  148|  9.08k|                bool expected_code_path = false;
  149|  9.08k|                try {
  150|  9.08k|                    auto cursor{CoinsViewCacheCursor(usage, sentinel, coins_map, /*will_erase=*/true)};
  151|  9.08k|                    coins_view_cache.BatchWrite(cursor, fuzzed_data_provider.ConsumeBool() ? ConsumeUInt256(fuzzed_data_provider) : coins_view_cache.GetBestBlock());
  ------------------
  |  Branch (151:57): [True: 2.20k, False: 6.88k]
  ------------------
  152|  9.08k|                    expected_code_path = true;
  153|  9.08k|                } catch (const std::logic_error& e) {
  154|  1.35k|                    if (e.what() == std::string{"FRESH flag misapplied to coin that exists in parent cache"}) {
  ------------------
  |  Branch (154:25): [True: 1.35k, False: 0]
  ------------------
  155|  1.35k|                        expected_code_path = true;
  156|  1.35k|                    }
  157|  1.35k|                }
  158|  9.08k|                assert(expected_code_path);
  159|  9.08k|            });
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_11clEv:
  214|    672|            [&] {
  215|    672|                const CTransaction transaction{random_mutable_transaction};
  216|    672|                bool is_spent = false;
  217|  1.21M|                for (const CTxOut& tx_out : transaction.vout) {
  ------------------
  |  Branch (217:43): [True: 1.21M, False: 672]
  ------------------
  218|  1.21M|                    if (Coin{tx_out, 0, transaction.IsCoinBase()}.IsSpent()) {
  ------------------
  |  Branch (218:25): [True: 11, False: 1.21M]
  ------------------
  219|     11|                        is_spent = true;
  220|     11|                    }
  221|  1.21M|                }
  222|    672|                if (is_spent) {
  ------------------
  |  Branch (222:21): [True: 5, False: 667]
  ------------------
  223|       |                    // Avoid:
  224|       |                    // coins.cpp:69: void CCoinsViewCache::AddCoin(const COutPoint &, Coin &&, bool): Assertion `!coin.IsSpent()' failed.
  225|      5|                    return;
  226|      5|                }
  227|    667|                bool expected_code_path = false;
  228|    667|                const int height{int(fuzzed_data_provider.ConsumeIntegral<uint32_t>() >> 1)};
  229|    667|                const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
  230|    667|                try {
  231|    667|                    AddCoins(coins_view_cache, transaction, height, possible_overwrite);
  232|    667|                    expected_code_path = true;
  233|    667|                } catch (const std::logic_error& e) {
  234|      0|                    if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
  ------------------
  |  Branch (234:25): [True: 0, False: 0]
  ------------------
  235|      0|                        assert(!possible_overwrite);
  236|      0|                        expected_code_path = true;
  237|      0|                    }
  238|      0|                }
  239|    667|                assert(expected_code_path);
  240|    667|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_12clEv:
  241|  2.80k|            [&] {
  242|  2.80k|                (void)AreInputsStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
  243|  2.80k|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_13clEv:
  244|    600|            [&] {
  245|    600|                TxValidationState state;
  246|    600|                CAmount tx_fee_out;
  247|    600|                const CTransaction transaction{random_mutable_transaction};
  248|    600|                if (ContainsSpentInput(transaction, coins_view_cache)) {
  ------------------
  |  Branch (248:21): [True: 14, False: 586]
  ------------------
  249|       |                    // Avoid:
  250|       |                    // consensus/tx_verify.cpp:171: bool Consensus::CheckTxInputs(const CTransaction &, TxValidationState &, const CCoinsViewCache &, int, CAmount &): Assertion `!coin.IsSpent()' failed.
  251|     14|                    return;
  252|     14|                }
  253|    586|                TxValidationState dummy;
  254|    586|                if (!CheckTransaction(transaction, dummy)) {
  ------------------
  |  Branch (254:21): [True: 196, False: 390]
  ------------------
  255|       |                    // It is not allowed to call CheckTxInputs if CheckTransaction failed
  256|    196|                    return;
  257|    196|                }
  258|    390|                if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out)) {
  ------------------
  |  Branch (258:21): [True: 122, False: 268]
  ------------------
  259|    122|                    assert(MoneyRange(tx_fee_out));
  260|    122|                }
  261|    390|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_14clEv:
  262|     87|            [&] {
  263|     87|                const CTransaction transaction{random_mutable_transaction};
  264|     87|                if (ContainsSpentInput(transaction, coins_view_cache)) {
  ------------------
  |  Branch (264:21): [True: 26, False: 61]
  ------------------
  265|       |                    // Avoid:
  266|       |                    // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
  267|     26|                    return;
  268|     26|                }
  269|     61|                (void)GetP2SHSigOpCount(transaction, coins_view_cache);
  270|     61|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_15clEv:
  271|    507|            [&] {
  272|    507|                const CTransaction transaction{random_mutable_transaction};
  273|    507|                if (ContainsSpentInput(transaction, coins_view_cache)) {
  ------------------
  |  Branch (273:21): [True: 6, False: 501]
  ------------------
  274|       |                    // Avoid:
  275|       |                    // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
  276|      6|                    return;
  277|      6|                }
  278|    501|                const auto flags{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
  279|    501|                if (!transaction.vin.empty() && (flags & SCRIPT_VERIFY_WITNESS) != 0 && (flags & SCRIPT_VERIFY_P2SH) == 0) {
  ------------------
  |  Branch (279:21): [True: 483, False: 18]
  |  Branch (279:49): [True: 339, False: 144]
  |  Branch (279:89): [True: 1, False: 338]
  ------------------
  280|       |                    // Avoid:
  281|       |                    // script/interpreter.cpp:1705: size_t CountWitnessSigOps(const CScript &, const CScript &, const CScriptWitness *, unsigned int): Assertion `(flags & SCRIPT_VERIFY_P2SH) != 0' failed.
  282|      1|                    return;
  283|      1|                }
  284|    500|                (void)GetTransactionSigOpCost(transaction, coins_view_cache, flags);
  285|    500|            },
coins_view.cpp:_ZZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_16clEv:
  286|    258|            [&] {
  287|    258|                (void)IsWitnessStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
  288|    258|            });

LLVMFuzzerTestOneInput:
  222|  8.67k|{
  223|  8.67k|    test_one_input({data, size});
  224|  8.67k|    return 0;
  225|  8.67k|}
fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE:
   83|  8.67k|{
   84|  8.67k|    CheckGlobals check{};
   85|  8.67k|    (*Assert(g_test_one_input))(buffer);
  ------------------
  |  |   85|  8.67k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   86|  8.67k|}

_Z18ContainsSpentInputRK12CTransactionRK15CCoinsViewCache:
  241|  1.19k|{
  242|  6.91k|    for (const CTxIn& tx_in : tx.vin) {
  ------------------
  |  Branch (242:29): [True: 6.91k, False: 1.14k]
  ------------------
  243|  6.91k|        const Coin& coin = inputs.AccessCoin(tx_in.prevout);
  244|  6.91k|        if (coin.IsSpent()) {
  ------------------
  |  Branch (244:13): [True: 46, False: 6.87k]
  ------------------
  245|     46|            return true;
  246|     46|        }
  247|  6.91k|    }
  248|  1.14k|    return false;
  249|  1.19k|}

_Z14ConsumeUInt256R18FuzzedDataProvider:
  172|  8.93k|{
  173|  8.93k|    const std::vector<uint8_t> v256 = fuzzed_data_provider.ConsumeBytes<uint8_t>(256 / 8);
  174|  8.93k|    if (v256.size() != 256 / 8) {
  ------------------
  |  Branch (174:9): [True: 71, False: 8.86k]
  ------------------
  175|     71|        return {};
  176|     71|    }
  177|  8.86k|    return uint256{v256};
  178|  8.93k|}
_Z29ConsumeRandomLengthByteVectorIhENSt3__16vectorIT_NS0_9allocatorIS2_EEEER18FuzzedDataProviderRKNS0_8optionalImEE:
   58|  29.3k|{
   59|  29.3k|    static_assert(sizeof(B) == 1);
   60|  29.3k|    const std::string s = max_length ?
  ------------------
  |  Branch (60:27): [True: 0, False: 29.3k]
  ------------------
   61|      0|                              fuzzed_data_provider.ConsumeRandomLengthString(*max_length) :
   62|  29.3k|                              fuzzed_data_provider.ConsumeRandomLengthString();
   63|  29.3k|    std::vector<B> ret(s.size());
   64|  29.3k|    std::copy(s.begin(), s.end(), reinterpret_cast<char*>(ret.data()));
   65|  29.3k|    return ret;
   66|  29.3k|}
_Z21ConsumeDeserializableI9COutPointENSt3__18optionalIT_EER18FuzzedDataProviderRKNS2_ImEE:
  120|  1.93k|{
  121|  1.93k|    const std::vector<uint8_t> buffer = ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length);
  122|  1.93k|    DataStream ds{buffer};
  123|  1.93k|    T obj;
  124|  1.93k|    try {
  125|  1.93k|        ds >> obj;
  126|  1.93k|    } catch (const std::ios_base::failure&) {
  127|     36|        return std::nullopt;
  128|     36|    }
  129|  1.89k|    return obj;
  130|  1.93k|}
_Z21ConsumeDeserializableI19CMutableTransaction20TransactionSerParamsENSt3__18optionalIT_EER18FuzzedDataProviderRKT0_RKNS3_ImEE:
  106|  11.8k|{
  107|  11.8k|    const std::vector<uint8_t> buffer{ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length)};
  108|  11.8k|    DataStream ds{buffer};
  109|  11.8k|    T obj;
  110|  11.8k|    try {
  111|  11.8k|        ds >> params(obj);
  112|  11.8k|    } catch (const std::ios_base::failure&) {
  113|    728|        return std::nullopt;
  114|    728|    }
  115|  11.0k|    return obj;
  116|  11.8k|}
coins_view.cpp:_Z9CallOneOfIJZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEE3$_0Z22coins_view_fuzz_targetS3_E3$_1Z22coins_view_fuzz_targetS3_E3$_2Z22coins_view_fuzz_targetS3_E3$_3Z22coins_view_fuzz_targetS3_E3$_4Z22coins_view_fuzz_targetS3_E3$_5Z22coins_view_fuzz_targetS3_E3$_6Z22coins_view_fuzz_targetS3_E3$_7Z22coins_view_fuzz_targetS3_E3$_8Z22coins_view_fuzz_targetS3_E3$_9Z22coins_view_fuzz_targetS3_E4$_10EEmR18FuzzedDataProviderDpT_:
   36|   148k|{
   37|   148k|    constexpr size_t call_size{sizeof...(callables)};
   38|   148k|    static_assert(call_size >= 1);
   39|   148k|    const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
   40|       |
   41|   148k|    size_t i{0};
   42|  1.63M|    ((i++ == call_index ? callables() : void()), ...);
  ------------------
  |  Branch (42:7): [True: 45.6k, False: 102k]
  |  Branch (42:7): [True: 5.14k, False: 143k]
  |  Branch (42:7): [True: 26.3k, False: 122k]
  |  Branch (42:7): [True: 6.72k, False: 141k]
  |  Branch (42:7): [True: 12.8k, False: 135k]
  |  Branch (42:7): [True: 5.59k, False: 142k]
  |  Branch (42:7): [True: 9.30k, False: 139k]
  |  Branch (42:7): [True: 1.93k, False: 146k]
  |  Branch (42:7): [True: 13.8k, False: 134k]
  |  Branch (42:7): [True: 11.8k, False: 136k]
  |  Branch (42:7): [True: 9.14k, False: 139k]
  ------------------
   43|   148k|    return call_size;
   44|   148k|}
_Z21ConsumeDeserializableI4CoinENSt3__18optionalIT_EER18FuzzedDataProviderRKNS2_ImEE:
  120|  15.6k|{
  121|  15.6k|    const std::vector<uint8_t> buffer = ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length);
  122|  15.6k|    DataStream ds{buffer};
  123|  15.6k|    T obj;
  124|  15.6k|    try {
  125|  15.6k|        ds >> obj;
  126|  15.6k|    } catch (const std::ios_base::failure&) {
  127|    757|        return std::nullopt;
  128|    757|    }
  129|  14.8k|    return obj;
  130|  15.6k|}
coins_view.cpp:_Z9CallOneOfIJZ22coins_view_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEE4$_11Z22coins_view_fuzz_targetS3_E4$_12Z22coins_view_fuzz_targetS3_E4$_13Z22coins_view_fuzz_targetS3_E4$_14Z22coins_view_fuzz_targetS3_E4$_15Z22coins_view_fuzz_targetS3_E4$_16EEmR18FuzzedDataProviderDpT_:
   36|  4.93k|{
   37|  4.93k|    constexpr size_t call_size{sizeof...(callables)};
   38|  4.93k|    static_assert(call_size >= 1);
   39|  4.93k|    const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
   40|       |
   41|  4.93k|    size_t i{0};
   42|  29.5k|    ((i++ == call_index ? callables() : void()), ...);
  ------------------
  |  Branch (42:7): [True: 672, False: 4.25k]
  |  Branch (42:7): [True: 2.80k, False: 2.12k]
  |  Branch (42:7): [True: 600, False: 4.33k]
  |  Branch (42:7): [True: 87, False: 4.84k]
  |  Branch (42:7): [True: 507, False: 4.42k]
  |  Branch (42:7): [True: 258, False: 4.67k]
  ------------------
   43|  4.93k|    return call_size;
   44|  4.93k|}

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

_ZN17BasicTestingSetupD2Ev:
  199|      2|{
  200|      2|    m_node.ecc_context.reset();
  201|      2|    m_node.kernel.reset();
  202|       |    if constexpr (!G_FUZZING) {
  203|       |        SetMockTime(0s); // Reset mocktime for following tests
  204|       |    }
  205|      2|    LogInstance().DisconnectTestLogger();
  206|      2|    if (m_has_custom_datadir) {
  ------------------
  |  Branch (206:9): [True: 0, False: 2]
  ------------------
  207|       |        // Only remove the lock file, preserve the data directory.
  208|      0|        UnlockDirectory(m_path_lock, ".lock");
  209|      0|        fs::remove(m_path_lock / ".lock");
  210|      2|    } else {
  211|      2|        fs::remove_all(m_path_root);
  212|      2|    }
  213|      2|    gArgs.ClearArgs();
  214|      2|}

_ZN12StdLockGuardC2ER8StdMutex:
   73|      2|    explicit StdLockGuard(StdMutex& cs) EXCLUSIVE_LOCK_FUNCTION(cs) : std::lock_guard<StdMutex>(cs) {}

_ZNK10tinyformat6detail9FormatArg6formatERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_i:
  541|    980|        {
  542|    980|            TINYFORMAT_ASSERT(m_value);
  ------------------
  |  |  153|    980|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  543|    980|            TINYFORMAT_ASSERT(m_formatImpl);
  ------------------
  |  |  153|    980|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  544|    980|            m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
  545|    980|        }
_ZN10tinyformat10FormatListC2EPNS_6detail9FormatArgEi:
  966|    518|            : m_args(args), m_N(N) { }
_ZN10tinyformat6detail18parseIntAndAdvanceERPKc:
  578|    308|{
  579|    308|    int i = 0;
  580|    924|    for (;*c >= '0' && *c <= '9'; ++c)
  ------------------
  |  Branch (580:11): [True: 924, False: 0]
  |  Branch (580:24): [True: 616, False: 308]
  ------------------
  581|    616|        i = 10*i + (*c - '0');
  582|    308|    return i;
  583|    308|}
_ZN10tinyformat6detail21parseWidthOrPrecisionERiRPKcbPKNS0_9FormatArgES1_i:
  593|    672|{
  594|    672|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (594:9): [True: 672, False: 0]
  |  Branch (594:22): [True: 0, False: 672]
  ------------------
  595|      0|        n = parseIntAndAdvance(c);
  596|      0|    }
  597|    672|    else if (*c == '*') {
  ------------------
  |  Branch (597:14): [True: 0, False: 672]
  ------------------
  598|      0|        ++c;
  599|      0|        n = 0;
  600|      0|        if (positionalMode) {
  ------------------
  |  Branch (600:13): [True: 0, False: 0]
  ------------------
  601|      0|            int pos = parseIntAndAdvance(c) - 1;
  602|      0|            if (*c != '$')
  ------------------
  |  Branch (602:17): [True: 0, False: 0]
  ------------------
  603|      0|                TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  604|      0|            if (pos >= 0 && pos < numArgs)
  ------------------
  |  Branch (604:17): [True: 0, False: 0]
  |  Branch (604:29): [True: 0, False: 0]
  ------------------
  605|      0|                n = args[pos].toInt();
  606|      0|            else
  607|      0|                TINYFORMAT_ERROR("tinyformat: Positional argument out of range");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  608|      0|            ++c;
  609|      0|        }
  610|      0|        else {
  611|      0|            if (argIndex < numArgs)
  ------------------
  |  Branch (611:17): [True: 0, False: 0]
  ------------------
  612|      0|                n = args[argIndex++].toInt();
  613|      0|            else
  614|      0|                TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width or precision");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  615|      0|        }
  616|      0|    }
  617|    672|    else {
  618|    672|        return false;
  619|    672|    }
  620|      0|    return true;
  621|    672|}
_ZN10tinyformat6detail24printFormatStringLiteralERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKc:
  629|  1.49k|{
  630|  1.49k|    const char* c = fmt;
  631|  7.65k|    for (;; ++c) {
  632|  7.65k|        if (*c == '\0') {
  ------------------
  |  Branch (632:13): [True: 518, False: 7.14k]
  ------------------
  633|    518|            out.write(fmt, c - fmt);
  634|    518|            return c;
  635|    518|        }
  636|  7.14k|        else if (*c == '%') {
  ------------------
  |  Branch (636:18): [True: 980, False: 6.16k]
  ------------------
  637|    980|            out.write(fmt, c - fmt);
  638|    980|            if (*(c+1) != '%')
  ------------------
  |  Branch (638:17): [True: 980, False: 0]
  ------------------
  639|    980|                return c;
  640|       |            // for "%%", tack trailing % onto next literal section.
  641|      0|            fmt = ++c;
  642|      0|        }
  643|  7.65k|    }
  644|  1.49k|}
_ZN10tinyformat6detail21streamStateFromFormatERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERbS7_RiPKcPKNS0_9FormatArgES8_i:
  685|    980|{
  686|    980|    TINYFORMAT_ASSERT(*fmtStart == '%');
  ------------------
  |  |  153|    980|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  687|       |    // Reset stream state to defaults.
  688|    980|    out.width(0);
  689|    980|    out.precision(6);
  690|    980|    out.fill(' ');
  691|       |    // Reset most flags; ignore irrelevant unitbuf & skipws.
  692|    980|    out.unsetf(std::ios::adjustfield | std::ios::basefield |
  693|    980|               std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
  694|    980|               std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
  695|    980|    bool precisionSet = false;
  696|    980|    bool widthSet = false;
  697|    980|    int widthExtra = 0;
  698|    980|    const char* c = fmtStart + 1;
  699|       |
  700|       |    // 1) Parse an argument index (if followed by '$') or a width possibly
  701|       |    // preceded with '0' flag.
  702|    980|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (702:9): [True: 980, False: 0]
  |  Branch (702:22): [True: 308, False: 672]
  ------------------
  703|    308|        const char tmpc = *c;
  704|    308|        int value = parseIntAndAdvance(c);
  705|    308|        if (*c == '$') {
  ------------------
  |  Branch (705:13): [True: 0, False: 308]
  ------------------
  706|       |            // value is an argument index
  707|      0|            if (value > 0 && value <= numArgs)
  ------------------
  |  Branch (707:17): [True: 0, False: 0]
  |  Branch (707:30): [True: 0, False: 0]
  ------------------
  708|      0|                argIndex = value - 1;
  709|      0|            else
  710|      0|                TINYFORMAT_ERROR("tinyformat: Positional argument out of range");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  711|      0|            ++c;
  712|      0|            positionalMode = true;
  713|      0|        }
  714|    308|        else if (positionalMode) {
  ------------------
  |  Branch (714:18): [True: 0, False: 308]
  ------------------
  715|      0|            TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  716|      0|        }
  717|    308|        else {
  718|    308|            if (tmpc == '0') {
  ------------------
  |  Branch (718:17): [True: 308, False: 0]
  ------------------
  719|       |                // Use internal padding so that numeric values are
  720|       |                // formatted correctly, eg -00010 rather than 000-10
  721|    308|                out.fill('0');
  722|    308|                out.setf(std::ios::internal, std::ios::adjustfield);
  723|    308|            }
  724|    308|            if (value != 0) {
  ------------------
  |  Branch (724:17): [True: 308, False: 0]
  ------------------
  725|       |                // Nonzero value means that we parsed width.
  726|    308|                widthSet = true;
  727|    308|                out.width(value);
  728|    308|            }
  729|    308|        }
  730|    308|    }
  731|    672|    else if (positionalMode) {
  ------------------
  |  Branch (731:14): [True: 0, False: 672]
  ------------------
  732|      0|        TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  733|      0|    }
  734|       |    // 2) Parse flags and width if we did not do it in previous step.
  735|    980|    if (!widthSet) {
  ------------------
  |  Branch (735:9): [True: 672, False: 308]
  ------------------
  736|       |        // Parse flags
  737|    672|        for (;; ++c) {
  738|    672|            switch (*c) {
  739|      0|                case '#':
  ------------------
  |  Branch (739:17): [True: 0, False: 672]
  ------------------
  740|      0|                    out.setf(std::ios::showpoint | std::ios::showbase);
  741|      0|                    continue;
  742|      0|                case '0':
  ------------------
  |  Branch (742:17): [True: 0, False: 672]
  ------------------
  743|       |                    // overridden by left alignment ('-' flag)
  744|      0|                    if (!(out.flags() & std::ios::left)) {
  ------------------
  |  Branch (744:25): [True: 0, False: 0]
  ------------------
  745|       |                        // Use internal padding so that numeric values are
  746|       |                        // formatted correctly, eg -00010 rather than 000-10
  747|      0|                        out.fill('0');
  748|      0|                        out.setf(std::ios::internal, std::ios::adjustfield);
  749|      0|                    }
  750|      0|                    continue;
  751|      0|                case '-':
  ------------------
  |  Branch (751:17): [True: 0, False: 672]
  ------------------
  752|      0|                    out.fill(' ');
  753|      0|                    out.setf(std::ios::left, std::ios::adjustfield);
  754|      0|                    continue;
  755|      0|                case ' ':
  ------------------
  |  Branch (755:17): [True: 0, False: 672]
  ------------------
  756|       |                    // overridden by show positive sign, '+' flag.
  757|      0|                    if (!(out.flags() & std::ios::showpos))
  ------------------
  |  Branch (757:25): [True: 0, False: 0]
  ------------------
  758|      0|                        spacePadPositive = true;
  759|      0|                    continue;
  760|      0|                case '+':
  ------------------
  |  Branch (760:17): [True: 0, False: 672]
  ------------------
  761|      0|                    out.setf(std::ios::showpos);
  762|      0|                    spacePadPositive = false;
  763|      0|                    widthExtra = 1;
  764|      0|                    continue;
  765|    672|                default:
  ------------------
  |  Branch (765:17): [True: 672, False: 0]
  ------------------
  766|    672|                    break;
  767|    672|            }
  768|    672|            break;
  769|    672|        }
  770|       |        // Parse width
  771|    672|        int width = 0;
  772|    672|        widthSet = parseWidthOrPrecision(width, c, positionalMode,
  773|    672|                                         args, argIndex, numArgs);
  774|    672|        if (widthSet) {
  ------------------
  |  Branch (774:13): [True: 0, False: 672]
  ------------------
  775|      0|            if (width < 0) {
  ------------------
  |  Branch (775:17): [True: 0, False: 0]
  ------------------
  776|       |                // negative widths correspond to '-' flag set
  777|      0|                out.fill(' ');
  778|      0|                out.setf(std::ios::left, std::ios::adjustfield);
  779|      0|                width = -width;
  780|      0|            }
  781|      0|            out.width(width);
  782|      0|        }
  783|    672|    }
  784|       |    // 3) Parse precision
  785|    980|    if (*c == '.') {
  ------------------
  |  Branch (785:9): [True: 0, False: 980]
  ------------------
  786|      0|        ++c;
  787|      0|        int precision = 0;
  788|      0|        parseWidthOrPrecision(precision, c, positionalMode,
  789|      0|                              args, argIndex, numArgs);
  790|       |        // Presence of `.` indicates precision set, unless the inferred value
  791|       |        // was negative in which case the default is used.
  792|      0|        precisionSet = precision >= 0;
  793|      0|        if (precisionSet)
  ------------------
  |  Branch (793:13): [True: 0, False: 0]
  ------------------
  794|      0|            out.precision(precision);
  795|      0|    }
  796|       |    // 4) Ignore any C99 length modifier
  797|    980|    while (*c == 'l' || *c == 'h' || *c == 'L' ||
  ------------------
  |  Branch (797:12): [True: 0, False: 980]
  |  Branch (797:25): [True: 0, False: 980]
  |  Branch (797:38): [True: 0, False: 980]
  ------------------
  798|    980|           *c == 'j' || *c == 'z' || *c == 't') {
  ------------------
  |  Branch (798:12): [True: 0, False: 980]
  |  Branch (798:25): [True: 0, False: 980]
  |  Branch (798:38): [True: 0, False: 980]
  ------------------
  799|      0|        ++c;
  800|      0|    }
  801|       |    // 5) We're up to the conversion specifier character.
  802|       |    // Set stream flags based on conversion specifier (thanks to the
  803|       |    // boost::format class for forging the way here).
  804|    980|    bool intConversion = false;
  805|    980|    switch (*c) {
  806|    672|        case 'u': case 'd': case 'i':
  ------------------
  |  Branch (806:9): [True: 0, False: 980]
  |  Branch (806:19): [True: 672, False: 308]
  |  Branch (806:29): [True: 0, False: 980]
  ------------------
  807|    672|            out.setf(std::ios::dec, std::ios::basefield);
  808|    672|            intConversion = true;
  809|    672|            break;
  810|      0|        case 'o':
  ------------------
  |  Branch (810:9): [True: 0, False: 980]
  ------------------
  811|      0|            out.setf(std::ios::oct, std::ios::basefield);
  812|      0|            intConversion = true;
  813|      0|            break;
  814|      0|        case 'X':
  ------------------
  |  Branch (814:9): [True: 0, False: 980]
  ------------------
  815|      0|            out.setf(std::ios::uppercase);
  816|      0|            [[fallthrough]];
  817|      0|        case 'x': case 'p':
  ------------------
  |  Branch (817:9): [True: 0, False: 980]
  |  Branch (817:19): [True: 0, False: 980]
  ------------------
  818|      0|            out.setf(std::ios::hex, std::ios::basefield);
  819|      0|            intConversion = true;
  820|      0|            break;
  821|      0|        case 'E':
  ------------------
  |  Branch (821:9): [True: 0, False: 980]
  ------------------
  822|      0|            out.setf(std::ios::uppercase);
  823|      0|            [[fallthrough]];
  824|      0|        case 'e':
  ------------------
  |  Branch (824:9): [True: 0, False: 980]
  ------------------
  825|      0|            out.setf(std::ios::scientific, std::ios::floatfield);
  826|      0|            out.setf(std::ios::dec, std::ios::basefield);
  827|      0|            break;
  828|      0|        case 'F':
  ------------------
  |  Branch (828:9): [True: 0, False: 980]
  ------------------
  829|      0|            out.setf(std::ios::uppercase);
  830|      0|            [[fallthrough]];
  831|      0|        case 'f':
  ------------------
  |  Branch (831:9): [True: 0, False: 980]
  ------------------
  832|      0|            out.setf(std::ios::fixed, std::ios::floatfield);
  833|      0|            break;
  834|      0|        case 'A':
  ------------------
  |  Branch (834:9): [True: 0, False: 980]
  ------------------
  835|      0|            out.setf(std::ios::uppercase);
  836|      0|            [[fallthrough]];
  837|      0|        case 'a':
  ------------------
  |  Branch (837:9): [True: 0, False: 980]
  ------------------
  838|       |#           ifdef _MSC_VER
  839|       |            // Workaround https://developercommunity.visualstudio.com/content/problem/520472/hexfloat-stream-output-does-not-ignore-precision-a.html
  840|       |            // by always setting maximum precision on MSVC to avoid precision
  841|       |            // loss for doubles.
  842|       |            out.precision(13);
  843|       |#           endif
  844|      0|            out.setf(std::ios::fixed | std::ios::scientific, std::ios::floatfield);
  845|      0|            break;
  846|      0|        case 'G':
  ------------------
  |  Branch (846:9): [True: 0, False: 980]
  ------------------
  847|      0|            out.setf(std::ios::uppercase);
  848|      0|            [[fallthrough]];
  849|      0|        case 'g':
  ------------------
  |  Branch (849:9): [True: 0, False: 980]
  ------------------
  850|      0|            out.setf(std::ios::dec, std::ios::basefield);
  851|       |            // As in boost::format, let stream decide float format.
  852|      0|            out.flags(out.flags() & ~std::ios::floatfield);
  853|      0|            break;
  854|      0|        case 'c':
  ------------------
  |  Branch (854:9): [True: 0, False: 980]
  ------------------
  855|       |            // Handled as special case inside formatValue()
  856|      0|            break;
  857|    308|        case 's':
  ------------------
  |  Branch (857:9): [True: 308, False: 672]
  ------------------
  858|    308|            if (precisionSet)
  ------------------
  |  Branch (858:17): [True: 0, False: 308]
  ------------------
  859|      0|                ntrunc = static_cast<int>(out.precision());
  860|       |            // Make %s print Booleans as "true" and "false"
  861|    308|            out.setf(std::ios::boolalpha);
  862|    308|            break;
  863|      0|        case 'n':
  ------------------
  |  Branch (863:9): [True: 0, False: 980]
  ------------------
  864|       |            // Not supported - will cause problems!
  865|      0|            TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  866|      0|            break;
  867|      0|        case '\0':
  ------------------
  |  Branch (867:9): [True: 0, False: 980]
  ------------------
  868|      0|            TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly "
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  869|      0|                             "terminated by end of string");
  870|      0|            return c;
  871|      0|        default:
  ------------------
  |  Branch (871:9): [True: 0, False: 980]
  ------------------
  872|      0|            break;
  873|    980|    }
  874|    980|    if (intConversion && precisionSet && !widthSet) {
  ------------------
  |  Branch (874:9): [True: 672, False: 308]
  |  Branch (874:26): [True: 0, False: 672]
  |  Branch (874:42): [True: 0, False: 0]
  ------------------
  875|       |        // "precision" for integers gives the minimum number of digits (to be
  876|       |        // padded with zeros on the left).  This isn't really supported by the
  877|       |        // iostreams, but we can approximately simulate it with the width if
  878|       |        // the width isn't otherwise used.
  879|      0|        out.width(out.precision() + widthExtra);
  880|      0|        out.setf(std::ios::internal, std::ios::adjustfield);
  881|      0|        out.fill('0');
  882|      0|    }
  883|    980|    return c+1;
  884|    980|}
_ZN10tinyformat6detail10formatImplERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcPKNS0_9FormatArgEi:
  891|    518|{
  892|       |    // Saved stream state
  893|    518|    std::streamsize origWidth = out.width();
  894|    518|    std::streamsize origPrecision = out.precision();
  895|    518|    std::ios::fmtflags origFlags = out.flags();
  896|    518|    char origFill = out.fill();
  897|       |
  898|       |    // "Positional mode" means all format specs should be of the form "%n$..."
  899|       |    // with `n` an integer. We detect this in `streamStateFromFormat`.
  900|    518|    bool positionalMode = false;
  901|    518|    int argIndex = 0;
  902|  1.49k|    while (true) {
  ------------------
  |  Branch (902:12): [Folded - Ignored]
  ------------------
  903|  1.49k|        fmt = printFormatStringLiteral(out, fmt);
  904|  1.49k|        if (*fmt == '\0') {
  ------------------
  |  Branch (904:13): [True: 518, False: 980]
  ------------------
  905|    518|            if (!positionalMode && argIndex < numArgs) {
  ------------------
  |  Branch (905:17): [True: 518, False: 0]
  |  Branch (905:36): [True: 0, False: 518]
  ------------------
  906|      0|                TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  907|      0|            }
  908|    518|            break;
  909|    518|        }
  910|    980|        bool spacePadPositive = false;
  911|    980|        int ntrunc = -1;
  912|    980|        const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt,
  913|    980|                                                   args, argIndex, numArgs);
  914|       |        // NB: argIndex may be incremented by reading variable width/precision
  915|       |        // in `streamStateFromFormat`, so do the bounds check here.
  916|    980|        if (argIndex >= numArgs) {
  ------------------
  |  Branch (916:13): [True: 0, False: 980]
  ------------------
  917|      0|            TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string");
  ------------------
  |  |  135|      0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString)
  ------------------
  918|      0|            return;
  919|      0|        }
  920|    980|        const FormatArg& arg = args[argIndex];
  921|       |        // Format the arg into the stream.
  922|    980|        if (!spacePadPositive) {
  ------------------
  |  Branch (922:13): [True: 980, False: 0]
  ------------------
  923|    980|            arg.format(out, fmt, fmtEnd, ntrunc);
  924|    980|        }
  925|      0|        else {
  926|       |            // The following is a special case with no direct correspondence
  927|       |            // between stream formatting and the printf() behaviour.  Simulate
  928|       |            // it crudely by formatting into a temporary string stream and
  929|       |            // munging the resulting string.
  930|      0|            std::ostringstream tmpStream;
  931|      0|            tmpStream.copyfmt(out);
  932|      0|            tmpStream.setf(std::ios::showpos);
  933|      0|            arg.format(tmpStream, fmt, fmtEnd, ntrunc);
  934|      0|            std::string result = tmpStream.str(); // allocates... yuck.
  935|      0|            for (size_t i = 0, iend = result.size(); i < iend; ++i) {
  ------------------
  |  Branch (935:54): [True: 0, False: 0]
  ------------------
  936|      0|                if (result[i] == '+')
  ------------------
  |  Branch (936:21): [True: 0, False: 0]
  ------------------
  937|      0|                    result[i] = ' ';
  938|      0|            }
  939|      0|            out << result;
  940|      0|        }
  941|    980|        if (!positionalMode)
  ------------------
  |  Branch (941:13): [True: 980, False: 0]
  ------------------
  942|    980|            ++argIndex;
  943|    980|        fmt = fmtEnd;
  944|    980|    }
  945|       |
  946|       |    // Restore stream state
  947|    518|    out.width(origWidth);
  948|    518|    out.precision(origPrecision);
  949|    518|    out.flags(origFlags);
  950|    518|    out.fill(origFill);
  951|    518|}
_ZN10tinyformat7vformatERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcRKNS_10FormatListE:
 1070|    518|{
 1071|    518|    detail::formatImpl(out, fmt, list.m_args, list.m_N);
 1072|    518|}
_ZN10tinyformat6formatIJiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|     56|{
 1089|     56|    std::ostringstream oss;
 1090|     56|    format(oss, fmt, args...);
 1091|     56|    return oss.str();
 1092|     56|}
_ZN10tinyformat6formatIJiEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|     56|{
 1081|     56|    vformat(out, fmt, makeFormatList(args...));
 1082|     56|}
_ZN10tinyformat17FormatStringCheckILj1EEcvPKcEv:
  197|     56|    operator const char*() { return fmt; }
_ZN10tinyformat14makeFormatListIJiEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|     56|{
 1045|     56|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|     56|}
_ZN10tinyformat6detail11FormatListNILi1EEC2IJiEEEDpRKT_:
  990|     56|            : FormatList(&m_formatterStore[0], N),
  991|     56|            m_formatterStore { FormatArg(args)... }
  992|     56|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2IiEERKT_:
  534|     56|            : m_value(static_cast<const void*>(&value)),
  535|     56|            m_formatImpl(&formatImpl<T>),
  536|     56|            m_toIntImpl(&toIntImpl<T>)
  537|     56|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIiEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|     56|        {
  559|     56|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|     56|        }
_ZN10tinyformat11formatValueIiEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|     56|{
  352|     56|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
  353|       |    // Since we don't support printing of wchar_t using "%ls", make it fail at
  354|       |    // compile time in preference to printing as a void* at runtime.
  355|     56|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|     56|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|     56|#endif
  358|       |    // The mess here is to support the %c and %p conversions: if these
  359|       |    // conversions are active we try to convert the type to a char or const
  360|       |    // void* respectively and format that instead of the value itself.  For the
  361|       |    // %p conversion it's important to avoid dereferencing the pointer, which
  362|       |    // could otherwise lead to a crash when printing a dangling (const char*).
  363|     56|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|     56|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|     56|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 56]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|     56|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|     56|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 56]
  ------------------
  373|       |        // Take care not to overread C strings in truncating conversions like
  374|       |        // "%.4s" where at most 4 characters may be read.
  375|      0|        detail::formatTruncated(out, value, ntrunc);
  376|      0|    }
  377|     56|    else
  378|     56|        out << value;
  379|     56|}
_ZN10tinyformat17FormatStringCheckILj2EEcvPKcEv:
  197|    462|    operator const char*() { return fmt; }
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    154|{
 1089|    154|    std::ostringstream oss;
 1090|    154|    format(oss, fmt, args...);
 1091|    154|    return oss.str();
 1092|    154|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    154|{
 1081|    154|    vformat(out, fmt, makeFormatList(args...));
 1082|    154|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    154|{
 1045|    154|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    154|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEESA_EEEDpRKT_:
  990|    154|            : FormatList(&m_formatterStore[0], N),
  991|    154|            m_formatterStore { FormatArg(args)... }
  992|    154|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_:
  534|    308|            : m_value(static_cast<const void*>(&value)),
  535|    308|            m_formatImpl(&formatImpl<T>),
  536|    308|            m_toIntImpl(&toIntImpl<T>)
  537|    308|        { }
_ZN10tinyformat6detail9FormatArg10formatImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRNS3_13basic_ostreamIcS6_EEPKcSE_iPKv:
  558|    308|        {
  559|    308|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|    308|        }
_ZN10tinyformat11formatValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRNS1_13basic_ostreamIcS4_EEPKcSC_iRKT_:
  351|    308|{
  352|    308|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
  353|       |    // Since we don't support printing of wchar_t using "%ls", make it fail at
  354|       |    // compile time in preference to printing as a void* at runtime.
  355|    308|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|    308|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|    308|#endif
  358|       |    // The mess here is to support the %c and %p conversions: if these
  359|       |    // conversions are active we try to convert the type to a char or const
  360|       |    // void* respectively and format that instead of the value itself.  For the
  361|       |    // %p conversion it's important to avoid dereferencing the pointer, which
  362|       |    // could otherwise lead to a crash when printing a dangling (const char*).
  363|    308|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|    308|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|    308|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|    308|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|    308|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 308]
  ------------------
  373|       |        // Take care not to overread C strings in truncating conversions like
  374|       |        // "%.4s" where at most 4 characters may be read.
  375|      0|        detail::formatTruncated(out, value, ntrunc);
  376|      0|    }
  377|    308|    else
  378|    308|        out << value;
  379|    308|}
_ZN10tinyformat6detail9FormatArgC2IlEERKT_:
  534|    616|            : m_value(static_cast<const void*>(&value)),
  535|    616|            m_formatImpl(&formatImpl<T>),
  536|    616|            m_toIntImpl(&toIntImpl<T>)
  537|    616|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIlEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|    616|        {
  559|    616|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|    616|        }
_ZN10tinyformat11formatValueIlEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|    616|{
  352|    616|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
  353|       |    // Since we don't support printing of wchar_t using "%ls", make it fail at
  354|       |    // compile time in preference to printing as a void* at runtime.
  355|    616|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|    616|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|    616|#endif
  358|       |    // The mess here is to support the %c and %p conversions: if these
  359|       |    // conversions are active we try to convert the type to a char or const
  360|       |    // void* respectively and format that instead of the value itself.  For the
  361|       |    // %p conversion it's important to avoid dereferencing the pointer, which
  362|       |    // could otherwise lead to a crash when printing a dangling (const char*).
  363|    616|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|    616|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|    616|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 616]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|    616|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|    616|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 616]
  ------------------
  373|       |        // Take care not to overread C strings in truncating conversions like
  374|       |        // "%.4s" where at most 4 characters may be read.
  375|      0|        detail::formatTruncated(out, value, ntrunc);
  376|      0|    }
  377|    616|    else
  378|    616|        out << value;
  379|    616|}
_ZN10tinyformat6formatIJllEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    308|{
 1089|    308|    std::ostringstream oss;
 1090|    308|    format(oss, fmt, args...);
 1091|    308|    return oss.str();
 1092|    308|}
_ZN10tinyformat6formatIJllEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    308|{
 1081|    308|    vformat(out, fmt, makeFormatList(args...));
 1082|    308|}
_ZN10tinyformat14makeFormatListIJllEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    308|{
 1045|    308|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    308|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJllEEEDpRKT_:
  990|    308|            : FormatList(&m_formatterStore[0], N),
  991|    308|            m_formatterStore { FormatArg(args)... }
  992|    308|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }

_ZN7uint256C2E4SpanIKhE:
  208|  8.86k|    constexpr explicit uint256(Span<const unsigned char> vch) : base_blob<256>(vch) {}
_ZN9base_blobILj256EE5beginEv:
  115|  43.4k|    constexpr unsigned char* begin() { return m_data.data(); }
_ZNK9base_blobILj256EE6IsNullEv:
   49|   834k|    {
   50|   834k|        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
   51|   834k|            return val == 0;
   52|   834k|        });
   53|   834k|    }
_ZNK9base_blobILj256EE7CompareERKS0_:
   64|   207k|    constexpr int Compare(const base_blob& other) const { return std::memcmp(m_data.data(), other.m_data.data(), WIDTH); }
_ZN7uint256C2Ev:
  205|   187k|    constexpr uint256() = default;
_ZN9base_blobILj256EEC2Ev:
   35|   187k|    constexpr base_blob() : m_data() {}
_ZN9base_blobILj256EEC2E4SpanIKhE:
   41|  8.86k|    {
   42|  8.86k|        assert(vch.size() == WIDTH);
   43|  8.86k|        std::copy(vch.begin(), vch.end(), m_data.begin());
   44|  8.86k|    }
_ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
  127|    963|    {
  128|    963|        s << Span(m_data);
  129|    963|    }
_ZN9base_blobILj256EE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
  133|   111k|    {
  134|   111k|        s.read(MakeWritableByteSpan(m_data));
  135|   111k|    }
_ZN9base_blobILj256EE11UnserializeI10DataStreamEEvRT_:
  133|  1.93k|    {
  134|  1.93k|        s.read(MakeWritableByteSpan(m_data));
  135|  1.93k|    }
_ZZNK9base_blobILj256EE6IsNullEvENKUlhE_clEh:
   50|  6.80M|        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
   51|  6.80M|            return val == 0;
   52|  6.80M|        });
_ZNK9base_blobILj256EE9GetUint64Ei:
  123|  14.7M|    constexpr uint64_t GetUint64(int pos) const { return ReadLE64(m_data.data() + pos * 8); }
_ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
  127|   120k|    {
  128|   120k|        s << Span(m_data);
  129|   120k|    }

_Z22inline_assertion_checkILb0EbEOT0_S1_PKciS3_S3_:
   52|  3.93M|{
   53|  3.93M|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  3.93M|    ) {
   58|  3.93M|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 3.93M]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  3.93M|    }
   62|  3.93M|    return std::forward<T>(val);
   63|  3.93M|}
_Z22inline_assertion_checkILb0EiEOT0_S1_PKciS3_S3_:
   52|  2.68M|{
   53|  2.68M|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  2.68M|    ) {
   58|  2.68M|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 2.68M]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  2.68M|    }
   62|  2.68M|    return std::forward<T>(val);
   63|  2.68M|}
_Z22inline_assertion_checkILb0ERKhEOT0_S3_PKciS5_S5_:
   52|  14.5k|{
   53|  14.5k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  14.5k|    ) {
   58|  14.5k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 14.5k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  14.5k|    }
   62|  14.5k|    return std::forward<T>(val);
   63|  14.5k|}
_Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_:
   52|  8.67k|{
   53|  8.67k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  8.67k|    ) {
   58|  8.67k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 8.67k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  8.67k|    }
   62|  8.67k|    return std::forward<T>(val);
   63|  8.67k|}
_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_:
   52|  8.67k|{
   53|  8.67k|    if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING
  ------------------
  |  Branch (53:9): [Folded - Ignored]
  |  Branch (53:22): [Folded - Ignored]
  |  Branch (53:54): [Folded - Ignored]
  ------------------
   54|       |#ifdef ABORT_ON_FAILED_ASSUME
   55|       |        || true
   56|       |#endif
   57|  8.67k|    ) {
   58|  8.67k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 8.67k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  8.67k|    }
   62|  8.67k|    return std::forward<T>(val);
   63|  8.67k|}

_ZN20SaltedOutpointHasherC2Eb:
   15|  17.8k|    k0{deterministic ? 0x8e819f2607a18de6 : FastRandomContext().rand64()},
  ------------------
  |  Branch (15:8): [True: 17.8k, False: 0]
  ------------------
   16|  17.8k|    k1{deterministic ? 0xf4020d2e3983b0eb : FastRandomContext().rand64()}
  ------------------
  |  Branch (16:8): [True: 17.8k, False: 0]
  ------------------
   17|  17.8k|{}

_ZNK20SaltedOutpointHasherclERK9COutPoint:
   49|  3.67M|    size_t operator()(const COutPoint& id) const noexcept {
   50|  3.67M|        return SipHashUint256Extra(k0, k1, id.hash, id.n);
   51|  3.67M|    }

_Z11FormatMoneyl:
   20|    308|{
   21|       |    // Note: not using straight sprintf here because we do NOT want
   22|       |    // localized number formatting.
   23|    308|    static_assert(COIN > 1);
   24|    308|    int64_t quotient = n / COIN;
   25|    308|    int64_t remainder = n % COIN;
   26|    308|    if (n < 0) {
  ------------------
  |  Branch (26:9): [True: 0, False: 308]
  ------------------
   27|      0|        quotient = -quotient;
   28|      0|        remainder = -remainder;
   29|      0|    }
   30|    308|    std::string str = strprintf("%d.%08d", quotient, remainder);
  ------------------
  |  | 1172|    308|#define strprintf tfm::format
  ------------------
   31|       |
   32|       |    // Right-trim excess zeros before the decimal point:
   33|    308|    int nTrim = 0;
   34|  1.00k|    for (int i = str.size()-1; (str[i] == '0' && IsDigit(str[i-2])); --i)
  ------------------
  |  Branch (34:33): [True: 787, False: 218]
  |  Branch (34:50): [True: 697, False: 90]
  ------------------
   35|    697|        ++nTrim;
   36|    308|    if (nTrim)
  ------------------
  |  Branch (36:9): [True: 163, False: 145]
  ------------------
   37|    163|        str.erase(str.size()-nTrim, nTrim);
   38|       |
   39|    308|    if (n < 0)
  ------------------
  |  Branch (39:9): [True: 0, False: 308]
  ------------------
   40|      0|        str.insert(uint32_t{0}, 1, '-');
   41|    308|    return str;
   42|    308|}

_Z16AdditionOverflowImEbT_S0_:
   16|  9.26M|{
   17|  9.26M|    static_assert(std::is_integral<T>::value, "Integral required.");
   18|       |    if constexpr (std::numeric_limits<T>::is_signed) {
   19|       |        return (i > 0 && j > std::numeric_limits<T>::max() - i) ||
   20|       |               (i < 0 && j < std::numeric_limits<T>::min() - i);
   21|       |    }
   22|  9.26M|    return std::numeric_limits<T>::max() - i < j;
   23|  9.26M|}
_Z10CheckedAddImENSt3__18optionalIT_EES2_S2_:
   27|  9.26M|{
   28|  9.26M|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 0, False: 9.26M]
  ------------------
   29|      0|        return std::nullopt;
   30|      0|    }
   31|  9.26M|    return i + j;
   32|  9.26M|}

_Z7IsDigitc:
  151|    787|{
  152|    787|    return c >= '0' && c <= '9';
  ------------------
  |  Branch (152:12): [True: 697, False: 90]
  |  Branch (152:24): [True: 697, False: 0]
  ------------------
  153|    787|}

_Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   42|  8.67k|{
   43|  8.67k|    Assert(mock_time_in >= 0s);
  ------------------
  |  |   85|  8.67k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   44|  8.67k|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   45|  8.67k|}

_ZN12TokenPipeEndD2Ev:
   34|      4|{
   35|      4|    Close();
   36|      4|}
_ZN12TokenPipeEnd5CloseEv:
   77|      4|{
   78|      4|    if (m_fd != -1) close(m_fd);
  ------------------
  |  Branch (78:9): [True: 4, False: 0]
  ------------------
   79|      4|    m_fd = -1;
   80|      4|}

_ZNK22transaction_identifierILb0EE6IsNullEv:
   43|   818k|    constexpr bool IsNull() const { return m_wrapped.IsNull(); }
_ZNK22transaction_identifierILb0EE7CompareERKS0_:
   21|   207k|    constexpr int Compare(const transaction_identifier<has_witness>& other) const { return m_wrapped.Compare(other.m_wrapped); }
_ZNK22transaction_identifierILb0EEltIS0_EEbRKT_:
   37|     52|    bool operator<(const Other& other) const { return Compare(other) < 0; }
_ZNK22transaction_identifierILb0EEeqIS0_EEbRKT_:
   33|   207k|    bool operator==(const Other& other) const { return Compare(other) == 0; }
_ZNK22transaction_identifierILb0EEcvRK7uint256Ev:
   67|  3.67M|    operator const uint256&() const LIFETIMEBOUND { return m_wrapped; }
_ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_:
   57|    963|    template <typename Stream> void Serialize(Stream& s) const { m_wrapped.Serialize(s); }
_ZN22transaction_identifierILb0EEC2Ev:
   30|   139k|    transaction_identifier() : m_wrapped{} {}
_ZN22transaction_identifierILb0EE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_:
   58|   111k|    template <typename Stream> void Unserialize(Stream& s) { m_wrapped.Unserialize(s); }
_ZN22transaction_identifierILb0EE11UnserializeI10DataStreamEEvRT_:
   58|  1.93k|    template <typename Stream> void Unserialize(Stream& s) { m_wrapped.Unserialize(s); }
_ZN22transaction_identifierILb0EE11FromUint256ERK7uint256:
   40|  13.6k|    static transaction_identifier FromUint256(const uint256& id) { return {id}; }
_ZN22transaction_identifierILb0EEC2ERK7uint256:
   16|  13.6k|    transaction_identifier(const uint256& wrapped) : m_wrapped{wrapped} {}
_ZN22transaction_identifierILb1EE11FromUint256ERK7uint256:
   40|  13.6k|    static transaction_identifier FromUint256(const uint256& id) { return {id}; }
_ZN22transaction_identifierILb1EEC2ERK7uint256:
   16|  13.6k|    transaction_identifier(const uint256& wrapped) : m_wrapped{wrapped} {}
_ZNK22transaction_identifierILb0EE9ToUint256Ev:
   39|  12.7k|    const uint256& ToUint256() const LIFETIMEBOUND { return m_wrapped; }
_ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_:
   57|   120k|    template <typename Stream> void Serialize(Stream& s) const { m_wrapped.Serialize(s); }