_ZN9base_uintILj256EElSEj:
   15|   480k|{
   16|   480k|    base_uint<BITS> a(*this);
   17|  4.32M|    for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (17:21): [True: 3.84M, False: 480k]
  ------------------
   18|  3.84M|        pn[i] = 0;
   19|   480k|    int k = shift / 32;
   20|   480k|    shift = shift % 32;
   21|  4.32M|    for (int i = 0; i < WIDTH; i++) {
  ------------------
  |  Branch (21:21): [True: 3.84M, False: 480k]
  ------------------
   22|  3.84M|        if (i + k + 1 < WIDTH && shift != 0)
  ------------------
  |  Branch (22:13): [True: 1.67M, False: 2.16M]
  |  Branch (22:34): [True: 240k, False: 1.43M]
  ------------------
   23|   240k|            pn[i + k + 1] |= (a.pn[i] >> (32 - shift));
   24|  3.84M|        if (i + k < WIDTH)
  ------------------
  |  Branch (24:13): [True: 2.15M, False: 1.68M]
  ------------------
   25|  2.15M|            pn[i + k] |= (a.pn[i] << shift);
   26|  3.84M|    }
   27|   480k|    return *this;
   28|   480k|}
_ZN9base_uintILj256EErSEj:
   32|  7.95M|{
   33|  7.95M|    base_uint<BITS> a(*this);
   34|  71.5M|    for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (34:21): [True: 63.6M, False: 7.95M]
  ------------------
   35|  63.6M|        pn[i] = 0;
   36|  7.95M|    int k = shift / 32;
   37|  7.95M|    shift = shift % 32;
   38|  71.5M|    for (int i = 0; i < WIDTH; i++) {
  ------------------
  |  Branch (38:21): [True: 63.6M, False: 7.95M]
  ------------------
   39|  63.6M|        if (i - k - 1 >= 0 && shift != 0)
  ------------------
  |  Branch (39:13): [True: 55.6M, False: 7.95M]
  |  Branch (39:31): [True: 55.6M, False: 0]
  ------------------
   40|  55.6M|            pn[i - k - 1] |= (a.pn[i] << (32 - shift));
   41|  63.6M|        if (i - k >= 0)
  ------------------
  |  Branch (41:13): [True: 63.6M, False: 1.08k]
  ------------------
   42|  63.6M|            pn[i - k] |= (a.pn[i] >> shift);
   43|  63.6M|    }
   44|  7.95M|    return *this;
   45|  7.95M|}
_ZN9base_uintILj256EEmLEj:
   49|    180|{
   50|    180|    uint64_t carry = 0;
   51|  1.62k|    for (int i = 0; i < WIDTH; i++) {
  ------------------
  |  Branch (51:21): [True: 1.44k, False: 180]
  ------------------
   52|  1.44k|        uint64_t n = carry + (uint64_t)b32 * pn[i];
   53|  1.44k|        pn[i] = n & 0xffffffff;
   54|  1.44k|        carry = n >> 32;
   55|  1.44k|    }
   56|    180|    return *this;
   57|    180|}
_ZN9base_uintILj256EEdVERKS0_:
   77|   239k|{
   78|   239k|    base_uint<BITS> div = b;     // make a copy, so we can shift.
   79|   239k|    base_uint<BITS> num = *this; // make a copy, so we can subtract.
   80|   239k|    *this = 0;                   // the quotient.
   81|   239k|    int num_bits = num.bits();
   82|   239k|    int div_bits = div.bits();
   83|   239k|    if (div_bits == 0)
  ------------------
  |  Branch (83:9): [True: 0, False: 239k]
  ------------------
   84|      0|        throw uint_error("Division by zero");
   85|   239k|    if (div_bits > num_bits) // the result is certainly 0.
  ------------------
  |  Branch (85:9): [True: 0, False: 239k]
  ------------------
   86|      0|        return *this;
   87|   239k|    int shift = num_bits - div_bits;
   88|   239k|    div <<= shift; // shift so that div and num align.
   89|  8.19M|    while (shift >= 0) {
  ------------------
  |  Branch (89:12): [True: 7.95M, False: 239k]
  ------------------
   90|  7.95M|        if (num >= div) {
  ------------------
  |  Branch (90:13): [True: 482k, False: 7.47M]
  ------------------
   91|   482k|            num -= div;
   92|   482k|            pn[shift / 32] |= (1U << (shift & 31)); // set a bit of the result.
   93|   482k|        }
   94|  7.95M|        div >>= 1; // shift back.
   95|  7.95M|        shift--;
   96|  7.95M|    }
   97|       |    // num now contains the remainder of the division.
   98|   239k|    return *this;
   99|   239k|}
_ZNK9base_uintILj256EE9CompareToERKS0_:
  103|  8.17M|{
  104|  8.87M|    for (int i = WIDTH - 1; i >= 0; i--) {
  ------------------
  |  Branch (104:29): [True: 8.87M, False: 262]
  ------------------
  105|  8.87M|        if (pn[i] < b.pn[i])
  ------------------
  |  Branch (105:13): [True: 7.68M, False: 1.18M]
  ------------------
  106|  7.68M|            return -1;
  107|  1.18M|        if (pn[i] > b.pn[i])
  ------------------
  |  Branch (107:13): [True: 483k, False: 700k]
  ------------------
  108|   483k|            return 1;
  109|  1.18M|    }
  110|    262|    return 0;
  111|  8.17M|}
_ZNK9base_uintILj256EE7EqualToEm:
  115|   239k|{
  116|   479k|    for (int i = WIDTH - 1; i >= 2; i--) {
  ------------------
  |  Branch (116:29): [True: 479k, False: 0]
  ------------------
  117|   479k|        if (pn[i])
  ------------------
  |  Branch (117:13): [True: 239k, False: 239k]
  ------------------
  118|   239k|            return false;
  119|   479k|    }
  120|      0|    if (pn[1] != (b >> 32))
  ------------------
  |  Branch (120:9): [True: 0, False: 0]
  ------------------
  121|      0|        return false;
  122|      0|    if (pn[0] != (b & 0xfffffffful))
  ------------------
  |  Branch (122:9): [True: 0, False: 0]
  ------------------
  123|      0|        return false;
  124|      0|    return true;
  125|      0|}
_ZNK9base_uintILj256EE4bitsEv:
  157|   480k|{
  158|   721k|    for (int pos = WIDTH - 1; pos >= 0; pos--) {
  ------------------
  |  Branch (158:31): [True: 721k, False: 0]
  ------------------
  159|   721k|        if (pn[pos]) {
  ------------------
  |  Branch (159:13): [True: 480k, False: 241k]
  ------------------
  160|   484k|            for (int nbits = 31; nbits > 0; nbits--) {
  ------------------
  |  Branch (160:34): [True: 484k, False: 0]
  ------------------
  161|   484k|                if (pn[pos] & 1U << nbits)
  ------------------
  |  Branch (161:21): [True: 480k, False: 4.13k]
  ------------------
  162|   480k|                    return 32 * pos + nbits + 1;
  163|   484k|            }
  164|      0|            return 32 * pos + 1;
  165|   480k|        }
  166|   721k|    }
  167|      0|    return 0;
  168|   480k|}
_ZN13arith_uint25610SetCompactEjPbS0_:
  176|   240k|{
  177|   240k|    int nSize = nCompact >> 24;
  178|   240k|    uint32_t nWord = nCompact & 0x007fffff;
  179|   240k|    if (nSize <= 3) {
  ------------------
  |  Branch (179:9): [True: 6, False: 240k]
  ------------------
  180|      6|        nWord >>= 8 * (3 - nSize);
  181|      6|        *this = nWord;
  182|   240k|    } else {
  183|   240k|        *this = nWord;
  184|   240k|        *this <<= 8 * (nSize - 3);
  185|   240k|    }
  186|   240k|    if (pfNegative)
  ------------------
  |  Branch (186:9): [True: 239k, False: 452]
  ------------------
  187|   239k|        *pfNegative = nWord != 0 && (nCompact & 0x00800000) != 0;
  ------------------
  |  Branch (187:23): [True: 239k, False: 0]
  |  Branch (187:37): [True: 4, False: 239k]
  ------------------
  188|   240k|    if (pfOverflow)
  ------------------
  |  Branch (188:9): [True: 239k, False: 452]
  ------------------
  189|   239k|        *pfOverflow = nWord != 0 && ((nSize > 34) ||
  ------------------
  |  Branch (189:23): [True: 239k, False: 0]
  |  Branch (189:38): [True: 0, False: 239k]
  ------------------
  190|   239k|                                     (nWord > 0xff && nSize > 33) ||
  ------------------
  |  Branch (190:39): [True: 239k, False: 0]
  |  Branch (190:55): [True: 0, False: 239k]
  ------------------
  191|   239k|                                     (nWord > 0xffff && nSize > 32));
  ------------------
  |  Branch (191:39): [True: 2, False: 239k]
  |  Branch (191:57): [True: 0, False: 2]
  ------------------
  192|   240k|    return *this;
  193|   240k|}
_ZNK13arith_uint25610GetCompactEb:
  196|    180|{
  197|    180|    int nSize = (bits() + 7) / 8;
  198|    180|    uint32_t nCompact = 0;
  199|    180|    if (nSize <= 3) {
  ------------------
  |  Branch (199:9): [True: 0, False: 180]
  ------------------
  200|      0|        nCompact = GetLow64() << 8 * (3 - nSize);
  201|    180|    } else {
  202|    180|        arith_uint256 bn = *this >> 8 * (nSize - 3);
  203|    180|        nCompact = bn.GetLow64();
  204|    180|    }
  205|       |    // The 0x00800000 bit denotes the sign.
  206|       |    // Thus, if it is already set, divide the mantissa by 256 and increase the exponent.
  207|    180|    if (nCompact & 0x00800000) {
  ------------------
  |  Branch (207:9): [True: 92, False: 88]
  ------------------
  208|     92|        nCompact >>= 8;
  209|     92|        nSize++;
  210|     92|    }
  211|    180|    assert((nCompact & ~0x007fffffU) == 0);
  212|    180|    assert(nSize < 256);
  213|    180|    nCompact |= nSize << 24;
  214|    180|    nCompact |= (fNegative && (nCompact & 0x007fffff) ? 0x00800000 : 0);
  ------------------
  |  Branch (214:18): [True: 0, False: 180]
  |  Branch (214:31): [True: 0, False: 0]
  ------------------
  215|    180|    return nCompact;
  216|    180|}
_Z14UintToArith256RK7uint256:
  226|  1.29k|{
  227|  1.29k|    arith_uint256 b;
  228|  11.6k|    for(int x=0; x<b.WIDTH; ++x)
  ------------------
  |  Branch (228:18): [True: 10.3k, False: 1.29k]
  ------------------
  229|  10.3k|        b.pn[x] = ReadLE32(a.begin() + x*4);
  230|  1.29k|    return b;
  231|  1.29k|}

_ZN13arith_uint256C2ERK9base_uintILj256EE:
  249|   239k|    arith_uint256(const base_uint<256>& b) : base_uint<256>(b) {}
_ZN13arith_uint256C2Em:
  250|   240k|    arith_uint256(uint64_t b) : base_uint<256>(b) {}
_ZN9base_uintILj256EEmIERKS0_:
  141|   482k|    {
  142|   482k|        *this += -b;
  143|   482k|        return *this;
  144|   482k|    }
_ZNK9base_uintILj256EEngEv:
   71|   482k|    {
   72|   482k|        base_uint ret;
   73|  4.34M|        for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (73:25): [True: 3.86M, False: 482k]
  ------------------
   74|  3.86M|            ret.pn[i] = ~pn[i];
   75|   482k|        ++ret;
   76|   482k|        return ret;
   77|   482k|    }
_ZN9base_uintILj256EEppEv:
  167|   482k|    {
  168|       |        // prefix operator
  169|   482k|        int i = 0;
  170|   741k|        while (i < WIDTH && ++pn[i] == 0)
  ------------------
  |  Branch (170:16): [True: 741k, False: 0]
  |  Branch (170:29): [True: 258k, False: 482k]
  ------------------
  171|   258k|            i++;
  172|   482k|        return *this;
  173|   482k|    }
_ZN9base_uintILj256EEpLERKS0_:
  129|  1.20M|    {
  130|  1.20M|        uint64_t carry = 0;
  131|  10.8M|        for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (131:25): [True: 9.61M, False: 1.20M]
  ------------------
  132|  9.61M|        {
  133|  9.61M|            uint64_t n = carry + pn[i] + b.pn[i];
  134|  9.61M|            pn[i] = n & 0xffffffff;
  135|  9.61M|            carry = n >> 32;
  136|  9.61M|        }
  137|  1.20M|        return *this;
  138|  1.20M|    }
_ZNK9base_uintILj256EEcoEv:
   63|   239k|    {
   64|   239k|        base_uint ret;
   65|  2.15M|        for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (65:25): [True: 1.91M, False: 239k]
  ------------------
   66|  1.91M|            ret.pn[i] = ~pn[i];
   67|   239k|        return ret;
   68|   239k|    }
_ZplRK9base_uintILj256EES2_:
  204|   479k|    friend inline base_uint operator+(const base_uint& a, const base_uint& b) { return base_uint(a) += b; }
_ZdvRK9base_uintILj256EES2_:
  207|   239k|    friend inline base_uint operator/(const base_uint& a, const base_uint& b) { return base_uint(a) /= b; }
_ZN9base_uintILj256EEaSERKS0_:
   46|   240k|    {
   47|   240k|        if (this != &b) {
  ------------------
  |  Branch (47:13): [True: 240k, False: 0]
  ------------------
   48|  2.16M|            for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (48:29): [True: 1.92M, False: 240k]
  ------------------
   49|  1.92M|                pn[i] = b.pn[i];
   50|   240k|        }
   51|   240k|        return *this;
   52|   240k|    }
_ZgeRK9base_uintILj256EES2_:
  218|  8.17M|    friend inline bool operator>=(const base_uint& a, const base_uint& b) { return a.CompareTo(b) >= 0; }
_ZN13arith_uint256C2Ev:
  248|   483k|    arith_uint256() = default;
_ZN9base_uintILj256EEC2Ev:
   34|  1.20M|    {
   35|  10.8M|        for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (35:25): [True: 9.64M, False: 1.20M]
  ------------------
   36|  9.64M|            pn[i] = 0;
   37|  1.20M|    }
_ZN9base_uintILj256EEC2ERKS0_:
   40|  10.5M|    {
   41|  95.3M|        for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (41:25): [True: 84.7M, False: 10.5M]
  ------------------
   42|  84.7M|            pn[i] = b.pn[i];
   43|  10.5M|    }
_ZNK9base_uintILj256EE8GetLow64Ev:
  239|    180|    {
  240|    180|        static_assert(WIDTH >= 2, "Assertion WIDTH >= 2 failed (WIDTH = BITS / 32). BITS is a template parameter.");
  241|    180|        return pn[0] | (uint64_t)pn[1] << 32;
  242|    180|    }
_ZN9base_uintILj256EEC2Em:
   55|   720k|    {
   56|   720k|        pn[0] = (unsigned int)b;
   57|   720k|        pn[1] = (unsigned int)(b >> 32);
   58|  5.04M|        for (int i = 2; i < WIDTH; i++)
  ------------------
  |  Branch (58:25): [True: 4.32M, False: 720k]
  ------------------
   59|  4.32M|            pn[i] = 0;
   60|   720k|    }
_ZltRK9base_uintILj256EES2_:
  217|     92|    friend inline bool operator<(const base_uint& a, const base_uint& b) { return a.CompareTo(b) < 0; }
_ZgtRK9base_uintILj256EES2_:
  216|    268|    friend inline bool operator>(const base_uint& a, const base_uint& b) { return a.CompareTo(b) > 0; }
_ZeqRK9base_uintILj256EEm:
  220|   239k|    friend inline bool operator==(const base_uint& a, uint64_t b) { return a.EqualTo(b); }
_ZN9base_uintILj256EEaSEm:
   82|   239k|    {
   83|   239k|        pn[0] = (unsigned int)b;
   84|   239k|        pn[1] = (unsigned int)(b >> 32);
   85|  1.67M|        for (int i = 2; i < WIDTH; i++)
  ------------------
  |  Branch (85:25): [True: 1.43M, False: 239k]
  ------------------
   86|  1.43M|            pn[i] = 0;
   87|   239k|        return *this;
   88|   239k|    }
_ZrsRK9base_uintILj256EEi:
  211|    180|    friend inline base_uint operator>>(const base_uint& a, int shift) { return base_uint(a) >>= shift; }

_Z14LocatorEntriesPK11CBlockIndex:
   32|   212k|{
   33|   212k|    int step = 1;
   34|   212k|    std::vector<uint256> have;
   35|   212k|    if (index == nullptr) return have;
  ------------------
  |  Branch (35:9): [True: 0, False: 212k]
  ------------------
   36|       |
   37|   212k|    have.reserve(32);
   38|   212k|    while (index) {
  ------------------
  |  Branch (38:12): [True: 212k, False: 0]
  ------------------
   39|   212k|        have.emplace_back(index->GetBlockHash());
   40|   212k|        if (index->nHeight == 0) break;
  ------------------
  |  Branch (40:13): [True: 212k, False: 0]
  ------------------
   41|       |        // Exponentially larger steps back, plus the genesis block.
   42|      0|        int height = std::max(index->nHeight - step, 0);
   43|       |        // Use skiplist.
   44|      0|        index = index->GetAncestor(height);
   45|      0|        if (have.size() > 10) step *= 2;
  ------------------
  |  Branch (45:13): [True: 0, False: 0]
  ------------------
   46|      0|    }
   47|   212k|    return have;
   48|   212k|}
_Z13GetBlockProofRK11CBlockIndex:
  132|   239k|{
  133|   239k|    arith_uint256 bnTarget;
  134|   239k|    bool fNegative;
  135|   239k|    bool fOverflow;
  136|   239k|    bnTarget.SetCompact(block.nBits, &fNegative, &fOverflow);
  137|   239k|    if (fNegative || fOverflow || bnTarget == 0)
  ------------------
  |  Branch (137:9): [True: 4, False: 239k]
  |  Branch (137:22): [True: 0, False: 239k]
  |  Branch (137:35): [True: 0, False: 239k]
  ------------------
  138|      4|        return 0;
  139|       |    // We need to compute 2**256 / (bnTarget+1), but we can't represent 2**256
  140|       |    // as it's too large for an arith_uint256. However, as 2**256 is at least as large
  141|       |    // as bnTarget+1, it is equal to ((2**256 - bnTarget - 1) / (bnTarget+1)) + 1,
  142|       |    // or ~bnTarget / (bnTarget+1) + 1.
  143|   239k|    return (~bnTarget / (bnTarget + 1)) + 1;
  144|   239k|}

_ZN11CBlockIndexC2ERK12CBlockHeader:
  200|   241k|        : nVersion{block.nVersion},
  201|   241k|          hashMerkleRoot{block.hashMerkleRoot},
  202|   241k|          nTime{block.nTime},
  203|   241k|          nBits{block.nBits},
  204|   241k|          nNonce{block.nNonce}
  205|   241k|    {
  206|   241k|    }
_ZNK11CBlockIndex14GetBlockHeaderEv:
  231|  1.20k|    {
  232|  1.20k|        CBlockHeader block;
  233|  1.20k|        block.nVersion = nVersion;
  234|  1.20k|        if (pprev)
  ------------------
  |  Branch (234:13): [True: 0, False: 1.20k]
  ------------------
  235|      0|            block.hashPrevBlock = pprev->GetBlockHash();
  236|  1.20k|        block.hashMerkleRoot = hashMerkleRoot;
  237|  1.20k|        block.nTime = nTime;
  238|  1.20k|        block.nBits = nBits;
  239|  1.20k|        block.nNonce = nNonce;
  240|  1.20k|        return block;
  241|  1.20k|    }
_ZNK11CBlockIndex12GetBlockHashEv:
  244|   212k|    {
  245|   212k|        assert(phashBlock != nullptr);
  246|   212k|        return *phashBlock;
  247|   212k|    }
_ZNK11CBlockIndex12GetBlockTimeEv:
  267|  2.44k|    {
  268|  2.44k|        return (int64_t)nTime;
  269|  2.44k|    }
_ZNK11CBlockIndex17GetMedianTimePastEv:
  279|  2.44k|    {
  280|  2.44k|        int64_t pmedian[nMedianTimeSpan];
  281|  2.44k|        int64_t* pbegin = &pmedian[nMedianTimeSpan];
  282|  2.44k|        int64_t* pend = &pmedian[nMedianTimeSpan];
  283|       |
  284|  2.44k|        const CBlockIndex* pindex = this;
  285|  4.88k|        for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
  ------------------
  |  Branch (285:25): [True: 4.88k, False: 0]
  |  Branch (285:48): [True: 2.44k, False: 2.44k]
  ------------------
  286|  2.44k|            *(--pbegin) = pindex->GetBlockTime();
  287|       |
  288|  2.44k|        std::sort(pbegin, pend);
  289|  2.44k|        return pbegin[(pend - pbegin) / 2];
  290|  2.44k|    }

_Z6Paramsv:
  105|  2.44k|const CChainParams &Params() {
  106|  2.44k|    assert(globalChainParams);
  107|  2.44k|    return *globalChainParams;
  108|  2.44k|}

_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|  10.5M|{
   55|  10.5M|#ifdef bitcoin_builtin_bswap32
   56|  10.5M|    return bitcoin_builtin_bswap32(x);
  ------------------
  |  |   24|  10.5M|#      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|  10.5M|}
_Z17internal_bswap_64m:
   64|  1.41M|{
   65|  1.41M|#ifdef bitcoin_builtin_bswap64
   66|  1.41M|    return bitcoin_builtin_bswap64(x);
  ------------------
  |  |   27|  1.41M|#      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|  1.41M|}

_Z16le16toh_internalt:
   29|     90|{
   30|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits);
   31|     90|        else return little_endian_16bits;
   32|     90|}
_Z16htobe32_internalj:
   34|  10.5M|{
   35|  10.5M|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(host_32bits);
   36|       |        else return host_32bits;
   37|  10.5M|}
_Z16htole32_internalj:
   39|  2.73M|{
   40|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits);
   41|  2.73M|        else return host_32bits;
   42|  2.73M|}
_Z16le32toh_internalj:
   49|  1.35M|{
   50|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits);
   51|  1.35M|        else return little_endian_32bits;
   52|  1.35M|}
_Z16htobe64_internalm:
   54|  1.35M|{
   55|  1.35M|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(host_64bits);
   56|       |        else return host_64bits;
   57|  1.35M|}
_Z16be64toh_internalm:
   64|  57.8k|{
   65|  57.8k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(big_endian_64bits);
   66|       |        else return big_endian_64bits;
   67|  57.8k|}
_Z16le64toh_internalm:
   69|  5.61k|{
   70|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits);
   71|  5.61k|        else return little_endian_64bits;
   72|  5.61k|}

_ZNK9Consensus6Params28DifficultyAdjustmentIntervalEv:
  123|   232k|    int64_t DifficultyAdjustmentInterval() const { return nPowTargetTimespan / nPowTargetSpacing; }

_ZN15ChaCha20Aligned6SetKeyE4SpanIKSt4byteE:
   26|  8.46k|{
   27|  8.46k|    assert(key.size() == KEYLEN);
   28|  8.46k|    input[0] = ReadLE32(key.data() + 0);
   29|  8.46k|    input[1] = ReadLE32(key.data() + 4);
   30|  8.46k|    input[2] = ReadLE32(key.data() + 8);
   31|  8.46k|    input[3] = ReadLE32(key.data() + 12);
   32|  8.46k|    input[4] = ReadLE32(key.data() + 16);
   33|  8.46k|    input[5] = ReadLE32(key.data() + 20);
   34|  8.46k|    input[6] = ReadLE32(key.data() + 24);
   35|  8.46k|    input[7] = ReadLE32(key.data() + 28);
   36|  8.46k|    input[8] = 0;
   37|  8.46k|    input[9] = 0;
   38|  8.46k|    input[10] = 0;
   39|  8.46k|    input[11] = 0;
   40|  8.46k|}
_ZN15ChaCha20AlignedD2Ev:
   43|  4.85k|{
   44|  4.85k|    memory_cleanse(input, sizeof(input));
   45|  4.85k|}
_ZN15ChaCha20AlignedC2E4SpanIKSt4byteE:
   48|  4.85k|{
   49|  4.85k|    SetKey(key);
   50|  4.85k|}
_ZN8ChaCha209KeystreamE4SpanISt4byteE:
  283|  7.23k|{
  284|  7.23k|    if (out.empty()) return;
  ------------------
  |  Branch (284:9): [True: 0, False: 7.23k]
  ------------------
  285|  7.23k|    if (m_bufleft) {
  ------------------
  |  Branch (285:9): [True: 1.20k, False: 6.02k]
  ------------------
  286|  1.20k|        unsigned reuse = std::min<size_t>(m_bufleft, out.size());
  287|  1.20k|        std::copy(m_buffer.end() - m_bufleft, m_buffer.end() - m_bufleft + reuse, out.begin());
  288|  1.20k|        m_bufleft -= reuse;
  289|  1.20k|        out = out.subspan(reuse);
  290|  1.20k|    }
  291|  7.23k|    if (out.size() >= m_aligned.BLOCKLEN) {
  ------------------
  |  Branch (291:9): [True: 0, False: 7.23k]
  ------------------
  292|      0|        size_t blocks = out.size() / m_aligned.BLOCKLEN;
  293|      0|        m_aligned.Keystream(out.first(blocks * m_aligned.BLOCKLEN));
  294|      0|        out = out.subspan(blocks * m_aligned.BLOCKLEN);
  295|      0|    }
  296|  7.23k|    if (!out.empty()) {
  ------------------
  |  Branch (296:9): [True: 6.02k, False: 1.20k]
  ------------------
  297|  6.02k|        m_aligned.Keystream(m_buffer);
  298|  6.02k|        std::copy(m_buffer.begin(), m_buffer.begin() + out.size(), out.begin());
  299|  6.02k|        m_bufleft = m_aligned.BLOCKLEN - out.size();
  300|  6.02k|    }
  301|  7.23k|}
_ZN8ChaCha20D2Ev:
  333|  4.85k|{
  334|  4.85k|    memory_cleanse(m_buffer.data(), m_buffer.size());
  335|  4.85k|}
_ZN8ChaCha206SetKeyE4SpanIKSt4byteE:
  338|  3.61k|{
  339|  3.61k|    m_aligned.SetKey(key);
  340|  3.61k|    m_bufleft = 0;
  341|  3.61k|    memory_cleanse(m_buffer.data(), m_buffer.size());
  342|  3.61k|}
_ZN15ChaCha20Aligned9KeystreamE4SpanISt4byteE:
   61|  6.02k|{
   62|  6.02k|    std::byte* c = output.data();
   63|  6.02k|    size_t blocks = output.size() / BLOCKLEN;
   64|  6.02k|    assert(blocks * BLOCKLEN == output.size());
   65|       |
   66|  6.02k|    uint32_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;
   67|  6.02k|    uint32_t j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15;
   68|       |
   69|  6.02k|    if (!blocks) return;
  ------------------
  |  Branch (69:9): [True: 0, False: 6.02k]
  ------------------
   70|       |
   71|  6.02k|    j4 = input[0];
   72|  6.02k|    j5 = input[1];
   73|  6.02k|    j6 = input[2];
   74|  6.02k|    j7 = input[3];
   75|  6.02k|    j8 = input[4];
   76|  6.02k|    j9 = input[5];
   77|  6.02k|    j10 = input[6];
   78|  6.02k|    j11 = input[7];
   79|  6.02k|    j12 = input[8];
   80|  6.02k|    j13 = input[9];
   81|  6.02k|    j14 = input[10];
   82|  6.02k|    j15 = input[11];
   83|       |
   84|  6.02k|    for (;;) {
   85|  6.02k|        x0 = 0x61707865;
   86|  6.02k|        x1 = 0x3320646e;
   87|  6.02k|        x2 = 0x79622d32;
   88|  6.02k|        x3 = 0x6b206574;
   89|  6.02k|        x4 = j4;
   90|  6.02k|        x5 = j5;
   91|  6.02k|        x6 = j6;
   92|  6.02k|        x7 = j7;
   93|  6.02k|        x8 = j8;
   94|  6.02k|        x9 = j9;
   95|  6.02k|        x10 = j10;
   96|  6.02k|        x11 = j11;
   97|  6.02k|        x12 = j12;
   98|  6.02k|        x13 = j13;
   99|  6.02k|        x14 = j14;
  100|  6.02k|        x15 = j15;
  101|       |
  102|       |        // The 20 inner ChaCha20 rounds are unrolled here for performance.
  103|  6.02k|        REPEAT10(
  ------------------
  |  |   23|  6.02k|#define REPEAT10(a) do { {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; } while(0)
  |  |  ------------------
  |  |  |  Branch (23:84): [Folded - Ignored]
  |  |  ------------------
  ------------------
  104|  6.02k|            QUARTERROUND( x0, x4, x8,x12);
  105|  6.02k|            QUARTERROUND( x1, x5, x9,x13);
  106|  6.02k|            QUARTERROUND( x2, x6,x10,x14);
  107|  6.02k|            QUARTERROUND( x3, x7,x11,x15);
  108|  6.02k|            QUARTERROUND( x0, x5,x10,x15);
  109|  6.02k|            QUARTERROUND( x1, x6,x11,x12);
  110|  6.02k|            QUARTERROUND( x2, x7, x8,x13);
  111|  6.02k|            QUARTERROUND( x3, x4, x9,x14);
  112|  6.02k|        );
  113|       |
  114|  6.02k|        x0 += 0x61707865;
  115|  6.02k|        x1 += 0x3320646e;
  116|  6.02k|        x2 += 0x79622d32;
  117|  6.02k|        x3 += 0x6b206574;
  118|  6.02k|        x4 += j4;
  119|  6.02k|        x5 += j5;
  120|  6.02k|        x6 += j6;
  121|  6.02k|        x7 += j7;
  122|  6.02k|        x8 += j8;
  123|  6.02k|        x9 += j9;
  124|  6.02k|        x10 += j10;
  125|  6.02k|        x11 += j11;
  126|  6.02k|        x12 += j12;
  127|  6.02k|        x13 += j13;
  128|  6.02k|        x14 += j14;
  129|  6.02k|        x15 += j15;
  130|       |
  131|  6.02k|        ++j12;
  132|  6.02k|        if (!j12) ++j13;
  ------------------
  |  Branch (132:13): [True: 0, False: 6.02k]
  ------------------
  133|       |
  134|  6.02k|        WriteLE32(c + 0, x0);
  135|  6.02k|        WriteLE32(c + 4, x1);
  136|  6.02k|        WriteLE32(c + 8, x2);
  137|  6.02k|        WriteLE32(c + 12, x3);
  138|  6.02k|        WriteLE32(c + 16, x4);
  139|  6.02k|        WriteLE32(c + 20, x5);
  140|  6.02k|        WriteLE32(c + 24, x6);
  141|  6.02k|        WriteLE32(c + 28, x7);
  142|  6.02k|        WriteLE32(c + 32, x8);
  143|  6.02k|        WriteLE32(c + 36, x9);
  144|  6.02k|        WriteLE32(c + 40, x10);
  145|  6.02k|        WriteLE32(c + 44, x11);
  146|  6.02k|        WriteLE32(c + 48, x12);
  147|  6.02k|        WriteLE32(c + 52, x13);
  148|  6.02k|        WriteLE32(c + 56, x14);
  149|  6.02k|        WriteLE32(c + 60, x15);
  150|       |
  151|  6.02k|        if (blocks == 1) {
  ------------------
  |  Branch (151:13): [True: 6.02k, False: 0]
  ------------------
  152|  6.02k|            input[8] = j12;
  153|  6.02k|            input[9] = j13;
  154|  6.02k|            return;
  155|  6.02k|        }
  156|      0|        blocks -= 1;
  157|      0|        c += BLOCKLEN;
  158|      0|    }
  159|  6.02k|}

_ZN8ChaCha20C2E4SpanIKSt4byteE:
   92|  4.85k|    ChaCha20(Span<const std::byte> key) noexcept : m_aligned(key) {}

_Z8ReadLE64ITk8ByteTypehEmPKT_:
   36|  1.88k|{
   37|  1.88k|    uint64_t x;
   38|  1.88k|    memcpy(&x, ptr, 8);
   39|  1.88k|    return le64toh_internal(x);
   40|  1.88k|}
_Z8ReadLE64ITk8ByteTypeSt4byteEmPKT_:
   36|  3.61k|{
   37|  3.61k|    uint64_t x;
   38|  3.61k|    memcpy(&x, ptr, 8);
   39|  3.61k|    return le64toh_internal(x);
   40|  3.61k|}
_Z9WriteLE32ITk8ByteTypeSt4byteEvPT_j:
   51|  96.4k|{
   52|  96.4k|    uint32_t v = htole32_internal(x);
   53|  96.4k|    memcpy(ptr, &v, 4);
   54|  96.4k|}
_Z8ReadLE32ITk8ByteTypehEjPKT_:
   28|  10.3k|{
   29|  10.3k|    uint32_t x;
   30|  10.3k|    memcpy(&x, ptr, 4);
   31|  10.3k|    return le32toh_internal(x);
   32|  10.3k|}
_Z9WriteBE32ITk8ByteTypehEvPT_j:
   96|  10.5M|{
   97|  10.5M|    uint32_t v = htobe32_internal(x);
   98|  10.5M|    memcpy(ptr, &v, 4);
   99|  10.5M|}
_Z9WriteBE64ITk8ByteTypehEvPT_m:
  103|  1.35M|{
  104|  1.35M|    uint64_t v = htobe64_internal(x);
  105|  1.35M|    memcpy(ptr, &v, 8);
  106|  1.35M|}
_Z8ReadBE64ITk8ByteTypehEmPKT_:
   81|  57.8k|{
   82|  57.8k|    uint64_t x;
   83|  57.8k|    memcpy(&x, ptr, 8);
   84|  57.8k|    return be64toh_internal(x);
   85|  57.8k|}
_Z8ReadLE32ITk8ByteTypeSt4byteEjPKT_:
   28|  67.7k|{
   29|  67.7k|    uint32_t x;
   30|  67.7k|    memcpy(&x, ptr, 4);
   31|  67.7k|    return le32toh_internal(x);
   32|  67.7k|}

_Z6HexStr4SpanIKhE:
   30|  1.23k|{
   31|  1.23k|    std::string rv(s.size() * 2, '\0');
   32|  1.23k|    static constexpr auto byte_to_hex = CreateByteToHexMap();
   33|  1.23k|    static_assert(sizeof(byte_to_hex) == 512);
   34|       |
   35|  1.23k|    char* it = rv.data();
   36|  39.5k|    for (uint8_t v : s) {
  ------------------
  |  Branch (36:20): [True: 39.5k, False: 1.23k]
  ------------------
   37|  39.5k|        std::memcpy(it, byte_to_hex[v].data(), 2);
   38|  39.5k|        it += 2;
   39|  39.5k|    }
   40|       |
   41|  1.23k|    assert(it == rv.data() + rv.size());
   42|  1.23k|    return rv;
   43|  1.23k|}

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

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

_ZN7CSHA512C2Ev:
  155|  3.61k|{
  156|  3.61k|    sha512::Initialize(s);
  157|  3.61k|}
_ZN7CSHA5125WriteEPKhm:
  160|  25.3k|{
  161|  25.3k|    const unsigned char* end = data + len;
  162|  25.3k|    size_t bufsize = bytes % 128;
  163|  25.3k|    if (bufsize && bufsize + len >= 128) {
  ------------------
  |  Branch (163:9): [True: 21.6k, False: 3.61k]
  |  Branch (163:20): [True: 3.61k, False: 18.0k]
  ------------------
  164|       |        // Fill the buffer, and process it.
  165|  3.61k|        memcpy(buf + bufsize, data, 128 - bufsize);
  166|  3.61k|        bytes += 128 - bufsize;
  167|  3.61k|        data += 128 - bufsize;
  168|  3.61k|        sha512::Transform(s, buf);
  169|  3.61k|        bufsize = 0;
  170|  3.61k|    }
  171|  25.3k|    while (end - data >= 128) {
  ------------------
  |  Branch (171:12): [True: 0, False: 25.3k]
  ------------------
  172|       |        // Process full chunks directly from the source.
  173|      0|        sha512::Transform(s, data);
  174|      0|        data += 128;
  175|      0|        bytes += 128;
  176|      0|    }
  177|  25.3k|    if (end > data) {
  ------------------
  |  Branch (177:9): [True: 21.6k, False: 3.61k]
  ------------------
  178|       |        // Fill the buffer with what remains.
  179|  21.6k|        memcpy(buf + bufsize, data, end - data);
  180|  21.6k|        bytes += end - data;
  181|  21.6k|    }
  182|  25.3k|    return *this;
  183|  25.3k|}
_ZN7CSHA5128FinalizeEPh:
  186|  3.61k|{
  187|  3.61k|    static const unsigned char pad[128] = {0x80};
  188|  3.61k|    unsigned char sizedesc[16] = {0x00};
  189|  3.61k|    WriteBE64(sizedesc + 8, bytes << 3);
  190|  3.61k|    Write(pad, 1 + ((239 - (bytes % 128)) % 128));
  191|  3.61k|    Write(sizedesc, 16);
  192|  3.61k|    WriteBE64(hash, s[0]);
  193|  3.61k|    WriteBE64(hash + 8, s[1]);
  194|  3.61k|    WriteBE64(hash + 16, s[2]);
  195|  3.61k|    WriteBE64(hash + 24, s[3]);
  196|  3.61k|    WriteBE64(hash + 32, s[4]);
  197|  3.61k|    WriteBE64(hash + 40, s[5]);
  198|  3.61k|    WriteBE64(hash + 48, s[6]);
  199|  3.61k|    WriteBE64(hash + 56, s[7]);
  200|  3.61k|}
_ZN7CSHA5125ResetEv:
  203|  3.61k|{
  204|  3.61k|    bytes = 0;
  205|  3.61k|    sha512::Initialize(s);
  206|  3.61k|    return *this;
  207|  3.61k|}
sha512.cpp:_ZN12_GLOBAL__N_16sha51210InitializeEPm:
   35|  7.23k|{
   36|  7.23k|    s[0] = 0x6a09e667f3bcc908ull;
   37|  7.23k|    s[1] = 0xbb67ae8584caa73bull;
   38|  7.23k|    s[2] = 0x3c6ef372fe94f82bull;
   39|  7.23k|    s[3] = 0xa54ff53a5f1d36f1ull;
   40|  7.23k|    s[4] = 0x510e527fade682d1ull;
   41|  7.23k|    s[5] = 0x9b05688c2b3e6c1full;
   42|  7.23k|    s[6] = 0x1f83d9abfb41bd6bull;
   43|  7.23k|    s[7] = 0x5be0cd19137e2179ull;
   44|  7.23k|}
sha512.cpp:_ZN12_GLOBAL__N_16sha5129TransformEPmPKh:
   48|  3.61k|{
   49|  3.61k|    uint64_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
   50|  3.61k|    uint64_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
   51|       |
   52|  3.61k|    Round(a, b, c, d, e, f, g, h, 0x428a2f98d728ae22ull, w0 = ReadBE64(chunk + 0));
   53|  3.61k|    Round(h, a, b, c, d, e, f, g, 0x7137449123ef65cdull, w1 = ReadBE64(chunk + 8));
   54|  3.61k|    Round(g, h, a, b, c, d, e, f, 0xb5c0fbcfec4d3b2full, w2 = ReadBE64(chunk + 16));
   55|  3.61k|    Round(f, g, h, a, b, c, d, e, 0xe9b5dba58189dbbcull, w3 = ReadBE64(chunk + 24));
   56|  3.61k|    Round(e, f, g, h, a, b, c, d, 0x3956c25bf348b538ull, w4 = ReadBE64(chunk + 32));
   57|  3.61k|    Round(d, e, f, g, h, a, b, c, 0x59f111f1b605d019ull, w5 = ReadBE64(chunk + 40));
   58|  3.61k|    Round(c, d, e, f, g, h, a, b, 0x923f82a4af194f9bull, w6 = ReadBE64(chunk + 48));
   59|  3.61k|    Round(b, c, d, e, f, g, h, a, 0xab1c5ed5da6d8118ull, w7 = ReadBE64(chunk + 56));
   60|  3.61k|    Round(a, b, c, d, e, f, g, h, 0xd807aa98a3030242ull, w8 = ReadBE64(chunk + 64));
   61|  3.61k|    Round(h, a, b, c, d, e, f, g, 0x12835b0145706fbeull, w9 = ReadBE64(chunk + 72));
   62|  3.61k|    Round(g, h, a, b, c, d, e, f, 0x243185be4ee4b28cull, w10 = ReadBE64(chunk + 80));
   63|  3.61k|    Round(f, g, h, a, b, c, d, e, 0x550c7dc3d5ffb4e2ull, w11 = ReadBE64(chunk + 88));
   64|  3.61k|    Round(e, f, g, h, a, b, c, d, 0x72be5d74f27b896full, w12 = ReadBE64(chunk + 96));
   65|  3.61k|    Round(d, e, f, g, h, a, b, c, 0x80deb1fe3b1696b1ull, w13 = ReadBE64(chunk + 104));
   66|  3.61k|    Round(c, d, e, f, g, h, a, b, 0x9bdc06a725c71235ull, w14 = ReadBE64(chunk + 112));
   67|  3.61k|    Round(b, c, d, e, f, g, h, a, 0xc19bf174cf692694ull, w15 = ReadBE64(chunk + 120));
   68|       |
   69|  3.61k|    Round(a, b, c, d, e, f, g, h, 0xe49b69c19ef14ad2ull, w0 += sigma1(w14) + w9 + sigma0(w1));
   70|  3.61k|    Round(h, a, b, c, d, e, f, g, 0xefbe4786384f25e3ull, w1 += sigma1(w15) + w10 + sigma0(w2));
   71|  3.61k|    Round(g, h, a, b, c, d, e, f, 0x0fc19dc68b8cd5b5ull, w2 += sigma1(w0) + w11 + sigma0(w3));
   72|  3.61k|    Round(f, g, h, a, b, c, d, e, 0x240ca1cc77ac9c65ull, w3 += sigma1(w1) + w12 + sigma0(w4));
   73|  3.61k|    Round(e, f, g, h, a, b, c, d, 0x2de92c6f592b0275ull, w4 += sigma1(w2) + w13 + sigma0(w5));
   74|  3.61k|    Round(d, e, f, g, h, a, b, c, 0x4a7484aa6ea6e483ull, w5 += sigma1(w3) + w14 + sigma0(w6));
   75|  3.61k|    Round(c, d, e, f, g, h, a, b, 0x5cb0a9dcbd41fbd4ull, w6 += sigma1(w4) + w15 + sigma0(w7));
   76|  3.61k|    Round(b, c, d, e, f, g, h, a, 0x76f988da831153b5ull, w7 += sigma1(w5) + w0 + sigma0(w8));
   77|  3.61k|    Round(a, b, c, d, e, f, g, h, 0x983e5152ee66dfabull, w8 += sigma1(w6) + w1 + sigma0(w9));
   78|  3.61k|    Round(h, a, b, c, d, e, f, g, 0xa831c66d2db43210ull, w9 += sigma1(w7) + w2 + sigma0(w10));
   79|  3.61k|    Round(g, h, a, b, c, d, e, f, 0xb00327c898fb213full, w10 += sigma1(w8) + w3 + sigma0(w11));
   80|  3.61k|    Round(f, g, h, a, b, c, d, e, 0xbf597fc7beef0ee4ull, w11 += sigma1(w9) + w4 + sigma0(w12));
   81|  3.61k|    Round(e, f, g, h, a, b, c, d, 0xc6e00bf33da88fc2ull, w12 += sigma1(w10) + w5 + sigma0(w13));
   82|  3.61k|    Round(d, e, f, g, h, a, b, c, 0xd5a79147930aa725ull, w13 += sigma1(w11) + w6 + sigma0(w14));
   83|  3.61k|    Round(c, d, e, f, g, h, a, b, 0x06ca6351e003826full, w14 += sigma1(w12) + w7 + sigma0(w15));
   84|  3.61k|    Round(b, c, d, e, f, g, h, a, 0x142929670a0e6e70ull, w15 += sigma1(w13) + w8 + sigma0(w0));
   85|       |
   86|  3.61k|    Round(a, b, c, d, e, f, g, h, 0x27b70a8546d22ffcull, w0 += sigma1(w14) + w9 + sigma0(w1));
   87|  3.61k|    Round(h, a, b, c, d, e, f, g, 0x2e1b21385c26c926ull, w1 += sigma1(w15) + w10 + sigma0(w2));
   88|  3.61k|    Round(g, h, a, b, c, d, e, f, 0x4d2c6dfc5ac42aedull, w2 += sigma1(w0) + w11 + sigma0(w3));
   89|  3.61k|    Round(f, g, h, a, b, c, d, e, 0x53380d139d95b3dfull, w3 += sigma1(w1) + w12 + sigma0(w4));
   90|  3.61k|    Round(e, f, g, h, a, b, c, d, 0x650a73548baf63deull, w4 += sigma1(w2) + w13 + sigma0(w5));
   91|  3.61k|    Round(d, e, f, g, h, a, b, c, 0x766a0abb3c77b2a8ull, w5 += sigma1(w3) + w14 + sigma0(w6));
   92|  3.61k|    Round(c, d, e, f, g, h, a, b, 0x81c2c92e47edaee6ull, w6 += sigma1(w4) + w15 + sigma0(w7));
   93|  3.61k|    Round(b, c, d, e, f, g, h, a, 0x92722c851482353bull, w7 += sigma1(w5) + w0 + sigma0(w8));
   94|  3.61k|    Round(a, b, c, d, e, f, g, h, 0xa2bfe8a14cf10364ull, w8 += sigma1(w6) + w1 + sigma0(w9));
   95|  3.61k|    Round(h, a, b, c, d, e, f, g, 0xa81a664bbc423001ull, w9 += sigma1(w7) + w2 + sigma0(w10));
   96|  3.61k|    Round(g, h, a, b, c, d, e, f, 0xc24b8b70d0f89791ull, w10 += sigma1(w8) + w3 + sigma0(w11));
   97|  3.61k|    Round(f, g, h, a, b, c, d, e, 0xc76c51a30654be30ull, w11 += sigma1(w9) + w4 + sigma0(w12));
   98|  3.61k|    Round(e, f, g, h, a, b, c, d, 0xd192e819d6ef5218ull, w12 += sigma1(w10) + w5 + sigma0(w13));
   99|  3.61k|    Round(d, e, f, g, h, a, b, c, 0xd69906245565a910ull, w13 += sigma1(w11) + w6 + sigma0(w14));
  100|  3.61k|    Round(c, d, e, f, g, h, a, b, 0xf40e35855771202aull, w14 += sigma1(w12) + w7 + sigma0(w15));
  101|  3.61k|    Round(b, c, d, e, f, g, h, a, 0x106aa07032bbd1b8ull, w15 += sigma1(w13) + w8 + sigma0(w0));
  102|       |
  103|  3.61k|    Round(a, b, c, d, e, f, g, h, 0x19a4c116b8d2d0c8ull, w0 += sigma1(w14) + w9 + sigma0(w1));
  104|  3.61k|    Round(h, a, b, c, d, e, f, g, 0x1e376c085141ab53ull, w1 += sigma1(w15) + w10 + sigma0(w2));
  105|  3.61k|    Round(g, h, a, b, c, d, e, f, 0x2748774cdf8eeb99ull, w2 += sigma1(w0) + w11 + sigma0(w3));
  106|  3.61k|    Round(f, g, h, a, b, c, d, e, 0x34b0bcb5e19b48a8ull, w3 += sigma1(w1) + w12 + sigma0(w4));
  107|  3.61k|    Round(e, f, g, h, a, b, c, d, 0x391c0cb3c5c95a63ull, w4 += sigma1(w2) + w13 + sigma0(w5));
  108|  3.61k|    Round(d, e, f, g, h, a, b, c, 0x4ed8aa4ae3418acbull, w5 += sigma1(w3) + w14 + sigma0(w6));
  109|  3.61k|    Round(c, d, e, f, g, h, a, b, 0x5b9cca4f7763e373ull, w6 += sigma1(w4) + w15 + sigma0(w7));
  110|  3.61k|    Round(b, c, d, e, f, g, h, a, 0x682e6ff3d6b2b8a3ull, w7 += sigma1(w5) + w0 + sigma0(w8));
  111|  3.61k|    Round(a, b, c, d, e, f, g, h, 0x748f82ee5defb2fcull, w8 += sigma1(w6) + w1 + sigma0(w9));
  112|  3.61k|    Round(h, a, b, c, d, e, f, g, 0x78a5636f43172f60ull, w9 += sigma1(w7) + w2 + sigma0(w10));
  113|  3.61k|    Round(g, h, a, b, c, d, e, f, 0x84c87814a1f0ab72ull, w10 += sigma1(w8) + w3 + sigma0(w11));
  114|  3.61k|    Round(f, g, h, a, b, c, d, e, 0x8cc702081a6439ecull, w11 += sigma1(w9) + w4 + sigma0(w12));
  115|  3.61k|    Round(e, f, g, h, a, b, c, d, 0x90befffa23631e28ull, w12 += sigma1(w10) + w5 + sigma0(w13));
  116|  3.61k|    Round(d, e, f, g, h, a, b, c, 0xa4506cebde82bde9ull, w13 += sigma1(w11) + w6 + sigma0(w14));
  117|  3.61k|    Round(c, d, e, f, g, h, a, b, 0xbef9a3f7b2c67915ull, w14 += sigma1(w12) + w7 + sigma0(w15));
  118|  3.61k|    Round(b, c, d, e, f, g, h, a, 0xc67178f2e372532bull, w15 += sigma1(w13) + w8 + sigma0(w0));
  119|       |
  120|  3.61k|    Round(a, b, c, d, e, f, g, h, 0xca273eceea26619cull, w0 += sigma1(w14) + w9 + sigma0(w1));
  121|  3.61k|    Round(h, a, b, c, d, e, f, g, 0xd186b8c721c0c207ull, w1 += sigma1(w15) + w10 + sigma0(w2));
  122|  3.61k|    Round(g, h, a, b, c, d, e, f, 0xeada7dd6cde0eb1eull, w2 += sigma1(w0) + w11 + sigma0(w3));
  123|  3.61k|    Round(f, g, h, a, b, c, d, e, 0xf57d4f7fee6ed178ull, w3 += sigma1(w1) + w12 + sigma0(w4));
  124|  3.61k|    Round(e, f, g, h, a, b, c, d, 0x06f067aa72176fbaull, w4 += sigma1(w2) + w13 + sigma0(w5));
  125|  3.61k|    Round(d, e, f, g, h, a, b, c, 0x0a637dc5a2c898a6ull, w5 += sigma1(w3) + w14 + sigma0(w6));
  126|  3.61k|    Round(c, d, e, f, g, h, a, b, 0x113f9804bef90daeull, w6 += sigma1(w4) + w15 + sigma0(w7));
  127|  3.61k|    Round(b, c, d, e, f, g, h, a, 0x1b710b35131c471bull, w7 += sigma1(w5) + w0 + sigma0(w8));
  128|  3.61k|    Round(a, b, c, d, e, f, g, h, 0x28db77f523047d84ull, w8 += sigma1(w6) + w1 + sigma0(w9));
  129|  3.61k|    Round(h, a, b, c, d, e, f, g, 0x32caab7b40c72493ull, w9 += sigma1(w7) + w2 + sigma0(w10));
  130|  3.61k|    Round(g, h, a, b, c, d, e, f, 0x3c9ebe0a15c9bebcull, w10 += sigma1(w8) + w3 + sigma0(w11));
  131|  3.61k|    Round(f, g, h, a, b, c, d, e, 0x431d67c49c100d4cull, w11 += sigma1(w9) + w4 + sigma0(w12));
  132|  3.61k|    Round(e, f, g, h, a, b, c, d, 0x4cc5d4becb3e42b6ull, w12 += sigma1(w10) + w5 + sigma0(w13));
  133|  3.61k|    Round(d, e, f, g, h, a, b, c, 0x597f299cfc657e2aull, w13 += sigma1(w11) + w6 + sigma0(w14));
  134|  3.61k|    Round(c, d, e, f, g, h, a, b, 0x5fcb6fab3ad6faecull, w14 + sigma1(w12) + w7 + sigma0(w15));
  135|  3.61k|    Round(b, c, d, e, f, g, h, a, 0x6c44198c4a475817ull, w15 + sigma1(w13) + w8 + sigma0(w0));
  136|       |
  137|  3.61k|    s[0] += a;
  138|  3.61k|    s[1] += b;
  139|  3.61k|    s[2] += c;
  140|  3.61k|    s[3] += d;
  141|  3.61k|    s[4] += e;
  142|  3.61k|    s[5] += f;
  143|  3.61k|    s[6] += g;
  144|  3.61k|    s[7] += h;
  145|  3.61k|}
sha512.cpp:_ZN12_GLOBAL__N_16sha5125RoundEmmmRmmmmS1_mm:
   26|   289k|{
   27|   289k|    uint64_t t1 = h + Sigma1(e) + Ch(e, f, g) + k + w;
   28|   289k|    uint64_t t2 = Sigma0(a) + Maj(a, b, c);
   29|   289k|    d += t1;
   30|   289k|    h = t1 + t2;
   31|   289k|}
sha512.cpp:_ZN12_GLOBAL__N_16sha5126Sigma1Em:
   20|   289k|uint64_t inline Sigma1(uint64_t x) { return (x >> 14 | x << 50) ^ (x >> 18 | x << 46) ^ (x >> 41 | x << 23); }
sha512.cpp:_ZN12_GLOBAL__N_16sha5122ChEmmm:
   17|   289k|uint64_t inline Ch(uint64_t x, uint64_t y, uint64_t z) { return z ^ (x & (y ^ z)); }
sha512.cpp:_ZN12_GLOBAL__N_16sha5126Sigma0Em:
   19|   289k|uint64_t inline Sigma0(uint64_t x) { return (x >> 28 | x << 36) ^ (x >> 34 | x << 30) ^ (x >> 39 | x << 25); }
sha512.cpp:_ZN12_GLOBAL__N_16sha5123MajEmmm:
   18|   289k|uint64_t inline Maj(uint64_t x, uint64_t y, uint64_t z) { return (x & y) | (z & (x | y)); }
sha512.cpp:_ZN12_GLOBAL__N_16sha5126sigma1Em:
   22|   231k|uint64_t inline sigma1(uint64_t x) { return (x >> 19 | x << 45) ^ (x >> 61 | x << 3) ^ (x >> 6); }
sha512.cpp:_ZN12_GLOBAL__N_16sha5126sigma0Em:
   21|   231k|uint64_t inline sigma0(uint64_t x) { return (x >> 1 | x << 63) ^ (x >> 8 | x << 56) ^ (x >> 7); }

_Z14SipHashUint256mmRK7uint256:
   96|    472|{
   97|       |    /* Specialized implementation for efficiency */
   98|    472|    uint64_t d = val.GetUint64(0);
   99|       |
  100|    472|    uint64_t v0 = 0x736f6d6570736575ULL ^ k0;
  101|    472|    uint64_t v1 = 0x646f72616e646f6dULL ^ k1;
  102|    472|    uint64_t v2 = 0x6c7967656e657261ULL ^ k0;
  103|    472|    uint64_t v3 = 0x7465646279746573ULL ^ k1 ^ d;
  104|       |
  105|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  106|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  107|    472|    v0 ^= d;
  108|    472|    d = val.GetUint64(1);
  109|    472|    v3 ^= d;
  110|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  111|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  112|    472|    v0 ^= d;
  113|    472|    d = val.GetUint64(2);
  114|    472|    v3 ^= d;
  115|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  116|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  117|    472|    v0 ^= d;
  118|    472|    d = val.GetUint64(3);
  119|    472|    v3 ^= d;
  120|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  121|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  122|    472|    v0 ^= d;
  123|    472|    v3 ^= (uint64_t{4}) << 59;
  124|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  125|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  126|    472|    v0 ^= (uint64_t{4}) << 59;
  127|    472|    v2 ^= 0xFF;
  128|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  129|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  130|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  131|    472|    SIPROUND;
  ------------------
  |  |    9|    472|#define SIPROUND do { \
  |  |   10|    472|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|    472|    v0 = std::rotl(v0, 32); \
  |  |   12|    472|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|    472|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|    472|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|    472|    v2 = std::rotl(v2, 32); \
  |  |   16|    472|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
  132|    472|    return v0 ^ v1 ^ v2 ^ v3;
  133|    472|}

_ZN10HashWriter5writeE4SpanIKSt4byteE:
  107|  3.96M|    {
  108|  3.96M|        ctx.Write(UCharCast(src.data()), src.size());
  109|  3.96M|    }
_ZN10HashWriter7GetHashEv:
  115|   660k|    uint256 GetHash() {
  116|   660k|        uint256 result;
  117|   660k|        ctx.Finalize(result.begin());
  118|   660k|        ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin());
  119|   660k|        return result;
  120|   660k|    }
_ZN10HashWriterlsI4SpanIKhEEERS_RKT_:
  142|  1.32M|    {
  143|  1.32M|        ::Serialize(*this, obj);
  144|  1.32M|        return *this;
  145|  1.32M|    }
_ZN10HashWriterlsI12CBlockHeaderEERS_RKT_:
  142|   660k|    {
  143|   660k|        ::Serialize(*this, obj);
  144|   660k|        return *this;
  145|   660k|    }

_ZN16HeadersSyncStateC2ElRKN9Consensus6ParamsEPK11CBlockIndexRK13arith_uint256:
   28|  1.20k|    m_commit_offset(FastRandomContext().randrange<unsigned>(HEADER_COMMITMENT_PERIOD)),
   29|  1.20k|    m_id(id), m_consensus_params(consensus_params),
   30|  1.20k|    m_chain_start(chain_start),
   31|  1.20k|    m_minimum_required_work(minimum_required_work),
   32|  1.20k|    m_current_chain_work(chain_start->nChainWork),
   33|  1.20k|    m_last_header_received(m_chain_start->GetBlockHeader()),
   34|  1.20k|    m_current_height(chain_start->nHeight)
   35|  1.20k|{
   36|       |    // Estimate the number of blocks that could possibly exist on the peer's
   37|       |    // chain *right now* using 6 blocks/second (fastest blockrate given the MTP
   38|       |    // rule) times the number of seconds from the last allowed block until
   39|       |    // today. This serves as a memory bound on how many commitments we might
   40|       |    // store from this peer, and we can safely give up syncing if the peer
   41|       |    // exceeds this bound, because it's not possible for a consensus-valid
   42|       |    // chain to be longer than this (at the current time -- in the future we
   43|       |    // could try again, if necessary, to sync a longer chain).
   44|  1.20k|    m_max_commitments = 6*(Ticks<std::chrono::seconds>(NodeClock::now() - NodeSeconds{std::chrono::seconds{chain_start->GetMedianTimePast()}}) + MAX_FUTURE_BLOCK_TIME) / HEADER_COMMITMENT_PERIOD;
   45|       |
   46|  1.20k|    LogDebug(BCLog::NET, "Initial headers sync started with peer=%d: height=%i, max_commitments=%i, min_work=%s\n", m_id, m_current_height, m_max_commitments, m_minimum_required_work.ToString());
  ------------------
  |  |  280|  1.20k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  1.20k|    do {                                                  \
  |  |  |  |  274|  1.20k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 1.20k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  1.20k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   47|  1.20k|}
_ZN16HeadersSyncState8FinalizeEv:
   53|    560|{
   54|    560|    Assume(m_download_state != State::FINAL);
  ------------------
  |  |   97|    560|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   55|    560|    ClearShrink(m_header_commitments);
   56|    560|    m_last_header_received.SetNull();
   57|    560|    ClearShrink(m_redownloaded_headers);
   58|    560|    m_redownload_buffer_last_hash.SetNull();
   59|    560|    m_redownload_buffer_first_prev_hash.SetNull();
   60|    560|    m_process_all_remaining_headers = false;
   61|    560|    m_current_height = 0;
   62|       |
   63|    560|    m_download_state = State::FINAL;
   64|    560|}
_ZN16HeadersSyncState18ProcessNextHeadersERKNSt3__16vectorI12CBlockHeaderNS0_9allocatorIS2_EEEEb:
   71|   212k|{
   72|   212k|    ProcessingResult ret;
   73|       |
   74|   212k|    Assume(!received_headers.empty());
  ------------------
  |  |   97|   212k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   75|   212k|    if (received_headers.empty()) return ret;
  ------------------
  |  Branch (75:9): [True: 0, False: 212k]
  ------------------
   76|       |
   77|   212k|    Assume(m_download_state != State::FINAL);
  ------------------
  |  |   97|   212k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   78|   212k|    if (m_download_state == State::FINAL) return ret;
  ------------------
  |  Branch (78:9): [True: 0, False: 212k]
  ------------------
   79|       |
   80|   212k|    if (m_download_state == State::PRESYNC) {
  ------------------
  |  Branch (80:9): [True: 212k, False: 429]
  ------------------
   81|       |        // During PRESYNC, we minimally validate block headers and
   82|       |        // occasionally add commitments to them, until we reach our work
   83|       |        // threshold (at which point m_download_state is updated to REDOWNLOAD).
   84|   212k|        ret.success = ValidateAndStoreHeadersCommitments(received_headers);
   85|   212k|        if (ret.success) {
  ------------------
  |  Branch (85:13): [True: 212k, False: 316]
  ------------------
   86|   212k|            if (full_headers_message || m_download_state == State::REDOWNLOAD) {
  ------------------
  |  Branch (86:17): [True: 211k, False: 174]
  |  Branch (86:41): [True: 115, False: 59]
  ------------------
   87|       |                // A full headers message means the peer may have more to give us;
   88|       |                // also if we just switched to REDOWNLOAD then we need to re-request
   89|       |                // headers from the beginning.
   90|   211k|                ret.request_more = true;
   91|   211k|            } else {
   92|     59|                Assume(m_download_state == State::PRESYNC);
  ------------------
  |  |   97|     59|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   93|       |                // If we're in PRESYNC and we get a non-full headers
   94|       |                // message, then the peer's chain has ended and definitely doesn't
   95|       |                // have enough work, so we can stop our sync.
   96|     59|                LogDebug(BCLog::NET, "Initial headers sync aborted with peer=%d: incomplete headers message at height=%i (presync phase)\n", m_id, m_current_height);
  ------------------
  |  |  280|     59|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|     59|    do {                                                  \
  |  |  |  |  274|     59|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 59]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|     59|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   97|     59|            }
   98|   212k|        }
   99|   212k|    } else if (m_download_state == State::REDOWNLOAD) {
  ------------------
  |  Branch (99:16): [True: 429, False: 0]
  ------------------
  100|       |        // During REDOWNLOAD, we compare our stored commitments to what we
  101|       |        // receive, and add headers to our redownload buffer. When the buffer
  102|       |        // gets big enough (meaning that we've checked enough commitments),
  103|       |        // we'll return a batch of headers to the caller for processing.
  104|    429|        ret.success = true;
  105|  5.80k|        for (const auto& hdr : received_headers) {
  ------------------
  |  Branch (105:30): [True: 5.80k, False: 415]
  ------------------
  106|  5.80k|            if (!ValidateAndStoreRedownloadedHeader(hdr)) {
  ------------------
  |  Branch (106:17): [True: 14, False: 5.79k]
  ------------------
  107|       |                // Something went wrong -- the peer gave us an unexpected chain.
  108|       |                // We could consider looking at the reason for failure and
  109|       |                // punishing the peer, but for now just give up on sync.
  110|     14|                ret.success = false;
  111|     14|                break;
  112|     14|            }
  113|  5.80k|        }
  114|       |
  115|    429|        if (ret.success) {
  ------------------
  |  Branch (115:13): [True: 415, False: 14]
  ------------------
  116|       |            // Return any headers that are ready for acceptance.
  117|    415|            ret.pow_validated_headers = PopHeadersReadyForAcceptance();
  118|       |
  119|       |            // If we hit our target blockhash, then all remaining headers will be
  120|       |            // returned and we can clear any leftover internal state.
  121|    415|            if (m_redownloaded_headers.empty() && m_process_all_remaining_headers) {
  ------------------
  |  Branch (121:17): [True: 102, False: 313]
  |  Branch (121:51): [True: 102, False: 0]
  ------------------
  122|    102|                LogDebug(BCLog::NET, "Initial headers sync complete with peer=%d: releasing all at height=%i (redownload phase)\n", m_id, m_redownload_buffer_last_height);
  ------------------
  |  |  280|    102|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|    102|    do {                                                  \
  |  |  |  |  274|    102|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 102]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|    102|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  123|    313|            } else if (full_headers_message) {
  ------------------
  |  Branch (123:24): [True: 244, False: 69]
  ------------------
  124|       |                // If the headers message is full, we need to request more.
  125|    244|                ret.request_more = true;
  126|    244|            } else {
  127|       |                // For some reason our peer gave us a high-work chain, but is now
  128|       |                // declining to serve us that full chain again. Give up.
  129|       |                // Note that there's no more processing to be done with these
  130|       |                // headers, so we can still return success.
  131|     69|                LogDebug(BCLog::NET, "Initial headers sync aborted with peer=%d: incomplete headers message at height=%i (redownload phase)\n", m_id, m_redownload_buffer_last_height);
  ------------------
  |  |  280|     69|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|     69|    do {                                                  \
  |  |  |  |  274|     69|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 69]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|     69|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  132|     69|            }
  133|    415|        }
  134|    429|    }
  135|       |
  136|   212k|    if (!(ret.success && ret.request_more)) Finalize();
  ------------------
  |  Branch (136:11): [True: 212k, False: 330]
  |  Branch (136:26): [True: 212k, False: 230]
  ------------------
  137|   212k|    return ret;
  138|   212k|}
_ZN16HeadersSyncState34ValidateAndStoreHeadersCommitmentsERKNSt3__16vectorI12CBlockHeaderNS0_9allocatorIS2_EEEE:
  141|   212k|{
  142|       |    // The caller should not give us an empty set of headers.
  143|   212k|    Assume(headers.size() > 0);
  ------------------
  |  |   97|   212k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  144|   212k|    if (headers.size() == 0) return true;
  ------------------
  |  Branch (144:9): [True: 0, False: 212k]
  ------------------
  145|       |
  146|   212k|    Assume(m_download_state == State::PRESYNC);
  ------------------
  |  |   97|   212k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  147|   212k|    if (m_download_state != State::PRESYNC) return false;
  ------------------
  |  Branch (147:9): [True: 0, False: 212k]
  ------------------
  148|       |
  149|   212k|    if (headers[0].hashPrevBlock != m_last_header_received.GetHash()) {
  ------------------
  |  Branch (149:9): [True: 185, False: 212k]
  ------------------
  150|       |        // Somehow our peer gave us a header that doesn't connect.
  151|       |        // This might be benign -- perhaps our peer reorged away from the chain
  152|       |        // they were on. Give up on this sync for now (likely we will start a
  153|       |        // new sync with a new starting point).
  154|    185|        LogDebug(BCLog::NET, "Initial headers sync aborted with peer=%d: non-continuous headers at height=%i (presync phase)\n", m_id, m_current_height);
  ------------------
  |  |  280|    185|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|    185|    do {                                                  \
  |  |  |  |  274|    185|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 185]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|    185|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  155|    185|        return false;
  156|    185|    }
  157|       |
  158|       |    // If it does connect, (minimally) validate and occasionally store
  159|       |    // commitments.
  160|   226k|    for (const auto& hdr : headers) {
  ------------------
  |  Branch (160:26): [True: 226k, False: 212k]
  ------------------
  161|   226k|        if (!ValidateAndProcessSingleHeader(hdr)) {
  ------------------
  |  Branch (161:13): [True: 131, False: 226k]
  ------------------
  162|    131|            return false;
  163|    131|        }
  164|   226k|    }
  165|       |
  166|   212k|    if (m_current_chain_work >= m_minimum_required_work) {
  ------------------
  |  Branch (166:9): [True: 227, False: 211k]
  ------------------
  167|    227|        m_redownloaded_headers.clear();
  168|    227|        m_redownload_buffer_last_height = m_chain_start->nHeight;
  169|    227|        m_redownload_buffer_first_prev_hash = m_chain_start->GetBlockHash();
  170|    227|        m_redownload_buffer_last_hash = m_chain_start->GetBlockHash();
  171|    227|        m_redownload_chain_work = m_chain_start->nChainWork;
  172|    227|        m_download_state = State::REDOWNLOAD;
  173|    227|        LogDebug(BCLog::NET, "Initial headers sync transition with peer=%d: reached sufficient work at height=%i, redownloading from height=%i\n", m_id, m_current_height, m_redownload_buffer_last_height);
  ------------------
  |  |  280|    227|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|    227|    do {                                                  \
  |  |  |  |  274|    227|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 227]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|    227|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  174|    227|    }
  175|   212k|    return true;
  176|   212k|}
_ZN16HeadersSyncState30ValidateAndProcessSingleHeaderERK12CBlockHeader:
  179|   226k|{
  180|   226k|    Assume(m_download_state == State::PRESYNC);
  ------------------
  |  |   97|   226k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  181|   226k|    if (m_download_state != State::PRESYNC) return false;
  ------------------
  |  Branch (181:9): [True: 0, False: 226k]
  ------------------
  182|       |
  183|   226k|    int next_height = m_current_height + 1;
  184|       |
  185|       |    // Verify that the difficulty isn't growing too fast; an adversary with
  186|       |    // limited hashing capability has a greater chance of producing a high
  187|       |    // work chain if they compress the work into as few blocks as possible,
  188|       |    // so don't let anyone give a chain that would violate the difficulty
  189|       |    // adjustment maximum.
  190|   226k|    if (!PermittedDifficultyTransition(m_consensus_params, next_height,
  ------------------
  |  Branch (190:9): [True: 131, False: 226k]
  ------------------
  191|   226k|                m_last_header_received.nBits, current.nBits)) {
  192|    131|        LogDebug(BCLog::NET, "Initial headers sync aborted with peer=%d: invalid difficulty transition at height=%i (presync phase)\n", m_id, next_height);
  ------------------
  |  |  280|    131|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|    131|    do {                                                  \
  |  |  |  |  274|    131|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 131]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|    131|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  193|    131|        return false;
  194|    131|    }
  195|       |
  196|   226k|    if (next_height % HEADER_COMMITMENT_PERIOD == m_commit_offset) {
  ------------------
  |  Branch (196:9): [True: 435, False: 225k]
  ------------------
  197|       |        // Add a commitment.
  198|    435|        m_header_commitments.push_back(m_hasher(current.GetHash()) & 1);
  199|    435|        if (m_header_commitments.size() > m_max_commitments) {
  ------------------
  |  Branch (199:13): [True: 0, False: 435]
  ------------------
  200|       |            // The peer's chain is too long; give up.
  201|       |            // It's possible the chain grew since we started the sync; so
  202|       |            // potentially we could succeed in syncing the peer's chain if we
  203|       |            // try again later.
  204|      0|            LogDebug(BCLog::NET, "Initial headers sync aborted with peer=%d: exceeded max commitments at height=%i (presync phase)\n", m_id, next_height);
  ------------------
  |  |  280|      0|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|      0|    do {                                                  \
  |  |  |  |  274|      0|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  205|      0|            return false;
  206|      0|        }
  207|    435|    }
  208|       |
  209|   226k|    m_current_chain_work += GetBlockProof(CBlockIndex(current));
  210|   226k|    m_last_header_received = current;
  211|   226k|    m_current_height = next_height;
  212|       |
  213|   226k|    return true;
  214|   226k|}
_ZN16HeadersSyncState34ValidateAndStoreRedownloadedHeaderERK12CBlockHeader:
  217|  5.80k|{
  218|  5.80k|    Assume(m_download_state == State::REDOWNLOAD);
  ------------------
  |  |   97|  5.80k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  219|  5.80k|    if (m_download_state != State::REDOWNLOAD) return false;
  ------------------
  |  Branch (219:9): [True: 0, False: 5.80k]
  ------------------
  220|       |
  221|  5.80k|    int64_t next_height = m_redownload_buffer_last_height + 1;
  222|       |
  223|       |    // Ensure that we're working on a header that connects to the chain we're
  224|       |    // downloading.
  225|  5.80k|    if (header.hashPrevBlock != m_redownload_buffer_last_hash) {
  ------------------
  |  Branch (225:9): [True: 12, False: 5.79k]
  ------------------
  226|     12|        LogDebug(BCLog::NET, "Initial headers sync aborted with peer=%d: non-continuous headers at height=%i (redownload phase)\n", m_id, next_height);
  ------------------
  |  |  280|     12|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|     12|    do {                                                  \
  |  |  |  |  274|     12|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 12]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|     12|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  227|     12|        return false;
  228|     12|    }
  229|       |
  230|       |    // Check that the difficulty adjustments are within our tolerance:
  231|  5.79k|    uint32_t previous_nBits{0};
  232|  5.79k|    if (!m_redownloaded_headers.empty()) {
  ------------------
  |  Branch (232:9): [True: 5.58k, False: 212]
  ------------------
  233|  5.58k|        previous_nBits = m_redownloaded_headers.back().nBits;
  234|  5.58k|    } else {
  235|    212|        previous_nBits = m_chain_start->nBits;
  236|    212|    }
  237|       |
  238|  5.79k|    if (!PermittedDifficultyTransition(m_consensus_params, next_height,
  ------------------
  |  Branch (238:9): [True: 1, False: 5.79k]
  ------------------
  239|  5.79k|                previous_nBits, header.nBits)) {
  240|      1|        LogDebug(BCLog::NET, "Initial headers sync aborted with peer=%d: invalid difficulty transition at height=%i (redownload phase)\n", m_id, next_height);
  ------------------
  |  |  280|      1|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|      1|    do {                                                  \
  |  |  |  |  274|      1|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|      1|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  241|      1|        return false;
  242|      1|    }
  243|       |
  244|       |    // Track work on the redownloaded chain
  245|  5.79k|    m_redownload_chain_work += GetBlockProof(CBlockIndex(header));
  246|       |
  247|  5.79k|    if (m_redownload_chain_work >= m_minimum_required_work) {
  ------------------
  |  Branch (247:9): [True: 121, False: 5.67k]
  ------------------
  248|    121|        m_process_all_remaining_headers = true;
  249|    121|    }
  250|       |
  251|       |    // If we're at a header for which we previously stored a commitment, verify
  252|       |    // it is correct. Failure will result in aborting download.
  253|       |    // Also, don't check commitments once we've gotten to our target blockhash;
  254|       |    // it's possible our peer has extended its chain between our first sync and
  255|       |    // our second, and we don't want to return failure after we've seen our
  256|       |    // target blockhash just because we ran out of commitments.
  257|  5.79k|    if (!m_process_all_remaining_headers && next_height % HEADER_COMMITMENT_PERIOD == m_commit_offset) {
  ------------------
  |  Branch (257:9): [True: 5.67k, False: 121]
  |  Branch (257:45): [True: 37, False: 5.63k]
  ------------------
  258|     37|        if (m_header_commitments.size() == 0) {
  ------------------
  |  Branch (258:13): [True: 0, False: 37]
  ------------------
  259|      0|            LogDebug(BCLog::NET, "Initial headers sync aborted with peer=%d: commitment overrun at height=%i (redownload phase)\n", m_id, next_height);
  ------------------
  |  |  280|      0|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|      0|    do {                                                  \
  |  |  |  |  274|      0|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  260|       |            // Somehow our peer managed to feed us a different chain and
  261|       |            // we've run out of commitments.
  262|      0|            return false;
  263|      0|        }
  264|     37|        bool commitment = m_hasher(header.GetHash()) & 1;
  265|     37|        bool expected_commitment = m_header_commitments.front();
  266|     37|        m_header_commitments.pop_front();
  267|     37|        if (commitment != expected_commitment) {
  ------------------
  |  Branch (267:13): [True: 1, False: 36]
  ------------------
  268|      1|            LogDebug(BCLog::NET, "Initial headers sync aborted with peer=%d: commitment mismatch at height=%i (redownload phase)\n", m_id, next_height);
  ------------------
  |  |  280|      1|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|      1|    do {                                                  \
  |  |  |  |  274|      1|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|      1|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  269|      1|            return false;
  270|      1|        }
  271|     37|    }
  272|       |
  273|       |    // Store this header for later processing.
  274|  5.79k|    m_redownloaded_headers.emplace_back(header);
  275|  5.79k|    m_redownload_buffer_last_height = next_height;
  276|  5.79k|    m_redownload_buffer_last_hash = header.GetHash();
  277|       |
  278|  5.79k|    return true;
  279|  5.79k|}
_ZN16HeadersSyncState28PopHeadersReadyForAcceptanceEv:
  282|    415|{
  283|    415|    std::vector<CBlockHeader> ret;
  284|       |
  285|    415|    Assume(m_download_state == State::REDOWNLOAD);
  ------------------
  |  |   97|    415|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  286|    415|    if (m_download_state != State::REDOWNLOAD) return ret;
  ------------------
  |  Branch (286:9): [True: 0, False: 415]
  ------------------
  287|       |
  288|  2.62k|    while (m_redownloaded_headers.size() > REDOWNLOAD_BUFFER_SIZE ||
  ------------------
  |  Branch (288:12): [True: 0, False: 2.62k]
  ------------------
  289|  2.62k|            (m_redownloaded_headers.size() > 0 && m_process_all_remaining_headers)) {
  ------------------
  |  Branch (289:14): [True: 2.52k, False: 102]
  |  Branch (289:51): [True: 2.21k, False: 313]
  ------------------
  290|  2.21k|        ret.emplace_back(m_redownloaded_headers.front().GetFullHeader(m_redownload_buffer_first_prev_hash));
  291|  2.21k|        m_redownloaded_headers.pop_front();
  292|  2.21k|        m_redownload_buffer_first_prev_hash = ret.back().GetHash();
  293|  2.21k|    }
  294|    415|    return ret;
  295|    415|}
_ZNK16HeadersSyncState25NextHeadersRequestLocatorEv:
  298|   212k|{
  299|   212k|    Assume(m_download_state != State::FINAL);
  ------------------
  |  |   97|   212k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  300|   212k|    if (m_download_state == State::FINAL) return {};
  ------------------
  |  Branch (300:9): [True: 0, False: 212k]
  ------------------
  301|       |
  302|   212k|    auto chain_start_locator = LocatorEntries(m_chain_start);
  303|   212k|    std::vector<uint256> locator;
  304|       |
  305|   212k|    if (m_download_state == State::PRESYNC) {
  ------------------
  |  Branch (305:9): [True: 211k, False: 471]
  ------------------
  306|       |        // During pre-synchronization, we continue from the last header received.
  307|   211k|        locator.push_back(m_last_header_received.GetHash());
  308|   211k|    }
  309|       |
  310|   212k|    if (m_download_state == State::REDOWNLOAD) {
  ------------------
  |  Branch (310:9): [True: 471, False: 211k]
  ------------------
  311|       |        // During redownload, we will download from the last received header that we stored.
  312|    471|        locator.push_back(m_redownload_buffer_last_hash);
  313|    471|    }
  314|       |
  315|   212k|    locator.insert(locator.end(), chain_start_locator.begin(), chain_start_locator.end());
  316|       |
  317|   212k|    return CBlockLocator{std::move(locator)};
  318|   212k|}

_ZNK16HeadersSyncState8GetStateEv:
  119|   211k|    State GetState() const { return m_download_state; }
_ZN16HeadersSyncStateD2Ev:
  103|  1.20k|    ~HeadersSyncState() = default;
_ZN16CompressedHeaderC2ERK12CBlockHeader:
   35|  5.79k|    {
   36|  5.79k|        nVersion = header.nVersion;
   37|  5.79k|        hashMerkleRoot = header.hashMerkleRoot;
   38|  5.79k|        nTime = header.nTime;
   39|  5.79k|        nBits = header.nBits;
   40|  5.79k|        nNonce = header.nNonce;
   41|  5.79k|    }
_ZN16CompressedHeader13GetFullHeaderERK7uint256:
   43|  2.21k|    CBlockHeader GetFullHeader(const uint256& hash_prev_block) {
   44|  2.21k|        CBlockHeader ret;
   45|  2.21k|        ret.nVersion = nVersion;
   46|  2.21k|        ret.hashPrevBlock = hash_prev_block;
   47|  2.21k|        ret.hashMerkleRoot = hashMerkleRoot;
   48|  2.21k|        ret.nTime = nTime;
   49|  2.21k|        ret.nBits = nBits;
   50|  2.21k|        ret.nNonce = nNonce;
   51|  2.21k|        return ret;
   52|  2.21k|    };

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

_ZNK12CChainParams12GetConsensusEv:
   93|  1.20k|    const Consensus::Params& GetConsensus() const { return consensus; }
_ZNK12CChainParams12GenesisBlockEv:
   98|  1.23k|    const CBlock& GenesisBlock() const { return genesis; }

_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|  3.23k|{
   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|  3.23k|    static BCLog::Logger* g_logger{new BCLog::Logger()};
   42|  3.23k|    return *g_logger;
   43|  3.23k|}
_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|}
_ZNK5BCLog6Logger15WillLogCategoryENS_8LogFlagsE:
  148|  1.99k|{
  149|  1.99k|    return (m_categories.load(std::memory_order_relaxed) & category) != 0;
  150|  1.99k|}
_ZNK5BCLog6Logger20WillLogCategoryLevelENS_8LogFlagsENS_5LevelE:
  153|  1.99k|{
  154|       |    // Log messages at Info, Warning and Error level unconditionally, so that
  155|       |    // important troubleshooting information doesn't get lost.
  156|  1.99k|    if (level >= BCLog::Level::Info) return true;
  ------------------
  |  Branch (156:9): [True: 0, False: 1.99k]
  ------------------
  157|       |
  158|  1.99k|    if (!WillLogCategory(category)) return false;
  ------------------
  |  Branch (158:9): [True: 1.99k, False: 0]
  ------------------
  159|       |
  160|      0|    StdLockGuard scoped_lock(m_cs);
  161|      0|    const auto it{m_category_log_levels.find(category)};
  162|      0|    return level >= (it == m_category_log_levels.end() ? LogLevel() : it->second);
  ------------------
  |  Branch (162:22): [True: 0, False: 0]
  ------------------
  163|  1.99k|}

_ZNK5BCLog6Logger7EnabledEv:
  150|  1.23k|        {
  151|  1.23k|            StdLockGuard scoped_lock(m_cs);
  152|  1.23k|            return m_buffering || m_print_to_console || m_print_to_file || !m_print_callbacks.empty();
  ------------------
  |  Branch (152:20): [True: 0, False: 1.23k]
  |  Branch (152:35): [True: 0, False: 1.23k]
  |  Branch (152:57): [True: 0, False: 1.23k]
  |  Branch (152:76): [True: 0, False: 1.23k]
  ------------------
  153|  1.23k|        }
headerssync.cpp:_ZL17LogAcceptCategoryN5BCLog8LogFlagsENS_5LevelE:
  234|  1.99k|{
  235|  1.99k|    return LogInstance().WillLogCategoryLevel(category, level);
  236|  1.99k|}
_Z22LogPrintFormatInternalIJPKcNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvNS2_17basic_string_viewIcS5_EESA_iN5BCLog8LogFlagsENSB_5LevelEN4util21ConstevalFormatStringIXsZT_EEEDpRKT_:
  243|  1.23k|{
  244|  1.23k|    if (LogInstance().Enabled()) {
  ------------------
  |  Branch (244:9): [True: 0, False: 1.23k]
  ------------------
  245|      0|        std::string log_msg;
  246|      0|        try {
  247|      0|            log_msg = tfm::format(fmt, args...);
  248|      0|        } catch (tinyformat::format_error& fmterr) {
  249|      0|            log_msg = "Error \"" + std::string{fmterr.what()} + "\" while formatting log message: " + fmt.fmt;
  250|      0|        }
  251|      0|        LogInstance().LogPrintStr(log_msg, logging_function, source_file, source_line, flag, level);
  252|      0|    }
  253|  1.23k|}

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

_Z29PermittedDifficultyTransitionRKN9Consensus6ParamsEljj:
   90|   232k|{
   91|   232k|    if (params.fPowAllowMinDifficultyBlocks) return true;
  ------------------
  |  Branch (91:9): [True: 0, False: 232k]
  ------------------
   92|       |
   93|   232k|    if (height % params.DifficultyAdjustmentInterval() == 0) {
  ------------------
  |  Branch (93:9): [True: 92, False: 232k]
  ------------------
   94|     92|        int64_t smallest_timespan = params.nPowTargetTimespan/4;
   95|     92|        int64_t largest_timespan = params.nPowTargetTimespan*4;
   96|       |
   97|     92|        const arith_uint256 pow_limit = UintToArith256(params.powLimit);
   98|     92|        arith_uint256 observed_new_target;
   99|     92|        observed_new_target.SetCompact(new_nbits);
  100|       |
  101|       |        // Calculate the largest difficulty value possible:
  102|     92|        arith_uint256 largest_difficulty_target;
  103|     92|        largest_difficulty_target.SetCompact(old_nbits);
  104|     92|        largest_difficulty_target *= largest_timespan;
  105|     92|        largest_difficulty_target /= params.nPowTargetTimespan;
  106|       |
  107|     92|        if (largest_difficulty_target > pow_limit) {
  ------------------
  |  Branch (107:13): [True: 92, False: 0]
  ------------------
  108|     92|            largest_difficulty_target = pow_limit;
  109|     92|        }
  110|       |
  111|       |        // Round and then compare this new calculated value to what is
  112|       |        // observed.
  113|     92|        arith_uint256 maximum_new_target;
  114|     92|        maximum_new_target.SetCompact(largest_difficulty_target.GetCompact());
  115|     92|        if (maximum_new_target < observed_new_target) return false;
  ------------------
  |  Branch (115:13): [True: 4, False: 88]
  ------------------
  116|       |
  117|       |        // Calculate the smallest difficulty value possible:
  118|     88|        arith_uint256 smallest_difficulty_target;
  119|     88|        smallest_difficulty_target.SetCompact(old_nbits);
  120|     88|        smallest_difficulty_target *= smallest_timespan;
  121|     88|        smallest_difficulty_target /= params.nPowTargetTimespan;
  122|       |
  123|     88|        if (smallest_difficulty_target > pow_limit) {
  ------------------
  |  Branch (123:13): [True: 0, False: 88]
  ------------------
  124|      0|            smallest_difficulty_target = pow_limit;
  125|      0|        }
  126|       |
  127|       |        // Round and then compare this new calculated value to what is
  128|       |        // observed.
  129|     88|        arith_uint256 minimum_new_target;
  130|     88|        minimum_new_target.SetCompact(smallest_difficulty_target.GetCompact());
  131|     88|        if (minimum_new_target > observed_new_target) return false;
  ------------------
  |  Branch (131:13): [True: 25, False: 63]
  ------------------
  132|   232k|    } else if (old_nbits != new_nbits) {
  ------------------
  |  Branch (132:16): [True: 103, False: 231k]
  ------------------
  133|    103|        return false;
  134|    103|    }
  135|   232k|    return true;
  136|   232k|}

_ZNK12CBlockHeader7GetHashEv:
   12|   660k|{
   13|   660k|    return (HashWriter{} << *this).GetHash();
   14|   660k|}

_ZN12CBlockHeaderC2Ev:
   33|   323k|    {
   34|   323k|        SetNull();
   35|   323k|    }
_ZN12CBlockHeader7SetNullEv:
   40|   324k|    {
   41|   324k|        nVersion = 0;
   42|   324k|        hashPrevBlock.SetNull();
   43|   324k|        hashMerkleRoot.SetNull();
   44|   324k|        nTime = 0;
   45|   324k|        nBits = 0;
   46|   324k|        nNonce = 0;
   47|   324k|    }
_ZN13CBlockLocatorC2EONSt3__16vectorI7uint256NS0_9allocatorIS2_EEEE:
  138|   212k|    explicit CBlockLocator(std::vector<uint256>&& have) : vHave(std::move(have)) {}
_ZN12CBlockHeader16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_:
   37|   320k|    SERIALIZE_METHODS(CBlockHeader, obj) { READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce); }
  ------------------
  |  |  156|   320k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
_ZN12CBlockHeader16SerializationOpsI10HashWriterKS_15ActionSerializeEEvRT0_RT_T1_:
   37|   660k|    SERIALIZE_METHODS(CBlockHeader, obj) { READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce); }
  ------------------
  |  |  156|   660k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------

_Z30MakeRandDeterministicDANGEROUSRK7uint256:
  671|  1.23k|{
  672|  1.23k|    GetRNGState().MakeDeterministic(seed);
  673|  1.23k|}
_Z12GetRandBytes4SpanIhE:
  677|  3.61k|{
  678|  3.61k|    g_used_g_prng = true;
  679|  3.61k|    ProcRand(bytes.data(), bytes.size(), RNGLevel::FAST, /*always_use_real_rng=*/false);
  680|  3.61k|}
_ZN17FastRandomContext10RandomSeedEv:
  695|  3.61k|{
  696|  3.61k|    uint256 seed = GetRandHash();
  697|  3.61k|    rng.SetKey(MakeByteSpan(seed));
  698|  3.61k|    requires_seed = false;
  699|  3.61k|}
_ZN17FastRandomContextC2Eb:
  764|  3.61k|FastRandomContext::FastRandomContext(bool fDeterministic) noexcept : requires_seed(!fDeterministic), rng(ZERO_KEY)
  765|  3.61k|{
  766|       |    // Note that despite always initializing with ZERO_KEY, requires_seed is set to true if not
  767|       |    // fDeterministic. That means the rng will be reinitialized with a secure random key upon first
  768|       |    // use.
  769|  3.61k|}
random.cpp:_ZN12_GLOBAL__N_111GetRNGStateEv:
  526|  4.85k|{
  527|       |    // This idiom relies on the guarantee that static variable are initialized
  528|       |    // on first call, even when multiple parallel calls are permitted.
  529|  4.85k|    static std::vector<RNGState, secure_allocator<RNGState>> g_rng(1);
  530|  4.85k|    return g_rng[0];
  531|  4.85k|}
random.cpp:_ZN12_GLOBAL__N_18RNGState17MakeDeterministicERK7uint256:
  475|  1.23k|    {
  476|  1.23k|        LOCK(m_mutex);
  ------------------
  |  |  257|  1.23k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  1.23k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  1.23k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  1.23k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  477|  1.23k|        m_deterministic_prng.emplace(MakeByteSpan(seed));
  478|  1.23k|    }
random.cpp:_ZN12_GLOBAL__N_18ProcRandEPhiNS_8RNGLevelEb:
  638|  3.61k|{
  639|       |    // Make sure the RNG is initialized first (as all Seed* function possibly need hwrand to be available).
  640|  3.61k|    RNGState& rng = GetRNGState();
  641|       |
  642|  3.61k|    assert(num <= 32);
  643|       |
  644|  3.61k|    CSHA512 hasher;
  645|  3.61k|    switch (level) {
  ------------------
  |  Branch (645:13): [True: 0, False: 3.61k]
  ------------------
  646|  3.61k|    case RNGLevel::FAST:
  ------------------
  |  Branch (646:5): [True: 3.61k, False: 0]
  ------------------
  647|  3.61k|        SeedFast(hasher);
  648|  3.61k|        break;
  649|      0|    case RNGLevel::SLOW:
  ------------------
  |  Branch (649:5): [True: 0, False: 3.61k]
  ------------------
  650|      0|        SeedSlow(hasher, rng);
  651|      0|        break;
  652|      0|    case RNGLevel::PERIODIC:
  ------------------
  |  Branch (652:5): [True: 0, False: 3.61k]
  ------------------
  653|      0|        SeedPeriodic(hasher, rng);
  654|      0|        break;
  655|  3.61k|    }
  656|       |
  657|       |    // Combine with and update state
  658|  3.61k|    if (!rng.MixExtract(out, num, std::move(hasher), false, always_use_real_rng)) {
  ------------------
  |  Branch (658:9): [True: 0, False: 3.61k]
  ------------------
  659|       |        // On the first invocation, also seed with SeedStartup().
  660|      0|        CSHA512 startup_hasher;
  661|      0|        SeedStartup(startup_hasher, rng);
  662|      0|        rng.MixExtract(out, num, std::move(startup_hasher), true, always_use_real_rng);
  663|      0|    }
  664|  3.61k|}
random.cpp:_ZN12_GLOBAL__N_18SeedFastER7CSHA512:
  545|  3.61k|{
  546|  3.61k|    unsigned char buffer[32];
  547|       |
  548|       |    // Stack pointer to indirectly commit to thread/callstack
  549|  3.61k|    const unsigned char* ptr = buffer;
  550|  3.61k|    hasher.Write((const unsigned char*)&ptr, sizeof(ptr));
  551|       |
  552|       |    // Hardware randomness is very fast when available; use it always.
  553|  3.61k|    SeedHardwareFast(hasher);
  554|       |
  555|       |    // High-precision timestamp
  556|  3.61k|    SeedTimestamp(hasher);
  557|  3.61k|}
random.cpp:_ZN12_GLOBAL__N_116SeedHardwareFastER7CSHA512:
  259|  3.61k|void SeedHardwareFast(CSHA512& hasher) noexcept {
  260|  3.61k|#if defined(__x86_64__) || defined(__amd64__) || defined(__i386__)
  261|  3.61k|    if (g_rdrand_supported) {
  ------------------
  |  Branch (261:9): [True: 3.61k, False: 0]
  ------------------
  262|  3.61k|        uint64_t out = GetRdRand();
  263|  3.61k|        hasher.Write((const unsigned char*)&out, sizeof(out));
  264|  3.61k|        return;
  265|  3.61k|    }
  266|       |#elif defined(__aarch64__) && defined(HWCAP2_RNG)
  267|       |    if (g_rndr_supported) {
  268|       |        uint64_t out = GetRNDR();
  269|       |        hasher.Write((const unsigned char*)&out, sizeof(out));
  270|       |        return;
  271|       |    }
  272|       |#endif
  273|  3.61k|}
random.cpp:_ZN12_GLOBAL__N_19GetRdRandEv:
  126|  3.61k|{
  127|       |    // RdRand may very rarely fail. Invoke it up to 10 times in a loop to reduce this risk.
  128|       |#ifdef __i386__
  129|       |    uint8_t ok = 0;
  130|       |    // Initialize to 0 to silence a compiler warning that r1 or r2 may be used
  131|       |    // uninitialized. Even if rdrand fails (!ok) it will set the output to 0,
  132|       |    // but there is no way that the compiler could know that.
  133|       |    uint32_t r1 = 0, r2 = 0;
  134|       |    for (int i = 0; i < 10; ++i) {
  135|       |        __asm__ volatile (".byte 0x0f, 0xc7, 0xf0; setc %1" : "=a"(r1), "=q"(ok) :: "cc"); // rdrand %eax
  136|       |        if (ok) break;
  137|       |    }
  138|       |    for (int i = 0; i < 10; ++i) {
  139|       |        __asm__ volatile (".byte 0x0f, 0xc7, 0xf0; setc %1" : "=a"(r2), "=q"(ok) :: "cc"); // rdrand %eax
  140|       |        if (ok) break;
  141|       |    }
  142|       |    return (((uint64_t)r2) << 32) | r1;
  143|       |#elif defined(__x86_64__) || defined(__amd64__)
  144|       |    uint8_t ok = 0;
  145|  3.61k|    uint64_t r1 = 0; // See above why we initialize to 0.
  146|  3.61k|    for (int i = 0; i < 10; ++i) {
  ------------------
  |  Branch (146:21): [True: 3.61k, False: 0]
  ------------------
  147|  3.61k|        __asm__ volatile (".byte 0x48, 0x0f, 0xc7, 0xf0; setc %1" : "=a"(r1), "=q"(ok) :: "cc"); // rdrand %rax
  148|  3.61k|        if (ok) break;
  ------------------
  |  Branch (148:13): [True: 3.61k, False: 0]
  ------------------
  149|  3.61k|    }
  150|  3.61k|    return r1;
  151|       |#else
  152|       |#error "RdRand is only supported on x86 and x86_64"
  153|       |#endif
  154|  3.61k|}
random.cpp:_ZN12_GLOBAL__N_113SeedTimestampER7CSHA512:
  539|  3.61k|{
  540|  3.61k|    int64_t perfcounter = GetPerformanceCounter();
  541|  3.61k|    hasher.Write((const unsigned char*)&perfcounter, sizeof(perfcounter));
  542|  3.61k|}
random.cpp:_ZN12_GLOBAL__N_121GetPerformanceCounterEv:
   65|  3.61k|{
   66|       |    // Read the hardware time stamp counter when available.
   67|       |    // See https://en.wikipedia.org/wiki/Time_Stamp_Counter for more information.
   68|       |#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
   69|       |    return __rdtsc();
   70|       |#elif !defined(_MSC_VER) && defined(__i386__)
   71|       |    uint64_t r = 0;
   72|       |    __asm__ volatile ("rdtsc" : "=A"(r)); // Constrain the r variable to the eax:edx pair.
   73|       |    return r;
   74|       |#elif !defined(_MSC_VER) && (defined(__x86_64__) || defined(__amd64__))
   75|       |    uint64_t r1 = 0, r2 = 0;
   76|  3.61k|    __asm__ volatile ("rdtsc" : "=a"(r1), "=d"(r2)); // Constrain r1 to rax and r2 to rdx.
   77|  3.61k|    return (r2 << 32) | r1;
   78|       |#else
   79|       |    // Fall back to using standard library clock (usually microsecond or nanosecond precision)
   80|       |    return std::chrono::high_resolution_clock::now().time_since_epoch().count();
   81|       |#endif
   82|  3.61k|}
random.cpp:_ZN12_GLOBAL__N_18RNGState10MixExtractEPhmO7CSHA512bb:
  488|  3.61k|    {
  489|  3.61k|        assert(num <= 32);
  490|  3.61k|        unsigned char buf[64];
  491|  3.61k|        static_assert(sizeof(buf) == CSHA512::OUTPUT_SIZE, "Buffer needs to have hasher's output size");
  492|  3.61k|        bool ret;
  493|  3.61k|        {
  494|  3.61k|            LOCK(m_mutex);
  ------------------
  |  |  257|  3.61k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  3.61k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  3.61k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  3.61k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  495|  3.61k|            ret = (m_strongly_seeded |= strong_seed);
  496|       |            // Write the current state of the RNG into the hasher
  497|  3.61k|            hasher.Write(m_state, 32);
  498|       |            // Write a new counter number into the state
  499|  3.61k|            hasher.Write((const unsigned char*)&m_counter, sizeof(m_counter));
  500|  3.61k|            ++m_counter;
  501|       |            // Finalize the hasher
  502|  3.61k|            hasher.Finalize(buf);
  503|       |            // Store the last 32 bytes of the hash output as new RNG state.
  504|  3.61k|            memcpy(m_state, buf + 32, 32);
  505|       |            // Handle requests for deterministic randomness.
  506|  3.61k|            if (!always_use_real_rng && m_deterministic_prng.has_value()) [[unlikely]] {
  ------------------
  |  Branch (506:17): [True: 3.61k, False: 0]
  |  Branch (506:41): [True: 3.61k, False: 0]
  ------------------
  507|       |                // Overwrite the beginning of buf, which will be used for output.
  508|  3.61k|                m_deterministic_prng->Keystream(AsWritableBytes(Span{buf, num}));
  509|       |                // Do not require strong seeding for deterministic output.
  510|  3.61k|                ret = true;
  511|  3.61k|            }
  512|  3.61k|        }
  513|       |        // If desired, copy (up to) the first 32 bytes of the hash output as output.
  514|  3.61k|        if (num) {
  ------------------
  |  Branch (514:13): [True: 3.61k, False: 0]
  ------------------
  515|  3.61k|            assert(out != nullptr);
  516|  3.61k|            memcpy(out, buf, num);
  517|  3.61k|        }
  518|       |        // Best effort cleanup of internal state
  519|  3.61k|        hasher.Reset();
  520|  3.61k|        memory_cleanse(buf, 64);
  521|  3.61k|        return ret;
  522|  3.61k|    }

_ZN11RandomMixinI17FastRandomContextE4ImplEv:
  185|  2.41k|    RandomNumberGenerator auto& Impl() noexcept { return static_cast<T&>(*this); }
_ZN11RandomMixinI17FastRandomContextE8randbitsEi:
  205|  1.20k|    {
  206|  1.20k|        Assume(bits <= 64);
  ------------------
  |  |   97|  1.20k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  207|       |        // Requests for the full 64 bits are passed through.
  208|  1.20k|        if (bits == 64) return Impl().rand64();
  ------------------
  |  Branch (208:13): [True: 0, False: 1.20k]
  ------------------
  209|  1.20k|        uint64_t ret;
  210|  1.20k|        if (bits <= bitbuf_size) {
  ------------------
  |  Branch (210:13): [True: 0, False: 1.20k]
  ------------------
  211|       |            // If there is enough entropy left in bitbuf, return its bottom bits bits.
  212|      0|            ret = bitbuf;
  213|      0|            bitbuf >>= bits;
  214|      0|            bitbuf_size -= bits;
  215|  1.20k|        } else {
  216|       |            // If not, return all of bitbuf, supplemented with the (bits - bitbuf_size) bottom
  217|       |            // bits of a newly generated 64-bit number on top. The remainder of that generated
  218|       |            // number becomes the new bitbuf.
  219|  1.20k|            uint64_t gen = Impl().rand64();
  220|  1.20k|            ret = (gen << bitbuf_size) | bitbuf;
  221|  1.20k|            bitbuf = gen >> (bits - bitbuf_size);
  222|  1.20k|            bitbuf_size = 64 + bitbuf_size - bits;
  223|  1.20k|        }
  224|       |        // Return the bottom bits bits of ret.
  225|  1.20k|        return ret & ((uint64_t{1} << bits) - 1);
  226|  1.20k|    }
_ZN17FastRandomContext6rand64Ev:
  396|  3.61k|    {
  397|  3.61k|        if (requires_seed) RandomSeed();
  ------------------
  |  Branch (397:13): [True: 3.61k, False: 0]
  ------------------
  398|  3.61k|        std::array<std::byte, 8> buf;
  399|  3.61k|        rng.Keystream(buf);
  400|  3.61k|        return ReadLE64(buf.data());
  401|  3.61k|    }
_Z11GetRandHashv:
  455|  3.61k|{
  456|  3.61k|    uint256 hash;
  457|  3.61k|    GetRandBytes(hash);
  458|  3.61k|    return hash;
  459|  3.61k|}
_ZN11RandomMixinI17FastRandomContextEC2Ev:
  195|  3.61k|    constexpr RandomMixin() noexcept = default;
_ZN11RandomMixinI17FastRandomContextE9randrangeITkNSt3__18integralEjEET_S4_:
  255|  1.20k|    {
  256|  1.20k|        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max());
  257|  1.20k|        Assume(range > 0);
  ------------------
  |  |   97|  1.20k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  258|  1.20k|        uint64_t maxval = range - 1U;
  259|  1.20k|        int bits = std::bit_width(maxval);
  260|  1.20k|        while (true) {
  ------------------
  |  Branch (260:16): [Folded - Ignored]
  ------------------
  261|  1.20k|            uint64_t ret = Impl().randbits(bits);
  262|  1.20k|            if (ret <= maxval) return ret;
  ------------------
  |  Branch (262:17): [True: 1.20k, False: 0]
  ------------------
  263|  1.20k|        }
  264|  1.20k|    }

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_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_clear:
  305|      2|static void secp256k1_ge_clear(secp256k1_ge *r) {
  306|      2|    secp256k1_memclear(r, sizeof(secp256k1_ge));
  307|      2|}

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.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_memclear:
  223|      6|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|      6|    memset(ptr, 0, len);
  240|      6|    __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|      6|}

_Z11UnserializeI10DataStreamR12CBlockHeaderQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|   320k|{
  763|   320k|    a.Unserialize(is);
  764|   320k|}
_ZN12CBlockHeader11UnserializeI10DataStreamEEvRT_:
  228|   320k|    {                                                                                               \
  229|   320k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   320k|        Unser(s, *this);                                                                            \
  231|   320k|    }
_ZN12CBlockHeader5UnserI10DataStreamEEvRT_RS_:
  180|   320k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJRiR7uint256S4_RjS5_S5_EEEvRT_DpOT0_:
 1033|   320k|    {
 1034|   320k|        ::UnserializeMany(s, args...);
 1035|   320k|    }
_Z15UnserializeManyI10DataStreamJRiR7uint256S3_RjS4_S4_EEvRT_DpOT0_:
 1001|   320k|{
 1002|   320k|    (::Unserialize(s, args), ...);
 1003|   320k|}
_Z11UnserializeI10DataStreamEvRT_Ri:
  276|   320k|template<typename Stream> inline void Unserialize(Stream& s, int32_t& a ) { a = ser_readdata32(s); }
_Z14ser_readdata32I10DataStreamEjRT_:
  102|  1.28M|{
  103|  1.28M|    uint32_t obj;
  104|  1.28M|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|  1.28M|    return le32toh_internal(obj);
  106|  1.28M|}
_Z11UnserializeI10DataStreamR7uint256Q14UnserializableIT0_T_EEvRS4_OS3_:
  762|   640k|{
  763|   640k|    a.Unserialize(is);
  764|   640k|}
_Z11UnserializeI10DataStreamEvRT_Rj:
  277|   960k|template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); }
_Z15ReadCompactSizeI10DataStreamEmRT_b:
  340|   213k|{
  341|   213k|    uint8_t chSize = ser_readdata8(is);
  342|   213k|    uint64_t nSizeRet = 0;
  343|   213k|    if (chSize < 253)
  ------------------
  |  Branch (343:9): [True: 212k, False: 399]
  ------------------
  344|   212k|    {
  345|   212k|        nSizeRet = chSize;
  346|   212k|    }
  347|    399|    else if (chSize == 253)
  ------------------
  |  Branch (347:14): [True: 91, False: 308]
  ------------------
  348|     91|    {
  349|     91|        nSizeRet = ser_readdata16(is);
  350|     91|        if (nSizeRet < 253)
  ------------------
  |  Branch (350:13): [True: 11, False: 80]
  ------------------
  351|     11|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|     91|    }
  353|    308|    else if (chSize == 254)
  ------------------
  |  Branch (353:14): [True: 82, False: 226]
  ------------------
  354|     82|    {
  355|     82|        nSizeRet = ser_readdata32(is);
  356|     82|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (356:13): [True: 19, False: 63]
  ------------------
  357|     19|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|     82|    }
  359|    226|    else
  360|    226|    {
  361|    226|        nSizeRet = ser_readdata64(is);
  362|    226|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (362:13): [True: 38, False: 188]
  ------------------
  363|     38|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  364|    226|    }
  365|   212k|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (365:9): [True: 212k, False: 120]
  |  Branch (365:24): [True: 91, False: 212k]
  ------------------
  366|     91|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  367|     91|    }
  368|   212k|    return nSizeRet;
  369|   212k|}
_Z13ser_readdata8I10DataStreamEhRT_:
   84|   213k|{
   85|   213k|    uint8_t obj;
   86|   213k|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|   213k|    return obj;
   88|   213k|}
_Z14ser_readdata16I10DataStreamEtRT_:
   90|     91|{
   91|     91|    uint16_t obj;
   92|     91|    s.read(AsWritableBytes(Span{&obj, 1}));
   93|     91|    return le16toh_internal(obj);
   94|     91|}
_Z14ser_readdata64I10DataStreamEmRT_:
  114|    110|{
  115|    110|    uint64_t obj;
  116|    110|    s.read(AsWritableBytes(Span{&obj, 1}));
  117|    110|    return le64toh_internal(obj);
  118|    110|}
_Z11UnserializeI10DataStream12CBlockHeaderNSt3__19allocatorIS1_EEEvRT_RNS2_6vectorIT0_T1_EE:
  866|   213k|{
  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|   213k|    } else {
  879|   213k|        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
  880|   213k|    }
  881|   213k|}
_Z11UnserializeI10DataStream7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI12CBlockHeaderNS5_9allocatorIS7_EEEEEQ14UnserializableIT0_T_EEvRSE_OSD_:
  762|   213k|{
  763|   213k|    a.Unserialize(is);
  764|   213k|}
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI12CBlockHeaderNS3_9allocatorIS5_EEEEE11UnserializeI10DataStreamEEvRT_:
  483|   213k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15VectorFormatterI16DefaultFormatterE5UnserI10DataStreamNSt3__16vectorI12CBlockHeaderNS4_9allocatorIS6_EEEEEEvRT_RT0_:
  672|   213k|    {
  673|   213k|        Formatter formatter;
  674|   213k|        v.clear();
  675|   213k|        size_t size = ReadCompactSize(s);
  676|   213k|        size_t allocated = 0;
  677|   425k|        while (allocated < size) {
  ------------------
  |  Branch (677:16): [True: 212k, False: 213k]
  ------------------
  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|   212k|            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
  682|   212k|            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
  683|   212k|            v.reserve(allocated);
  684|   533k|            while (v.size() < allocated) {
  ------------------
  |  Branch (684:20): [True: 320k, False: 212k]
  ------------------
  685|   320k|                v.emplace_back();
  686|   320k|                formatter.Unser(s, v.back());
  687|   320k|            }
  688|   212k|        }
  689|   213k|    };
_ZN16DefaultFormatter5UnserI10DataStream12CBlockHeaderEEvRT_RT0_:
  777|   320k|    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
headerssync.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI12CBlockHeaderNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_:
  497|   213k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI12CBlockHeaderNS3_9allocatorIS5_EEEEEC2ES9_:
  481|   213k|    explicit Wrapper(T obj) : m_object(obj) {}
_Z9SerializeI10HashWriterEvRT_j:
  262|  1.98M|template<typename Stream> inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); }
_Z15ser_writedata32I10HashWriterEvRT_j:
   69|  2.64M|{
   70|  2.64M|    obj = htole32_internal(obj);
   71|  2.64M|    s.write(AsBytes(Span{&obj, 1}));
   72|  2.64M|}
_Z9SerializeI10HashWriter7uint256Q12SerializableIT0_T_EEvRS3_RKS2_:
  753|  1.32M|{
  754|  1.32M|    a.Serialize(os);
  755|  1.32M|}
_Z9SerializeI10HashWriterTk9BasicByteKhEvRT_4SpanIT0_E:
  268|  1.32M|template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
_Z9SerializeI10HashWriterEvRT_i:
  261|   660k|template<typename Stream> inline void Serialize(Stream& s, int32_t a ) { ser_writedata32(s, a); }
_Z9SerializeI10HashWriter12CBlockHeaderQ12SerializableIT0_T_EEvRS3_RKS2_:
  753|   660k|{
  754|   660k|    a.Serialize(os);
  755|   660k|}
_ZNK12CBlockHeader9SerializeI10HashWriterEEvRT_:
  222|   660k|    {                                                                                               \
  223|   660k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|   660k|        Ser(s, *this);                                                                              \
  225|   660k|    }                                                                                               \
_ZN12CBlockHeader3SerI10HashWriterEEvRT_RKS_:
  178|   660k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI10HashWriterJi7uint256S2_jjjEEEvRT_DpRKT0_:
 1013|   660k|    {
 1014|   660k|        ::SerializeMany(s, args...);
 1015|   660k|    }
_Z13SerializeManyI10HashWriterJi7uint256S1_jjjEEvRT_DpRKT0_:
  995|   660k|{
  996|   660k|    (::Serialize(s, args), ...);
  997|   660k|}

_Z9UCharCastPKSt4byte:
  287|  3.96M|inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast<const unsigned char*>(c); }
_ZNK4SpanIKSt4byteE4sizeEv:
  187|  4.18M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKSt4byteE4dataEv:
  174|  4.45M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4sizeEv:
  187|  2.36k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKhE5beginEv:
  175|  2.36k|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKhE3endEv:
  176|  2.36k|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIhE4sizeEv:
  187|  3.61k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIhE4dataEv:
  174|   864k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4dataEv:
  174|  1.53M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanISt4byteE4sizeEv:
  187|  6.45M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanISt4byteE4dataEv:
  174|  2.14M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanISt4byteE7subspanEm:
  196|  1.20k|    {
  197|  1.20k|        ASSERT_IF_DEBUG(size() >= offset);
  198|  1.20k|        return Span<C>(m_data + offset, m_size - offset);
  199|  1.20k|    }
_ZNK4SpanIKhE10size_bytesEv:
  188|  1.53M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIKhE4SpanIKSt4byteES1_IT_E:
  259|  1.53M|{
  260|  1.53M|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  1.53M|}
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalISA_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISA_EE4sizeEEmEE5valueEDnE4typeE:
  172|   214k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m:
  119|  4.17M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanISt4byteEC2INSt3__15arrayIS0_Lm8EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  165|  3.61k|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIjE4dataEv:
  174|  3.92M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIjE10size_bytesEv:
  188|  3.92M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIjE4SpanIKSt4byteES0_IT_E:
  259|  2.64M|{
  260|  2.64M|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  2.64M|}
_ZNK4SpanIhE10size_bytesEv:
  188|   860k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIhE4SpanIKSt4byteES0_IT_E:
  259|  3.61k|{
  260|  3.61k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  3.61k|}
_ZNK4SpanItE4dataEv:
  174|     91|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanItE10size_bytesEv:
  188|     91|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_ZNK4SpanImE4dataEv:
  174|    110|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanImE10size_bytesEv:
  188|    110|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  2.13M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E:
  264|   857k|{
  265|   857k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|   857k|}
_ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m:
  119|   216k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesItE4SpanISt4byteES0_IT_E:
  264|     91|{
  265|     91|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|     91|}
_ZN4SpanItEC2ItTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_tEE5valueEiE4typeELi0EEEPS4_m:
  119|     91|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIjE4SpanISt4byteES0_IT_E:
  264|  1.28M|{
  265|  1.28M|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  1.28M|}
_ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m:
  119|  3.92M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesImE4SpanISt4byteES0_IT_E:
  264|    110|{
  265|    110|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|    110|}
_ZN4SpanImEC2ImTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_mEE5valueEiE4typeELi0EEEPS4_m:
  119|    110|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanIKSt4byteEC2INSt3__15arrayIS0_Lm32EEEEERKT_NS4_9enable_ifIXaaaantsr7is_SpanIS7_EE5valuesr3std14is_convertibleIPA_NS4_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S1_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE:
  172|  3.61k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2INSt3__15arrayIhLm32EEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE:
  172|  1.32M|        : m_data(other.data()), m_size(other.size()){}
_Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEE4SpanISt4byteEOT_:
  275|   640k|{
  276|   640k|    return AsWritableBytes(Span{std::forward<V>(v)});
  277|   640k|}
_ZN4SpanIhEC2INSt3__15arrayIhLm32EEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  165|   640k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2I7uint256EERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS7_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  172|  1.23k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIhEC2I7uint256EERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS3_EE5valuesr3std14is_convertibleIPA_NS5_14remove_pointerIDTcldtclsr3stdE7declvalIS4_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS4_EE4sizeEEmEE5valueEDnE4typeE:
  165|  7.23k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2ILi32EEERAT__S0_:
  151|  1.23k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZNK4SpanISt4byteE5beginEv:
  175|  7.23k|    constexpr C* begin() const noexcept { return m_data; }
_Z12MakeByteSpanIRK7uint256E4SpanIKSt4byteEOT_:
  270|  1.23k|{
  271|  1.23k|    return AsBytes(Span{std::forward<V>(v)});
  272|  1.23k|}
_Z12MakeByteSpanIR7uint256E4SpanIKSt4byteEOT_:
  270|  3.61k|{
  271|  3.61k|    return AsBytes(Span{std::forward<V>(v)});
  272|  3.61k|}
_ZNK4SpanISt4byteE5emptyEv:
  189|  14.4k|    constexpr bool empty() const noexcept { return size() == 0; }
_ZN4SpanISt4byteEC2INSt3__15arrayIS0_Lm64EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  165|  6.02k|        : m_data(other.data()), m_size(other.size()){}

_ZN10DataStreamC2E4SpanIKhE:
  165|   213k|    explicit DataStream(Span<const uint8_t> sp) : DataStream{AsBytes(sp)} {}
_ZN10DataStreamC2E4SpanIKSt4byteE:
  166|   213k|    explicit DataStream(Span<const value_type> sp) : vch(sp.data(), sp.data() + sp.size()) {}
_ZN10DataStream4readE4SpanISt4byteE:
  219|  2.13M|    {
  220|  2.13M|        if (dst.size() == 0) return;
  ------------------
  |  Branch (220:13): [True: 0, False: 2.13M]
  ------------------
  221|       |
  222|       |        // Read from the beginning of the buffer
  223|  2.13M|        auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
  224|  2.13M|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (224:13): [True: 0, False: 2.13M]
  |  Branch (224:43): [True: 451, False: 2.13M]
  ------------------
  225|    451|            throw std::ios_base::failure("DataStream::read(): end of data");
  226|    451|        }
  227|  2.13M|        memcpy(dst.data(), &vch[m_read_pos], dst.size());
  228|  2.13M|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (228:13): [True: 17.2k, False: 2.11M]
  ------------------
  229|  17.2k|            m_read_pos = 0;
  230|  17.2k|            vch.clear();
  231|  17.2k|            return;
  232|  17.2k|        }
  233|  2.11M|        m_read_pos = next_read_pos.value();
  234|  2.11M|    }
_ZN10DataStreamrsIRNSt3__16vectorI12CBlockHeaderNS1_9allocatorIS3_EEEEEERS_OT_:
  266|   213k|    {
  267|   213k|        ::Unserialize(*this, obj);
  268|   213k|        return (*this);
  269|   213k|    }

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

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

_Z17MaybeCheckNotHeldR14AnnotatedMixinINSt3__15mutexEE:
  247|  4.85k|inline Mutex& MaybeCheckNotHeld(Mutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEEC2ERS3_PKcS7_ib:
  177|  4.85k|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  178|  4.85k|    {
  179|  4.85k|        if (fTry)
  ------------------
  |  Branch (179:13): [True: 0, False: 4.85k]
  ------------------
  180|      0|            TryEnter(pszName, pszFile, nLine);
  181|  4.85k|        else
  182|  4.85k|            Enter(pszName, pszFile, nLine);
  183|  4.85k|    }
_Z13EnterCriticalINSt3__15mutexEEvPKcS3_iPT_b:
   75|  4.85k|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_Z13LeaveCriticalv:
   76|  4.85k|inline void LeaveCritical() {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEE5EnterEPKcS6_i:
  157|  4.85k|    {
  158|  4.85k|        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|  4.85k|        Base::lock();
  164|  4.85k|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEED2Ev:
  197|  4.85k|    {
  198|  4.85k|        if (Base::owns_lock())
  ------------------
  |  Branch (198:13): [True: 4.85k, False: 0]
  ------------------
  199|  4.85k|            LeaveCritical();
  200|  4.85k|    }
_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|  1.23k|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIlEET_S1_S1_:
  205|  1.23k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.23k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  1.23k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.23k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.23k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.23k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.23k|  uint64_t result = 0;
  215|  1.23k|  size_t offset = 0;
  216|       |
  217|  6.13k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 6.13k, False: 0]
  |  Branch (217:43): [True: 4.92k, False: 1.21k]
  ------------------
  218|  6.13k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 4.89k, False: 24]
  ------------------
  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|  4.89k|    --remaining_bytes_;
  226|  4.89k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  4.89k|    offset += CHAR_BIT;
  228|  4.89k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.23k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 1.23k, False: 0]
  ------------------
  232|  1.23k|    result = result % (range + 1);
  233|       |
  234|  1.23k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.23k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_:
  205|    409|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|    409|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|    409|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|    409|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 409]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|    409|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|    409|  uint64_t result = 0;
  215|    409|  size_t offset = 0;
  216|       |
  217|    755|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 755, False: 0]
  |  Branch (217:43): [True: 377, False: 378]
  ------------------
  218|    755|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 346, False: 31]
  ------------------
  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|    346|    --remaining_bytes_;
  226|    346|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|    346|    offset += CHAR_BIT;
  228|    346|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|    409|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 409, False: 0]
  ------------------
  232|    409|    result = result % (range + 1);
  233|       |
  234|    409|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|    409|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_:
  205|  1.20k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.20k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  1.20k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.20k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.20k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.20k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.20k|  uint64_t result = 0;
  215|  1.20k|  size_t offset = 0;
  216|       |
  217|  3.46k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 3.46k, False: 0]
  |  Branch (217:43): [True: 2.33k, False: 1.12k]
  ------------------
  218|  3.46k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 2.25k, False: 77]
  ------------------
  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.25k|    --remaining_bytes_;
  226|  2.25k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  2.25k|    offset += CHAR_BIT;
  228|  2.25k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.20k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 1.20k, False: 0]
  ------------------
  232|  1.20k|    result = result % (range + 1);
  233|       |
  234|  1.20k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.20k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v:
  195|   425k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|   425k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|   425k|                                std::numeric_limits<T>::max());
  198|   425k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_:
  205|   425k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|   425k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|   425k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|   425k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 425k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|   425k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|   425k|  uint64_t result = 0;
  215|   425k|  size_t offset = 0;
  216|       |
  217|   850k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 425k, False: 424k]
  |  Branch (217:43): [True: 425k, False: 0]
  ------------------
  218|   850k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 424k, False: 708]
  ------------------
  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|   424k|    --remaining_bytes_;
  226|   424k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|   424k|    offset += CHAR_BIT;
  228|   424k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|   425k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 425k, False: 0]
  ------------------
  232|   425k|    result = result % (range + 1);
  233|       |
  234|   425k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|   425k|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm:
  153|   213k|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|   213k|  std::string result;
  161|       |
  162|       |  // Reserve the anticipated capacity to prevent several reallocations.
  163|   213k|  result.reserve(std::min(max_length, remaining_bytes_));
  164|  44.0M|  for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) {
  ------------------
  |  Branch (164:22): [True: 44.0M, False: 748]
  |  Branch (164:40): [True: 44.0M, False: 36]
  ------------------
  165|  44.0M|    char next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  166|  44.0M|    Advance(1);
  167|  44.0M|    if (next == '\\' && remaining_bytes_ != 0) {
  ------------------
  |  Branch (167:9): [True: 368k, False: 43.6M]
  |  Branch (167:25): [True: 368k, False: 5]
  ------------------
  168|   368k|      next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  169|   368k|      Advance(1);
  170|   368k|      if (next != '\\')
  ------------------
  |  Branch (170:11): [True: 212k, False: 156k]
  ------------------
  171|   212k|        break;
  172|   368k|    }
  173|  43.8M|    result += next;
  174|  43.8M|  }
  175|       |
  176|   213k|  result.shrink_to_fit();
  177|   213k|  return result;
  178|   213k|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEv:
  181|   213k|inline std::string FuzzedDataProvider::ConsumeRandomLengthString() {
  182|   213k|  return ConsumeRandomLengthString(remaining_bytes_);
  183|   213k|}
_ZN18FuzzedDataProvider11ConsumeBoolEv:
  289|   425k|inline bool FuzzedDataProvider::ConsumeBool() {
  290|   425k|  return 1 & ConsumeIntegral<uint8_t>();
  291|   425k|}
_ZN18FuzzedDataProvider14CopyAndAdvanceEPvm:
  339|  1.14k|                                               size_t num_bytes) {
  340|  1.14k|  std::memcpy(destination, data_ptr_, num_bytes);
  341|  1.14k|  Advance(num_bytes);
  342|  1.14k|}
_ZN18FuzzedDataProvider7AdvanceEm:
  344|  44.4M|inline void FuzzedDataProvider::Advance(size_t num_bytes) {
  345|  44.4M|  if (num_bytes > remaining_bytes_)
  ------------------
  |  Branch (345:7): [True: 0, False: 44.4M]
  ------------------
  346|      0|    abort();
  347|       |
  348|  44.4M|  data_ptr_ += num_bytes;
  349|  44.4M|  remaining_bytes_ -= num_bytes;
  350|  44.4M|}
_ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_:
  379|  44.4M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) {
  380|  44.4M|  static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types.");
  381|  44.4M|  static_assert(!std::numeric_limits<TU>::is_signed,
  382|  44.4M|                "Source type must be unsigned.");
  383|       |
  384|       |  // TODO(Dor1s): change to `if constexpr` once C++17 becomes mainstream.
  385|  44.4M|  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|  44.4M|  if (value <= std::numeric_limits<TS>::max()) {
  ------------------
  |  Branch (390:7): [True: 31.8M, False: 12.5M]
  ------------------
  391|  31.8M|    return static_cast<TS>(value);
  392|  31.8M|  } else {
  393|  12.5M|    constexpr auto TS_min = std::numeric_limits<TS>::min();
  394|  12.5M|    return TS_min + static_cast<TS>(value - TS_min);
  395|  12.5M|  }
  396|  44.4M|}
_ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEm:
  109|  1.20k|std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t num_bytes) {
  110|  1.20k|  num_bytes = std::min(num_bytes, remaining_bytes_);
  111|  1.20k|  return ConsumeBytes<T>(num_bytes, num_bytes);
  112|  1.20k|}
_ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEmm:
  353|  1.20k|std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t size, size_t num_bytes) {
  354|  1.20k|  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|  1.20k|  std::vector<T> result(size);
  363|  1.20k|  if (size == 0) {
  ------------------
  |  Branch (363:7): [True: 62, False: 1.14k]
  ------------------
  364|     62|    if (num_bytes != 0)
  ------------------
  |  Branch (364:9): [True: 0, False: 62]
  ------------------
  365|      0|      abort();
  366|     62|    return result;
  367|     62|  }
  368|       |
  369|  1.14k|  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|  1.14k|  result.shrink_to_fit();
  375|  1.14k|  return result;
  376|  1.20k|}

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

_Z21MakeHeadersContinuousRK12CBlockHeaderRKNSt3__16vectorIS_NS2_9allocatorIS_EEEERS6_:
   26|   212k|{
   27|   212k|    Assume(!new_headers.empty());
  ------------------
  |  |   97|   212k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   28|       |
   29|   212k|    const CBlockHeader* prev_header{
   30|   212k|        all_headers.empty() ? &genesis_header : &all_headers.back()};
  ------------------
  |  Branch (30:9): [True: 475, False: 211k]
  ------------------
   31|       |
   32|   226k|    for (auto& header : new_headers) {
  ------------------
  |  Branch (32:23): [True: 226k, False: 212k]
  ------------------
   33|   226k|        header.hashPrevBlock = prev_header->GetHash();
   34|       |
   35|   226k|        prev_header = &header;
   36|   226k|    }
   37|   212k|}
_Z30headers_sync_state_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   50|  1.23k|{
   51|  1.23k|    SeedRandomStateForTest(SeedRand::ZEROS);
   52|  1.23k|    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
   53|  1.23k|    auto mock_time{ConsumeTime(fuzzed_data_provider)};
   54|       |
   55|  1.23k|    CBlockHeader genesis_header{Params().GenesisBlock()};
   56|  1.23k|    CBlockIndex start_index(genesis_header);
   57|       |
   58|  1.23k|    if (mock_time < start_index.GetMedianTimePast()) return;
  ------------------
  |  Branch (58:9): [True: 32, False: 1.20k]
  ------------------
   59|  1.20k|    SetMockTime(mock_time);
   60|       |
   61|  1.20k|    const uint256 genesis_hash = genesis_header.GetHash();
   62|  1.20k|    start_index.phashBlock = &genesis_hash;
   63|       |
   64|  1.20k|    arith_uint256 min_work{UintToArith256(ConsumeUInt256(fuzzed_data_provider))};
   65|  1.20k|    FuzzedHeadersSyncState headers_sync(
   66|  1.20k|        /*commit_offset=*/fuzzed_data_provider.ConsumeIntegralInRange<unsigned>(1, 1024),
   67|  1.20k|        /*chain_start=*/&start_index,
   68|  1.20k|        /*minimum_required_work=*/min_work);
   69|       |
   70|       |    // Store headers for potential redownload phase.
   71|  1.20k|    std::vector<CBlockHeader> all_headers;
   72|  1.20k|    std::vector<CBlockHeader>::const_iterator redownloaded_it;
   73|  1.20k|    bool presync{true};
   74|  1.20k|    bool requested_more{true};
   75|       |
   76|   214k|    while (requested_more) {
  ------------------
  |  Branch (76:12): [True: 213k, False: 560]
  ------------------
   77|   213k|        std::vector<CBlockHeader> headers;
   78|       |
   79|       |        // Consume headers from fuzzer or maybe replay headers if we got to the
   80|       |        // redownload phase.
   81|   213k|        if (presync || fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (81:13): [True: 212k, False: 471]
  |  Branch (81:24): [True: 62, False: 409]
  ------------------
   82|   213k|            auto deser_headers = ConsumeDeserializable<std::vector<CBlockHeader>>(fuzzed_data_provider);
   83|   213k|            if (!deser_headers || deser_headers->empty()) return;
  ------------------
  |  Branch (83:17): [True: 610, False: 212k]
  |  Branch (83:35): [True: 35, False: 212k]
  ------------------
   84|       |
   85|   212k|            if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (85:17): [True: 212k, False: 283]
  ------------------
   86|   212k|                MakeHeadersContinuous(genesis_header, all_headers, *deser_headers);
   87|   212k|            }
   88|       |
   89|   212k|            headers.swap(*deser_headers);
   90|   212k|        } else if (auto num_headers_left{std::distance(redownloaded_it, all_headers.cend())}; num_headers_left > 0) {
  ------------------
  |  Branch (90:95): [True: 409, False: 0]
  ------------------
   91|       |            // Consume some headers from the redownload buffer (At least one
   92|       |            // header is consumed).
   93|    409|            auto begin_it{redownloaded_it};
   94|    409|            std::advance(redownloaded_it, fuzzed_data_provider.ConsumeIntegralInRange<int>(1, num_headers_left));
   95|    409|            headers.insert(headers.cend(), begin_it, redownloaded_it);
   96|    409|        }
   97|       |
   98|   212k|        if (headers.empty()) return;
  ------------------
  |  Branch (98:13): [True: 0, False: 212k]
  ------------------
   99|   212k|        auto result = headers_sync.ProcessNextHeaders(headers, fuzzed_data_provider.ConsumeBool());
  100|   212k|        requested_more = result.request_more;
  101|       |
  102|   212k|        if (result.request_more) {
  ------------------
  |  Branch (102:13): [True: 212k, False: 560]
  ------------------
  103|   212k|            if (presync) {
  ------------------
  |  Branch (103:17): [True: 211k, False: 244]
  ------------------
  104|   211k|                all_headers.insert(all_headers.cend(), headers.cbegin(), headers.cend());
  105|       |
  106|   211k|                if (headers_sync.GetState() == HeadersSyncState::State::REDOWNLOAD) {
  ------------------
  |  Branch (106:21): [True: 227, False: 211k]
  ------------------
  107|    227|                    presync = false;
  108|    227|                    redownloaded_it = all_headers.cbegin();
  109|       |
  110|       |                    // If we get to redownloading, the presynced headers need
  111|       |                    // to have the min amount of work on them.
  112|    227|                    assert(CalculateClaimedHeadersWork(all_headers) >= min_work);
  113|    227|                }
  114|   211k|            }
  115|       |
  116|   212k|            (void)headers_sync.NextHeadersRequestLocator();
  117|   212k|        }
  118|   212k|    }
  119|  1.20k|}
_ZN22FuzzedHeadersSyncStateC2EjPK11CBlockIndexRK13arith_uint256:
   43|  1.20k|        : HeadersSyncState(/*id=*/0, Params().GetConsensus(), chain_start, minimum_required_work)
   44|  1.20k|    {
   45|  1.20k|        const_cast<unsigned&>(m_commit_offset) = commit_offset;
   46|  1.20k|    }

_Z11ConsumeTimeR18FuzzedDataProviderRKNSt3__18optionalIlEES5_:
   35|  1.23k|{
   36|       |    // Avoid t=0 (1970-01-01T00:00:00Z) since SetMockTime(0) disables mocktime.
   37|  1.23k|    static const int64_t time_min{ParseISO8601DateTime("2000-01-01T00:00:01Z").value()};
   38|  1.23k|    static const int64_t time_max{ParseISO8601DateTime("2100-12-31T23:59:59Z").value()};
   39|  1.23k|    return fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(min.value_or(time_min), max.value_or(time_max));
   40|  1.23k|}

_Z14ConsumeUInt256R18FuzzedDataProvider:
  172|  1.20k|{
  173|  1.20k|    const std::vector<uint8_t> v256 = fuzzed_data_provider.ConsumeBytes<uint8_t>(256 / 8);
  174|  1.20k|    if (v256.size() != 256 / 8) {
  ------------------
  |  Branch (174:9): [True: 75, False: 1.13k]
  ------------------
  175|     75|        return {};
  176|     75|    }
  177|  1.13k|    return uint256{v256};
  178|  1.20k|}
_Z29ConsumeRandomLengthByteVectorIhENSt3__16vectorIT_NS0_9allocatorIS2_EEEER18FuzzedDataProviderRKNS0_8optionalImEE:
   58|   213k|{
   59|   213k|    static_assert(sizeof(B) == 1);
   60|   213k|    const std::string s = max_length ?
  ------------------
  |  Branch (60:27): [True: 0, False: 213k]
  ------------------
   61|      0|                              fuzzed_data_provider.ConsumeRandomLengthString(*max_length) :
   62|   213k|                              fuzzed_data_provider.ConsumeRandomLengthString();
   63|   213k|    std::vector<B> ret(s.size());
   64|   213k|    std::copy(s.begin(), s.end(), reinterpret_cast<char*>(ret.data()));
   65|   213k|    return ret;
   66|   213k|}
_Z21ConsumeDeserializableINSt3__16vectorI12CBlockHeaderNS0_9allocatorIS2_EEEEENS0_8optionalIT_EER18FuzzedDataProviderRKNS6_ImEE:
  120|   213k|{
  121|   213k|    const std::vector<uint8_t> buffer = ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length);
  122|   213k|    DataStream ds{buffer};
  123|   213k|    T obj;
  124|   213k|    try {
  125|   213k|        ds >> obj;
  126|   213k|    } catch (const std::ios_base::failure&) {
  127|    610|        return std::nullopt;
  128|    610|    }
  129|   212k|    return obj;
  130|   213k|}

_ZN12CheckGlobalsC2Ev:
   56|  1.23k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique<CheckGlobalsImpl>()) {}
_ZN12CheckGlobalsD2Ev:
   57|  1.23k|CheckGlobals::~CheckGlobals() = default;
_ZN16CheckGlobalsImplC2Ev:
   17|  1.23k|    {
   18|  1.23k|        g_used_g_prng = false;
   19|  1.23k|        g_seeded_g_prng_zero = false;
   20|  1.23k|        g_used_system_time = false;
   21|  1.23k|        SetMockTime(0s);
   22|  1.23k|    }
_ZN16CheckGlobalsImplD2Ev:
   24|  1.23k|    {
   25|  1.23k|        if (g_used_g_prng && !g_seeded_g_prng_zero) {
  ------------------
  |  Branch (25:13): [True: 1.20k, False: 32]
  |  Branch (25:30): [True: 0, False: 1.20k]
  ------------------
   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|  1.23k|        if (g_used_system_time) {
  ------------------
  |  Branch (41:13): [True: 0, False: 1.23k]
  ------------------
   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|  1.23k|    }

_Z22SeedRandomStateForTest8SeedRand:
   20|  1.23k|{
   21|  1.23k|    constexpr auto RANDOM_CTX_SEED{"RANDOM_CTX_SEED"};
   22|       |
   23|       |    // Do this once, on the first call, regardless of seedtype, because once
   24|       |    // MakeRandDeterministicDANGEROUS is called, the output of GetRandHash is
   25|       |    // no longer truly random. It should be enough to get the seed once for the
   26|       |    // process.
   27|  1.23k|    static const auto g_ctx_seed = []() -> std::optional<uint256> {
   28|  1.23k|        if constexpr (G_FUZZING) return {};
   29|       |        // If RANDOM_CTX_SEED is set, use that as seed.
   30|  1.23k|        if (const char* num{std::getenv(RANDOM_CTX_SEED)}) {
   31|  1.23k|            if (auto num_parsed{uint256::FromUserHex(num)}) {
   32|  1.23k|                return *num_parsed;
   33|  1.23k|            } else {
   34|  1.23k|                std::cerr << RANDOM_CTX_SEED << " must consist of up to " << uint256::size() * 2 << " hex digits (\"0x\" prefix allowed), it was set to: '" << num << "'.\n";
   35|  1.23k|                std::abort();
   36|  1.23k|            }
   37|  1.23k|        }
   38|       |        // Otherwise use a (truly) random value.
   39|  1.23k|        return GetRandHash();
   40|  1.23k|    }();
   41|       |
   42|  1.23k|    g_seeded_g_prng_zero = seedtype == SeedRand::ZEROS;
   43|  1.23k|    if constexpr (G_FUZZING) {
   44|  1.23k|        Assert(g_seeded_g_prng_zero); // Only SeedRandomStateForTest(SeedRand::ZEROS) is allowed in fuzz tests
  ------------------
  |  |   85|  1.23k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   45|  1.23k|        Assert(!g_used_g_prng);       // The global PRNG must not have been used before SeedRandomStateForTest(SeedRand::ZEROS)
  ------------------
  |  |   85|  1.23k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   46|  1.23k|    }
   47|  1.23k|    const uint256& seed{seedtype == SeedRand::FIXED_SEED ? g_ctx_seed.value() : uint256::ZERO};
  ------------------
  |  Branch (47:25): [True: 0, False: 1.23k]
  ------------------
   48|  1.23k|    LogInfo("Setting random seed for current tests to %s=%s\n", RANDOM_CTX_SEED, seed.GetHex());
  ------------------
  |  |  261|  1.23k|#define LogInfo(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  255|  1.23k|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  ------------------
  ------------------
   49|  1.23k|    MakeRandDeterministicDANGEROUS(seed);
   50|  1.23k|}

_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|  1.23k|    explicit StdLockGuard(StdMutex& cs) EXCLUSIVE_LOCK_FUNCTION(cs) : std::lock_guard<StdMutex>(cs) {}

_ZNK9base_blobILj256EE6GetHexEv:
   12|  1.23k|{
   13|  1.23k|    uint8_t m_data_rev[WIDTH];
   14|  40.8k|    for (int i = 0; i < WIDTH; ++i) {
  ------------------
  |  Branch (14:21): [True: 39.5k, False: 1.23k]
  ------------------
   15|  39.5k|        m_data_rev[i] = m_data[WIDTH - 1 - i];
   16|  39.5k|    }
   17|  1.23k|    return HexStr(m_data_rev);
   18|  1.23k|}

_ZN7uint256C2E4SpanIKhE:
  208|  1.13k|    constexpr explicit uint256(Span<const unsigned char> vch) : base_blob<256>(vch) {}
_ZN9base_blobILj256EE5beginEv:
  115|  1.98M|    constexpr unsigned char* begin() { return m_data.data(); }
_ZNK9base_blobILj256EE5beginEv:
  118|  10.3k|    constexpr const unsigned char* begin() const { return m_data.data(); }
_ZN9base_blobILj256EE4sizeEv:
  121|  8.46k|    static constexpr unsigned int size() { return WIDTH; }
_ZNK9base_blobILj256EE7CompareERKS0_:
   64|   218k|    constexpr int Compare(const base_blob& other) const { return std::memcmp(m_data.data(), other.m_data.data(), WIDTH); }
_ZneRK9base_blobILj256EES2_:
   67|   218k|    friend constexpr bool operator!=(const base_blob& a, const base_blob& b) { return a.Compare(b) != 0; }
_ZN9base_blobILj256EE7SetNullEv:
   56|   649k|    {
   57|   649k|        std::fill(m_data.begin(), m_data.end(), 0);
   58|   649k|    }
_ZNK9base_blobILj256EE4dataEv:
  112|  1.23k|    constexpr const unsigned char* data() const { return m_data.data(); }
_ZN9base_blobILj256EE4dataEv:
  113|  7.23k|    constexpr unsigned char* data() { return m_data.data(); }
_ZN7uint256C2Ev:
  205|  1.31M|    constexpr uint256() = default;
_ZN9base_blobILj256EEC2Ev:
   35|  1.31M|    constexpr base_blob() : m_data() {}
_ZN9base_blobILj256EEC2E4SpanIKhE:
   41|  1.13k|    {
   42|  1.13k|        assert(vch.size() == WIDTH);
   43|  1.13k|        std::copy(vch.begin(), vch.end(), m_data.begin());
   44|  1.13k|    }
_ZN9base_blobILj256EE11UnserializeI10DataStreamEEvRT_:
  133|   640k|    {
  134|   640k|        s.read(MakeWritableByteSpan(m_data));
  135|   640k|    }
_ZNK9base_blobILj256EE9GetUint64Ei:
  123|  1.88k|    constexpr uint64_t GetUint64(int pos) const { return ReadLE64(m_data.data() + pos * 8); }
_ZNK9base_blobILj256EE9SerializeI10HashWriterEEvRT_:
  127|  1.32M|    {
  128|  1.32M|        s << Span(m_data);
  129|  1.32M|    }

_ZN8bitdequeILi32768EEC2Ev:
  212|  1.76k|    explicit bitdeque() : m_pad_begin{0}, m_pad_end{0} {}
_ZN8bitdequeILi32768EE4swapERS0_:
  402|    560|    {
  403|    560|        std::swap(m_deque, other.m_deque);
  404|    560|        std::swap(m_pad_begin, other.m_pad_begin);
  405|    560|        std::swap(m_pad_end, other.m_pad_end);
  406|    560|    }
_ZN8bitdequeILi32768EE9push_backEb:
  352|    435|    {
  353|    435|        extend_back(1);
  354|    435|        back() = val;
  355|    435|    }
_ZN8bitdequeILi32768EE11extend_backEm:
  156|    435|    {
  157|    435|        if (n > static_cast<size_type>(m_pad_end)) {
  ------------------
  |  Branch (157:13): [True: 177, False: 258]
  ------------------
  158|    177|            n -= m_pad_end + 1;
  159|    177|            m_pad_end = BITS_PER_WORD - 1;
  160|    177|            m_deque.insert(m_deque.end(), 1 + (n / BITS_PER_WORD), {});
  161|    177|            n %= BITS_PER_WORD;
  162|    177|        }
  163|    435|        m_pad_end -= n;
  164|    435|    }
_ZN8bitdequeILi32768EE4backEv:
  334|    435|    reference back() { return end()[-1]; }
_ZN8bitdequeILi32768EE3endEv:
  249|    435|    iterator end() noexcept { return iterator{m_deque.end(), 0} - m_pad_end; }
_ZmiN8bitdequeILi32768EE8IteratorILb0EEEl:
  101|    435|        friend Iterator operator-(Iterator x, difference_type dist) { x -= dist; return x; }
_ZN8bitdequeILi32768EE8IteratorILb0EEmIEl:
   94|    435|        Iterator& operator-=(difference_type dist) { return operator+=(-dist); }
_ZN8bitdequeILi32768EE8IteratorILb0EEpLEl:
   64|    870|        {
   65|    870|            if (dist > 0) {
  ------------------
  |  Branch (65:17): [True: 0, False: 870]
  ------------------
   66|      0|                if (dist + m_bitpos >= BITS_PER_WORD) {
  ------------------
  |  Branch (66:21): [True: 0, False: 0]
  ------------------
   67|      0|                    ++m_it;
   68|      0|                    dist -= BITS_PER_WORD - m_bitpos;
   69|      0|                    m_bitpos = 0;
   70|      0|                }
   71|      0|                auto jump = dist / BITS_PER_WORD;
   72|      0|                m_it += jump;
   73|      0|                m_bitpos += dist - jump * BITS_PER_WORD;
   74|    870|            } else if (dist < 0) {
  ------------------
  |  Branch (74:24): [True: 870, False: 0]
  ------------------
   75|    870|                dist = -dist;
   76|    870|                if (dist > m_bitpos) {
  ------------------
  |  Branch (76:21): [True: 435, False: 435]
  ------------------
   77|    435|                    --m_it;
   78|    435|                    dist -= m_bitpos + 1;
   79|    435|                    m_bitpos = BITS_PER_WORD - 1;
   80|    435|                }
   81|    870|                auto jump = dist / BITS_PER_WORD;
   82|    870|                m_it -= jump;
   83|    870|                m_bitpos -= dist - jump * BITS_PER_WORD;
   84|    870|            }
   85|    870|            return *this;
   86|    870|        }
_ZN8bitdequeILi32768EE8IteratorILb0EEC2ERKNSt3__116__deque_iteratorINS3_6bitsetILm32768EEEPS6_RS6_PS7_lLl16EEEi:
   41|    472|        Iterator(const deque_iterator& it, int bitpos) : m_it(it), m_bitpos(bitpos) {}
_ZNK8bitdequeILi32768EE8IteratorILb0EEixEl:
  109|    435|        reference operator[](difference_type pos) const { return *(*this + pos); }
_ZplN8bitdequeILi32768EE8IteratorILb0EEEl:
   99|    435|        friend Iterator operator+(Iterator x, difference_type dist) { x += dist; return x; }
_ZNK8bitdequeILi32768EE8IteratorILb0EEdeEv:
  108|    472|        reference operator*() const { return (*m_it)[m_bitpos]; }
_ZNK8bitdequeILi32768EE4sizeEv:
  262|    472|    size_type size() const noexcept { return m_deque.size() * BITS_PER_WORD - m_pad_begin - m_pad_end; }
_ZN8bitdequeILi32768EE5frontEv:
  332|     37|    reference front() { return *begin(); }
_ZN8bitdequeILi32768EE5beginEv:
  248|     37|    iterator begin() noexcept { return {m_deque.begin(), m_pad_begin}; }
_ZN8bitdequeILi32768EE9pop_frontEv:
  386|     37|    {
  387|     37|        erase_front(1);
  388|     37|    }
_ZN8bitdequeILi32768EE11erase_frontEm:
  168|     37|    {
  169|     37|        if (n >= static_cast<size_type>(BITS_PER_WORD - m_pad_begin)) {
  ------------------
  |  Branch (169:13): [True: 0, False: 37]
  ------------------
  170|      0|            n -= BITS_PER_WORD - m_pad_begin;
  171|      0|            m_pad_begin = 0;
  172|      0|            m_deque.erase(m_deque.begin(), m_deque.begin() + 1 + (n / BITS_PER_WORD));
  173|      0|            n %= BITS_PER_WORD;
  174|      0|        }
  175|     37|        if (n) {
  ------------------
  |  Branch (175:13): [True: 37, False: 0]
  ------------------
  176|     37|            auto& first = m_deque.front();
  177|     74|            while (n) {
  ------------------
  |  Branch (177:20): [True: 37, False: 37]
  ------------------
  178|     37|                first.reset(m_pad_begin);
  179|     37|                ++m_pad_begin;
  180|     37|                --n;
  181|     37|            }
  182|     37|        }
  183|     37|    }

_Z22inline_assertion_checkILb0EbEOT0_S1_PKciS3_S3_:
   52|  1.51M|{
   53|  1.51M|    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|  1.51M|    ) {
   58|  1.51M|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 1.51M]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  1.51M|    }
   62|  1.51M|    return std::forward<T>(val);
   63|  1.51M|}
_Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_:
   52|  3.67k|{
   53|  3.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|  3.67k|    ) {
   58|  3.67k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 3.67k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  3.67k|    }
   62|  3.67k|    return std::forward<T>(val);
   63|  3.67k|}
_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_:
   52|  1.23k|{
   53|  1.23k|    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|  1.23k|    ) {
   58|  1.23k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 1.23k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  1.23k|    }
   62|  1.23k|    return std::forward<T>(val);
   63|  1.23k|}
_Z22inline_assertion_checkILb1ERNSt3__16atomicIbEEEOT0_S5_PKciS7_S7_:
   52|  1.23k|{
   53|  1.23k|    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|  1.23k|    ) {
   58|  1.23k|        if (!val) {
  ------------------
  |  Branch (58:13): [True: 0, False: 1.23k]
  ------------------
   59|      0|            assertion_fail(file, line, func, assertion);
   60|      0|        }
   61|  1.23k|    }
   62|  1.23k|    return std::forward<T>(val);
   63|  1.23k|}

_ZN16SaltedTxidHasherC2Ev:
   11|  1.20k|    k0{FastRandomContext().rand64()},
   12|  1.20k|    k1{FastRandomContext().rand64()} {}

_ZNK16SaltedTxidHasherclERK7uint256:
   26|    472|    size_t operator()(const uint256& txid) const {
   27|    472|        return SipHashUint256(k0, k1, txid);
   28|    472|    }

_Z16AdditionOverflowImEbT_S0_:
   16|  2.13M|{
   17|  2.13M|    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|  2.13M|    return std::numeric_limits<T>::max() - i < j;
   23|  2.13M|}
_Z10CheckedAddImENSt3__18optionalIT_EES2_S2_:
   27|  2.13M|{
   28|  2.13M|    if (AdditionOverflow(i, j)) {
  ------------------
  |  Branch (28:9): [True: 0, False: 2.13M]
  ------------------
   29|      0|        return std::nullopt;
   30|      0|    }
   31|  2.13M|    return i + j;
   32|  2.13M|}

_Z10ToIntegralIhENSt3__18optionalIT_EENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE:
  180|     10|{
  181|     10|    static_assert(std::is_integral<T>::value);
  182|     10|    T result;
  183|     10|    const auto [first_nonmatching, error_condition] = std::from_chars(str.data(), str.data() + str.size(), result);
  184|     10|    if (first_nonmatching != str.data() + str.size() || error_condition != std::errc{}) {
  ------------------
  |  Branch (184:9): [True: 0, False: 10]
  |  Branch (184:57): [True: 0, False: 10]
  ------------------
  185|      0|        return std::nullopt;
  186|      0|    }
  187|     10|    return result;
  188|     10|}
_Z10ToIntegralItENSt3__18optionalIT_EENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE:
  180|      2|{
  181|      2|    static_assert(std::is_integral<T>::value);
  182|      2|    T result;
  183|      2|    const auto [first_nonmatching, error_condition] = std::from_chars(str.data(), str.data() + str.size(), result);
  184|      2|    if (first_nonmatching != str.data() + str.size() || error_condition != std::errc{}) {
  ------------------
  |  Branch (184:9): [True: 0, False: 2]
  |  Branch (184:57): [True: 0, False: 2]
  ------------------
  185|      0|        return std::nullopt;
  186|      0|    }
  187|      2|    return result;
  188|      2|}

_ZN9NodeClock3nowEv:
   27|  1.20k|{
   28|  1.20k|    const auto mocktime{g_mock_time.load(std::memory_order_relaxed)};
   29|  1.20k|    if (!mocktime.count()) {
  ------------------
  |  Branch (29:9): [True: 0, False: 1.20k]
  ------------------
   30|      0|        g_used_system_time = true;
   31|      0|    }
   32|  1.20k|    const auto ret{
   33|  1.20k|        mocktime.count() ?
  ------------------
  |  Branch (33:9): [True: 1.20k, False: 0]
  ------------------
   34|  1.20k|            mocktime :
   35|  1.20k|            std::chrono::system_clock::now().time_since_epoch()};
   36|  1.20k|    assert(ret > 0s);
   37|  1.20k|    return time_point{ret};
   38|  1.20k|};
_Z11SetMockTimel:
   40|  1.20k|void SetMockTime(int64_t nMockTimeIn) { SetMockTime(std::chrono::seconds{nMockTimeIn}); }
_Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   42|  2.44k|{
   43|  2.44k|    Assert(mock_time_in >= 0s);
  ------------------
  |  |   85|  2.44k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   44|  2.44k|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   45|  2.44k|}
_Z20ParseISO8601DateTimeNSt3__117basic_string_viewIcNS_11char_traitsIcEEEE:
   96|      2|{
   97|      2|    constexpr auto FMT_SIZE{std::string_view{"2000-01-01T01:01:01Z"}.size()};
   98|      2|    if (str.size() != FMT_SIZE || str[4] != '-' || str[7] != '-' || str[10] != 'T' || str[13] != ':' || str[16] != ':' || str[19] != 'Z') {
  ------------------
  |  Branch (98:9): [True: 0, False: 2]
  |  Branch (98:35): [True: 0, False: 2]
  |  Branch (98:52): [True: 0, False: 2]
  |  Branch (98:69): [True: 0, False: 2]
  |  Branch (98:87): [True: 0, False: 2]
  |  Branch (98:105): [True: 0, False: 2]
  |  Branch (98:123): [True: 0, False: 2]
  ------------------
   99|      0|        return {};
  100|      0|    }
  101|      2|    const auto year{ToIntegral<uint16_t>(str.substr(0, 4))};
  102|      2|    const auto month{ToIntegral<uint8_t>(str.substr(5, 2))};
  103|      2|    const auto day{ToIntegral<uint8_t>(str.substr(8, 2))};
  104|      2|    const auto hour{ToIntegral<uint8_t>(str.substr(11, 2))};
  105|      2|    const auto min{ToIntegral<uint8_t>(str.substr(14, 2))};
  106|      2|    const auto sec{ToIntegral<uint8_t>(str.substr(17, 2))};
  107|      2|    if (!year || !month || !day || !hour || !min || !sec) {
  ------------------
  |  Branch (107:9): [True: 0, False: 2]
  |  Branch (107:18): [True: 0, False: 2]
  |  Branch (107:28): [True: 0, False: 2]
  |  Branch (107:36): [True: 0, False: 2]
  |  Branch (107:45): [True: 0, False: 2]
  |  Branch (107:53): [True: 0, False: 2]
  ------------------
  108|      0|        return {};
  109|      0|    }
  110|      2|    const std::chrono::year_month_day ymd{std::chrono::year{*year}, std::chrono::month{*month}, std::chrono::day{*day}};
  111|      2|    if (!ymd.ok()) {
  ------------------
  |  Branch (111:9): [True: 0, False: 2]
  ------------------
  112|      0|        return {};
  113|      0|    }
  114|      2|    const auto time{std::chrono::hours{*hour} + std::chrono::minutes{*min} + std::chrono::seconds{*sec}};
  115|      2|    const auto tp{std::chrono::sys_days{ymd} + time};
  116|      2|    return int64_t{TicksSinceEpoch<std::chrono::seconds>(tp)};
  117|      2|}

_Z5TicksINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEES5_EDaT0_:
   73|      2|{
   74|      2|    return std::chrono::duration_cast<Dur1>(d).count();
   75|      2|}
_Z15TicksSinceEpochINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEENS1_10time_pointINS1_12system_clockES5_EEEDaT0_:
   78|      2|{
   79|      2|    return Ticks<Duration>(t.time_since_epoch());
   80|      2|}
_Z5TicksINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEENS2_IxNS3_ILl1ELl1000000EEEEEEDaT0_:
   73|  1.20k|{
   74|  1.20k|    return std::chrono::duration_cast<Dur1>(d).count();
   75|  1.20k|}

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

_Z11ClearShrinkI8bitdequeILi32768EEEvRT_:
   57|    560|{
   58|       |    // There are various ways to clear a vector and release its memory:
   59|       |    //
   60|       |    // 1. V{}.swap(v)
   61|       |    // 2. v = V{}
   62|       |    // 3. v = {}; v.shrink_to_fit();
   63|       |    // 4. v.clear(); v.shrink_to_fit();
   64|       |    //
   65|       |    // (2) does not appear to release memory in glibc debug mode, even if v.shrink_to_fit()
   66|       |    // follows. (3) and (4) rely on std::vector::shrink_to_fit, which is only a non-binding
   67|       |    // request. Therefore, we use method (1).
   68|       |
   69|    560|    V{}.swap(v);
   70|    560|}
_Z11ClearShrinkINSt3__15dequeI16CompressedHeaderNS0_9allocatorIS2_EEEEEvRT_:
   57|    560|{
   58|       |    // There are various ways to clear a vector and release its memory:
   59|       |    //
   60|       |    // 1. V{}.swap(v)
   61|       |    // 2. v = V{}
   62|       |    // 3. v = {}; v.shrink_to_fit();
   63|       |    // 4. v.clear(); v.shrink_to_fit();
   64|       |    //
   65|       |    // (2) does not appear to release memory in glibc debug mode, even if v.shrink_to_fit()
   66|       |    // follows. (3) and (4) rely on std::vector::shrink_to_fit, which is only a non-binding
   67|       |    // request. Therefore, we use method (1).
   68|       |
   69|    560|    V{}.swap(v);
   70|    560|}

_Z27CalculateClaimedHeadersWorkNSt3__14spanIK12CBlockHeaderLm18446744073709551615EEE:
 4188|    227|{
 4189|    227|    arith_uint256 total_work{0};
 4190|  7.80k|    for (const CBlockHeader& header : headers) {
  ------------------
  |  Branch (4190:37): [True: 7.80k, False: 227]
  ------------------
 4191|  7.80k|        CBlockIndex dummy(header);
 4192|  7.80k|        total_work += GetBlockProof(dummy);
 4193|  7.80k|    }
 4194|    227|    return total_work;
 4195|    227|}