_ZNK8AddrInfo14GetTriedBucketERK7uint256RK15NetGroupManager:
   49|   578k|{
   50|   578k|    uint64_t hash1 = (HashWriter{} << nKey << GetKey()).GetCheapHash();
   51|   578k|    uint64_t hash2 = (HashWriter{} << nKey << netgroupman.GetGroup(*this) << (hash1 % ADDRMAN_TRIED_BUCKETS_PER_GROUP)).GetCheapHash();
   52|   578k|    return hash2 % ADDRMAN_TRIED_BUCKET_COUNT;
   53|   578k|}
_ZNK8AddrInfo12GetNewBucketERK7uint256RK8CNetAddrRK15NetGroupManager:
   56|  4.28M|{
   57|  4.28M|    std::vector<unsigned char> vchSourceGroupKey = netgroupman.GetGroup(src);
   58|  4.28M|    uint64_t hash1 = (HashWriter{} << nKey << netgroupman.GetGroup(*this) << vchSourceGroupKey).GetCheapHash();
   59|  4.28M|    uint64_t hash2 = (HashWriter{} << nKey << vchSourceGroupKey << (hash1 % ADDRMAN_NEW_BUCKETS_PER_SOURCE_GROUP)).GetCheapHash();
   60|  4.28M|    return hash2 % ADDRMAN_NEW_BUCKET_COUNT;
   61|  4.28M|}
_ZNK8AddrInfo17GetBucketPositionERK7uint256bi:
   64|  21.0M|{
   65|  21.0M|    uint64_t hash1 = (HashWriter{} << nKey << (fNew ? uint8_t{'N'} : uint8_t{'K'}) << bucket << GetKey()).GetCheapHash();
  ------------------
  |  Branch (65:48): [True: 20.5M, False: 578k]
  ------------------
   66|  21.0M|    return hash1 % ADDRMAN_BUCKET_SIZE;
   67|  21.0M|}
_ZNK8AddrInfo10IsTerribleENSt3__16chrono10time_pointI9NodeClockNS1_8durationIxNS0_5ratioILl1ELl1EEEEEEE:
   70|  3.49M|{
   71|  3.49M|    if (now - m_last_try <= 1min) { // never remove things tried in the last minute
  ------------------
  |  Branch (71:9): [True: 29.1k, False: 3.46M]
  ------------------
   72|  29.1k|        return false;
   73|  29.1k|    }
   74|       |
   75|  3.46M|    if (nTime > now + 10min) { // came in a flying DeLorean
  ------------------
  |  Branch (75:9): [True: 2.61M, False: 846k]
  ------------------
   76|  2.61M|        return true;
   77|  2.61M|    }
   78|       |
   79|   846k|    if (now - nTime > ADDRMAN_HORIZON) { // not seen in recent history
  ------------------
  |  Branch (79:9): [True: 824k, False: 22.5k]
  ------------------
   80|   824k|        return true;
   81|   824k|    }
   82|       |
   83|  22.5k|    if (TicksSinceEpoch<std::chrono::seconds>(m_last_success) == 0 && nAttempts >= ADDRMAN_RETRIES) { // tried N times and never a success
  ------------------
  |  Branch (83:9): [True: 22.1k, False: 465]
  |  Branch (83:71): [True: 1, False: 22.1k]
  ------------------
   84|      1|        return true;
   85|      1|    }
   86|       |
   87|  22.5k|    if (now - m_last_success > ADDRMAN_MIN_FAIL && nAttempts >= ADDRMAN_MAX_FAILURES) { // N successive failures in the last week
  ------------------
  |  Branch (87:9): [True: 22.4k, False: 164]
  |  Branch (87:9): [True: 15, False: 22.5k]
  |  Branch (87:52): [True: 15, False: 22.3k]
  ------------------
   88|     15|        return true;
   89|     15|    }
   90|       |
   91|  22.5k|    return false;
   92|  22.5k|}
_ZNK8AddrInfo9GetChanceENSt3__16chrono10time_pointI9NodeClockNS1_8durationIxNS0_5ratioILl1ELl1EEEEEEE:
   95|  10.5k|{
   96|  10.5k|    double fChance = 1.0;
   97|       |
   98|       |    // deprioritize very recent attempts away
   99|  10.5k|    if (now - m_last_try < 10min) {
  ------------------
  |  Branch (99:9): [True: 4.91k, False: 5.63k]
  ------------------
  100|  4.91k|        fChance *= 0.01;
  101|  4.91k|    }
  102|       |
  103|       |    // deprioritize 66% after each failed attempt, but at most 1/28th to avoid the search taking forever or overly penalizing outages.
  104|  10.5k|    fChance *= pow(0.66, std::min(nAttempts, 8));
  105|       |
  106|  10.5k|    return fChance;
  107|  10.5k|}
_ZN11AddrManImplC2ERK15NetGroupManagerbi:
  110|  9.54k|    : insecure_rand{deterministic}
  111|  9.54k|    , nKey{deterministic ? uint256{1} : insecure_rand.rand256()}
  ------------------
  |  Branch (111:12): [True: 9.54k, False: 0]
  ------------------
  112|  9.54k|    , m_consistency_check_ratio{consistency_check_ratio}
  113|  9.54k|    , m_netgroupman{netgroupman}
  114|  9.54k|{
  115|  9.77M|    for (auto& bucket : vvNew) {
  ------------------
  |  Branch (115:23): [True: 9.77M, False: 9.54k]
  ------------------
  116|   625M|        for (auto& entry : bucket) {
  ------------------
  |  Branch (116:26): [True: 625M, False: 9.77M]
  ------------------
  117|   625M|            entry = -1;
  118|   625M|        }
  119|  9.77M|    }
  120|  2.44M|    for (auto& bucket : vvTried) {
  ------------------
  |  Branch (120:23): [True: 2.44M, False: 9.54k]
  ------------------
  121|   156M|        for (auto& entry : bucket) {
  ------------------
  |  Branch (121:26): [True: 156M, False: 2.44M]
  ------------------
  122|   156M|            entry = -1;
  123|   156M|        }
  124|  2.44M|    }
  125|  9.54k|}
_ZN11AddrManImplD2Ev:
  128|  9.54k|{
  129|  9.54k|    nKey.SetNull();
  130|  9.54k|}
_ZN11AddrManImpl4FindERK8CServicePl:
  402|  6.39M|{
  403|  6.39M|    AssertLockHeld(cs);
  ------------------
  |  |  142|  6.39M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  404|       |
  405|  6.39M|    const auto it = mapAddr.find(addr);
  406|  6.39M|    if (it == mapAddr.end())
  ------------------
  |  Branch (406:9): [True: 4.29M, False: 2.09M]
  ------------------
  407|  4.29M|        return nullptr;
  408|  2.09M|    if (pnId)
  ------------------
  |  Branch (408:9): [True: 2.08M, False: 3.54k]
  ------------------
  409|  2.08M|        *pnId = (*it).second;
  410|  2.09M|    const auto it2 = mapInfo.find((*it).second);
  411|  2.09M|    if (it2 != mapInfo.end())
  ------------------
  |  Branch (411:9): [True: 2.09M, False: 0]
  ------------------
  412|  2.09M|        return &(*it2).second;
  413|      0|    return nullptr;
  414|  2.09M|}
_ZN11AddrManImpl6CreateERK8CAddressRK8CNetAddrPl:
  417|  3.85M|{
  418|  3.85M|    AssertLockHeld(cs);
  ------------------
  |  |  142|  3.85M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  419|       |
  420|  3.85M|    nid_type nId = nIdCount++;
  421|  3.85M|    mapInfo[nId] = AddrInfo(addr, addrSource);
  422|  3.85M|    mapAddr[addr] = nId;
  423|  3.85M|    mapInfo[nId].nRandomPos = vRandom.size();
  424|  3.85M|    vRandom.push_back(nId);
  425|  3.85M|    nNew++;
  426|  3.85M|    m_network_counts[addr.GetNetwork()].n_new++;
  427|  3.85M|    if (pnId)
  ------------------
  |  Branch (427:9): [True: 3.85M, False: 0]
  ------------------
  428|  3.85M|        *pnId = nId;
  429|  3.85M|    return &mapInfo[nId];
  430|  3.85M|}
_ZNK11AddrManImpl10SwapRandomEjj:
  433|  3.76M|{
  434|  3.76M|    AssertLockHeld(cs);
  ------------------
  |  |  142|  3.76M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  435|       |
  436|  3.76M|    if (nRndPos1 == nRndPos2)
  ------------------
  |  Branch (436:9): [True: 44.6k, False: 3.72M]
  ------------------
  437|  44.6k|        return;
  438|       |
  439|  3.72M|    assert(nRndPos1 < vRandom.size() && nRndPos2 < vRandom.size());
  440|       |
  441|  3.72M|    nid_type nId1 = vRandom[nRndPos1];
  442|  3.72M|    nid_type nId2 = vRandom[nRndPos2];
  443|       |
  444|  3.72M|    const auto it_1{mapInfo.find(nId1)};
  445|  3.72M|    const auto it_2{mapInfo.find(nId2)};
  446|  3.72M|    assert(it_1 != mapInfo.end());
  447|  3.72M|    assert(it_2 != mapInfo.end());
  448|       |
  449|  3.72M|    it_1->second.nRandomPos = nRndPos2;
  450|  3.72M|    it_2->second.nRandomPos = nRndPos1;
  451|       |
  452|  3.72M|    vRandom[nRndPos1] = nId2;
  453|  3.72M|    vRandom[nRndPos2] = nId1;
  454|  3.72M|}
_ZN11AddrManImpl6DeleteEl:
  457|  2.32M|{
  458|  2.32M|    AssertLockHeld(cs);
  ------------------
  |  |  142|  2.32M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  459|       |
  460|  2.32M|    assert(mapInfo.count(nId) != 0);
  461|  2.32M|    AddrInfo& info = mapInfo[nId];
  462|  2.32M|    assert(!info.fInTried);
  463|  2.32M|    assert(info.nRefCount == 0);
  464|       |
  465|  2.32M|    SwapRandom(info.nRandomPos, vRandom.size() - 1);
  466|  2.32M|    m_network_counts[info.GetNetwork()].n_new--;
  467|  2.32M|    vRandom.pop_back();
  468|  2.32M|    mapAddr.erase(info);
  469|  2.32M|    mapInfo.erase(nId);
  470|  2.32M|    nNew--;
  471|  2.32M|}
_ZN11AddrManImpl8ClearNewEii:
  474|  3.97M|{
  475|  3.97M|    AssertLockHeld(cs);
  ------------------
  |  |  142|  3.97M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  476|       |
  477|       |    // if there is an entry in the specified bucket, delete it.
  478|  3.97M|    if (vvNew[nUBucket][nUBucketPos] != -1) {
  ------------------
  |  Branch (478:9): [True: 2.33M, False: 1.64M]
  ------------------
  479|  2.33M|        nid_type nIdDelete = vvNew[nUBucket][nUBucketPos];
  480|  2.33M|        AddrInfo& infoDelete = mapInfo[nIdDelete];
  481|  2.33M|        assert(infoDelete.nRefCount > 0);
  482|  2.33M|        infoDelete.nRefCount--;
  483|  2.33M|        vvNew[nUBucket][nUBucketPos] = -1;
  484|  2.33M|        LogDebug(BCLog::ADDRMAN, "Removed %s from new[%i][%i]\n", infoDelete.ToStringAddrPort(), nUBucket, nUBucketPos);
  ------------------
  |  |  280|  2.33M|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  2.33M|    do {                                                  \
  |  |  |  |  274|  2.33M|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 2.33M]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  2.33M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  485|  2.33M|        if (infoDelete.nRefCount == 0) {
  ------------------
  |  Branch (485:13): [True: 2.29M, False: 39.7k]
  ------------------
  486|  2.29M|            Delete(nIdDelete);
  487|  2.29M|        }
  488|  2.33M|    }
  489|  3.97M|}
_ZN11AddrManImpl9MakeTriedER8AddrInfol:
  492|   119k|{
  493|   119k|    AssertLockHeld(cs);
  ------------------
  |  |  142|   119k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  494|       |
  495|       |    // remove the entry from all new buckets
  496|   119k|    const int start_bucket{info.GetNewBucket(nKey, m_netgroupman)};
  497|  16.3M|    for (int n = 0; n < ADDRMAN_NEW_BUCKET_COUNT; ++n) {
  ------------------
  |  Branch (497:21): [True: 16.3M, False: 0]
  ------------------
  498|  16.3M|        const int bucket{(start_bucket + n) % ADDRMAN_NEW_BUCKET_COUNT};
  499|  16.3M|        const int pos{info.GetBucketPosition(nKey, true, bucket)};
  500|  16.3M|        if (vvNew[bucket][pos] == nId) {
  ------------------
  |  Branch (500:13): [True: 155k, False: 16.1M]
  ------------------
  501|   155k|            vvNew[bucket][pos] = -1;
  502|   155k|            info.nRefCount--;
  503|   155k|            if (info.nRefCount == 0) break;
  ------------------
  |  Branch (503:17): [True: 119k, False: 36.0k]
  ------------------
  504|   155k|        }
  505|  16.3M|    }
  506|   119k|    nNew--;
  507|   119k|    m_network_counts[info.GetNetwork()].n_new--;
  508|       |
  509|   119k|    assert(info.nRefCount == 0);
  510|       |
  511|       |    // which tried bucket to move the entry to
  512|   119k|    int nKBucket = info.GetTriedBucket(nKey, m_netgroupman);
  513|   119k|    int nKBucketPos = info.GetBucketPosition(nKey, false, nKBucket);
  514|       |
  515|       |    // first make space to add it (the existing tried entry there is moved to new, deleting whatever is there).
  516|   119k|    if (vvTried[nKBucket][nKBucketPos] != -1) {
  ------------------
  |  Branch (516:9): [True: 14.1k, False: 105k]
  ------------------
  517|       |        // find an item to evict
  518|  14.1k|        nid_type nIdEvict = vvTried[nKBucket][nKBucketPos];
  519|  14.1k|        assert(mapInfo.count(nIdEvict) == 1);
  520|  14.1k|        AddrInfo& infoOld = mapInfo[nIdEvict];
  521|       |
  522|       |        // Remove the to-be-evicted item from the tried set.
  523|  14.1k|        infoOld.fInTried = false;
  524|  14.1k|        vvTried[nKBucket][nKBucketPos] = -1;
  525|  14.1k|        nTried--;
  526|  14.1k|        m_network_counts[infoOld.GetNetwork()].n_tried--;
  527|       |
  528|       |        // find which new bucket it belongs to
  529|  14.1k|        int nUBucket = infoOld.GetNewBucket(nKey, m_netgroupman);
  530|  14.1k|        int nUBucketPos = infoOld.GetBucketPosition(nKey, true, nUBucket);
  531|  14.1k|        ClearNew(nUBucket, nUBucketPos);
  532|  14.1k|        assert(vvNew[nUBucket][nUBucketPos] == -1);
  533|       |
  534|       |        // Enter it into the new set again.
  535|  14.1k|        infoOld.nRefCount = 1;
  536|  14.1k|        vvNew[nUBucket][nUBucketPos] = nIdEvict;
  537|  14.1k|        nNew++;
  538|  14.1k|        m_network_counts[infoOld.GetNetwork()].n_new++;
  539|  14.1k|        LogDebug(BCLog::ADDRMAN, "Moved %s from tried[%i][%i] to new[%i][%i] to make space\n",
  ------------------
  |  |  280|  14.1k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  14.1k|    do {                                                  \
  |  |  |  |  274|  14.1k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 14.1k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  14.1k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  540|  14.1k|                 infoOld.ToStringAddrPort(), nKBucket, nKBucketPos, nUBucket, nUBucketPos);
  541|  14.1k|    }
  542|   119k|    assert(vvTried[nKBucket][nKBucketPos] == -1);
  543|       |
  544|   119k|    vvTried[nKBucket][nKBucketPos] = nId;
  545|   119k|    nTried++;
  546|   119k|    info.fInTried = true;
  547|   119k|    m_network_counts[info.GetNetwork()].n_tried++;
  548|   119k|}
_ZN11AddrManImpl9AddSingleERK8CAddressRK8CNetAddrNSt3__16chrono8durationIxNS6_5ratioILl1ELl1EEEEE:
  551|  5.47M|{
  552|  5.47M|    AssertLockHeld(cs);
  ------------------
  |  |  142|  5.47M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  553|       |
  554|  5.47M|    if (!addr.IsRoutable())
  ------------------
  |  Branch (554:9): [True: 50.4k, False: 5.42M]
  ------------------
  555|  50.4k|        return false;
  556|       |
  557|  5.42M|    nid_type nId;
  558|  5.42M|    AddrInfo* pinfo = Find(addr, &nId);
  559|       |
  560|       |    // Do not set a penalty for a source's self-announcement
  561|  5.42M|    if (addr == source) {
  ------------------
  |  Branch (561:9): [True: 19.3k, False: 5.40M]
  ------------------
  562|  19.3k|        time_penalty = 0s;
  563|  19.3k|    }
  564|       |
  565|  5.42M|    if (pinfo) {
  ------------------
  |  Branch (565:9): [True: 1.57M, False: 3.85M]
  ------------------
  566|       |        // periodically update nTime
  567|  1.57M|        const bool currently_online{NodeClock::now() - addr.nTime < 24h};
  568|  1.57M|        const auto update_interval{currently_online ? 1h : 24h};
  ------------------
  |  Branch (568:36): [True: 1.13M, False: 437k]
  ------------------
  569|  1.57M|        if (pinfo->nTime < addr.nTime - update_interval - time_penalty) {
  ------------------
  |  Branch (569:13): [True: 81.8k, False: 1.48M]
  ------------------
  570|  81.8k|            pinfo->nTime = std::max(NodeSeconds{0s}, addr.nTime - time_penalty);
  571|  81.8k|        }
  572|       |
  573|       |        // add services
  574|  1.57M|        pinfo->nServices = ServiceFlags(pinfo->nServices | addr.nServices);
  575|       |
  576|       |        // do not update if no new information is present
  577|  1.57M|        if (addr.nTime <= pinfo->nTime) {
  ------------------
  |  Branch (577:13): [True: 249k, False: 1.32M]
  ------------------
  578|   249k|            return false;
  579|   249k|        }
  580|       |
  581|       |        // do not update if the entry was already in the "tried" table
  582|  1.32M|        if (pinfo->fInTried)
  ------------------
  |  Branch (582:13): [True: 600k, False: 721k]
  ------------------
  583|   600k|            return false;
  584|       |
  585|       |        // do not update if the max reference count is reached
  586|   721k|        if (pinfo->nRefCount == ADDRMAN_NEW_BUCKETS_PER_ADDRESS)
  ------------------
  |  Branch (586:13): [True: 426, False: 720k]
  ------------------
  587|    426|            return false;
  588|       |
  589|       |        // stochastic test: previous nRefCount == N: 2^N times harder to increase it
  590|   720k|        if (pinfo->nRefCount > 0) {
  ------------------
  |  Branch (590:13): [True: 720k, False: 0]
  ------------------
  591|   720k|            const int nFactor{1 << pinfo->nRefCount};
  592|   720k|            if (insecure_rand.randrange(nFactor) != 0) return false;
  ------------------
  |  Branch (592:17): [True: 429k, False: 291k]
  ------------------
  593|   720k|        }
  594|  3.85M|    } else {
  595|  3.85M|        pinfo = Create(addr, source, &nId);
  596|  3.85M|        pinfo->nTime = std::max(NodeSeconds{0s}, pinfo->nTime - time_penalty);
  597|  3.85M|    }
  598|       |
  599|  4.14M|    int nUBucket = pinfo->GetNewBucket(nKey, source, m_netgroupman);
  600|  4.14M|    int nUBucketPos = pinfo->GetBucketPosition(nKey, true, nUBucket);
  601|  4.14M|    bool fInsert = vvNew[nUBucket][nUBucketPos] == -1;
  602|  4.14M|    if (vvNew[nUBucket][nUBucketPos] != nId) {
  ------------------
  |  Branch (602:9): [True: 3.98M, False: 155k]
  ------------------
  603|  3.98M|        if (!fInsert) {
  ------------------
  |  Branch (603:13): [True: 2.35M, False: 1.63M]
  ------------------
  604|  2.35M|            AddrInfo& infoExisting = mapInfo[vvNew[nUBucket][nUBucketPos]];
  605|  2.35M|            if (infoExisting.IsTerrible() || (infoExisting.nRefCount > 1 && pinfo->nRefCount == 0)) {
  ------------------
  |  Branch (605:17): [True: 2.33M, False: 20.8k]
  |  Branch (605:47): [True: 1.06k, False: 19.8k]
  |  Branch (605:77): [True: 573, False: 487]
  ------------------
  606|       |                // Overwrite the existing new table entry.
  607|  2.33M|                fInsert = true;
  608|  2.33M|            }
  609|  2.35M|        }
  610|  3.98M|        if (fInsert) {
  ------------------
  |  Branch (610:13): [True: 3.96M, False: 20.2k]
  ------------------
  611|  3.96M|            ClearNew(nUBucket, nUBucketPos);
  612|  3.96M|            pinfo->nRefCount++;
  613|  3.96M|            vvNew[nUBucket][nUBucketPos] = nId;
  614|  3.96M|            const auto mapped_as{m_netgroupman.GetMappedAS(addr)};
  615|  3.96M|            LogDebug(BCLog::ADDRMAN, "Added %s%s to new[%i][%i]\n",
  ------------------
  |  |  280|  3.96M|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  3.96M|    do {                                                  \
  |  |  |  |  274|  3.96M|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 3.96M]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (255:116): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  3.96M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  616|  3.96M|                     addr.ToStringAddrPort(), (mapped_as ? strprintf(" mapped to AS%i", mapped_as) : ""), nUBucket, nUBucketPos);
  617|  3.96M|        } else {
  618|  20.2k|            if (pinfo->nRefCount == 0) {
  ------------------
  |  Branch (618:17): [True: 19.4k, False: 875]
  ------------------
  619|  19.4k|                Delete(nId);
  620|  19.4k|            }
  621|  20.2k|        }
  622|  3.98M|    }
  623|  4.14M|    return fInsert;
  624|  5.42M|}
_ZN11AddrManImpl5Good_ERK8CServicebNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
  627|   901k|{
  628|   901k|    AssertLockHeld(cs);
  ------------------
  |  |  142|   901k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  629|       |
  630|   901k|    nid_type nId;
  631|       |
  632|   901k|    m_last_good = time;
  633|       |
  634|   901k|    AddrInfo* pinfo = Find(addr, &nId);
  635|       |
  636|       |    // if not found, bail out
  637|   901k|    if (!pinfo) return false;
  ------------------
  |  Branch (637:9): [True: 382k, False: 518k]
  ------------------
  638|       |
  639|   518k|    AddrInfo& info = *pinfo;
  640|       |
  641|       |    // update info
  642|   518k|    info.m_last_success = time;
  643|   518k|    info.m_last_try = time;
  644|   518k|    info.nAttempts = 0;
  645|       |    // nTime is not updated here, to avoid leaking information about
  646|       |    // currently-connected peers.
  647|       |
  648|       |    // if it is already in the tried set, don't do anything else
  649|   518k|    if (info.fInTried) return false;
  ------------------
  |  Branch (649:9): [True: 326k, False: 192k]
  ------------------
  650|       |
  651|       |    // if it is not in new, something bad happened
  652|   192k|    if (!Assume(info.nRefCount > 0)) return false;
  ------------------
  |  |   97|   192k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  |  Branch (652:9): [True: 0, False: 192k]
  ------------------
  653|       |
  654|       |
  655|       |    // which tried bucket to move the entry to
  656|   192k|    int tried_bucket = info.GetTriedBucket(nKey, m_netgroupman);
  657|   192k|    int tried_bucket_pos = info.GetBucketPosition(nKey, false, tried_bucket);
  658|       |
  659|       |    // Will moving this address into tried evict another entry?
  660|   192k|    if (test_before_evict && (vvTried[tried_bucket][tried_bucket_pos] != -1)) {
  ------------------
  |  Branch (660:9): [True: 177k, False: 14.1k]
  |  Branch (660:30): [True: 72.6k, False: 105k]
  ------------------
  661|  72.6k|        if (m_tried_collisions.size() < ADDRMAN_SET_TRIED_COLLISION_SIZE) {
  ------------------
  |  Branch (661:13): [True: 61.5k, False: 11.1k]
  ------------------
  662|  61.5k|            m_tried_collisions.insert(nId);
  663|  61.5k|        }
  664|       |        // Output the entry we'd be colliding with, for debugging purposes
  665|  72.6k|        auto colliding_entry = mapInfo.find(vvTried[tried_bucket][tried_bucket_pos]);
  666|  72.6k|        LogDebug(BCLog::ADDRMAN, "Collision with %s while attempting to move %s to tried table. Collisions=%d\n",
  ------------------
  |  |  280|  72.6k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  72.6k|    do {                                                  \
  |  |  |  |  274|  72.6k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 72.6k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (255:116): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  72.6k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  667|  72.6k|                 colliding_entry != mapInfo.end() ? colliding_entry->second.ToStringAddrPort() : "",
  668|  72.6k|                 addr.ToStringAddrPort(),
  669|  72.6k|                 m_tried_collisions.size());
  670|  72.6k|        return false;
  671|   119k|    } else {
  672|       |        // move nId to the tried tables
  673|   119k|        MakeTried(info, nId);
  674|   119k|        const auto mapped_as{m_netgroupman.GetMappedAS(addr)};
  675|   119k|        LogDebug(BCLog::ADDRMAN, "Moved %s%s to tried[%i][%i]\n",
  ------------------
  |  |  280|   119k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|   119k|    do {                                                  \
  |  |  |  |  274|   119k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 119k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (255:116): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|   119k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  676|   119k|                 addr.ToStringAddrPort(), (mapped_as ? strprintf(" mapped to AS%i", mapped_as) : ""), tried_bucket, tried_bucket_pos);
  677|   119k|        return true;
  678|   119k|    }
  679|   192k|}
_ZN11AddrManImpl4Add_ERKNSt3__16vectorI8CAddressNS0_9allocatorIS2_EEEERK8CNetAddrNS0_6chrono8durationIxNS0_5ratioILl1ELl1EEEEE:
  682|  28.4k|{
  683|  28.4k|    int added{0};
  684|  5.50M|    for (std::vector<CAddress>::const_iterator it = vAddr.begin(); it != vAddr.end(); it++) {
  ------------------
  |  Branch (684:68): [True: 5.47M, False: 28.4k]
  ------------------
  685|  5.47M|        added += AddSingle(*it, source, time_penalty) ? 1 : 0;
  ------------------
  |  Branch (685:18): [True: 3.96M, False: 1.50M]
  ------------------
  686|  5.47M|    }
  687|  28.4k|    if (added > 0) {
  ------------------
  |  Branch (687:9): [True: 23.5k, False: 4.88k]
  ------------------
  688|  23.5k|        LogDebug(BCLog::ADDRMAN, "Added %i addresses (of %i) from %s: %i tried, %i new\n", added, vAddr.size(), source.ToStringAddr(), nTried, nNew);
  ------------------
  |  |  280|  23.5k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  23.5k|    do {                                                  \
  |  |  |  |  274|  23.5k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 23.5k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  23.5k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  689|  23.5k|    }
  690|  28.4k|    return added > 0;
  691|  28.4k|}
_ZN11AddrManImpl8Attempt_ERK8CServicebNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
  694|  4.80k|{
  695|  4.80k|    AssertLockHeld(cs);
  ------------------
  |  |  142|  4.80k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  696|       |
  697|  4.80k|    AddrInfo* pinfo = Find(addr);
  698|       |
  699|       |    // if not found, bail out
  700|  4.80k|    if (!pinfo)
  ------------------
  |  Branch (700:9): [True: 3.10k, False: 1.70k]
  ------------------
  701|  3.10k|        return;
  702|       |
  703|  1.70k|    AddrInfo& info = *pinfo;
  704|       |
  705|       |    // update info
  706|  1.70k|    info.m_last_try = time;
  707|  1.70k|    if (fCountFailure && info.m_last_count_attempt < m_last_good) {
  ------------------
  |  Branch (707:9): [True: 1.62k, False: 76]
  |  Branch (707:26): [True: 530, False: 1.09k]
  ------------------
  708|    530|        info.m_last_count_attempt = time;
  709|    530|        info.nAttempts++;
  710|    530|    }
  711|  1.70k|}
_ZNK11AddrManImpl7Select_EbRKNSt3__113unordered_setI7NetworkNS0_4hashIS2_EENS0_8equal_toIS2_EENS0_9allocatorIS2_EEEE:
  714|  7.15k|{
  715|  7.15k|    AssertLockHeld(cs);
  ------------------
  |  |  142|  7.15k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  716|       |
  717|  7.15k|    if (vRandom.empty()) return {};
  ------------------
  |  Branch (717:9): [True: 2.38k, False: 4.77k]
  ------------------
  718|       |
  719|  4.77k|    size_t new_count = nNew;
  720|  4.77k|    size_t tried_count = nTried;
  721|       |
  722|  4.77k|    if (!networks.empty()) {
  ------------------
  |  Branch (722:9): [True: 710, False: 4.06k]
  ------------------
  723|    710|        new_count = 0;
  724|    710|        tried_count = 0;
  725|  3.27k|        for (auto& network : networks) {
  ------------------
  |  Branch (725:28): [True: 3.27k, False: 710]
  ------------------
  726|  3.27k|            auto it = m_network_counts.find(network);
  727|  3.27k|            if (it == m_network_counts.end()) {
  ------------------
  |  Branch (727:17): [True: 1.93k, False: 1.33k]
  ------------------
  728|  1.93k|                continue;
  729|  1.93k|            }
  730|  1.33k|            auto counts = it->second;
  731|  1.33k|            new_count += counts.n_new;
  732|  1.33k|            tried_count += counts.n_tried;
  733|  1.33k|        }
  734|    710|    }
  735|       |
  736|  4.77k|    if (new_only && new_count == 0) return {};
  ------------------
  |  Branch (736:9): [True: 432, False: 4.34k]
  |  Branch (736:21): [True: 23, False: 409]
  ------------------
  737|  4.74k|    if (new_count + tried_count == 0) return {};
  ------------------
  |  Branch (737:9): [True: 55, False: 4.69k]
  ------------------
  738|       |
  739|       |    // Decide if we are going to search the new or tried table
  740|       |    // If either option is viable, use a 50% chance to choose
  741|  4.69k|    bool search_tried;
  742|  4.69k|    if (new_only || tried_count == 0) {
  ------------------
  |  Branch (742:9): [True: 409, False: 4.28k]
  |  Branch (742:21): [True: 3.08k, False: 1.19k]
  ------------------
  743|  3.49k|        search_tried = false;
  744|  3.49k|    } else if (new_count == 0) {
  ------------------
  |  Branch (744:16): [True: 283, False: 913]
  ------------------
  745|    283|        search_tried = true;
  746|    913|    } else {
  747|    913|        search_tried = insecure_rand.randbool();
  748|    913|    }
  749|       |
  750|  4.69k|    const int bucket_count{search_tried ? ADDRMAN_TRIED_BUCKET_COUNT : ADDRMAN_NEW_BUCKET_COUNT};
  ------------------
  |  Branch (750:28): [True: 783, False: 3.91k]
  ------------------
  751|       |
  752|       |    // Loop through the addrman table until we find an appropriate entry
  753|  4.69k|    double chance_factor = 1.0;
  754|  4.98M|    while (1) {
  ------------------
  |  Branch (754:12): [Folded - Ignored]
  ------------------
  755|       |        // Pick a bucket, and an initial position in that bucket.
  756|  4.98M|        int bucket = insecure_rand.randrange(bucket_count);
  757|  4.98M|        int initial_position = insecure_rand.randrange(ADDRMAN_BUCKET_SIZE);
  758|       |
  759|       |        // Iterate over the positions of that bucket, starting at the initial one,
  760|       |        // and looping around.
  761|  4.98M|        int i, position;
  762|  4.98M|        nid_type node_id;
  763|   323M|        for (i = 0; i < ADDRMAN_BUCKET_SIZE; ++i) {
  ------------------
  |  Branch (763:21): [True: 318M, False: 4.97M]
  ------------------
  764|   318M|            position = (initial_position + i) % ADDRMAN_BUCKET_SIZE;
  765|   318M|            node_id = GetEntry(search_tried, bucket, position);
  766|   318M|            if (node_id != -1) {
  ------------------
  |  Branch (766:17): [True: 116k, False: 318M]
  ------------------
  767|   116k|                if (!networks.empty()) {
  ------------------
  |  Branch (767:21): [True: 107k, False: 9.41k]
  ------------------
  768|   107k|                    const auto it{mapInfo.find(node_id)};
  769|   107k|                    if (Assume(it != mapInfo.end()) && networks.contains(it->second.GetNetwork())) break;
  ------------------
  |  |   97|   214k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  |  |  ------------------
  |  |  |  Branch (97:21): [True: 107k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (769:25): [True: 1.14k, False: 105k]
  |  Branch (769:56): [True: 1.14k, False: 105k]
  ------------------
  770|   107k|                } else {
  771|  9.41k|                    break;
  772|  9.41k|                }
  773|   116k|            }
  774|   318M|        }
  775|       |
  776|       |        // If the bucket is entirely empty, start over with a (likely) different one.
  777|  4.98M|        if (i == ADDRMAN_BUCKET_SIZE) continue;
  ------------------
  |  Branch (777:13): [True: 4.97M, False: 10.5k]
  ------------------
  778|       |
  779|       |        // Find the entry to return.
  780|  10.5k|        const auto it_found{mapInfo.find(node_id)};
  781|  10.5k|        assert(it_found != mapInfo.end());
  782|  10.5k|        const AddrInfo& info{it_found->second};
  783|       |
  784|       |        // With probability GetChance() * chance_factor, return the entry.
  785|  10.5k|        if (insecure_rand.randbits<30>() < chance_factor * info.GetChance() * (1 << 30)) {
  ------------------
  |  Branch (785:13): [True: 4.69k, False: 5.86k]
  ------------------
  786|  4.69k|            LogDebug(BCLog::ADDRMAN, "Selected %s from %s\n", info.ToStringAddrPort(), search_tried ? "tried" : "new");
  ------------------
  |  |  280|  4.69k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  4.69k|    do {                                                  \
  |  |  |  |  274|  4.69k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 4.69k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (255:116): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  4.69k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  787|  4.69k|            return {info, info.m_last_try};
  788|  4.69k|        }
  789|       |
  790|       |        // Otherwise start over with a (likely) different bucket, and increased chance factor.
  791|  5.86k|        chance_factor *= 1.2;
  792|  5.86k|    }
  793|  4.69k|}
_ZNK11AddrManImpl8GetEntryEbmm:
  796|   318M|{
  797|   318M|    AssertLockHeld(cs);
  ------------------
  |  |  142|   318M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  798|       |
  799|   318M|    if (use_tried) {
  ------------------
  |  Branch (799:9): [True: 52.9M, False: 265M]
  ------------------
  800|  52.9M|        if (Assume(position < ADDRMAN_BUCKET_SIZE) && Assume(bucket < ADDRMAN_TRIED_BUCKET_COUNT)) {
  ------------------
  |  |   97|   105M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  |  |  ------------------
  |  |  |  Branch (97:21): [True: 52.9M, False: 0]
  |  |  ------------------
  ------------------
                      if (Assume(position < ADDRMAN_BUCKET_SIZE) && Assume(bucket < ADDRMAN_TRIED_BUCKET_COUNT)) {
  ------------------
  |  |   97|  52.9M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  |  |  ------------------
  |  |  |  Branch (97:21): [True: 52.9M, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (800:13): [True: 52.9M, False: 0]
  ------------------
  801|  52.9M|            return vvTried[bucket][position];
  802|  52.9M|        }
  803|   265M|    } else {
  804|   265M|        if (Assume(position < ADDRMAN_BUCKET_SIZE) && Assume(bucket < ADDRMAN_NEW_BUCKET_COUNT)) {
  ------------------
  |  |   97|   530M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  |  |  ------------------
  |  |  |  Branch (97:21): [True: 265M, False: 0]
  |  |  ------------------
  ------------------
                      if (Assume(position < ADDRMAN_BUCKET_SIZE) && Assume(bucket < ADDRMAN_NEW_BUCKET_COUNT)) {
  ------------------
  |  |   97|   265M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  |  |  ------------------
  |  |  |  Branch (97:21): [True: 265M, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (804:13): [True: 265M, False: 0]
  ------------------
  805|   265M|            return vvNew[bucket][position];
  806|   265M|        }
  807|   265M|    }
  808|       |
  809|      0|    return -1;
  810|   318M|}
_ZNK11AddrManImpl8GetAddr_EmmNSt3__18optionalI7NetworkEEb:
  813|  7.15k|{
  814|  7.15k|    AssertLockHeld(cs);
  ------------------
  |  |  142|  7.15k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  815|  7.15k|    Assume(max_pct <= 100);
  ------------------
  |  |   97|  7.15k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  816|       |
  817|  7.15k|    size_t nNodes = vRandom.size();
  818|  7.15k|    if (max_pct != 0) {
  ------------------
  |  Branch (818:9): [True: 767, False: 6.39k]
  ------------------
  819|    767|        max_pct = std::min(max_pct, size_t{100});
  820|    767|        nNodes = max_pct * nNodes / 100;
  821|    767|    }
  822|  7.15k|    if (max_addresses != 0) {
  ------------------
  |  Branch (822:9): [True: 856, False: 6.30k]
  ------------------
  823|    856|        nNodes = std::min(nNodes, max_addresses);
  824|    856|    }
  825|       |
  826|       |    // gather a list of random nodes, skipping those of low quality
  827|  7.15k|    const auto now{Now<NodeSeconds>()};
  828|  7.15k|    std::vector<CAddress> addresses;
  829|  7.15k|    addresses.reserve(nNodes);
  830|  1.44M|    for (unsigned int n = 0; n < vRandom.size(); n++) {
  ------------------
  |  Branch (830:30): [True: 1.44M, False: 6.92k]
  ------------------
  831|  1.44M|        if (addresses.size() >= nNodes)
  ------------------
  |  Branch (831:13): [True: 235, False: 1.44M]
  ------------------
  832|    235|            break;
  833|       |
  834|  1.44M|        int nRndPos = insecure_rand.randrange(vRandom.size() - n) + n;
  835|  1.44M|        SwapRandom(n, nRndPos);
  836|  1.44M|        const auto it{mapInfo.find(vRandom[n])};
  837|  1.44M|        assert(it != mapInfo.end());
  838|       |
  839|  1.44M|        const AddrInfo& ai{it->second};
  840|       |
  841|       |        // Filter by network (optional)
  842|  1.44M|        if (network != std::nullopt && ai.GetNetClass() != network) continue;
  ------------------
  |  Branch (842:13): [True: 315k, False: 1.12M]
  |  Branch (842:13): [True: 297k, False: 1.14M]
  |  Branch (842:40): [True: 297k, False: 18.6k]
  ------------------
  843|       |
  844|       |        // Filter for quality
  845|  1.14M|        if (ai.IsTerrible(now) && filtered) continue;
  ------------------
  |  Branch (845:13): [True: 1.11M, False: 30.8k]
  |  Branch (845:35): [True: 159k, False: 953k]
  ------------------
  846|       |
  847|   984k|        addresses.push_back(ai);
  848|   984k|    }
  849|  7.15k|    LogDebug(BCLog::ADDRMAN, "GetAddr returned %d random addresses\n", addresses.size());
  ------------------
  |  |  280|  7.15k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  7.15k|    do {                                                  \
  |  |  |  |  274|  7.15k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 7.15k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  7.15k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  850|  7.15k|    return addresses;
  851|  7.15k|}
_ZN11AddrManImpl10Connected_ERK8CServiceNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
  878|  3.27k|{
  879|  3.27k|    AssertLockHeld(cs);
  ------------------
  |  |  142|  3.27k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  880|       |
  881|  3.27k|    AddrInfo* pinfo = Find(addr);
  882|       |
  883|       |    // if not found, bail out
  884|  3.27k|    if (!pinfo)
  ------------------
  |  Branch (884:9): [True: 2.12k, False: 1.14k]
  ------------------
  885|  2.12k|        return;
  886|       |
  887|  1.14k|    AddrInfo& info = *pinfo;
  888|       |
  889|       |    // update info
  890|  1.14k|    const auto update_interval{20min};
  891|  1.14k|    if (time - info.nTime > update_interval) {
  ------------------
  |  Branch (891:9): [True: 411, False: 733]
  ------------------
  892|    411|        info.nTime = time;
  893|    411|    }
  894|  1.14k|}
_ZN11AddrManImpl12SetServices_ERK8CService12ServiceFlags:
  897|  58.9k|{
  898|  58.9k|    AssertLockHeld(cs);
  ------------------
  |  |  142|  58.9k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  899|       |
  900|  58.9k|    AddrInfo* pinfo = Find(addr);
  901|       |
  902|       |    // if not found, bail out
  903|  58.9k|    if (!pinfo)
  ------------------
  |  Branch (903:9): [True: 58.2k, False: 696]
  ------------------
  904|  58.2k|        return;
  905|       |
  906|    696|    AddrInfo& info = *pinfo;
  907|       |
  908|       |    // update info
  909|    696|    info.nServices = nServices;
  910|    696|}
_ZN11AddrManImpl18ResolveCollisions_Ev:
  913|  18.9k|{
  914|  18.9k|    AssertLockHeld(cs);
  ------------------
  |  |  142|  18.9k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  915|       |
  916|  91.6k|    for (std::set<nid_type>::iterator it = m_tried_collisions.begin(); it != m_tried_collisions.end();) {
  ------------------
  |  Branch (916:72): [True: 72.7k, False: 18.9k]
  ------------------
  917|  72.7k|        nid_type id_new = *it;
  918|       |
  919|  72.7k|        bool erase_collision = false;
  920|       |
  921|       |        // If id_new not found in mapInfo remove it from m_tried_collisions
  922|  72.7k|        if (mapInfo.count(id_new) != 1) {
  ------------------
  |  Branch (922:13): [True: 219, False: 72.5k]
  ------------------
  923|    219|            erase_collision = true;
  924|  72.5k|        } else {
  925|  72.5k|            AddrInfo& info_new = mapInfo[id_new];
  926|       |
  927|       |            // Which tried bucket to move the entry to.
  928|  72.5k|            int tried_bucket = info_new.GetTriedBucket(nKey, m_netgroupman);
  929|  72.5k|            int tried_bucket_pos = info_new.GetBucketPosition(nKey, false, tried_bucket);
  930|  72.5k|            if (!info_new.IsValid()) { // id_new may no longer map to a valid address
  ------------------
  |  Branch (930:17): [True: 0, False: 72.5k]
  ------------------
  931|      0|                erase_collision = true;
  932|  72.5k|            } else if (vvTried[tried_bucket][tried_bucket_pos] != -1) { // The position in the tried bucket is not empty
  ------------------
  |  Branch (932:24): [True: 72.5k, False: 0]
  ------------------
  933|       |
  934|       |                // Get the to-be-evicted address that is being tested
  935|  72.5k|                nid_type id_old = vvTried[tried_bucket][tried_bucket_pos];
  936|  72.5k|                AddrInfo& info_old = mapInfo[id_old];
  937|       |
  938|  72.5k|                const auto current_time{Now<NodeSeconds>()};
  939|       |
  940|       |                // Has successfully connected in last X hours
  941|  72.5k|                if (current_time - info_old.m_last_success < ADDRMAN_REPLACEMENT) {
  ------------------
  |  Branch (941:21): [True: 32.5k, False: 39.9k]
  ------------------
  942|  32.5k|                    erase_collision = true;
  943|  39.9k|                } else if (current_time - info_old.m_last_try < ADDRMAN_REPLACEMENT) { // attempted to connect and failed in last X hours
  ------------------
  |  Branch (943:28): [True: 289, False: 39.6k]
  ------------------
  944|       |
  945|       |                    // Give address at least 60 seconds to successfully connect
  946|    289|                    if (current_time - info_old.m_last_try > 60s) {
  ------------------
  |  Branch (946:25): [True: 1, False: 288]
  ------------------
  947|      1|                        LogDebug(BCLog::ADDRMAN, "Replacing %s with %s in tried table\n", info_old.ToStringAddrPort(), info_new.ToStringAddrPort());
  ------------------
  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  948|       |
  949|       |                        // Replaces an existing address already in the tried table with the new address
  950|      1|                        Good_(info_new, false, current_time);
  951|      1|                        erase_collision = true;
  952|      1|                    }
  953|  39.6k|                } else if (current_time - info_new.m_last_success > ADDRMAN_TEST_WINDOW) {
  ------------------
  |  Branch (953:28): [True: 14.1k, False: 25.5k]
  ------------------
  954|       |                    // If the collision hasn't resolved in some reasonable amount of time,
  955|       |                    // just evict the old entry -- we must not be able to
  956|       |                    // connect to it for some reason.
  957|  14.1k|                    LogDebug(BCLog::ADDRMAN, "Unable to test; replacing %s with %s in tried table anyway\n", info_old.ToStringAddrPort(), info_new.ToStringAddrPort());
  ------------------
  |  |  280|  14.1k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  14.1k|    do {                                                  \
  |  |  |  |  274|  14.1k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 14.1k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  14.1k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  958|  14.1k|                    Good_(info_new, false, current_time);
  959|  14.1k|                    erase_collision = true;
  960|  14.1k|                }
  961|  72.5k|            } else { // Collision is not actually a collision anymore
  962|      0|                Good_(info_new, false, Now<NodeSeconds>());
  963|      0|                erase_collision = true;
  964|      0|            }
  965|  72.5k|        }
  966|       |
  967|  72.7k|        if (erase_collision) {
  ------------------
  |  Branch (967:13): [True: 46.9k, False: 25.8k]
  ------------------
  968|  46.9k|            m_tried_collisions.erase(it++);
  969|  46.9k|        } else {
  970|  25.8k|            it++;
  971|  25.8k|        }
  972|  72.7k|    }
  973|  18.9k|}
_ZN11AddrManImpl21SelectTriedCollision_Ev:
  976|   239k|{
  977|   239k|    AssertLockHeld(cs);
  ------------------
  |  |  142|   239k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  978|       |
  979|   239k|    if (m_tried_collisions.size() == 0) return {};
  ------------------
  |  Branch (979:9): [True: 59.0k, False: 180k]
  ------------------
  980|       |
  981|   180k|    std::set<nid_type>::iterator it = m_tried_collisions.begin();
  982|       |
  983|       |    // Selects a random element from m_tried_collisions
  984|   180k|    std::advance(it, insecure_rand.randrange(m_tried_collisions.size()));
  985|   180k|    nid_type id_new = *it;
  986|       |
  987|       |    // If id_new not found in mapInfo remove it from m_tried_collisions
  988|   180k|    if (mapInfo.count(id_new) != 1) {
  ------------------
  |  Branch (988:9): [True: 920, False: 179k]
  ------------------
  989|    920|        m_tried_collisions.erase(it);
  990|    920|        return {};
  991|    920|    }
  992|       |
  993|   179k|    const AddrInfo& newInfo = mapInfo[id_new];
  994|       |
  995|       |    // which tried bucket to move the entry to
  996|   179k|    int tried_bucket = newInfo.GetTriedBucket(nKey, m_netgroupman);
  997|   179k|    int tried_bucket_pos = newInfo.GetBucketPosition(nKey, false, tried_bucket);
  998|       |
  999|   179k|    const AddrInfo& info_old = mapInfo[vvTried[tried_bucket][tried_bucket_pos]];
 1000|   179k|    return {info_old, info_old.m_last_try};
 1001|   180k|}
_ZNK11AddrManImpl5Size_ENSt3__18optionalI7NetworkEENS1_IbEE:
 1027|  7.15k|{
 1028|  7.15k|    AssertLockHeld(cs);
  ------------------
  |  |  142|  7.15k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
 1029|       |
 1030|  7.15k|    if (!net.has_value()) {
  ------------------
  |  Branch (1030:9): [True: 6.69k, False: 462]
  ------------------
 1031|  6.69k|        if (in_new.has_value()) {
  ------------------
  |  Branch (1031:13): [True: 233, False: 6.46k]
  ------------------
 1032|    233|            return *in_new ? nNew : nTried;
  ------------------
  |  Branch (1032:20): [True: 165, False: 68]
  ------------------
 1033|  6.46k|        } else {
 1034|  6.46k|            return vRandom.size();
 1035|  6.46k|        }
 1036|  6.69k|    }
 1037|    462|    if (auto it = m_network_counts.find(*net); it != m_network_counts.end()) {
  ------------------
  |  Branch (1037:48): [True: 187, False: 275]
  ------------------
 1038|    187|        auto net_count = it->second;
 1039|    187|        if (in_new.has_value()) {
  ------------------
  |  Branch (1039:13): [True: 132, False: 55]
  ------------------
 1040|    132|            return *in_new ? net_count.n_new : net_count.n_tried;
  ------------------
  |  Branch (1040:20): [True: 113, False: 19]
  ------------------
 1041|    132|        } else {
 1042|     55|            return net_count.n_new + net_count.n_tried;
 1043|     55|        }
 1044|    187|    }
 1045|    275|    return 0;
 1046|    462|}
_ZNK11AddrManImpl5CheckEv:
 1049|  2.52M|{
 1050|  2.52M|    AssertLockHeld(cs);
  ------------------
  |  |  142|  2.52M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
 1051|       |
 1052|       |    // Run consistency checks 1 in m_consistency_check_ratio times if enabled
 1053|  2.52M|    if (m_consistency_check_ratio == 0) return;
  ------------------
  |  Branch (1053:9): [True: 2.52M, False: 0]
  ------------------
 1054|      0|    if (insecure_rand.randrange(m_consistency_check_ratio) >= 1) return;
  ------------------
  |  Branch (1054:9): [True: 0, False: 0]
  ------------------
 1055|       |
 1056|      0|    const int err{CheckAddrman()};
 1057|      0|    if (err) {
  ------------------
  |  Branch (1057:9): [True: 0, False: 0]
  ------------------
 1058|      0|        LogPrintf("ADDRMAN CONSISTENCY CHECK FAILED!!! err=%i\n", err);
  ------------------
  |  |  266|      0|#define LogPrintf(...) LogInfo(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |  261|      0|#define LogInfo(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1059|      0|        assert(false);
 1060|      0|    }
 1061|      0|}
_ZNK11AddrManImpl12CheckAddrmanEv:
 1064|    657|{
 1065|    657|    AssertLockHeld(cs);
  ------------------
  |  |  142|    657|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
 1066|       |
 1067|    657|    LOG_TIME_MILLIS_WITH_CATEGORY_MSG_ONCE(
  ------------------
  |  |  106|    657|    BCLog::Timer<std::chrono::milliseconds> UNIQUE_NAME(logging_timer)(__func__, end_msg, log_category, /* msg_on_completion=*/false)
  |  |  ------------------
  |  |  |  |   11|    657|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|    657|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|    657|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1068|    657|        strprintf("new %i, tried %i, total %u", nNew, nTried, vRandom.size()), BCLog::ADDRMAN);
 1069|       |
 1070|    657|    std::unordered_set<nid_type> setTried;
 1071|    657|    std::unordered_map<nid_type, int> mapNew;
 1072|    657|    std::unordered_map<Network, NewTriedCount> local_counts;
 1073|       |
 1074|    657|    if (vRandom.size() != (size_t)(nTried + nNew))
  ------------------
  |  Branch (1074:9): [True: 0, False: 657]
  ------------------
 1075|      0|        return -7;
 1076|       |
 1077|  1.32k|    for (const auto& entry : mapInfo) {
  ------------------
  |  Branch (1077:28): [True: 1.32k, False: 508]
  ------------------
 1078|  1.32k|        nid_type n = entry.first;
 1079|  1.32k|        const AddrInfo& info = entry.second;
 1080|  1.32k|        if (info.fInTried) {
  ------------------
  |  Branch (1080:13): [True: 935, False: 394]
  ------------------
 1081|    935|            if (!TicksSinceEpoch<std::chrono::seconds>(info.m_last_success)) {
  ------------------
  |  Branch (1081:17): [True: 14, False: 921]
  ------------------
 1082|     14|                return -1;
 1083|     14|            }
 1084|    921|            if (info.nRefCount)
  ------------------
  |  Branch (1084:17): [True: 0, False: 921]
  ------------------
 1085|      0|                return -2;
 1086|    921|            setTried.insert(n);
 1087|    921|            local_counts[info.GetNetwork()].n_tried++;
 1088|    921|        } else {
 1089|    394|            if (info.nRefCount < 0 || info.nRefCount > ADDRMAN_NEW_BUCKETS_PER_ADDRESS)
  ------------------
  |  Branch (1089:17): [True: 0, False: 394]
  |  Branch (1089:39): [True: 0, False: 394]
  ------------------
 1090|      0|                return -3;
 1091|    394|            if (!info.nRefCount)
  ------------------
  |  Branch (1091:17): [True: 0, False: 394]
  ------------------
 1092|      0|                return -4;
 1093|    394|            mapNew[n] = info.nRefCount;
 1094|    394|            local_counts[info.GetNetwork()].n_new++;
 1095|    394|        }
 1096|  1.31k|        const auto it{mapAddr.find(info)};
 1097|  1.31k|        if (it == mapAddr.end() || it->second != n) {
  ------------------
  |  Branch (1097:13): [True: 4, False: 1.31k]
  |  Branch (1097:13): [True: 6, False: 1.30k]
  |  Branch (1097:36): [True: 2, False: 1.30k]
  ------------------
 1098|      6|            return -5;
 1099|      6|        }
 1100|  1.30k|        if (info.nRandomPos < 0 || (size_t)info.nRandomPos >= vRandom.size() || vRandom[info.nRandomPos] != n)
  ------------------
  |  Branch (1100:13): [True: 0, False: 1.30k]
  |  Branch (1100:36): [True: 0, False: 1.30k]
  |  Branch (1100:81): [True: 0, False: 1.30k]
  ------------------
 1101|      0|            return -14;
 1102|  1.30k|        if (info.m_last_try < NodeSeconds{0s}) {
  ------------------
  |  Branch (1102:13): [True: 0, False: 1.30k]
  ------------------
 1103|      0|            return -6;
 1104|      0|        }
 1105|  1.30k|        if (info.m_last_success < NodeSeconds{0s}) {
  ------------------
  |  Branch (1105:13): [True: 129, False: 1.18k]
  ------------------
 1106|    129|            return -8;
 1107|    129|        }
 1108|  1.30k|    }
 1109|       |
 1110|    508|    if (setTried.size() != (size_t)nTried)
  ------------------
  |  Branch (1110:9): [True: 0, False: 508]
  ------------------
 1111|      0|        return -9;
 1112|    508|    if (mapNew.size() != (size_t)nNew)
  ------------------
  |  Branch (1112:9): [True: 0, False: 508]
  ------------------
 1113|      0|        return -10;
 1114|       |
 1115|   130k|    for (int n = 0; n < ADDRMAN_TRIED_BUCKET_COUNT; n++) {
  ------------------
  |  Branch (1115:21): [True: 130k, False: 508]
  ------------------
 1116|  8.45M|        for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
  ------------------
  |  Branch (1116:25): [True: 8.32M, False: 130k]
  ------------------
 1117|  8.32M|            if (vvTried[n][i] != -1) {
  ------------------
  |  Branch (1117:17): [True: 636, False: 8.32M]
  ------------------
 1118|    636|                if (!setTried.count(vvTried[n][i]))
  ------------------
  |  Branch (1118:21): [True: 0, False: 636]
  ------------------
 1119|      0|                    return -11;
 1120|    636|                const auto it{mapInfo.find(vvTried[n][i])};
 1121|    636|                if (it == mapInfo.end() || it->second.GetTriedBucket(nKey, m_netgroupman) != n) {
  ------------------
  |  Branch (1121:21): [True: 0, False: 636]
  |  Branch (1121:21): [True: 0, False: 636]
  |  Branch (1121:44): [True: 0, False: 636]
  ------------------
 1122|      0|                    return -17;
 1123|      0|                }
 1124|    636|                if (it->second.GetBucketPosition(nKey, false, n) != i) {
  ------------------
  |  Branch (1124:21): [True: 0, False: 636]
  ------------------
 1125|      0|                    return -18;
 1126|      0|                }
 1127|    636|                setTried.erase(vvTried[n][i]);
 1128|    636|            }
 1129|  8.32M|        }
 1130|   130k|    }
 1131|       |
 1132|   520k|    for (int n = 0; n < ADDRMAN_NEW_BUCKET_COUNT; n++) {
  ------------------
  |  Branch (1132:21): [True: 520k, False: 508]
  ------------------
 1133|  33.8M|        for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
  ------------------
  |  Branch (1133:25): [True: 33.2M, False: 520k]
  ------------------
 1134|  33.2M|            if (vvNew[n][i] != -1) {
  ------------------
  |  Branch (1134:17): [True: 387, False: 33.2M]
  ------------------
 1135|    387|                if (!mapNew.count(vvNew[n][i]))
  ------------------
  |  Branch (1135:21): [True: 0, False: 387]
  ------------------
 1136|      0|                    return -12;
 1137|    387|                const auto it{mapInfo.find(vvNew[n][i])};
 1138|    387|                if (it == mapInfo.end() || it->second.GetBucketPosition(nKey, true, n) != i) {
  ------------------
  |  Branch (1138:21): [True: 0, False: 387]
  |  Branch (1138:21): [True: 0, False: 387]
  |  Branch (1138:44): [True: 0, False: 387]
  ------------------
 1139|      0|                    return -19;
 1140|      0|                }
 1141|    387|                if (--mapNew[vvNew[n][i]] == 0)
  ------------------
  |  Branch (1141:21): [True: 338, False: 49]
  ------------------
 1142|    338|                    mapNew.erase(vvNew[n][i]);
 1143|    387|            }
 1144|  33.2M|        }
 1145|   520k|    }
 1146|       |
 1147|    508|    if (setTried.size())
  ------------------
  |  Branch (1147:9): [True: 0, False: 508]
  ------------------
 1148|      0|        return -13;
 1149|    508|    if (mapNew.size())
  ------------------
  |  Branch (1149:9): [True: 0, False: 508]
  ------------------
 1150|      0|        return -15;
 1151|    508|    if (nKey.IsNull())
  ------------------
  |  Branch (1151:9): [True: 4, False: 504]
  ------------------
 1152|      4|        return -16;
 1153|       |
 1154|       |    // It's possible that m_network_counts may have all-zero entries that local_counts
 1155|       |    // doesn't have if addrs from a network were being added and then removed again in the past.
 1156|    504|    if (m_network_counts.size() < local_counts.size()) {
  ------------------
  |  Branch (1156:9): [True: 0, False: 504]
  ------------------
 1157|      0|        return -20;
 1158|      0|    }
 1159|    663|    for (const auto& [net, count] : m_network_counts) {
  ------------------
  |  Branch (1159:35): [True: 663, False: 504]
  ------------------
 1160|    663|        if (local_counts[net].n_new != count.n_new || local_counts[net].n_tried != count.n_tried) {
  ------------------
  |  Branch (1160:13): [True: 0, False: 663]
  |  Branch (1160:55): [True: 0, False: 663]
  ------------------
 1161|      0|            return -21;
 1162|      0|        }
 1163|    663|    }
 1164|       |
 1165|    504|    return 0;
 1166|    504|}
_ZNK11AddrManImpl4SizeENSt3__18optionalI7NetworkEENS1_IbEE:
 1169|  7.15k|{
 1170|  7.15k|    LOCK(cs);
  ------------------
  |  |  257|  7.15k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.15k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.15k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.15k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1171|  7.15k|    Check();
 1172|  7.15k|    auto ret = Size_(net, in_new);
 1173|  7.15k|    Check();
 1174|  7.15k|    return ret;
 1175|  7.15k|}
_ZN11AddrManImpl3AddERKNSt3__16vectorI8CAddressNS0_9allocatorIS2_EEEERK8CNetAddrNS0_6chrono8durationIxNS0_5ratioILl1ELl1EEEEE:
 1178|  28.4k|{
 1179|  28.4k|    LOCK(cs);
  ------------------
  |  |  257|  28.4k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  28.4k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  28.4k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  28.4k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1180|  28.4k|    Check();
 1181|  28.4k|    auto ret = Add_(vAddr, source, time_penalty);
 1182|  28.4k|    Check();
 1183|  28.4k|    return ret;
 1184|  28.4k|}
_ZN11AddrManImpl4GoodERK8CServiceNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
 1187|   886k|{
 1188|   886k|    LOCK(cs);
  ------------------
  |  |  257|   886k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|   886k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|   886k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|   886k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1189|   886k|    Check();
 1190|   886k|    auto ret = Good_(addr, /*test_before_evict=*/true, time);
 1191|   886k|    Check();
 1192|   886k|    return ret;
 1193|   886k|}
_ZN11AddrManImpl7AttemptERK8CServicebNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
 1196|  4.80k|{
 1197|  4.80k|    LOCK(cs);
  ------------------
  |  |  257|  4.80k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  4.80k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  4.80k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  4.80k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1198|  4.80k|    Check();
 1199|  4.80k|    Attempt_(addr, fCountFailure, time);
 1200|  4.80k|    Check();
 1201|  4.80k|}
_ZN11AddrManImpl17ResolveCollisionsEv:
 1204|  18.9k|{
 1205|  18.9k|    LOCK(cs);
  ------------------
  |  |  257|  18.9k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  18.9k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  18.9k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  18.9k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1206|  18.9k|    Check();
 1207|  18.9k|    ResolveCollisions_();
 1208|  18.9k|    Check();
 1209|  18.9k|}
_ZN11AddrManImpl20SelectTriedCollisionEv:
 1212|   239k|{
 1213|   239k|    LOCK(cs);
  ------------------
  |  |  257|   239k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|   239k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|   239k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|   239k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1214|   239k|    Check();
 1215|   239k|    auto ret = SelectTriedCollision_();
 1216|   239k|    Check();
 1217|   239k|    return ret;
 1218|   239k|}
_ZNK11AddrManImpl6SelectEbRKNSt3__113unordered_setI7NetworkNS0_4hashIS2_EENS0_8equal_toIS2_EENS0_9allocatorIS2_EEEE:
 1221|  7.15k|{
 1222|  7.15k|    LOCK(cs);
  ------------------
  |  |  257|  7.15k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.15k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.15k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.15k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1223|  7.15k|    Check();
 1224|  7.15k|    auto addrRet = Select_(new_only, networks);
 1225|  7.15k|    Check();
 1226|  7.15k|    return addrRet;
 1227|  7.15k|}
_ZNK11AddrManImpl7GetAddrEmmNSt3__18optionalI7NetworkEEb:
 1230|  7.15k|{
 1231|  7.15k|    LOCK(cs);
  ------------------
  |  |  257|  7.15k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.15k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.15k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.15k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1232|  7.15k|    Check();
 1233|  7.15k|    auto addresses = GetAddr_(max_addresses, max_pct, network, filtered);
 1234|  7.15k|    Check();
 1235|  7.15k|    return addresses;
 1236|  7.15k|}
_ZN11AddrManImpl9ConnectedERK8CServiceNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
 1248|  3.27k|{
 1249|  3.27k|    LOCK(cs);
  ------------------
  |  |  257|  3.27k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  3.27k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  3.27k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  3.27k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1250|  3.27k|    Check();
 1251|  3.27k|    Connected_(addr, time);
 1252|  3.27k|    Check();
 1253|  3.27k|}
_ZN11AddrManImpl11SetServicesERK8CService12ServiceFlags:
 1256|  58.9k|{
 1257|  58.9k|    LOCK(cs);
  ------------------
  |  |  257|  58.9k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  58.9k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  58.9k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  58.9k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1258|  58.9k|    Check();
 1259|  58.9k|    SetServices_(addr, nServices);
 1260|  58.9k|    Check();
 1261|  58.9k|}
_ZN7AddrManC2ERK15NetGroupManagerbi:
 1273|  9.54k|    : m_impl(std::make_unique<AddrManImpl>(netgroupman, deterministic, consistency_check_ratio)) {}
_ZN7AddrManD2Ev:
 1275|  9.54k|AddrMan::~AddrMan() = default;
_ZNK7AddrMan9SerializeI10DataStreamEEvRT_:
 1279|  7.15k|{
 1280|  7.15k|    m_impl->Serialize<Stream>(s_);
 1281|  7.15k|}
_ZN7AddrMan11UnserializeI10DataStreamEEvRT_:
 1285|  2.89k|{
 1286|  2.89k|    m_impl->Unserialize<Stream>(s_);
 1287|  2.89k|}
_ZNK7AddrMan4SizeENSt3__18optionalI7NetworkEENS1_IbEE:
 1298|  7.15k|{
 1299|  7.15k|    return m_impl->Size(net, in_new);
 1300|  7.15k|}
_ZN7AddrMan3AddERKNSt3__16vectorI8CAddressNS0_9allocatorIS2_EEEERK8CNetAddrNS0_6chrono8durationIxNS0_5ratioILl1ELl1EEEEE:
 1303|  28.4k|{
 1304|  28.4k|    return m_impl->Add(vAddr, source, time_penalty);
 1305|  28.4k|}
_ZN7AddrMan4GoodERK8CServiceNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
 1308|   886k|{
 1309|   886k|    return m_impl->Good(addr, time);
 1310|   886k|}
_ZN7AddrMan7AttemptERK8CServicebNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
 1313|  4.80k|{
 1314|  4.80k|    m_impl->Attempt(addr, fCountFailure, time);
 1315|  4.80k|}
_ZN7AddrMan17ResolveCollisionsEv:
 1318|  18.9k|{
 1319|  18.9k|    m_impl->ResolveCollisions();
 1320|  18.9k|}
_ZN7AddrMan20SelectTriedCollisionEv:
 1323|   239k|{
 1324|   239k|    return m_impl->SelectTriedCollision();
 1325|   239k|}
_ZNK7AddrMan6SelectEbRKNSt3__113unordered_setI7NetworkNS0_4hashIS2_EENS0_8equal_toIS2_EENS0_9allocatorIS2_EEEE:
 1328|  7.15k|{
 1329|  7.15k|    return m_impl->Select(new_only, networks);
 1330|  7.15k|}
_ZNK7AddrMan7GetAddrEmmNSt3__18optionalI7NetworkEEb:
 1333|  7.15k|{
 1334|  7.15k|    return m_impl->GetAddr(max_addresses, max_pct, network, filtered);
 1335|  7.15k|}
_ZN7AddrMan9ConnectedERK8CServiceNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
 1343|  3.27k|{
 1344|  3.27k|    m_impl->Connected(addr, time);
 1345|  3.27k|}
_ZN7AddrMan11SetServicesERK8CService12ServiceFlags:
 1348|  58.9k|{
 1349|  58.9k|    m_impl->SetServices(addr, nServices);
 1350|  58.9k|}
_ZNK11AddrManImpl9SerializeI10DataStreamEEvRT_:
  134|  7.15k|{
  135|  7.15k|    LOCK(cs);
  ------------------
  |  |  257|  7.15k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.15k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.15k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.15k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  136|       |
  137|       |    /**
  138|       |     * Serialized format.
  139|       |     * * format version byte (@see `Format`)
  140|       |     * * lowest compatible format version byte. This is used to help old software decide
  141|       |     *   whether to parse the file. For example:
  142|       |     *   * Bitcoin Core version N knows how to parse up to format=3. If a new format=4 is
  143|       |     *     introduced in version N+1 that is compatible with format=3 and it is known that
  144|       |     *     version N will be able to parse it, then version N+1 will write
  145|       |     *     (format=4, lowest_compatible=3) in the first two bytes of the file, and so
  146|       |     *     version N will still try to parse it.
  147|       |     *   * Bitcoin Core version N+2 introduces a new incompatible format=5. It will write
  148|       |     *     (format=5, lowest_compatible=5) and so any versions that do not know how to parse
  149|       |     *     format=5 will not try to read the file.
  150|       |     * * nKey
  151|       |     * * nNew
  152|       |     * * nTried
  153|       |     * * number of "new" buckets XOR 2**30
  154|       |     * * all new addresses (total count: nNew)
  155|       |     * * all tried addresses (total count: nTried)
  156|       |     * * for each new bucket:
  157|       |     *   * number of elements
  158|       |     *   * for each element: index in the serialized "all new addresses"
  159|       |     * * asmap checksum
  160|       |     *
  161|       |     * 2**30 is xorred with the number of buckets to make addrman deserializer v0 detect it
  162|       |     * as incompatible. This is necessary because it did not check the version number on
  163|       |     * deserialization.
  164|       |     *
  165|       |     * vvNew, vvTried, mapInfo, mapAddr and vRandom are never encoded explicitly;
  166|       |     * they are instead reconstructed from the other information.
  167|       |     *
  168|       |     * This format is more complex, but significantly smaller (at most 1.5 MiB), and supports
  169|       |     * changes to the ADDRMAN_ parameters without breaking the on-disk structure.
  170|       |     *
  171|       |     * We don't use SERIALIZE_METHODS since the serialization and deserialization code has
  172|       |     * very little in common.
  173|       |     */
  174|       |
  175|       |    // Always serialize in the latest version (FILE_FORMAT).
  176|  7.15k|    ParamsStream s{s_, CAddress::V2_DISK};
  177|       |
  178|  7.15k|    s << static_cast<uint8_t>(FILE_FORMAT);
  179|       |
  180|       |    // Increment `lowest_compatible` iff a newly introduced format is incompatible with
  181|       |    // the previous one.
  182|  7.15k|    static constexpr uint8_t lowest_compatible = Format::V4_MULTIPORT;
  183|  7.15k|    s << static_cast<uint8_t>(INCOMPATIBILITY_BASE + lowest_compatible);
  184|       |
  185|  7.15k|    s << nKey;
  186|  7.15k|    s << nNew;
  187|  7.15k|    s << nTried;
  188|       |
  189|  7.15k|    int nUBuckets = ADDRMAN_NEW_BUCKET_COUNT ^ (1 << 30);
  190|  7.15k|    s << nUBuckets;
  191|  7.15k|    std::unordered_map<nid_type, int> mapUnkIds;
  192|  7.15k|    int nIds = 0;
  193|  1.53M|    for (const auto& entry : mapInfo) {
  ------------------
  |  Branch (193:28): [True: 1.53M, False: 7.15k]
  ------------------
  194|  1.53M|        mapUnkIds[entry.first] = nIds;
  195|  1.53M|        const AddrInfo& info = entry.second;
  196|  1.53M|        if (info.nRefCount) {
  ------------------
  |  Branch (196:13): [True: 1.43M, False: 105k]
  ------------------
  197|  1.43M|            assert(nIds != nNew); // this means nNew was wrong, oh ow
  198|  1.43M|            s << info;
  199|  1.43M|            nIds++;
  200|  1.43M|        }
  201|  1.53M|    }
  202|  7.15k|    nIds = 0;
  203|  1.53M|    for (const auto& entry : mapInfo) {
  ------------------
  |  Branch (203:28): [True: 1.53M, False: 7.15k]
  ------------------
  204|  1.53M|        const AddrInfo& info = entry.second;
  205|  1.53M|        if (info.fInTried) {
  ------------------
  |  Branch (205:13): [True: 105k, False: 1.43M]
  ------------------
  206|   105k|            assert(nIds != nTried); // this means nTried was wrong, oh ow
  207|   105k|            s << info;
  208|   105k|            nIds++;
  209|   105k|        }
  210|  1.53M|    }
  211|  7.33M|    for (int bucket = 0; bucket < ADDRMAN_NEW_BUCKET_COUNT; bucket++) {
  ------------------
  |  Branch (211:26): [True: 7.32M, False: 7.15k]
  ------------------
  212|  7.32M|        int nSize = 0;
  213|   476M|        for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
  ------------------
  |  Branch (213:25): [True: 469M, False: 7.32M]
  ------------------
  214|   469M|            if (vvNew[bucket][i] != -1)
  ------------------
  |  Branch (214:17): [True: 1.49M, False: 467M]
  ------------------
  215|  1.49M|                nSize++;
  216|   469M|        }
  217|  7.32M|        s << nSize;
  218|   476M|        for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
  ------------------
  |  Branch (218:25): [True: 469M, False: 7.32M]
  ------------------
  219|   469M|            if (vvNew[bucket][i] != -1) {
  ------------------
  |  Branch (219:17): [True: 1.49M, False: 467M]
  ------------------
  220|  1.49M|                int nIndex = mapUnkIds[vvNew[bucket][i]];
  221|  1.49M|                s << nIndex;
  222|  1.49M|            }
  223|   469M|        }
  224|  7.32M|    }
  225|       |    // Store asmap checksum after bucket entries so that it
  226|       |    // can be ignored by older clients for backward compatibility.
  227|  7.15k|    s << m_netgroupman.GetAsmapChecksum();
  228|  7.15k|}
_ZN11AddrManImpl11UnserializeI10DataStreamEEvRT_:
  232|  2.89k|{
  233|  2.89k|    LOCK(cs);
  ------------------
  |  |  257|  2.89k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  2.89k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  2.89k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  2.89k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  234|       |
  235|  2.89k|    assert(vRandom.empty());
  236|       |
  237|  2.89k|    Format format;
  238|  2.89k|    s_ >> Using<CustomUintFormatter<1>>(format);
  239|       |
  240|  2.89k|    const auto ser_params = (format >= Format::V3_BIP155 ? CAddress::V2_DISK : CAddress::V1_DISK);
  ------------------
  |  Branch (240:30): [True: 1.95k, False: 943]
  ------------------
  241|  2.89k|    ParamsStream s{s_, ser_params};
  242|       |
  243|  2.89k|    uint8_t compat;
  244|  2.89k|    s >> compat;
  245|  2.89k|    if (compat < INCOMPATIBILITY_BASE) {
  ------------------
  |  Branch (245:9): [True: 499, False: 2.39k]
  ------------------
  246|    499|        throw std::ios_base::failure(strprintf(
  ------------------
  |  | 1172|    499|#define strprintf tfm::format
  ------------------
  247|    499|            "Corrupted addrman database: The compat value (%u) "
  248|    499|            "is lower than the expected minimum value %u.",
  249|    499|            compat, INCOMPATIBILITY_BASE));
  250|    499|    }
  251|  2.39k|    const uint8_t lowest_compatible = compat - INCOMPATIBILITY_BASE;
  252|  2.39k|    if (lowest_compatible > FILE_FORMAT) {
  ------------------
  |  Branch (252:9): [True: 332, False: 2.06k]
  ------------------
  253|    332|        throw InvalidAddrManVersionError(strprintf(
  ------------------
  |  | 1172|    332|#define strprintf tfm::format
  ------------------
  254|    332|            "Unsupported format of addrman database: %u. It is compatible with formats >=%u, "
  255|    332|            "but the maximum supported by this version of %s is %u.",
  256|    332|            uint8_t{format}, lowest_compatible, CLIENT_NAME, uint8_t{FILE_FORMAT}));
  ------------------
  |  |  127|    332|#define CLIENT_NAME "Bitcoin Core"
  ------------------
  257|    332|    }
  258|       |
  259|  2.06k|    s >> nKey;
  260|  2.06k|    s >> nNew;
  261|  2.06k|    s >> nTried;
  262|  2.06k|    int nUBuckets = 0;
  263|  2.06k|    s >> nUBuckets;
  264|  2.06k|    if (format >= Format::V1_DETERMINISTIC) {
  ------------------
  |  Branch (264:9): [True: 1.13k, False: 927]
  ------------------
  265|  1.13k|        nUBuckets ^= (1 << 30);
  266|  1.13k|    }
  267|       |
  268|  2.06k|    if (nNew > ADDRMAN_NEW_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE || nNew < 0) {
  ------------------
  |  Branch (268:9): [True: 308, False: 1.75k]
  |  Branch (268:66): [True: 30, False: 1.72k]
  ------------------
  269|     40|        throw std::ios_base::failure(
  270|     40|                strprintf("Corrupt AddrMan serialization: nNew=%d, should be in [0, %d]",
  ------------------
  |  | 1172|     40|#define strprintf tfm::format
  ------------------
  271|     40|                    nNew,
  272|     40|                    ADDRMAN_NEW_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE));
  273|     40|    }
  274|       |
  275|  2.02k|    if (nTried > ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE || nTried < 0) {
  ------------------
  |  Branch (275:9): [True: 301, False: 1.72k]
  |  Branch (275:70): [True: 32, False: 1.69k]
  ------------------
  276|     35|        throw std::ios_base::failure(
  277|     35|                strprintf("Corrupt AddrMan serialization: nTried=%d, should be in [0, %d]",
  ------------------
  |  | 1172|     35|#define strprintf tfm::format
  ------------------
  278|     35|                    nTried,
  279|     35|                    ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE));
  280|     35|    }
  281|       |
  282|       |    // Deserialize entries from the new table.
  283|   107k|    for (int n = 0; n < nNew; n++) {
  ------------------
  |  Branch (283:21): [True: 105k, False: 1.98k]
  ------------------
  284|   105k|        AddrInfo& info = mapInfo[n];
  285|   105k|        s >> info;
  286|   105k|        mapAddr[info] = n;
  287|   105k|        info.nRandomPos = vRandom.size();
  288|   105k|        vRandom.push_back(n);
  289|   105k|        m_network_counts[info.GetNetwork()].n_new++;
  290|   105k|    }
  291|  1.98k|    nIdCount = nNew;
  292|       |
  293|       |    // Deserialize entries from the tried table.
  294|  1.98k|    int nLost = 0;
  295|  16.5k|    for (int n = 0; n < nTried; n++) {
  ------------------
  |  Branch (295:21): [True: 14.5k, False: 1.98k]
  ------------------
  296|  14.5k|        AddrInfo info;
  297|  14.5k|        s >> info;
  298|  14.5k|        int nKBucket = info.GetTriedBucket(nKey, m_netgroupman);
  299|  14.5k|        int nKBucketPos = info.GetBucketPosition(nKey, false, nKBucket);
  300|  14.5k|        if (info.IsValid()
  ------------------
  |  Branch (300:13): [True: 2.65k, False: 11.9k]
  ------------------
  301|  14.5k|                && vvTried[nKBucket][nKBucketPos] == -1) {
  ------------------
  |  Branch (301:20): [True: 1.91k, False: 736]
  ------------------
  302|  1.91k|            info.nRandomPos = vRandom.size();
  303|  1.91k|            info.fInTried = true;
  304|  1.91k|            vRandom.push_back(nIdCount);
  305|  1.91k|            mapInfo[nIdCount] = info;
  306|  1.91k|            mapAddr[info] = nIdCount;
  307|  1.91k|            vvTried[nKBucket][nKBucketPos] = nIdCount;
  308|  1.91k|            nIdCount++;
  309|  1.91k|            m_network_counts[info.GetNetwork()].n_tried++;
  310|  12.6k|        } else {
  311|  12.6k|            nLost++;
  312|  12.6k|        }
  313|  14.5k|    }
  314|  1.98k|    nTried -= nLost;
  315|       |
  316|       |    // Store positions in the new table buckets to apply later (if possible).
  317|       |    // An entry may appear in up to ADDRMAN_NEW_BUCKETS_PER_ADDRESS buckets,
  318|       |    // so we store all bucket-entry_index pairs to iterate through later.
  319|  1.98k|    std::vector<std::pair<int, int>> bucket_entries;
  320|       |
  321|  33.1k|    for (int bucket = 0; bucket < nUBuckets; ++bucket) {
  ------------------
  |  Branch (321:26): [True: 31.1k, False: 1.98k]
  ------------------
  322|  31.1k|        int num_entries{0};
  323|  31.1k|        s >> num_entries;
  324|   720k|        for (int n = 0; n < num_entries; ++n) {
  ------------------
  |  Branch (324:25): [True: 689k, False: 31.1k]
  ------------------
  325|   689k|            int entry_index{0};
  326|   689k|            s >> entry_index;
  327|   689k|            if (entry_index >= 0 && entry_index < nNew) {
  ------------------
  |  Branch (327:17): [True: 677k, False: 11.6k]
  |  Branch (327:37): [True: 645k, False: 32.5k]
  ------------------
  328|   645k|                bucket_entries.emplace_back(bucket, entry_index);
  329|   645k|            }
  330|   689k|        }
  331|  31.1k|    }
  332|       |
  333|       |    // If the bucket count and asmap checksum haven't changed, then attempt
  334|       |    // to restore the entries to the buckets/positions they were in before
  335|       |    // serialization.
  336|  1.98k|    uint256 supplied_asmap_checksum{m_netgroupman.GetAsmapChecksum()};
  337|  1.98k|    uint256 serialized_asmap_checksum;
  338|  1.98k|    if (format >= Format::V2_ASMAP) {
  ------------------
  |  Branch (338:9): [True: 157, False: 1.83k]
  ------------------
  339|    157|        s >> serialized_asmap_checksum;
  340|    157|    }
  341|  1.98k|    const bool restore_bucketing{nUBuckets == ADDRMAN_NEW_BUCKET_COUNT &&
  ------------------
  |  Branch (341:34): [True: 22, False: 1.96k]
  ------------------
  342|  1.98k|        serialized_asmap_checksum == supplied_asmap_checksum};
  ------------------
  |  Branch (342:9): [True: 21, False: 1]
  ------------------
  343|       |
  344|  1.98k|    if (!restore_bucketing) {
  ------------------
  |  Branch (344:9): [True: 636, False: 1.35k]
  ------------------
  345|    636|        LogDebug(BCLog::ADDRMAN, "Bucketing method was updated, re-bucketing addrman entries from disk\n");
  ------------------
  |  |  280|    636|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|    636|    do {                                                  \
  |  |  |  |  274|    636|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 636]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|    636|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  346|    636|    }
  347|       |
  348|  9.14k|    for (auto bucket_entry : bucket_entries) {
  ------------------
  |  Branch (348:28): [True: 9.14k, False: 1.98k]
  ------------------
  349|  9.14k|        int bucket{bucket_entry.first};
  350|  9.14k|        const int entry_index{bucket_entry.second};
  351|  9.14k|        AddrInfo& info = mapInfo[entry_index];
  352|       |
  353|       |        // Don't store the entry in the new bucket if it's not a valid address for our addrman
  354|  9.14k|        if (!info.IsValid()) continue;
  ------------------
  |  Branch (354:13): [True: 673, False: 8.47k]
  ------------------
  355|       |
  356|       |        // The entry shouldn't appear in more than
  357|       |        // ADDRMAN_NEW_BUCKETS_PER_ADDRESS. If it has already, just skip
  358|       |        // this bucket_entry.
  359|  8.47k|        if (info.nRefCount >= ADDRMAN_NEW_BUCKETS_PER_ADDRESS) continue;
  ------------------
  |  Branch (359:13): [True: 234, False: 8.24k]
  ------------------
  360|       |
  361|  8.24k|        int bucket_position = info.GetBucketPosition(nKey, true, bucket);
  362|  8.24k|        if (restore_bucketing && vvNew[bucket][bucket_position] == -1) {
  ------------------
  |  Branch (362:13): [True: 434, False: 7.80k]
  |  Branch (362:34): [True: 125, False: 309]
  ------------------
  363|       |            // Bucketing has not changed, using existing bucket positions for the new table
  364|    125|            vvNew[bucket][bucket_position] = entry_index;
  365|    125|            ++info.nRefCount;
  366|  8.11k|        } else {
  367|       |            // In case the new table data cannot be used (bucket count wrong or new asmap),
  368|       |            // try to give them a reference based on their primary source address.
  369|  8.11k|            bucket = info.GetNewBucket(nKey, m_netgroupman);
  370|  8.11k|            bucket_position = info.GetBucketPosition(nKey, true, bucket);
  371|  8.11k|            if (vvNew[bucket][bucket_position] == -1) {
  ------------------
  |  Branch (371:17): [True: 398, False: 7.71k]
  ------------------
  372|    398|                vvNew[bucket][bucket_position] = entry_index;
  373|    398|                ++info.nRefCount;
  374|    398|            }
  375|  8.11k|        }
  376|  8.24k|    }
  377|       |
  378|       |    // Prune new entries with refcount 0 (as a result of collisions or invalid address).
  379|  1.98k|    int nLostUnk = 0;
  380|  15.9k|    for (auto it = mapInfo.cbegin(); it != mapInfo.cend(); ) {
  ------------------
  |  Branch (380:38): [True: 13.9k, False: 1.98k]
  ------------------
  381|  13.9k|        if (it->second.fInTried == false && it->second.nRefCount == 0) {
  ------------------
  |  Branch (381:13): [True: 12.8k, False: 1.12k]
  |  Branch (381:45): [True: 12.4k, False: 406]
  ------------------
  382|  12.4k|            const auto itCopy = it++;
  383|  12.4k|            Delete(itCopy->first);
  384|  12.4k|            ++nLostUnk;
  385|  12.4k|        } else {
  386|  1.53k|            ++it;
  387|  1.53k|        }
  388|  13.9k|    }
  389|  1.98k|    if (nLost + nLostUnk > 0) {
  ------------------
  |  Branch (389:9): [True: 263, False: 1.72k]
  ------------------
  390|    263|        LogDebug(BCLog::ADDRMAN, "addrman lost %i new and %i tried addresses due to collisions or invalid addresses\n", nLostUnk, nLost);
  ------------------
  |  |  280|    263|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|    263|    do {                                                  \
  |  |  |  |  274|    263|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 263]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|    263|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  391|    263|    }
  392|       |
  393|  1.98k|    const int check_code{CheckAddrman()};
  394|  1.98k|    if (check_code != 0) {
  ------------------
  |  Branch (394:9): [True: 153, False: 1.83k]
  ------------------
  395|    153|        throw std::ios_base::failure(strprintf(
  ------------------
  |  | 1172|    153|#define strprintf tfm::format
  ------------------
  396|    153|            "Corrupt data. Consistency check failed with code %s",
  397|    153|            check_code));
  398|    153|    }
  399|  1.98k|}

_ZN26InvalidAddrManVersionErrorC2ENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   25|    332|    InvalidAddrManVersionError(std::string msg) : std::ios_base::failure(msg) { }

_ZN8AddrInfoC2ERK8CAddressRK8CNetAddr:
   77|  3.85M|    AddrInfo(const CAddress &addrIn, const CNetAddr &addrSource) : CAddress(addrIn), source(addrSource)
   78|  3.85M|    {
   79|  3.85M|    }
_ZN8AddrInfoC2Ev:
   81|  3.97M|    AddrInfo() : CAddress(), source()
   82|  3.97M|    {
   83|  3.97M|    }
_ZNK8AddrInfo12GetNewBucketERK7uint256RK15NetGroupManager:
   93|   141k|    {
   94|   141k|        return GetNewBucket(nKey, source, netgroupman);
   95|   141k|    }
_ZN8AddrInfo16SerializationOpsI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEES_17ActionUnserializeEEvRT0_RT_T1_:
   73|   119k|    {
   74|   119k|        READWRITE(AsBase<CAddress>(obj), obj.source, Using<ChronoFormatter<int64_t>>(obj.m_last_success), obj.nAttempts);
  ------------------
  |  |  156|   119k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
   75|   119k|    }
_ZN8AddrInfo16SerializationOpsI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEKS_15ActionSerializeEEvRT0_RT_T1_:
   73|  1.53M|    {
   74|  1.53M|        READWRITE(AsBase<CAddress>(obj), obj.source, Using<ChronoFormatter<int64_t>>(obj.m_last_success), obj.nAttempts);
  ------------------
  |  |  156|  1.53M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
   75|  1.53M|    }

_ZN11ArgsManagerD2Ev:
  134|      2|ArgsManager::~ArgsManager() = default;
_ZNK11ArgsManager9GetIntArgERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEl:
  483|  9.54k|{
  484|  9.54k|    return GetIntArg(strArg).value_or(nDefault);
  485|  9.54k|}
_ZNK11ArgsManager9GetIntArgERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  488|  9.54k|{
  489|  9.54k|    const common::SettingsValue value = GetSetting(strArg);
  490|  9.54k|    return SettingToInt(value);
  491|  9.54k|}
_Z12SettingToIntRK8UniValue:
  494|  9.54k|{
  495|  9.54k|    if (value.isNull()) return std::nullopt;
  ------------------
  |  Branch (495:9): [True: 9.54k, False: 0]
  ------------------
  496|      0|    if (value.isFalse()) return 0;
  ------------------
  |  Branch (496:9): [True: 0, False: 0]
  ------------------
  497|      0|    if (value.isTrue()) return 1;
  ------------------
  |  Branch (497:9): [True: 0, False: 0]
  ------------------
  498|      0|    if (value.isNum()) return value.getInt<int64_t>();
  ------------------
  |  Branch (498:9): [True: 0, False: 0]
  ------------------
  499|      0|    return LocaleIndependentAtoi<int64_t>(value.get_str());
  500|      0|}
_ZNK11ArgsManager17UseDefaultSectionERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  821|  9.54k|{
  822|  9.54k|    return m_network == ChainTypeToString(ChainType::MAIN) || m_network_only_args.count(arg) == 0;
  ------------------
  |  Branch (822:12): [True: 0, False: 9.54k]
  |  Branch (822:63): [True: 9.54k, False: 0]
  ------------------
  823|  9.54k|}
_ZNK11ArgsManager10GetSettingERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  826|  9.54k|{
  827|  9.54k|    LOCK(cs_args);
  ------------------
  |  |  257|  9.54k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  9.54k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  9.54k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  9.54k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  828|  9.54k|    return common::GetSetting(
  829|  9.54k|        m_settings, m_network, SettingName(arg), !UseDefaultSection(arg),
  830|  9.54k|        /*ignore_nonpersistent=*/false, /*get_chain_type=*/false);
  831|  9.54k|}
args.cpp:_ZL11SettingNameRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE:
   67|  9.54k|{
   68|  9.54k|    return arg.size() > 0 && arg[0] == '-' ? arg.substr(1) : arg;
  ------------------
  |  Branch (68:12): [True: 9.54k, False: 0]
  |  Branch (68:30): [True: 9.54k, False: 0]
  ------------------
   69|  9.54k|}

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

_ZN6common10GetSettingERKNS_8SettingsERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_bbb:
  152|  9.54k|{
  153|  9.54k|    SettingsValue result;
  154|  9.54k|    bool done = false; // Done merging any more settings sources.
  155|  9.54k|    MergeSettings(settings, section, name, [&](SettingsSpan span, Source source) {
  156|       |        // Weird behavior preserved for backwards compatibility: Apply negated
  157|       |        // setting even if non-negated setting would be ignored. A negated
  158|       |        // value in the default section is applied to network specific options,
  159|       |        // even though normal non-negated values there would be ignored.
  160|  9.54k|        const bool never_ignore_negated_setting = span.last_negated();
  161|       |
  162|       |        // Weird behavior preserved for backwards compatibility: Take first
  163|       |        // assigned value instead of last. In general, later settings take
  164|       |        // precedence over early settings, but for backwards compatibility in
  165|       |        // the config file the precedence is reversed for all settings except
  166|       |        // chain type settings.
  167|  9.54k|        const bool reverse_precedence =
  168|  9.54k|            (source == Source::CONFIG_FILE_NETWORK_SECTION || source == Source::CONFIG_FILE_DEFAULT_SECTION) &&
  169|  9.54k|            !get_chain_type;
  170|       |
  171|       |        // Weird behavior preserved for backwards compatibility: Negated
  172|       |        // -regtest and -testnet arguments which you would expect to override
  173|       |        // values set in the configuration file are currently accepted but
  174|       |        // silently ignored. It would be better to apply these just like other
  175|       |        // negated values, or at least warn they are ignored.
  176|  9.54k|        const bool skip_negated_command_line = get_chain_type;
  177|       |
  178|  9.54k|        if (done) return;
  179|       |
  180|       |        // Ignore settings in default config section if requested.
  181|  9.54k|        if (ignore_default_section_config && source == Source::CONFIG_FILE_DEFAULT_SECTION &&
  182|  9.54k|            !never_ignore_negated_setting) {
  183|  9.54k|            return;
  184|  9.54k|        }
  185|       |
  186|       |        // Ignore nonpersistent settings if requested.
  187|  9.54k|        if (ignore_nonpersistent && (source == Source::COMMAND_LINE || source == Source::FORCED)) return;
  188|       |
  189|       |        // Skip negated command line settings.
  190|  9.54k|        if (skip_negated_command_line && span.last_negated()) return;
  191|       |
  192|  9.54k|        if (!span.empty()) {
  193|  9.54k|            result = reverse_precedence ? span.begin()[0] : span.end()[-1];
  194|  9.54k|            done = true;
  195|  9.54k|        } else if (span.last_negated()) {
  196|  9.54k|            result = false;
  197|  9.54k|            done = true;
  198|  9.54k|        }
  199|  9.54k|    });
  200|  9.54k|    return result;
  201|  9.54k|}
settings.cpp:_ZN6common12_GLOBAL__N_113MergeSettingsIZNS_10GetSettingERKNS_8SettingsERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_bbbE3$_0EEvS4_SD_SD_OT_:
   42|  9.54k|{
   43|       |    // Merge in the forced settings
   44|  9.54k|    if (auto* value = FindKey(settings.forced_settings, name)) {
  ------------------
  |  Branch (44:15): [True: 0, False: 9.54k]
  ------------------
   45|      0|        fn(SettingsSpan(*value), Source::FORCED);
   46|      0|    }
   47|       |    // Merge in the command-line options
   48|  9.54k|    if (auto* values = FindKey(settings.command_line_options, name)) {
  ------------------
  |  Branch (48:15): [True: 0, False: 9.54k]
  ------------------
   49|      0|        fn(SettingsSpan(*values), Source::COMMAND_LINE);
   50|      0|    }
   51|       |    // Merge in the read-write settings
   52|  9.54k|    if (const SettingsValue* value = FindKey(settings.rw_settings, name)) {
  ------------------
  |  Branch (52:30): [True: 0, False: 9.54k]
  ------------------
   53|      0|        fn(SettingsSpan(*value), Source::RW_SETTINGS);
   54|      0|    }
   55|       |    // Merge in the network-specific section of the config file
   56|  9.54k|    if (!section.empty()) {
  ------------------
  |  Branch (56:9): [True: 9.54k, False: 0]
  ------------------
   57|  9.54k|        if (auto* map = FindKey(settings.ro_config, section)) {
  ------------------
  |  Branch (57:19): [True: 0, False: 9.54k]
  ------------------
   58|      0|            if (auto* values = FindKey(*map, name)) {
  ------------------
  |  Branch (58:23): [True: 0, False: 0]
  ------------------
   59|      0|                fn(SettingsSpan(*values), Source::CONFIG_FILE_NETWORK_SECTION);
   60|      0|            }
   61|      0|        }
   62|  9.54k|    }
   63|       |    // Merge in the default section of the config file
   64|  9.54k|    if (auto* map = FindKey(settings.ro_config, "")) {
  ------------------
  |  Branch (64:15): [True: 0, False: 9.54k]
  ------------------
   65|      0|        if (auto* values = FindKey(*map, name)) {
  ------------------
  |  Branch (65:19): [True: 0, False: 0]
  ------------------
   66|      0|            fn(SettingsSpan(*values), Source::CONFIG_FILE_DEFAULT_SECTION);
   67|      0|        }
   68|      0|    }
   69|  9.54k|}

_ZN6common7FindKeyIRKNSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE8UniValueNS1_4lessIS8_EENS6_INS1_4pairIKS8_S9_EEEEEERSD_EEDTadcldtfp_2atfp0_EEOT_OT0_:
  108|  19.0k|{
  109|  19.0k|    auto it = map.find(key);
  110|  19.0k|    return it == map.end() ? nullptr : &it->second;
  ------------------
  |  Branch (110:12): [True: 19.0k, False: 0]
  ------------------
  111|  19.0k|}
_ZN6common7FindKeyIRKNSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_6vectorI8UniValueNS6_ISA_EEEENS1_4lessIS8_EENS6_INS1_4pairIKS8_SC_EEEEEERSG_EEDTadcldtfp_2atfp0_EEOT_OT0_:
  108|  9.54k|{
  109|  9.54k|    auto it = map.find(key);
  110|  9.54k|    return it == map.end() ? nullptr : &it->second;
  ------------------
  |  Branch (110:12): [True: 9.54k, False: 0]
  ------------------
  111|  9.54k|}
_ZN6common7FindKeyIRKNSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS2_IS8_NS1_6vectorI8UniValueNS6_ISA_EEEENS1_4lessIS8_EENS6_INS1_4pairIKS8_SC_EEEEEESE_NS6_INSF_ISG_SJ_EEEEEERSG_EEDTadcldtfp_2atfp0_EEOT_OT0_:
  108|  9.54k|{
  109|  9.54k|    auto it = map.find(key);
  110|  9.54k|    return it == map.end() ? nullptr : &it->second;
  ------------------
  |  Branch (110:12): [True: 9.54k, False: 0]
  ------------------
  111|  9.54k|}
_ZN6common7FindKeyIRKNSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS2_IS8_NS1_6vectorI8UniValueNS6_ISA_EEEENS1_4lessIS8_EENS6_INS1_4pairIKS8_SC_EEEEEESE_NS6_INSF_ISG_SJ_EEEEEERA1_KcEEDTadcldtfp_2atfp0_EEOT_OT0_:
  108|  9.54k|{
  109|  9.54k|    auto it = map.find(key);
  110|  9.54k|    return it == map.end() ? nullptr : &it->second;
  ------------------
  |  Branch (110:12): [True: 9.54k, False: 0]
  ------------------
  111|  9.54k|}

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

_Z16htole16_internalt:
   19|  6.05k|{
   20|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(host_16bits);
   21|  6.05k|        else return host_16bits;
   22|  6.05k|}
_Z16le16toh_internalt:
   29|     57|{
   30|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits);
   31|     57|        else return little_endian_16bits;
   32|     57|}
_Z16htobe32_internalj:
   34|   493M|{
   35|   493M|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(host_32bits);
   36|       |        else return host_32bits;
   37|   493M|}
_Z16htole32_internalj:
   39|  38.2M|{
   40|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits);
   41|  38.2M|        else return host_32bits;
   42|  38.2M|}
_Z16be32toh_internalj:
   44|  3.93M|{
   45|  3.93M|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(big_endian_32bits);
   46|       |        else return big_endian_32bits;
   47|  3.93M|}
_Z16le32toh_internalj:
   49|  1.60M|{
   50|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits);
   51|  1.60M|        else return little_endian_32bits;
   52|  1.60M|}
_Z16htobe64_internalm:
   54|  63.3M|{
   55|  63.3M|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(host_64bits);
   56|       |        else return host_64bits;
   57|  63.3M|}
_Z16htole64_internalm:
   59|  6.42M|{
   60|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(host_64bits);
   61|  6.42M|        else return host_64bits;
   62|  6.42M|}
_Z16be64toh_internalm:
   64|   424k|{
   65|   424k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(big_endian_64bits);
   66|       |        else return big_endian_64bits;
   67|   424k|}
_Z16le64toh_internalm:
   69|  32.6M|{
   70|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits);
   71|  32.6M|        else return little_endian_64bits;
   72|  32.6M|}

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

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

_Z8ReadLE64ITk8ByteTypehEmPKT_:
   36|  30.8M|{
   37|  30.8M|    uint64_t x;
   38|  30.8M|    memcpy(&x, ptr, 8);
   39|  30.8M|    return le64toh_internal(x);
   40|  30.8M|}
_Z8ReadLE64ITk8ByteTypeSt4byteEmPKT_:
   36|  1.61M|{
   37|  1.61M|    uint64_t x;
   38|  1.61M|    memcpy(&x, ptr, 8);
   39|  1.61M|    return le64toh_internal(x);
   40|  1.61M|}
_Z9WriteLE32ITk8ByteTypeSt4byteEvPT_j:
   51|  3.68M|{
   52|  3.68M|    uint32_t v = htole32_internal(x);
   53|  3.68M|    memcpy(ptr, &v, 4);
   54|  3.68M|}
_Z9WriteBE32ITk8ByteTypehEvPT_j:
   96|   493M|{
   97|   493M|    uint32_t v = htobe32_internal(x);
   98|   493M|    memcpy(ptr, &v, 4);
   99|   493M|}
_Z8ReadBE32ITk8ByteTypehEjPKT_:
   73|  3.93M|{
   74|  3.93M|    uint32_t x;
   75|  3.93M|    memcpy(&x, ptr, 4);
   76|  3.93M|    return be32toh_internal(x);
   77|  3.93M|}
_Z9WriteBE64ITk8ByteTypehEvPT_m:
  103|  61.8M|{
  104|  61.8M|    uint64_t v = htobe64_internal(x);
  105|  61.8M|    memcpy(ptr, &v, 8);
  106|  61.8M|}
_Z8ReadBE64ITk8ByteTypehEmPKT_:
   81|   305k|{
   82|   305k|    uint64_t x;
   83|   305k|    memcpy(&x, ptr, 8);
   84|   305k|    return be64toh_internal(x);
   85|   305k|}
_Z8ReadLE32ITk8ByteTypeSt4byteEjPKT_:
   28|   515k|{
   29|   515k|    uint32_t x;
   30|   515k|    memcpy(&x, ptr, 4);
   31|   515k|    return le32toh_internal(x);
   32|   515k|}

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

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

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

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

_ZN10CSipHasherC2Emm:
   19|  12.6M|{
   20|  12.6M|    v[0] = 0x736f6d6570736575ULL ^ k0;
   21|  12.6M|    v[1] = 0x646f72616e646f6dULL ^ k1;
   22|  12.6M|    v[2] = 0x6c7967656e657261ULL ^ k0;
   23|  12.6M|    v[3] = 0x7465646279746573ULL ^ k1;
   24|  12.6M|    count = 0;
   25|  12.6M|    tmp = 0;
   26|  12.6M|}
_ZN10CSipHasher5WriteEm:
   29|  25.3M|{
   30|  25.3M|    uint64_t v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
   31|       |
   32|  25.3M|    assert(count % 8 == 0);
   33|       |
   34|  25.3M|    v3 ^= data;
   35|  25.3M|    SIPROUND;
  ------------------
  |  |    9|  25.3M|#define SIPROUND do { \
  |  |   10|  25.3M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  25.3M|    v0 = std::rotl(v0, 32); \
  |  |   12|  25.3M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  25.3M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  25.3M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  25.3M|    v2 = std::rotl(v2, 32); \
  |  |   16|  25.3M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   36|  25.3M|    SIPROUND;
  ------------------
  |  |    9|  25.3M|#define SIPROUND do { \
  |  |   10|  25.3M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  25.3M|    v0 = std::rotl(v0, 32); \
  |  |   12|  25.3M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  25.3M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  25.3M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  25.3M|    v2 = std::rotl(v2, 32); \
  |  |   16|  25.3M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   37|  25.3M|    v0 ^= data;
   38|       |
   39|  25.3M|    v[0] = v0;
   40|  25.3M|    v[1] = v1;
   41|  25.3M|    v[2] = v2;
   42|  25.3M|    v[3] = v3;
   43|       |
   44|  25.3M|    count += 8;
   45|  25.3M|    return *this;
   46|  25.3M|}
_ZN10CSipHasher5WriteE4SpanIKhE:
   49|  12.6M|{
   50|  12.6M|    uint64_t v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
   51|  12.6M|    uint64_t t = tmp;
   52|  12.6M|    uint8_t c = count;
   53|       |
   54|   267M|    while (data.size() > 0) {
  ------------------
  |  Branch (54:12): [True: 254M, False: 12.6M]
  ------------------
   55|   254M|        t |= uint64_t{data.front()} << (8 * (c % 8));
   56|   254M|        c++;
   57|   254M|        if ((c & 7) == 0) {
  ------------------
  |  Branch (57:13): [True: 31.8M, False: 223M]
  ------------------
   58|  31.8M|            v3 ^= t;
   59|  31.8M|            SIPROUND;
  ------------------
  |  |    9|  31.8M|#define SIPROUND do { \
  |  |   10|  31.8M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  31.8M|    v0 = std::rotl(v0, 32); \
  |  |   12|  31.8M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  31.8M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  31.8M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  31.8M|    v2 = std::rotl(v2, 32); \
  |  |   16|  31.8M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   60|  31.8M|            SIPROUND;
  ------------------
  |  |    9|  31.8M|#define SIPROUND do { \
  |  |   10|  31.8M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  31.8M|    v0 = std::rotl(v0, 32); \
  |  |   12|  31.8M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  31.8M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  31.8M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  31.8M|    v2 = std::rotl(v2, 32); \
  |  |   16|  31.8M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   61|  31.8M|            v0 ^= t;
   62|  31.8M|            t = 0;
   63|  31.8M|        }
   64|   254M|        data = data.subspan(1);
   65|   254M|    }
   66|       |
   67|  12.6M|    v[0] = v0;
   68|  12.6M|    v[1] = v1;
   69|  12.6M|    v[2] = v2;
   70|  12.6M|    v[3] = v3;
   71|  12.6M|    count = c;
   72|  12.6M|    tmp = t;
   73|       |
   74|  12.6M|    return *this;
   75|  12.6M|}
_ZNK10CSipHasher8FinalizeEv:
   78|  12.6M|{
   79|  12.6M|    uint64_t v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
   80|       |
   81|  12.6M|    uint64_t t = tmp | (((uint64_t)count) << 56);
   82|       |
   83|  12.6M|    v3 ^= t;
   84|  12.6M|    SIPROUND;
  ------------------
  |  |    9|  12.6M|#define SIPROUND do { \
  |  |   10|  12.6M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  12.6M|    v0 = std::rotl(v0, 32); \
  |  |   12|  12.6M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  12.6M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  12.6M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  12.6M|    v2 = std::rotl(v2, 32); \
  |  |   16|  12.6M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   85|  12.6M|    SIPROUND;
  ------------------
  |  |    9|  12.6M|#define SIPROUND do { \
  |  |   10|  12.6M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  12.6M|    v0 = std::rotl(v0, 32); \
  |  |   12|  12.6M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  12.6M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  12.6M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  12.6M|    v2 = std::rotl(v2, 32); \
  |  |   16|  12.6M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   86|  12.6M|    v0 ^= t;
   87|  12.6M|    v2 ^= 0xFF;
   88|  12.6M|    SIPROUND;
  ------------------
  |  |    9|  12.6M|#define SIPROUND do { \
  |  |   10|  12.6M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  12.6M|    v0 = std::rotl(v0, 32); \
  |  |   12|  12.6M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  12.6M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  12.6M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  12.6M|    v2 = std::rotl(v2, 32); \
  |  |   16|  12.6M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   89|  12.6M|    SIPROUND;
  ------------------
  |  |    9|  12.6M|#define SIPROUND do { \
  |  |   10|  12.6M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  12.6M|    v0 = std::rotl(v0, 32); \
  |  |   12|  12.6M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  12.6M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  12.6M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  12.6M|    v2 = std::rotl(v2, 32); \
  |  |   16|  12.6M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   90|  12.6M|    SIPROUND;
  ------------------
  |  |    9|  12.6M|#define SIPROUND do { \
  |  |   10|  12.6M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  12.6M|    v0 = std::rotl(v0, 32); \
  |  |   12|  12.6M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  12.6M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  12.6M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  12.6M|    v2 = std::rotl(v2, 32); \
  |  |   16|  12.6M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   91|  12.6M|    SIPROUND;
  ------------------
  |  |    9|  12.6M|#define SIPROUND do { \
  |  |   10|  12.6M|    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
  |  |   11|  12.6M|    v0 = std::rotl(v0, 32); \
  |  |   12|  12.6M|    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
  |  |   13|  12.6M|    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
  |  |   14|  12.6M|    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
  |  |   15|  12.6M|    v2 = std::rotl(v2, 32); \
  |  |   16|  12.6M|} while (0)
  |  |  ------------------
  |  |  |  Branch (16:10): [Folded - Ignored]
  |  |  ------------------
  ------------------
   92|  12.6M|    return v0 ^ v1 ^ v2 ^ v3;
   93|  12.6M|}

_ZN10HashWriter5writeE4SpanIKSt4byteE:
  107|   148M|    {
  108|   148M|        ctx.Write(UCharCast(src.data()), src.size());
  109|   148M|    }
_ZN10HashWriter7GetHashEv:
  115|  30.8M|    uint256 GetHash() {
  116|  30.8M|        uint256 result;
  117|  30.8M|        ctx.Finalize(result.begin());
  118|  30.8M|        ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin());
  119|  30.8M|        return result;
  120|  30.8M|    }
_ZN10HashWriter12GetCheapHashEv:
  135|  30.8M|    inline uint64_t GetCheapHash() {
  136|  30.8M|        uint256 result = GetHash();
  137|  30.8M|        return ReadLE64(result.begin());
  138|  30.8M|    }
_ZN10HashWriterlsINSt3__16vectorIhNS1_9allocatorIhEEEEEERS_RKT_:
  142|  35.0M|    {
  143|  35.0M|        ::Serialize(*this, obj);
  144|  35.0M|        return *this;
  145|  35.0M|    }
_ZN10HashWriterlsI7uint256EERS_RKT_:
  142|  30.8M|    {
  143|  30.8M|        ::Serialize(*this, obj);
  144|  30.8M|        return *this;
  145|  30.8M|    }
_ZN10HashWriterlsI4SpanIKhEEERS_RKT_:
  142|  30.8M|    {
  143|  30.8M|        ::Serialize(*this, obj);
  144|  30.8M|        return *this;
  145|  30.8M|    }
_ZN10HashWriterlsImEERS_RKT_:
  142|  4.86M|    {
  143|  4.86M|        ::Serialize(*this, obj);
  144|  4.86M|        return *this;
  145|  4.86M|    }
_ZN10HashWriterlsIhEERS_RKT_:
  142|  21.0M|    {
  143|  21.0M|        ::Serialize(*this, obj);
  144|  21.0M|        return *this;
  145|  21.0M|    }
_ZN10HashWriterlsIiEERS_RKT_:
  142|  21.0M|    {
  143|  21.0M|        ::Serialize(*this, obj);
  144|  21.0M|        return *this;
  145|  21.0M|    }
_ZN10HashWriterlsINSt3__16vectorIbNS1_9allocatorIbEEEEEERS_RKT_:
  142|  2.28k|    {
  143|  2.28k|        ::Serialize(*this, obj);
  144|  2.28k|        return *this;
  145|  2.28k|    }

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

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

_Z11LogInstancev:
   25|  6.56M|{
   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|  6.56M|    static BCLog::Logger* g_logger{new BCLog::Logger()};
   42|  6.56M|    return *g_logger;
   43|  6.56M|}
_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|  6.55M|{
  149|  6.55M|    return (m_categories.load(std::memory_order_relaxed) & category) != 0;
  150|  6.55M|}
_ZNK5BCLog6Logger20WillLogCategoryLevelENS_8LogFlagsENS_5LevelE:
  153|  6.55M|{
  154|       |    // Log messages at Info, Warning and Error level unconditionally, so that
  155|       |    // important troubleshooting information doesn't get lost.
  156|  6.55M|    if (level >= BCLog::Level::Info) return true;
  ------------------
  |  Branch (156:9): [True: 0, False: 6.55M]
  ------------------
  157|       |
  158|  6.55M|    if (!WillLogCategory(category)) return false;
  ------------------
  |  Branch (158:9): [True: 6.55M, 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|  6.55M|}

_ZNK5BCLog6Logger7EnabledEv:
  150|  7.15k|        {
  151|  7.15k|            StdLockGuard scoped_lock(m_cs);
  152|  7.15k|            return m_buffering || m_print_to_console || m_print_to_file || !m_print_callbacks.empty();
  ------------------
  |  Branch (152:20): [True: 0, False: 7.15k]
  |  Branch (152:35): [True: 0, False: 7.15k]
  |  Branch (152:57): [True: 0, False: 7.15k]
  |  Branch (152:76): [True: 0, False: 7.15k]
  ------------------
  153|  7.15k|        }
addrman.cpp:_ZL17LogAcceptCategoryN5BCLog8LogFlagsENS_5LevelE:
  234|  6.55M|{
  235|  6.55M|    return LogInstance().WillLogCategoryLevel(category, level);
  236|  6.55M|}
_Z22LogPrintFormatInternalIJPKcNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvNS2_17basic_string_viewIcS5_EESA_iN5BCLog8LogFlagsENSB_5LevelEN4util21ConstevalFormatStringIXsZT_EEEDpRKT_:
  243|  7.15k|{
  244|  7.15k|    if (LogInstance().Enabled()) {
  ------------------
  |  Branch (244:9): [True: 0, False: 7.15k]
  ------------------
  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|  7.15k|}

_ZN5BCLog5TimerINSt3__16chrono8durationIxNS1_5ratioILl1ELl1000EEEEEEC2ENS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEESD_NS_8LogFlagsEb:
   33|    657|        : m_prefix(std::move(prefix)),
   34|    657|          m_title(std::move(end_msg)),
   35|    657|          m_log_category(log_category),
   36|    657|          m_message_on_completion(msg_on_completion)
   37|    657|    {
   38|    657|        this->Log(strprintf("%s started", m_title));
  ------------------
  |  | 1172|    657|#define strprintf tfm::format
  ------------------
   39|    657|        m_start_t = std::chrono::steady_clock::now();
   40|    657|    }
_ZN5BCLog5TimerINSt3__16chrono8durationIxNS1_5ratioILl1ELl1000EEEEEE3LogERKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   52|  1.31k|    {
   53|  1.31k|        const std::string full_msg = this->LogMsg(msg);
   54|       |
   55|  1.31k|        if (m_log_category == BCLog::LogFlags::ALL) {
  ------------------
  |  Branch (55:13): [True: 0, False: 1.31k]
  ------------------
   56|      0|            LogPrintf("%s\n", full_msg);
  ------------------
  |  |  266|      0|#define LogPrintf(...) LogInfo(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |  261|      0|#define LogInfo(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   57|  1.31k|        } else {
   58|  1.31k|            LogDebug(m_log_category, "%s\n", full_msg);
  ------------------
  |  |  280|  1.31k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  1.31k|    do {                                                  \
  |  |  |  |  274|  1.31k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 1.31k]
  |  |  |  |  ------------------
  |  |  |  |  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.31k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   59|  1.31k|        }
   60|  1.31k|    }
_ZN5BCLog5TimerINSt3__16chrono8durationIxNS1_5ratioILl1ELl1000EEEEEE6LogMsgERKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   63|  1.31k|    {
   64|  1.31k|        const auto end_time{std::chrono::steady_clock::now()};
   65|  1.31k|        if (!m_start_t) {
  ------------------
  |  Branch (65:13): [True: 657, False: 657]
  ------------------
   66|    657|            return strprintf("%s: %s", m_prefix, msg);
  ------------------
  |  | 1172|    657|#define strprintf tfm::format
  ------------------
   67|    657|        }
   68|    657|        const auto duration{end_time - *m_start_t};
   69|       |
   70|       |        if constexpr (std::is_same<TimeType, std::chrono::microseconds>::value) {
   71|       |            return strprintf("%s: %s (%iμs)", m_prefix, msg, Ticks<std::chrono::microseconds>(duration));
   72|    657|        } else if constexpr (std::is_same<TimeType, std::chrono::milliseconds>::value) {
   73|    657|            return strprintf("%s: %s (%.2fms)", m_prefix, msg, Ticks<MillisecondsDouble>(duration));
  ------------------
  |  | 1172|    657|#define strprintf tfm::format
  ------------------
   74|       |        } else if constexpr (std::is_same<TimeType, std::chrono::seconds>::value) {
   75|       |            return strprintf("%s: %s (%.2fs)", m_prefix, msg, Ticks<SecondsDouble>(duration));
   76|       |        } else {
   77|       |            static_assert(ALWAYS_FALSE<TimeType>, "Error: unexpected time type");
   78|       |        }
   79|    657|    }
_ZN5BCLog5TimerINSt3__16chrono8durationIxNS1_5ratioILl1ELl1000EEEEEED2Ev:
   43|    657|    {
   44|    657|        if (m_message_on_completion) {
  ------------------
  |  Branch (44:13): [True: 0, False: 657]
  ------------------
   45|      0|            this->Log(strprintf("%s completed", m_title));
  ------------------
  |  | 1172|      0|#define strprintf tfm::format
  ------------------
   46|    657|        } else {
   47|    657|            this->Log("completed");
   48|    657|        }
   49|    657|    }

_Z11BytesToBitsRKNSt3__16vectorIhNS_9allocatorIhEEEE:
   22|  7.15k|{
   23|  7.15k|    std::vector<bool> ret(bytes.size() * 8);
   24|   163M|    for (unsigned int p = 0; p < ret.size(); p++) {
  ------------------
  |  Branch (24:30): [True: 163M, False: 7.15k]
  ------------------
   25|   163M|        ret[p] = (bytes[p / 8] & (1 << (p % 8))) != 0;
   26|   163M|    }
   27|  7.15k|    return ret;
   28|  7.15k|}

_ZNK8CNetAddr16GetBIP155NetworkEv:
   27|  2.70M|{
   28|  2.70M|    switch (m_net) {
  ------------------
  |  Branch (28:13): [True: 0, False: 2.70M]
  ------------------
   29|   363k|    case NET_IPV4:
  ------------------
  |  Branch (29:5): [True: 363k, False: 2.33M]
  ------------------
   30|   363k|        return BIP155Network::IPV4;
   31|  1.35M|    case NET_IPV6:
  ------------------
  |  Branch (31:5): [True: 1.35M, False: 1.34M]
  ------------------
   32|  1.35M|        return BIP155Network::IPV6;
   33|   179k|    case NET_ONION:
  ------------------
  |  Branch (33:5): [True: 179k, False: 2.52M]
  ------------------
   34|   179k|        return BIP155Network::TORV3;
   35|   779k|    case NET_I2P:
  ------------------
  |  Branch (35:5): [True: 779k, False: 1.92M]
  ------------------
   36|   779k|        return BIP155Network::I2P;
   37|  24.1k|    case NET_CJDNS:
  ------------------
  |  Branch (37:5): [True: 24.1k, False: 2.67M]
  ------------------
   38|  24.1k|        return BIP155Network::CJDNS;
   39|      0|    case NET_INTERNAL:   // should have been handled before calling this function
  ------------------
  |  Branch (39:5): [True: 0, False: 2.70M]
  ------------------
   40|      0|    case NET_UNROUTABLE: // m_net is never and should not be set to NET_UNROUTABLE
  ------------------
  |  Branch (40:5): [True: 0, False: 2.70M]
  ------------------
   41|      0|    case NET_MAX:        // m_net is never and should not be set to NET_MAX
  ------------------
  |  Branch (41:5): [True: 0, False: 2.70M]
  ------------------
   42|      0|        assert(false);
   43|  2.70M|    } // no default case, so the compiler can warn about missing cases
   44|       |
   45|      0|    assert(false);
   46|      0|}
_ZN8CNetAddr23SetNetFromBIP155NetworkEhm:
   49|  6.54M|{
   50|  6.54M|    switch (possible_bip155_net) {
  ------------------
  |  Branch (50:13): [True: 109k, False: 6.43M]
  ------------------
   51|  61.0k|    case BIP155Network::IPV4:
  ------------------
  |  Branch (51:5): [True: 61.0k, False: 6.48M]
  ------------------
   52|  61.0k|        if (address_size == ADDR_IPV4_SIZE) {
  ------------------
  |  Branch (52:13): [True: 61.0k, False: 6]
  ------------------
   53|  61.0k|            m_net = NET_IPV4;
   54|  61.0k|            return true;
   55|  61.0k|        }
   56|      6|        throw std::ios_base::failure(
   57|      6|            strprintf("BIP155 IPv4 address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|      6|#define strprintf tfm::format
  ------------------
   58|      6|                      ADDR_IPV4_SIZE));
   59|  4.08M|    case BIP155Network::IPV6:
  ------------------
  |  Branch (59:5): [True: 4.08M, False: 2.45M]
  ------------------
   60|  4.08M|        if (address_size == ADDR_IPV6_SIZE) {
  ------------------
  |  Branch (60:13): [True: 4.08M, False: 7]
  ------------------
   61|  4.08M|            m_net = NET_IPV6;
   62|  4.08M|            return true;
   63|  4.08M|        }
   64|      7|        throw std::ios_base::failure(
   65|      7|            strprintf("BIP155 IPv6 address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|      7|#define strprintf tfm::format
  ------------------
   66|      7|                      ADDR_IPV6_SIZE));
   67|  60.5k|    case BIP155Network::TORV3:
  ------------------
  |  Branch (67:5): [True: 60.5k, False: 6.48M]
  ------------------
   68|  60.5k|        if (address_size == ADDR_TORV3_SIZE) {
  ------------------
  |  Branch (68:13): [True: 60.5k, False: 3]
  ------------------
   69|  60.5k|            m_net = NET_ONION;
   70|  60.5k|            return true;
   71|  60.5k|        }
   72|      3|        throw std::ios_base::failure(
   73|      3|            strprintf("BIP155 TORv3 address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|      3|#define strprintf tfm::format
  ------------------
   74|      3|                      ADDR_TORV3_SIZE));
   75|  2.22M|    case BIP155Network::I2P:
  ------------------
  |  Branch (75:5): [True: 2.22M, False: 4.31M]
  ------------------
   76|  2.22M|        if (address_size == ADDR_I2P_SIZE) {
  ------------------
  |  Branch (76:13): [True: 2.22M, False: 8]
  ------------------
   77|  2.22M|            m_net = NET_I2P;
   78|  2.22M|            return true;
   79|  2.22M|        }
   80|      8|        throw std::ios_base::failure(
   81|      8|            strprintf("BIP155 I2P address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|      8|#define strprintf tfm::format
  ------------------
   82|      8|                      ADDR_I2P_SIZE));
   83|  3.99k|    case BIP155Network::CJDNS:
  ------------------
  |  Branch (83:5): [True: 3.99k, False: 6.53M]
  ------------------
   84|  3.99k|        if (address_size == ADDR_CJDNS_SIZE) {
  ------------------
  |  Branch (84:13): [True: 3.98k, False: 7]
  ------------------
   85|  3.98k|            m_net = NET_CJDNS;
   86|  3.98k|            return true;
   87|  3.98k|        }
   88|      7|        throw std::ios_base::failure(
   89|      7|            strprintf("BIP155 CJDNS address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|      7|#define strprintf tfm::format
  ------------------
   90|      7|                      ADDR_CJDNS_SIZE));
   91|  6.54M|    }
   92|       |
   93|       |    // Don't throw on addresses with unknown network ids (maybe from the future).
   94|       |    // Instead silently drop them and have the unserialization code consume
   95|       |    // subsequent ones which may be known to us.
   96|   109k|    return false;
   97|  6.54M|}
_ZN8CNetAddrC2Ev:
  104|  14.4M|CNetAddr::CNetAddr() = default;
_ZN8CNetAddr13SetLegacyIPv6E4SpanIKhE:
  138|   126k|{
  139|   126k|    assert(ipv6.size() == ADDR_IPV6_SIZE);
  140|       |
  141|   126k|    size_t skip{0};
  142|       |
  143|   126k|    if (HasPrefix(ipv6, IPV4_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (143:9): [True: 92, False: 126k]
  ------------------
  144|       |        // IPv4-in-IPv6
  145|     92|        m_net = NET_IPV4;
  146|     92|        skip = sizeof(IPV4_IN_IPV6_PREFIX);
  147|   126k|    } else if (HasPrefix(ipv6, TORV2_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (147:16): [True: 15, False: 126k]
  ------------------
  148|       |        // TORv2-in-IPv6 (unsupported). Unserialize as !IsValid(), thus ignoring them.
  149|       |        // Mimic a default-constructed CNetAddr object which is !IsValid() and thus
  150|       |        // will not be gossiped, but continue reading next addresses from the stream.
  151|     15|        m_net = NET_IPV6;
  152|     15|        m_addr.assign(ADDR_IPV6_SIZE, 0x0);
  153|     15|        return;
  154|   126k|    } else if (HasPrefix(ipv6, INTERNAL_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (154:16): [True: 36, False: 126k]
  ------------------
  155|       |        // Internal-in-IPv6
  156|     36|        m_net = NET_INTERNAL;
  157|     36|        skip = sizeof(INTERNAL_IN_IPV6_PREFIX);
  158|   126k|    } else {
  159|       |        // IPv6
  160|   126k|        m_net = NET_IPV6;
  161|   126k|    }
  162|       |
  163|   126k|    m_addr.assign(ipv6.begin() + skip, ipv6.end());
  164|   126k|}
_ZN8CNetAddr11SetInternalERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  173|  24.6k|{
  174|  24.6k|    if (name.empty()) {
  ------------------
  |  Branch (174:9): [True: 15, False: 24.6k]
  ------------------
  175|     15|        return false;
  176|     15|    }
  177|  24.6k|    m_net = NET_INTERNAL;
  178|  24.6k|    unsigned char hash[32] = {};
  179|  24.6k|    CSHA256().Write((const unsigned char*)name.data(), name.size()).Finalize(hash);
  180|  24.6k|    m_addr.assign(hash, hash + ADDR_INTERNAL_SIZE);
  181|  24.6k|    return true;
  182|  24.6k|}
_ZNK8CNetAddr9IsRFC1918Ev:
  316|  62.5M|{
  317|  62.5M|    return IsIPv4() && (
  ------------------
  |  Branch (317:12): [True: 2.65M, False: 59.9M]
  ------------------
  318|  2.65M|        m_addr[0] == 10 ||
  ------------------
  |  Branch (318:9): [True: 1.12k, False: 2.65M]
  ------------------
  319|  2.65M|        (m_addr[0] == 192 && m_addr[1] == 168) ||
  ------------------
  |  Branch (319:10): [True: 16.3k, False: 2.63M]
  |  Branch (319:30): [True: 1.05k, False: 15.3k]
  ------------------
  320|  2.65M|        (m_addr[0] == 172 && m_addr[1] >= 16 && m_addr[1] <= 31));
  ------------------
  |  Branch (320:10): [True: 2.91k, False: 2.65M]
  |  Branch (320:30): [True: 2.19k, False: 719]
  |  Branch (320:49): [True: 22, False: 2.17k]
  ------------------
  321|  62.5M|}
_ZNK8CNetAddr9IsRFC2544Ev:
  324|  62.5M|{
  325|  62.5M|    return IsIPv4() && m_addr[0] == 198 && (m_addr[1] == 18 || m_addr[1] == 19);
  ------------------
  |  Branch (325:12): [True: 2.65M, False: 59.9M]
  |  Branch (325:24): [True: 27.7k, False: 2.62M]
  |  Branch (325:45): [True: 235, False: 27.5k]
  |  Branch (325:64): [True: 2, False: 27.4k]
  ------------------
  326|  62.5M|}
_ZNK8CNetAddr9IsRFC3927Ev:
  329|  62.5M|{
  330|  62.5M|    return IsIPv4() && HasPrefix(m_addr, std::array<uint8_t, 2>{169, 254});
  ------------------
  |  Branch (330:12): [True: 2.65M, False: 59.9M]
  |  Branch (330:24): [True: 221, False: 2.65M]
  ------------------
  331|  62.5M|}
_ZNK8CNetAddr9IsRFC6598Ev:
  334|  62.5M|{
  335|  62.5M|    return IsIPv4() && m_addr[0] == 100 && m_addr[1] >= 64 && m_addr[1] <= 127;
  ------------------
  |  Branch (335:12): [True: 2.65M, False: 59.9M]
  |  Branch (335:24): [True: 15.8k, False: 2.63M]
  |  Branch (335:44): [True: 10.7k, False: 5.10k]
  |  Branch (335:63): [True: 772, False: 9.96k]
  ------------------
  336|  62.5M|}
_ZNK8CNetAddr9IsRFC5737Ev:
  339|  62.5M|{
  340|  62.5M|    return IsIPv4() && (HasPrefix(m_addr, std::array<uint8_t, 3>{192, 0, 2}) ||
  ------------------
  |  Branch (340:12): [True: 2.65M, False: 59.9M]
  |  Branch (340:25): [True: 287, False: 2.65M]
  ------------------
  341|  2.65M|                        HasPrefix(m_addr, std::array<uint8_t, 3>{198, 51, 100}) ||
  ------------------
  |  Branch (341:25): [True: 297, False: 2.65M]
  ------------------
  342|  2.65M|                        HasPrefix(m_addr, std::array<uint8_t, 3>{203, 0, 113}));
  ------------------
  |  Branch (342:25): [True: 61, False: 2.65M]
  ------------------
  343|  62.5M|}
_ZNK8CNetAddr9IsRFC3849Ev:
  346|  63.3M|{
  347|  63.3M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 4>{0x20, 0x01, 0x0D, 0xB8});
  ------------------
  |  Branch (347:12): [True: 38.0M, False: 25.3M]
  |  Branch (347:24): [True: 1.47k, False: 38.0M]
  ------------------
  348|  63.3M|}
_ZNK8CNetAddr9IsRFC3964Ev:
  351|  26.3M|{
  352|  26.3M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 2>{0x20, 0x02});
  ------------------
  |  Branch (352:12): [True: 16.8M, False: 9.44M]
  |  Branch (352:24): [True: 2.06k, False: 16.8M]
  ------------------
  353|  26.3M|}
_ZNK8CNetAddr9IsRFC6052Ev:
  356|  26.3M|{
  357|  26.3M|    return IsIPv6() &&
  ------------------
  |  Branch (357:12): [True: 16.8M, False: 9.44M]
  ------------------
  358|  26.3M|           HasPrefix(m_addr, std::array<uint8_t, 12>{0x00, 0x64, 0xFF, 0x9B, 0x00, 0x00,
  ------------------
  |  Branch (358:12): [True: 1.81k, False: 16.8M]
  ------------------
  359|  16.8M|                                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00});
  360|  26.3M|}
_ZNK8CNetAddr9IsRFC4380Ev:
  363|  26.3M|{
  364|  26.3M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 4>{0x20, 0x01, 0x00, 0x00});
  ------------------
  |  Branch (364:12): [True: 16.8M, False: 9.44M]
  |  Branch (364:24): [True: 1.13k, False: 16.8M]
  ------------------
  365|  26.3M|}
_ZNK8CNetAddr9IsRFC4862Ev:
  368|  62.5M|{
  369|  62.5M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 8>{0xFE, 0x80, 0x00, 0x00,
  ------------------
  |  Branch (369:12): [True: 38.0M, False: 24.5M]
  |  Branch (369:24): [True: 695, False: 38.0M]
  ------------------
  370|  38.0M|                                                                0x00, 0x00, 0x00, 0x00});
  371|  62.5M|}
_ZNK8CNetAddr9IsRFC4193Ev:
  374|  62.5M|{
  375|  62.5M|    return IsIPv6() && (m_addr[0] & 0xFE) == 0xFC;
  ------------------
  |  Branch (375:12): [True: 38.0M, False: 24.5M]
  |  Branch (375:24): [True: 46.5k, False: 38.0M]
  ------------------
  376|  62.5M|}
_ZNK8CNetAddr9IsRFC6145Ev:
  379|  26.3M|{
  380|  26.3M|    return IsIPv6() &&
  ------------------
  |  Branch (380:12): [True: 16.8M, False: 9.44M]
  ------------------
  381|  26.3M|           HasPrefix(m_addr, std::array<uint8_t, 12>{0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  ------------------
  |  Branch (381:12): [True: 1.86k, False: 16.8M]
  ------------------
  382|  16.8M|                                                     0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00});
  383|  26.3M|}
_ZNK8CNetAddr9IsRFC4843Ev:
  386|  62.5M|{
  387|  62.5M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 3>{0x20, 0x01, 0x00}) &&
  ------------------
  |  Branch (387:12): [True: 38.0M, False: 24.5M]
  |  Branch (387:24): [True: 2.24k, False: 38.0M]
  ------------------
  388|  62.5M|           (m_addr[3] & 0xF0) == 0x10;
  ------------------
  |  Branch (388:12): [True: 285, False: 1.96k]
  ------------------
  389|  62.5M|}
_ZNK8CNetAddr9IsRFC7343Ev:
  392|  62.5M|{
  393|  62.5M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 3>{0x20, 0x01, 0x00}) &&
  ------------------
  |  Branch (393:12): [True: 38.0M, False: 24.5M]
  |  Branch (393:24): [True: 1.96k, False: 38.0M]
  ------------------
  394|  62.5M|           (m_addr[3] & 0xF0) == 0x20;
  ------------------
  |  Branch (394:12): [True: 259, False: 1.70k]
  ------------------
  395|  62.5M|}
_ZNK8CNetAddr7IsHeNetEv:
  398|  2.11M|{
  399|  2.11M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 4>{0x20, 0x01, 0x04, 0x70});
  ------------------
  |  Branch (399:12): [True: 2.11M, False: 0]
  |  Branch (399:24): [True: 326, False: 2.10M]
  ------------------
  400|  2.11M|}
_ZNK8CNetAddr7IsLocalEv:
  403|  68.8M|{
  404|       |    // IPv4 loopback (127.0.0.0/8 or 0.0.0.0/8)
  405|  68.8M|    if (IsIPv4() && (m_addr[0] == 127 || m_addr[0] == 0)) {
  ------------------
  |  Branch (405:9): [True: 3.29M, False: 65.5M]
  |  Branch (405:22): [True: 4.49k, False: 3.28M]
  |  Branch (405:42): [True: 336k, False: 2.94M]
  ------------------
  406|   341k|        return true;
  407|   341k|    }
  408|       |
  409|       |    // IPv6 loopback (::1/128)
  410|  68.5M|    static const unsigned char pchLocal[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
  411|  68.5M|    if (IsIPv6() && memcmp(m_addr.data(), pchLocal, sizeof(pchLocal)) == 0) {
  ------------------
  |  Branch (411:9): [True: 40.1M, False: 28.3M]
  |  Branch (411:21): [True: 1.81k, False: 40.1M]
  ------------------
  412|  1.81k|        return true;
  413|  1.81k|    }
  414|       |
  415|  68.5M|    return false;
  416|  68.5M|}
_ZNK8CNetAddr7IsValidEv:
  429|  63.5M|{
  430|       |    // unspecified IPv6 address (::/128)
  431|  63.5M|    unsigned char ipNone6[16] = {};
  432|  63.5M|    if (IsIPv6() && memcmp(m_addr.data(), ipNone6, sizeof(ipNone6)) == 0) {
  ------------------
  |  Branch (432:9): [True: 38.2M, False: 25.3M]
  |  Branch (432:21): [True: 179k, False: 38.0M]
  ------------------
  433|   179k|        return false;
  434|   179k|    }
  435|       |
  436|  63.3M|    if (IsCJDNS() && !HasCJDNSPrefix()) {
  ------------------
  |  Branch (436:9): [True: 350k, False: 63.0M]
  |  Branch (436:22): [True: 329, False: 350k]
  ------------------
  437|    329|        return false;
  438|    329|    }
  439|       |
  440|       |    // documentation IPv6 address
  441|  63.3M|    if (IsRFC3849())
  ------------------
  |  Branch (441:9): [True: 1.47k, False: 63.3M]
  ------------------
  442|  1.47k|        return false;
  443|       |
  444|  63.3M|    if (IsInternal())
  ------------------
  |  Branch (444:9): [True: 9.12k, False: 63.3M]
  ------------------
  445|  9.12k|        return false;
  446|       |
  447|  63.3M|    if (IsIPv4()) {
  ------------------
  |  Branch (447:9): [True: 3.38M, False: 60.0M]
  ------------------
  448|  3.38M|        const uint32_t addr = ReadBE32(m_addr.data());
  449|  3.38M|        if (addr == INADDR_ANY || addr == INADDR_NONE) {
  ------------------
  |  Branch (449:13): [True: 603k, False: 2.77M]
  |  Branch (449:35): [True: 123k, False: 2.65M]
  ------------------
  450|   727k|            return false;
  451|   727k|        }
  452|  3.38M|    }
  453|       |
  454|  62.6M|    return true;
  455|  63.3M|}
_ZNK8CNetAddr10IsRoutableEv:
  467|  63.4M|{
  468|  63.4M|    return IsValid() && !(IsRFC1918() || IsRFC2544() || IsRFC3927() || IsRFC4862() || IsRFC6598() || IsRFC5737() || IsRFC4193() || IsRFC4843() || IsRFC7343() || IsLocal() || IsInternal());
  ------------------
  |  Branch (468:12): [True: 62.5M, False: 905k]
  |  Branch (468:27): [True: 2.20k, False: 62.5M]
  |  Branch (468:42): [True: 237, False: 62.5M]
  |  Branch (468:57): [True: 221, False: 62.5M]
  |  Branch (468:72): [True: 695, False: 62.5M]
  |  Branch (468:87): [True: 772, False: 62.5M]
  |  Branch (468:102): [True: 645, False: 62.5M]
  |  Branch (468:117): [True: 46.5k, False: 62.5M]
  |  Branch (468:132): [True: 285, False: 62.5M]
  |  Branch (468:147): [True: 259, False: 62.5M]
  |  Branch (468:162): [True: 28.8k, False: 62.4M]
  |  Branch (468:175): [True: 0, False: 62.4M]
  ------------------
  469|  63.4M|}
_ZNK8CNetAddr10IsInternalEv:
  477|   161M|{
  478|   161M|   return m_net == NET_INTERNAL;
  479|   161M|}
_ZNK8CNetAddr18IsAddrV1CompatibleEv:
  482|  32.3M|{
  483|  32.3M|    switch (m_net) {
  ------------------
  |  Branch (483:13): [True: 0, False: 32.3M]
  ------------------
  484|   400k|    case NET_IPV4:
  ------------------
  |  Branch (484:5): [True: 400k, False: 31.9M]
  ------------------
  485|  13.5M|    case NET_IPV6:
  ------------------
  |  Branch (485:5): [True: 13.1M, False: 19.2M]
  ------------------
  486|  14.2M|    case NET_INTERNAL:
  ------------------
  |  Branch (486:5): [True: 754k, False: 31.6M]
  ------------------
  487|  14.2M|        return true;
  488|   700k|    case NET_ONION:
  ------------------
  |  Branch (488:5): [True: 700k, False: 31.6M]
  ------------------
  489|  18.0M|    case NET_I2P:
  ------------------
  |  Branch (489:5): [True: 17.3M, False: 15.0M]
  ------------------
  490|  18.0M|    case NET_CJDNS:
  ------------------
  |  Branch (490:5): [True: 59.6k, False: 32.3M]
  ------------------
  491|  18.0M|        return false;
  492|      0|    case NET_UNROUTABLE: // m_net is never and should not be set to NET_UNROUTABLE
  ------------------
  |  Branch (492:5): [True: 0, False: 32.3M]
  ------------------
  493|      0|    case NET_MAX:        // m_net is never and should not be set to NET_MAX
  ------------------
  |  Branch (493:5): [True: 0, False: 32.3M]
  ------------------
  494|      0|        assert(false);
  495|  32.3M|    } // no default case, so the compiler can warn about missing cases
  496|       |
  497|      0|    assert(false);
  498|      0|}
_ZNK8CNetAddr10GetNetworkEv:
  501|  6.65M|{
  502|  6.65M|    if (IsInternal())
  ------------------
  |  Branch (502:9): [True: 252, False: 6.65M]
  ------------------
  503|    252|        return NET_INTERNAL;
  504|       |
  505|  6.65M|    if (!IsRoutable())
  ------------------
  |  Branch (505:9): [True: 113k, False: 6.54M]
  ------------------
  506|   113k|        return NET_UNROUTABLE;
  507|       |
  508|  6.54M|    return m_net;
  509|  6.65M|}
_ZeqRK8CNetAddrS1_:
  608|  9.93M|{
  609|  9.93M|    return a.m_net == b.m_net && a.m_addr == b.m_addr;
  ------------------
  |  Branch (609:12): [True: 6.19M, False: 3.73M]
  |  Branch (609:34): [True: 4.52M, False: 1.66M]
  ------------------
  610|  9.93M|}
_ZNK8CNetAddr13HasLinkedIPv4Ev:
  657|  27.7M|{
  658|  27.7M|    return IsRoutable() && (IsIPv4() || IsRFC6145() || IsRFC6052() || IsRFC3964() || IsRFC4380());
  ------------------
  |  Branch (658:12): [True: 27.7M, False: 0]
  |  Branch (658:29): [True: 1.39M, False: 26.3M]
  |  Branch (658:41): [True: 1.37k, False: 26.3M]
  |  Branch (658:56): [True: 1.35k, False: 26.3M]
  |  Branch (658:71): [True: 1.50k, False: 26.3M]
  |  Branch (658:86): [True: 793, False: 26.3M]
  ------------------
  659|  27.7M|}
_ZNK8CNetAddr13GetLinkedIPv4Ev:
  662|   554k|{
  663|   554k|    if (IsIPv4()) {
  ------------------
  |  Branch (663:9): [True: 552k, False: 1.83k]
  ------------------
  664|   552k|        return ReadBE32(m_addr.data());
  665|   552k|    } else if (IsRFC6052() || IsRFC6145()) {
  ------------------
  |  Branch (665:16): [True: 461, False: 1.37k]
  |  Branch (665:31): [True: 482, False: 896]
  ------------------
  666|       |        // mapped IPv4, SIIT translated IPv4: the IPv4 address is the last 4 bytes of the address
  667|    943|        return ReadBE32(Span{m_addr}.last(ADDR_IPV4_SIZE).data());
  668|    943|    } else if (IsRFC3964()) {
  ------------------
  |  Branch (668:16): [True: 554, False: 342]
  ------------------
  669|       |        // 6to4 tunneled IPv4: the IPv4 address is in bytes 2-6
  670|    554|        return ReadBE32(Span{m_addr}.subspan(2, ADDR_IPV4_SIZE).data());
  671|    554|    } else if (IsRFC4380()) {
  ------------------
  |  Branch (671:16): [True: 342, False: 0]
  ------------------
  672|       |        // Teredo tunneled IPv4: the IPv4 address is in the last 4 bytes of the address, but bitflipped
  673|    342|        return ~ReadBE32(Span{m_addr}.last(ADDR_IPV4_SIZE).data());
  674|    342|    }
  675|      0|    assert(false);
  676|      0|}
_ZNK8CNetAddr11GetNetClassEv:
  679|  19.8M|{
  680|       |    // Make sure that if we return NET_IPV6, then IsIPv6() is true. The callers expect that.
  681|       |
  682|       |    // Check for "internal" first because such addresses are also !IsRoutable()
  683|       |    // and we don't want to return NET_UNROUTABLE in that case.
  684|  19.8M|    if (IsInternal()) {
  ------------------
  |  Branch (684:9): [True: 1.50M, False: 18.3M]
  ------------------
  685|  1.50M|        return NET_INTERNAL;
  686|  1.50M|    }
  687|  18.3M|    if (!IsRoutable()) {
  ------------------
  |  Branch (687:9): [True: 757k, False: 17.6M]
  ------------------
  688|   757k|        return NET_UNROUTABLE;
  689|   757k|    }
  690|  17.6M|    if (HasLinkedIPv4()) {
  ------------------
  |  Branch (690:9): [True: 847k, False: 16.7M]
  ------------------
  691|   847k|        return NET_IPV4;
  692|   847k|    }
  693|  16.7M|    return m_net;
  694|  17.6M|}
_ZNK8CNetAddr12GetAddrBytesEv:
  697|  32.3M|{
  698|  32.3M|    if (IsAddrV1Compatible()) {
  ------------------
  |  Branch (698:9): [True: 14.2M, False: 18.0M]
  ------------------
  699|  14.2M|        uint8_t serialized[V1_SERIALIZATION_SIZE];
  700|  14.2M|        SerializeV1Array(serialized);
  701|  14.2M|        return {std::begin(serialized), std::end(serialized)};
  702|  14.2M|    }
  703|  18.0M|    return std::vector<unsigned char>(m_addr.begin(), m_addr.end());
  704|  32.3M|}
_ZN8CServiceC2Ev:
  784|  4.03M|CService::CService() : port(0)
  785|  4.03M|{
  786|  4.03M|}
_ZN8CServiceC2ERK8CNetAddrt:
  788|  6.42M|CService::CService(const CNetAddr& cip, uint16_t portIn) : CNetAddr(cip), port(portIn)
  789|  6.42M|{
  790|  6.42M|}
_ZeqRK8CServiceS1_:
  845|  4.51M|{
  846|  4.51M|    return static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) && a.port == b.port;
  ------------------
  |  Branch (846:12): [True: 4.51M, False: 0]
  |  Branch (846:68): [True: 4.51M, False: 0]
  ------------------
  847|  4.51M|}
_ZNK8CService6GetKeyEv:
  900|  21.6M|{
  901|  21.6M|    auto key = GetAddrBytes();
  902|  21.6M|    key.push_back(port / 0x100); // most significant byte of our port
  903|  21.6M|    key.push_back(port & 0x0FF); // least significant byte of our port
  904|  21.6M|    return key;
  905|  21.6M|}

_ZNK8CNetAddr6IsIPv4Ev:
  157|   473M|    [[nodiscard]] bool IsIPv4() const { return m_net == NET_IPV4; } // IPv4 mapped address (::FFFF:0:0/96, 0.0.0.0/0)
_ZNK8CNetAddr6IsIPv6Ev:
  158|   557M|    [[nodiscard]] bool IsIPv6() const { return m_net == NET_IPV6; } // IPv6 address (not mapped IPv4, not Tor)
_ZNK8CNetAddr5IsTorEv:
  174|  4.90M|    [[nodiscard]] bool IsTor() const { return m_net == NET_ONION; }
_ZNK8CNetAddr5IsI2PEv:
  175|  4.37M|    [[nodiscard]] bool IsI2P() const { return m_net == NET_I2P; }
_ZNK8CNetAddr7IsCJDNSEv:
  176|  65.5M|    [[nodiscard]] bool IsCJDNS() const { return m_net == NET_CJDNS; }
_ZNK8CNetAddr14HasCJDNSPrefixEv:
  177|   350k|    [[nodiscard]] bool HasCJDNSPrefix() const { return m_addr[0] == CJDNS_PREFIX; }
_ZNK8CNetAddr16SerializeV1ArrayERA16_h:
  325|  14.6M|    {
  326|  14.6M|        size_t prefix_size;
  327|       |
  328|  14.6M|        switch (m_net) {
  ------------------
  |  Branch (328:17): [True: 0, False: 14.6M]
  ------------------
  329|  13.1M|        case NET_IPV6:
  ------------------
  |  Branch (329:9): [True: 13.1M, False: 1.53M]
  ------------------
  330|  13.1M|            assert(m_addr.size() == sizeof(arr));
  331|  13.1M|            memcpy(arr, m_addr.data(), m_addr.size());
  332|  13.1M|            return;
  333|   400k|        case NET_IPV4:
  ------------------
  |  Branch (333:9): [True: 400k, False: 14.2M]
  ------------------
  334|   400k|            prefix_size = sizeof(IPV4_IN_IPV6_PREFIX);
  335|   400k|            assert(prefix_size + m_addr.size() == sizeof(arr));
  336|   400k|            memcpy(arr, IPV4_IN_IPV6_PREFIX.data(), prefix_size);
  337|   400k|            memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
  338|   400k|            return;
  339|  1.13M|        case NET_INTERNAL:
  ------------------
  |  Branch (339:9): [True: 1.13M, False: 13.5M]
  ------------------
  340|  1.13M|            prefix_size = sizeof(INTERNAL_IN_IPV6_PREFIX);
  341|  1.13M|            assert(prefix_size + m_addr.size() == sizeof(arr));
  342|  1.13M|            memcpy(arr, INTERNAL_IN_IPV6_PREFIX.data(), prefix_size);
  343|  1.13M|            memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
  344|  1.13M|            return;
  345|      0|        case NET_ONION:
  ------------------
  |  Branch (345:9): [True: 0, False: 14.6M]
  ------------------
  346|      0|        case NET_I2P:
  ------------------
  |  Branch (346:9): [True: 0, False: 14.6M]
  ------------------
  347|      0|        case NET_CJDNS:
  ------------------
  |  Branch (347:9): [True: 0, False: 14.6M]
  ------------------
  348|      0|            break;
  349|      0|        case NET_UNROUTABLE:
  ------------------
  |  Branch (349:9): [True: 0, False: 14.6M]
  ------------------
  350|      0|        case NET_MAX:
  ------------------
  |  Branch (350:9): [True: 0, False: 14.6M]
  ------------------
  351|      0|            assert(false);
  352|  14.6M|        } // no default case, so the compiler can warn about missing cases
  353|       |
  354|       |        // Serialize ONION, I2P and CJDNS as all-zeros.
  355|      0|        memset(arr, 0x0, V1_SERIALIZATION_SIZE);
  356|      0|    }
_ZN8CNetAddr18UnserializeV1ArrayERA16_h:
  400|   126k|    {
  401|       |        // Use SetLegacyIPv6() so that m_net is set correctly. For example
  402|       |        // ::FFFF:0102:0304 should be set as m_net=NET_IPV4 (1.2.3.4).
  403|   126k|        SetLegacyIPv6(arr);
  404|   126k|    }
_ZN12CServiceHashC2Ev:
  577|  9.54k|        : m_salt_k0{FastRandomContext().rand64()},
  578|  9.54k|          m_salt_k1{FastRandomContext().rand64()}
  579|  9.54k|    {
  580|  9.54k|    }
_ZNK12CServiceHashclERK8CService:
  585|  12.6M|    {
  586|  12.6M|        CSipHasher hasher(m_salt_k0, m_salt_k1);
  587|  12.6M|        hasher.Write(a.m_net);
  588|  12.6M|        hasher.Write(a.port);
  589|  12.6M|        hasher.Write(a.m_addr);
  590|  12.6M|        return static_cast<size_t>(hasher.Finalize());
  591|  12.6M|    }
_ZN8CService16SerializationOpsI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEES_17ActionUnserializeEEvRT0_RT_T1_:
  565|   119k|    {
  566|   119k|        READWRITE(AsBase<CNetAddr>(obj), Using<BigEndianFormatter<2>>(obj.port));
  ------------------
  |  |  156|   119k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  567|   119k|    }
_ZN8CNetAddr11UnserializeI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  252|   119k|    {
  253|   119k|        if (s.template GetParams<SerParams>().enc == Encoding::V2) {
  ------------------
  |  Branch (253:13): [True: 4.97k, False: 114k]
  ------------------
  254|  4.97k|            UnserializeV2Stream(s);
  255|   114k|        } else {
  256|   114k|            UnserializeV1Stream(s);
  257|   114k|        }
  258|   119k|    }
_ZN8CNetAddr19UnserializeV2StreamI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  424|  4.97k|    {
  425|  4.97k|        uint8_t bip155_net;
  426|  4.97k|        s >> bip155_net;
  427|       |
  428|  4.97k|        size_t address_size;
  429|  4.97k|        s >> COMPACTSIZE(address_size);
  ------------------
  |  |  501|  4.97k|#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
  ------------------
  430|       |
  431|  4.97k|        if (address_size > MAX_ADDRV2_SIZE) {
  ------------------
  |  Branch (431:13): [True: 30, False: 4.94k]
  ------------------
  432|     30|            throw std::ios_base::failure(strprintf(
  ------------------
  |  | 1172|     30|#define strprintf tfm::format
  ------------------
  433|     30|                "Address too long: %u > %u", address_size, MAX_ADDRV2_SIZE));
  434|     30|        }
  435|       |
  436|  4.94k|        m_scope_id = 0;
  437|       |
  438|  4.94k|        if (SetNetFromBIP155Network(bip155_net, address_size)) {
  ------------------
  |  Branch (438:13): [True: 1.97k, False: 2.97k]
  ------------------
  439|  1.97k|            m_addr.resize(address_size);
  440|  1.97k|            s >> Span{m_addr};
  441|       |
  442|  1.97k|            if (m_net != NET_IPV6) {
  ------------------
  |  Branch (442:17): [True: 1.31k, False: 654]
  ------------------
  443|  1.31k|                return;
  444|  1.31k|            }
  445|       |
  446|       |            // Do some special checks on IPv6 addresses.
  447|       |
  448|       |            // Recognize NET_INTERNAL embedded in IPv6, such addresses are not
  449|       |            // gossiped but could be coming from addrman, when unserializing from
  450|       |            // disk.
  451|    654|            if (util::HasPrefix(m_addr, INTERNAL_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (451:17): [True: 235, False: 419]
  ------------------
  452|    235|                m_net = NET_INTERNAL;
  453|    235|                memmove(m_addr.data(), m_addr.data() + INTERNAL_IN_IPV6_PREFIX.size(),
  454|    235|                        ADDR_INTERNAL_SIZE);
  455|    235|                m_addr.resize(ADDR_INTERNAL_SIZE);
  456|    235|                return;
  457|    235|            }
  458|       |
  459|    419|            if (!util::HasPrefix(m_addr, IPV4_IN_IPV6_PREFIX) &&
  ------------------
  |  Branch (459:17): [True: 340, False: 79]
  ------------------
  460|    419|                !util::HasPrefix(m_addr, TORV2_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (460:17): [True: 218, False: 122]
  ------------------
  461|    218|                return;
  462|    218|            }
  463|       |
  464|       |            // IPv4 and TORv2 are not supposed to be embedded in IPv6 (like in V1
  465|       |            // encoding). Unserialize as !IsValid(), thus ignoring them.
  466|  2.97k|        } else {
  467|       |            // If we receive an unknown BIP155 network id (from the future?) then
  468|       |            // ignore the address - unserialize as !IsValid().
  469|  2.97k|            s.ignore(address_size);
  470|  2.97k|        }
  471|       |
  472|       |        // Mimic a default-constructed CNetAddr object which is !IsValid() and thus
  473|       |        // will not be gossiped, but continue reading next addresses from the stream.
  474|  3.17k|        m_net = NET_IPV6;
  475|  3.17k|        m_addr.assign(ADDR_IPV6_SIZE, 0x0);
  476|  3.17k|    }
_ZN8CNetAddr19UnserializeV1StreamI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  411|   114k|    {
  412|   114k|        uint8_t serialized[V1_SERIALIZATION_SIZE];
  413|       |
  414|   114k|        s >> serialized;
  415|       |
  416|   114k|        UnserializeV1Array(serialized);
  417|   114k|    }
_ZN8CNetAddr11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  252|  6.54M|    {
  253|  6.54M|        if (s.template GetParams<SerParams>().enc == Encoding::V2) {
  ------------------
  |  Branch (253:13): [True: 6.53M, False: 11.9k]
  ------------------
  254|  6.53M|            UnserializeV2Stream(s);
  255|  6.53M|        } else {
  256|  11.9k|            UnserializeV1Stream(s);
  257|  11.9k|        }
  258|  6.54M|    }
_ZN8CNetAddr19UnserializeV2StreamI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  424|  6.53M|    {
  425|  6.53M|        uint8_t bip155_net;
  426|  6.53M|        s >> bip155_net;
  427|       |
  428|  6.53M|        size_t address_size;
  429|  6.53M|        s >> COMPACTSIZE(address_size);
  ------------------
  |  |  501|  6.53M|#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
  ------------------
  430|       |
  431|  6.53M|        if (address_size > MAX_ADDRV2_SIZE) {
  ------------------
  |  Branch (431:13): [True: 34, False: 6.53M]
  ------------------
  432|     34|            throw std::ios_base::failure(strprintf(
  ------------------
  |  | 1172|     34|#define strprintf tfm::format
  ------------------
  433|     34|                "Address too long: %u > %u", address_size, MAX_ADDRV2_SIZE));
  434|     34|        }
  435|       |
  436|  6.53M|        m_scope_id = 0;
  437|       |
  438|  6.53M|        if (SetNetFromBIP155Network(bip155_net, address_size)) {
  ------------------
  |  Branch (438:13): [True: 6.43M, False: 106k]
  ------------------
  439|  6.43M|            m_addr.resize(address_size);
  440|  6.43M|            s >> Span{m_addr};
  441|       |
  442|  6.43M|            if (m_net != NET_IPV6) {
  ------------------
  |  Branch (442:17): [True: 2.34M, False: 4.08M]
  ------------------
  443|  2.34M|                return;
  444|  2.34M|            }
  445|       |
  446|       |            // Do some special checks on IPv6 addresses.
  447|       |
  448|       |            // Recognize NET_INTERNAL embedded in IPv6, such addresses are not
  449|       |            // gossiped but could be coming from addrman, when unserializing from
  450|       |            // disk.
  451|  4.08M|            if (util::HasPrefix(m_addr, INTERNAL_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (451:17): [True: 1.51k, False: 4.08M]
  ------------------
  452|  1.51k|                m_net = NET_INTERNAL;
  453|  1.51k|                memmove(m_addr.data(), m_addr.data() + INTERNAL_IN_IPV6_PREFIX.size(),
  454|  1.51k|                        ADDR_INTERNAL_SIZE);
  455|  1.51k|                m_addr.resize(ADDR_INTERNAL_SIZE);
  456|  1.51k|                return;
  457|  1.51k|            }
  458|       |
  459|  4.08M|            if (!util::HasPrefix(m_addr, IPV4_IN_IPV6_PREFIX) &&
  ------------------
  |  Branch (459:17): [True: 4.07M, False: 1.28k]
  ------------------
  460|  4.08M|                !util::HasPrefix(m_addr, TORV2_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (460:17): [True: 4.07M, False: 65]
  ------------------
  461|  4.07M|                return;
  462|  4.07M|            }
  463|       |
  464|       |            // IPv4 and TORv2 are not supposed to be embedded in IPv6 (like in V1
  465|       |            // encoding). Unserialize as !IsValid(), thus ignoring them.
  466|  4.08M|        } else {
  467|       |            // If we receive an unknown BIP155 network id (from the future?) then
  468|       |            // ignore the address - unserialize as !IsValid().
  469|   106k|            s.ignore(address_size);
  470|   106k|        }
  471|       |
  472|       |        // Mimic a default-constructed CNetAddr object which is !IsValid() and thus
  473|       |        // will not be gossiped, but continue reading next addresses from the stream.
  474|   108k|        m_net = NET_IPV6;
  475|   108k|        m_addr.assign(ADDR_IPV6_SIZE, 0x0);
  476|   108k|    }
_ZN8CNetAddr19UnserializeV1StreamI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  411|  11.9k|    {
  412|  11.9k|        uint8_t serialized[V1_SERIALIZATION_SIZE];
  413|       |
  414|  11.9k|        s >> serialized;
  415|       |
  416|  11.9k|        UnserializeV1Array(serialized);
  417|  11.9k|    }
_ZN8CService16SerializationOpsI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEKS_15ActionSerializeEEvRT0_RT_T1_:
  565|  1.53M|    {
  566|  1.53M|        READWRITE(AsBase<CNetAddr>(obj), Using<BigEndianFormatter<2>>(obj.port));
  ------------------
  |  |  156|  1.53M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  567|  1.53M|    }
_ZNK8CNetAddr9SerializeI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  239|  1.53M|    {
  240|  1.53M|        if (s.template GetParams<SerParams>().enc == Encoding::V2) {
  ------------------
  |  Branch (240:13): [True: 1.53M, False: 0]
  ------------------
  241|  1.53M|            SerializeV2Stream(s);
  242|  1.53M|        } else {
  243|      0|            SerializeV1Stream(s);
  244|      0|        }
  245|  1.53M|    }
_ZNK8CNetAddr17SerializeV2StreamI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  376|  1.53M|    {
  377|  1.53M|        if (IsInternal()) {
  ------------------
  |  Branch (377:13): [True: 0, False: 1.53M]
  ------------------
  378|       |            // Serialize NET_INTERNAL as embedded in IPv6. We need to
  379|       |            // serialize such addresses from addrman.
  380|      0|            s << static_cast<uint8_t>(BIP155Network::IPV6);
  381|      0|            s << COMPACTSIZE(ADDR_IPV6_SIZE);
  ------------------
  |  |  501|      0|#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
  ------------------
  382|      0|            SerializeV1Stream(s);
  383|      0|            return;
  384|      0|        }
  385|       |
  386|  1.53M|        s << static_cast<uint8_t>(GetBIP155Network());
  387|  1.53M|        s << m_addr;
  388|  1.53M|    }
_ZNK8CNetAddr9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  239|  1.53M|    {
  240|  1.53M|        if (s.template GetParams<SerParams>().enc == Encoding::V2) {
  ------------------
  |  Branch (240:13): [True: 1.53M, False: 0]
  ------------------
  241|  1.53M|            SerializeV2Stream(s);
  242|  1.53M|        } else {
  243|      0|            SerializeV1Stream(s);
  244|      0|        }
  245|  1.53M|    }
_ZNK8CNetAddr17SerializeV2StreamI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  376|  1.53M|    {
  377|  1.53M|        if (IsInternal()) {
  ------------------
  |  Branch (377:13): [True: 376k, False: 1.16M]
  ------------------
  378|       |            // Serialize NET_INTERNAL as embedded in IPv6. We need to
  379|       |            // serialize such addresses from addrman.
  380|   376k|            s << static_cast<uint8_t>(BIP155Network::IPV6);
  381|   376k|            s << COMPACTSIZE(ADDR_IPV6_SIZE);
  ------------------
  |  |  501|   376k|#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
  ------------------
  382|   376k|            SerializeV1Stream(s);
  383|   376k|            return;
  384|   376k|        }
  385|       |
  386|  1.16M|        s << static_cast<uint8_t>(GetBIP155Network());
  387|  1.16M|        s << m_addr;
  388|  1.16M|    }
_ZNK8CNetAddr17SerializeV1StreamI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  363|   376k|    {
  364|   376k|        uint8_t serialized[V1_SERIALIZATION_SIZE];
  365|       |
  366|   376k|        SerializeV1Array(serialized);
  367|       |
  368|   376k|        s << serialized;
  369|   376k|    }

_ZNK15NetGroupManager16GetAsmapChecksumEv:
   12|  7.82k|{
   13|  7.82k|    if (!m_asmap.size()) return {};
  ------------------
  |  Branch (13:9): [True: 5.54k, False: 2.28k]
  ------------------
   14|       |
   15|  2.28k|    return (HashWriter{} << m_asmap).GetHash();
   16|  7.82k|}
_ZNK15NetGroupManager8GetGroupERK8CNetAddr:
   19|  9.14M|{
   20|  9.14M|    std::vector<unsigned char> vchRet;
   21|       |    // If non-empty asmap is supplied and the address is IPv4/IPv6,
   22|       |    // return ASN to be used for bucketing.
   23|  9.14M|    uint32_t asn = GetMappedAS(address);
   24|  9.14M|    if (asn != 0) { // Either asmap was empty, or address has non-asmappable net class (e.g. TOR).
  ------------------
  |  Branch (24:9): [True: 2.81M, False: 6.32M]
  ------------------
   25|  2.81M|        vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in the same bucket
   26|  14.0M|        for (int i = 0; i < 4; i++) {
  ------------------
  |  Branch (26:25): [True: 11.2M, False: 2.81M]
  ------------------
   27|  11.2M|            vchRet.push_back((asn >> (8 * i)) & 0xFF);
   28|  11.2M|        }
   29|  2.81M|        return vchRet;
   30|  2.81M|    }
   31|       |
   32|  6.32M|    vchRet.push_back(address.GetNetClass());
   33|  6.32M|    int nStartByte{0};
   34|  6.32M|    int nBits{0};
   35|       |
   36|  6.32M|    if (address.IsLocal()) {
  ------------------
  |  Branch (36:9): [True: 314k, False: 6.01M]
  ------------------
   37|       |        // all local addresses belong to the same group
   38|  6.01M|    } else if (address.IsInternal()) {
  ------------------
  |  Branch (38:16): [True: 754k, False: 5.25M]
  ------------------
   39|       |        // All internal-usage addresses get their own group.
   40|       |        // Skip over the INTERNAL_IN_IPV6_PREFIX returned by CAddress::GetAddrBytes().
   41|   754k|        nStartByte = INTERNAL_IN_IPV6_PREFIX.size();
   42|   754k|        nBits = ADDR_INTERNAL_SIZE * 8;
   43|  5.25M|    } else if (!address.IsRoutable()) {
  ------------------
  |  Branch (43:16): [True: 64.4k, False: 5.19M]
  ------------------
   44|       |        // all other unroutable addresses belong to the same group
   45|  5.19M|    } else if (address.HasLinkedIPv4()) {
  ------------------
  |  Branch (45:16): [True: 284k, False: 4.90M]
  ------------------
   46|       |        // IPv4 addresses (and mapped IPv4 addresses) use /16 groups
   47|   284k|        uint32_t ipv4 = address.GetLinkedIPv4();
   48|   284k|        vchRet.push_back((ipv4 >> 24) & 0xFF);
   49|   284k|        vchRet.push_back((ipv4 >> 16) & 0xFF);
   50|   284k|        return vchRet;
   51|  4.90M|    } else if (address.IsTor() || address.IsI2P()) {
  ------------------
  |  Branch (51:16): [True: 530k, False: 4.37M]
  |  Branch (51:35): [True: 2.21M, False: 2.16M]
  ------------------
   52|  2.74M|        nBits = 4;
   53|  2.74M|    } else if (address.IsCJDNS()) {
  ------------------
  |  Branch (53:16): [True: 56.1k, False: 2.11M]
  ------------------
   54|       |        // Treat in the same way as Tor and I2P because the address in all of
   55|       |        // them is "random" bytes (derived from a public key). However in CJDNS
   56|       |        // the first byte is a constant (see CJDNS_PREFIX), so the random bytes
   57|       |        // come after it. Thus skip the constant 8 bits at the start.
   58|  56.1k|        nBits = 12;
   59|  2.11M|    } else if (address.IsHeNet()) {
  ------------------
  |  Branch (59:16): [True: 326, False: 2.10M]
  ------------------
   60|       |        // for he.net, use /36 groups
   61|    326|        nBits = 36;
   62|  2.10M|    } else {
   63|       |        // for the rest of the IPv6 network, use /32 groups
   64|  2.10M|        nBits = 32;
   65|  2.10M|    }
   66|       |
   67|       |    // Push our address onto vchRet.
   68|  6.04M|    auto addr_bytes = address.GetAddrBytes();
   69|  6.04M|    const size_t num_bytes = nBits / 8;
   70|  6.04M|    vchRet.insert(vchRet.end(), addr_bytes.begin() + nStartByte, addr_bytes.begin() + nStartByte + num_bytes);
   71|  6.04M|    nBits %= 8;
   72|       |    // ...for the last byte, push nBits and for the rest of the byte push 1's
   73|  6.04M|    if (nBits > 0) {
  ------------------
  |  Branch (73:9): [True: 2.79M, False: 3.24M]
  ------------------
   74|  2.79M|        assert(num_bytes < addr_bytes.size());
   75|  2.79M|        vchRet.push_back(addr_bytes[num_bytes + nStartByte] | ((1 << (8 - nBits)) - 1));
   76|  2.79M|    }
   77|       |
   78|  6.04M|    return vchRet;
   79|  6.04M|}
_ZNK15NetGroupManager11GetMappedASERK8CNetAddr:
   82|  13.2M|{
   83|  13.2M|    uint32_t net_class = address.GetNetClass();
   84|  13.2M|    if (m_asmap.size() == 0 || (net_class != NET_IPV4 && net_class != NET_IPV6)) {
  ------------------
  |  Branch (84:9): [True: 6.10M, False: 7.12M]
  |  Branch (84:33): [True: 6.84M, False: 270k]
  |  Branch (84:58): [True: 2.18M, False: 4.66M]
  ------------------
   85|  8.29M|        return 0; // Indicates not found, safe because AS0 is reserved per RFC7607.
   86|  8.29M|    }
   87|  4.93M|    std::vector<bool> ip_bits(128);
   88|  4.93M|    if (address.HasLinkedIPv4()) {
  ------------------
  |  Branch (88:9): [True: 270k, False: 4.66M]
  ------------------
   89|       |        // For lookup, treat as if it was just an IPv4 address (IPV4_IN_IPV6_PREFIX + IPv4 bits)
   90|  3.51M|        for (int8_t byte_i = 0; byte_i < 12; ++byte_i) {
  ------------------
  |  Branch (90:33): [True: 3.24M, False: 270k]
  ------------------
   91|  29.1M|            for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
  ------------------
  |  Branch (91:37): [True: 25.9M, False: 3.24M]
  ------------------
   92|  25.9M|                ip_bits[byte_i * 8 + bit_i] = (IPV4_IN_IPV6_PREFIX[byte_i] >> (7 - bit_i)) & 1;
   93|  25.9M|            }
   94|  3.24M|        }
   95|   270k|        uint32_t ipv4 = address.GetLinkedIPv4();
   96|  8.91M|        for (int i = 0; i < 32; ++i) {
  ------------------
  |  Branch (96:25): [True: 8.64M, False: 270k]
  ------------------
   97|  8.64M|            ip_bits[96 + i] = (ipv4 >> (31 - i)) & 1;
   98|  8.64M|        }
   99|  4.66M|    } else {
  100|       |        // Use all 128 bits of the IPv6 address otherwise
  101|  4.66M|        assert(address.IsIPv6());
  102|  4.66M|        auto addr_bytes = address.GetAddrBytes();
  103|  79.2M|        for (int8_t byte_i = 0; byte_i < 16; ++byte_i) {
  ------------------
  |  Branch (103:33): [True: 74.6M, False: 4.66M]
  ------------------
  104|  74.6M|            uint8_t cur_byte = addr_bytes[byte_i];
  105|   671M|            for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
  ------------------
  |  Branch (105:37): [True: 596M, False: 74.6M]
  ------------------
  106|   596M|                ip_bits[byte_i * 8 + bit_i] = (cur_byte >> (7 - bit_i)) & 1;
  107|   596M|            }
  108|  74.6M|        }
  109|  4.66M|    }
  110|  4.93M|    uint32_t mapped_as = Interpret(m_asmap, ip_bits);
  111|  4.93M|    return mapped_as;
  112|  4.93M|}

_ZN15NetGroupManagerC2ENSt3__16vectorIbNS0_9allocatorIbEEEE:
   19|  7.15k|        : m_asmap{std::move(asmap)}
   20|  7.15k|    {}

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

_ZN9prevectorILj16EhjiEaSEOS0_:
  284|  7.70M|    prevector& operator=(prevector<N, T, Size, Diff>&& other) noexcept {
  285|  7.70M|        if (!is_direct()) {
  ------------------
  |  Branch (285:13): [True: 0, False: 7.70M]
  ------------------
  286|      0|            free(_union.indirect_contents.indirect);
  287|      0|        }
  288|  7.70M|        _union = std::move(other._union);
  289|  7.70M|        _size = other._size;
  290|  7.70M|        other._size = 0;
  291|  7.70M|        return *this;
  292|  7.70M|    }
_ZNK9prevectorILj16EhjiE9is_directEv:
  173|  1.14G|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj16EhjiED2Ev:
  474|  61.3M|    ~prevector() {
  475|  61.3M|        if (!is_direct()) {
  ------------------
  |  Branch (475:13): [True: 12.7M, False: 48.6M]
  ------------------
  476|  12.7M|            free(_union.indirect_contents.indirect);
  477|  12.7M|            _union.indirect_contents.indirect = nullptr;
  478|  12.7M|        }
  479|  61.3M|    }
_ZN9prevectorILj16EhjiEC2ERKS0_:
  263|  33.6M|    prevector(const prevector<N, T, Size, Diff>& other) {
  264|  33.6M|        size_type n = other.size();
  265|  33.6M|        change_capacity(n);
  266|  33.6M|        _size += n;
  267|  33.6M|        fill(item_ptr(0), other.begin(),  other.end());
  268|  33.6M|    }
_ZNK9prevectorILj16EhjiE4sizeEv:
  294|   425M|    size_type size() const {
  295|   425M|        return is_direct() ? _size : _size - N - 1;
  ------------------
  |  Branch (295:16): [True: 372M, False: 53.1M]
  ------------------
  296|   425M|    }
_ZN9prevectorILj16EhjiE15change_capacityEj:
  175|  50.3M|    void change_capacity(size_type new_capacity) {
  176|  50.3M|        if (new_capacity <= N) {
  ------------------
  |  Branch (176:13): [True: 37.6M, False: 12.7M]
  ------------------
  177|  37.6M|            if (!is_direct()) {
  ------------------
  |  Branch (177:17): [True: 0, False: 37.6M]
  ------------------
  178|      0|                T* indirect = indirect_ptr(0);
  179|      0|                T* src = indirect;
  180|      0|                T* dst = direct_ptr(0);
  181|      0|                memcpy(dst, src, size() * sizeof(T));
  182|      0|                free(indirect);
  183|      0|                _size -= N + 1;
  184|      0|            }
  185|  37.6M|        } else {
  186|  12.7M|            if (!is_direct()) {
  ------------------
  |  Branch (186:17): [True: 0, False: 12.7M]
  ------------------
  187|       |                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
  188|       |                    success. These should instead use an allocator or new/delete so that handlers
  189|       |                    are called as necessary, but performance would be slightly degraded by doing so. */
  190|      0|                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
  191|      0|                assert(_union.indirect_contents.indirect);
  192|      0|                _union.indirect_contents.capacity = new_capacity;
  193|  12.7M|            } else {
  194|  12.7M|                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
  195|  12.7M|                assert(new_indirect);
  196|  12.7M|                T* src = direct_ptr(0);
  197|  12.7M|                T* dst = reinterpret_cast<T*>(new_indirect);
  198|  12.7M|                memcpy(dst, src, size() * sizeof(T));
  199|  12.7M|                _union.indirect_contents.indirect = new_indirect;
  200|  12.7M|                _union.indirect_contents.capacity = new_capacity;
  201|  12.7M|                _size += N + 1;
  202|  12.7M|            }
  203|  12.7M|        }
  204|  50.3M|    }
_ZN9prevectorILj16EhjiE12indirect_ptrEi:
  171|  15.0M|    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
_ZN9prevectorILj16EhjiE10direct_ptrEi:
  169|  55.7M|    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
_ZN9prevectorILj16EhjiE4fillITkNSt3__114input_iteratorENS0_14const_iteratorEEEvPhT_S5_:
  214|  33.6M|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|   723M|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 690M, False: 33.6M]
  ------------------
  216|   690M|            new(static_cast<void*>(dst)) T(*first);
  217|   690M|            ++dst;
  218|   690M|            ++first;
  219|   690M|        }
  220|  33.6M|    }
_ZNK9prevectorILj16EhjiE14const_iteratorneES1_:
  125|   827M|        bool operator!=(const_iterator x) const { return ptr != x.ptr; }
_ZNK9prevectorILj16EhjiE14const_iteratordeEv:
  111|   925M|        const T& operator*() const { return *ptr; }
_ZN9prevectorILj16EhjiE14const_iteratorppEv:
  114|   885M|        const_iterator& operator++() { ptr++; return *this; }
_ZN9prevectorILj16EhjiE8item_ptrEi:
  206|  58.0M|    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (206:47): [True: 43.0M, False: 15.0M]
  ------------------
_ZNK9prevectorILj16EhjiE5beginEv:
  303|   308M|    const_iterator begin() const { return const_iterator(item_ptr(0)); }
_ZNK9prevectorILj16EhjiE8item_ptrEi:
  207|   537M|    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (207:59): [True: 470M, False: 66.9M]
  ------------------
_ZNK9prevectorILj16EhjiE10direct_ptrEi:
  170|   470M|    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
_ZNK9prevectorILj16EhjiE12indirect_ptrEi:
  172|  66.9M|    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
_ZN9prevectorILj16EhjiE14const_iteratorC2EPKh:
  109|   366M|        const_iterator(const T* ptr_) : ptr(ptr_) {}
_ZNK9prevectorILj16EhjiE3endEv:
  305|  57.9M|    const_iterator end() const { return const_iterator(item_ptr(size())); }
_ZN9prevectorILj16EhjiEaSERKS0_:
  276|  3.83k|    prevector& operator=(const prevector<N, T, Size, Diff>& other) {
  277|  3.83k|        if (&other == this) {
  ------------------
  |  Branch (277:13): [True: 0, False: 3.83k]
  ------------------
  278|      0|            return *this;
  279|      0|        }
  280|  3.83k|        assign(other.begin(), other.end());
  281|  3.83k|        return *this;
  282|  3.83k|    }
_ZN9prevectorILj16EhjiE6assignITkNSt3__114input_iteratorENS0_14const_iteratorEEEvT_S4_:
  233|  3.83k|    void assign(InputIterator first, InputIterator last) {
  234|  3.83k|        size_type n = last - first;
  235|  3.83k|        clear();
  236|  3.83k|        if (capacity() < n) {
  ------------------
  |  Branch (236:13): [True: 451, False: 3.38k]
  ------------------
  237|    451|            change_capacity(n);
  238|    451|        }
  239|  3.83k|        _size += n;
  240|  3.83k|        fill(item_ptr(0), first, last);
  241|  3.83k|    }
_ZmiN9prevectorILj16EhjiE14const_iteratorES1_:
  118|  18.0M|        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
_ZN9prevectorILj16EhjiE5clearEv:
  355|   265k|    void clear() {
  356|   265k|        resize(0);
  357|   265k|    }
_ZN9prevectorILj16EhjiE6resizeEj:
  328|  6.69M|    void resize(size_type new_size) {
  329|  6.69M|        size_type cur_size = size();
  330|  6.69M|        if (cur_size == new_size) {
  ------------------
  |  Branch (330:13): [True: 4.08M, False: 2.61M]
  ------------------
  331|  4.08M|            return;
  332|  4.08M|        }
  333|  2.61M|        if (cur_size > new_size) {
  ------------------
  |  Branch (333:13): [True: 328k, False: 2.28M]
  ------------------
  334|   328k|            erase(item_ptr(new_size), end());
  335|   328k|            return;
  336|   328k|        }
  337|  2.28M|        if (new_size > capacity()) {
  ------------------
  |  Branch (337:13): [True: 2.28M, False: 0]
  ------------------
  338|  2.28M|            change_capacity(new_size);
  339|  2.28M|        }
  340|  2.28M|        ptrdiff_t increase = new_size - cur_size;
  341|  2.28M|        fill(item_ptr(cur_size), increase);
  342|  2.28M|        _size += increase;
  343|  2.28M|    }
_ZN9prevectorILj16EhjiE5eraseENS0_8iteratorES1_:
  420|   328k|    iterator erase(iterator first, iterator last) {
  421|       |        // Erase is not allowed to the change the object's capacity. That means
  422|       |        // that when starting with an indirectly allocated prevector with
  423|       |        // size and capacity > N, the result may be a still indirectly allocated
  424|       |        // prevector with size <= N and capacity > N. A shrink_to_fit() call is
  425|       |        // necessary to switch to the (more efficient) directly allocated
  426|       |        // representation (with capacity N and size <= N).
  427|   328k|        iterator p = first;
  428|   328k|        char* endp = (char*)&(*end());
  429|   328k|        _size -= last - p;
  430|   328k|        memmove(&(*first), &(*last), endp - ((char*)(&(*last))));
  431|   328k|        return first;
  432|   328k|    }
_ZNK9prevectorILj16EhjiE8iteratordeEv:
   59|  1.97M|        T& operator*() const { return *ptr; }
_ZmiN9prevectorILj16EhjiE8iteratorES1_:
   66|   328k|        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
_ZN9prevectorILj16EhjiE8iteratorC2EPh:
   58|   985k|        iterator(T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj16EhjiE3endEv:
  304|   657k|    iterator end() { return iterator(item_ptr(size())); }
_ZN9prevectorILj16EhjiE4fillEPhlRKh:
  209|  16.8M|    void fill(T* dst, ptrdiff_t count, const T& value = T{}) {
  210|  16.8M|        std::fill_n(dst, count, value);
  211|  16.8M|    }
_ZNK9prevectorILj16EhjiE8capacityEv:
  312|  2.54M|    size_t capacity() const {
  313|  2.54M|        if (is_direct()) {
  ------------------
  |  Branch (313:13): [True: 2.54M, False: 0]
  ------------------
  314|  2.54M|            return N;
  315|  2.54M|        } else {
  316|      0|            return _union.indirect_contents.capacity;
  317|      0|        }
  318|  2.54M|    }
_ZN9prevectorILj16EhjiEC2EOS0_:
  271|  13.2M|        : _union(std::move(other._union)), _size(other._size)
  272|  13.2M|    {
  273|  13.2M|        other._size = 0;
  274|  13.2M|    }
_ZNK9prevectorILj16EhjiEixEj:
  324|  58.3M|    const T& operator[](size_type pos) const {
  325|  58.3M|        return *item_ptr(pos);
  326|  58.3M|    }
_ZNK9prevectorILj16EhjiE4dataEv:
  537|   112M|    const value_type* data() const {
  538|   112M|        return item_ptr(0);
  539|   112M|    }
_ZN9prevectorILj16EhjiE4dataEv:
  533|  6.43M|    value_type* data() {
  534|  6.43M|        return item_ptr(0);
  535|  6.43M|    }
_ZNK9prevectorILj16EhjiE14const_iteratorptEv:
  112|   280M|        const T* operator->() const { return ptr; }
_ZN9prevectorILj16EhjiE6assignEjRKh:
  223|   111k|    void assign(size_type n, const T& val) {
  224|   111k|        clear();
  225|   111k|        if (capacity() < n) {
  ------------------
  |  Branch (225:13): [True: 0, False: 111k]
  ------------------
  226|      0|            change_capacity(n);
  227|      0|        }
  228|   111k|        _size += n;
  229|   111k|        fill(item_ptr(0), n, val);
  230|   111k|    }
_ZNK9prevectorILj16EhjiE5emptyEv:
  298|  2.70M|    bool empty() const {
  299|  2.70M|        return size() == 0;
  300|  2.70M|    }
_ZN9prevectorILj16EhjiEC2EjRKh:
  249|  14.4M|    explicit prevector(size_type n, const T& val) {
  250|  14.4M|        change_capacity(n);
  251|  14.4M|        _size += n;
  252|  14.4M|        fill(item_ptr(0), n, val);
  253|  14.4M|    }
_ZN9prevectorILj16EhjiE6assignITkNSt3__114input_iteratorEPKhEEvT_S5_:
  233|   126k|    void assign(InputIterator first, InputIterator last) {
  234|   126k|        size_type n = last - first;
  235|   126k|        clear();
  236|   126k|        if (capacity() < n) {
  ------------------
  |  Branch (236:13): [True: 0, False: 126k]
  ------------------
  237|      0|            change_capacity(n);
  238|      0|        }
  239|   126k|        _size += n;
  240|   126k|        fill(item_ptr(0), first, last);
  241|   126k|    }
_ZN9prevectorILj16EhjiE4fillITkNSt3__114input_iteratorEPKhEEvPhT_S6_:
  214|   126k|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|  2.14M|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 2.01M, False: 126k]
  ------------------
  216|  2.01M|            new(static_cast<void*>(dst)) T(*first);
  217|  2.01M|            ++dst;
  218|  2.01M|            ++first;
  219|  2.01M|        }
  220|   126k|    }
_ZN9prevectorILj16EhjiE6assignITkNSt3__114input_iteratorEPhEEvT_S4_:
  233|  24.6k|    void assign(InputIterator first, InputIterator last) {
  234|  24.6k|        size_type n = last - first;
  235|  24.6k|        clear();
  236|  24.6k|        if (capacity() < n) {
  ------------------
  |  Branch (236:13): [True: 0, False: 24.6k]
  ------------------
  237|      0|            change_capacity(n);
  238|      0|        }
  239|  24.6k|        _size += n;
  240|  24.6k|        fill(item_ptr(0), first, last);
  241|  24.6k|    }
_ZN9prevectorILj16EhjiE4fillITkNSt3__114input_iteratorEPhEEvS3_T_S4_:
  214|  24.6k|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|   271k|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 246k, False: 24.6k]
  ------------------
  216|   246k|            new(static_cast<void*>(dst)) T(*first);
  217|   246k|            ++dst;
  218|   246k|            ++first;
  219|   246k|        }
  220|  24.6k|    }
_ZNK9prevectorILj16EhjiEeqERKS0_:
  481|  6.19M|    bool operator==(const prevector<N, T, Size, Diff>& other) const {
  482|  6.19M|        if (other.size() != size()) {
  ------------------
  |  Branch (482:13): [True: 0, False: 6.19M]
  ------------------
  483|      0|            return false;
  484|      0|        }
  485|  6.19M|        const_iterator b1 = begin();
  486|  6.19M|        const_iterator b2 = other.begin();
  487|  6.19M|        const_iterator e1 = end();
  488|   104M|        while (b1 != e1) {
  ------------------
  |  Branch (488:16): [True: 99.5M, False: 4.52M]
  ------------------
  489|  99.5M|            if ((*b1) != (*b2)) {
  ------------------
  |  Branch (489:17): [True: 1.66M, False: 97.9M]
  ------------------
  490|  1.66M|                return false;
  491|  1.66M|            }
  492|  97.9M|            ++b1;
  493|  97.9M|            ++b2;
  494|  97.9M|        }
  495|  4.52M|        return true;
  496|  6.19M|    }

_ZN8CAddressC2Ev:
  396|  4.03M|    CAddress() : CService{} {};
_ZN8CAddressC2E8CService12ServiceFlagsNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEE:
  398|  5.47M|    CAddress(CService ipIn, ServiceFlags nServicesIn, NodeSeconds time) : CService{ipIn}, nTime{time}, nServices{nServicesIn} {};
_ZN8CAddress16SerializationOpsI12ParamsStreamIR10DataStreamNS_9SerParamsEES_17ActionUnserializeEEvRT0_RT_T1_:
  414|   119k|    {
  415|   119k|        bool use_v2;
  416|   119k|        auto& params = SER_PARAMS(SerParams);
  ------------------
  |  |  217|   119k|#define SER_PARAMS(type) (s.template GetParams<type>())
  ------------------
  417|   119k|        if (params.fmt == Format::Disk) {
  ------------------
  |  Branch (417:13): [True: 119k, False: 0]
  ------------------
  418|       |            // In the disk serialization format, the encoding (v1 or v2) is determined by a flag version
  419|       |            // that's part of the serialization itself. ADDRV2_FORMAT in the stream version only determines
  420|       |            // whether V2 is chosen/permitted at all.
  421|   119k|            uint32_t stored_format_version = DISK_VERSION_INIT;
  422|   119k|            if (params.enc == Encoding::V2) stored_format_version |= DISK_VERSION_ADDRV2;
  ------------------
  |  Branch (422:17): [True: 107k, False: 11.9k]
  ------------------
  423|   119k|            READWRITE(stored_format_version);
  ------------------
  |  |  156|   119k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  424|   119k|            stored_format_version &= ~DISK_VERSION_IGNORE_MASK; // ignore low bits
  425|   119k|            if (stored_format_version == 0) {
  ------------------
  |  Branch (425:17): [True: 114k, False: 5.22k]
  ------------------
  426|   114k|                use_v2 = false;
  427|   114k|            } else if (stored_format_version == DISK_VERSION_ADDRV2 && params.enc == Encoding::V2) {
  ------------------
  |  Branch (427:24): [True: 5.00k, False: 222]
  |  Branch (427:72): [True: 5.00k, False: 1]
  ------------------
  428|       |                // Only support v2 deserialization if V2 is set.
  429|  5.00k|                use_v2 = true;
  430|  5.00k|            } else {
  431|    223|                throw std::ios_base::failure("Unsupported CAddress disk format version");
  432|    223|            }
  433|   119k|        } else {
  434|      0|            assert(params.fmt == Format::Network);
  435|       |            // In the network serialization format, the encoding (v1 or v2) is determined directly by
  436|       |            // the value of enc in the stream params, as no explicitly encoded version
  437|       |            // exists in the stream.
  438|      0|            use_v2 = params.enc == Encoding::V2;
  439|      0|        }
  440|       |
  441|   119k|        READWRITE(Using<LossyChronoFormatter<uint32_t>>(obj.nTime));
  ------------------
  |  |  156|   119k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  442|       |        // nServices is serialized as CompactSize in V2; as uint64_t in V1.
  443|   119k|        if (use_v2) {
  ------------------
  |  Branch (443:13): [True: 4.99k, False: 114k]
  ------------------
  444|  4.99k|            uint64_t services_tmp;
  445|  4.99k|            SER_WRITE(obj, services_tmp = obj.nServices);
  ------------------
  |  |  158|  4.99k|#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
  ------------------
  446|  4.99k|            READWRITE(Using<CompactSizeFormatter<false>>(services_tmp));
  ------------------
  |  |  156|  4.99k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  447|  4.99k|            SER_READ(obj, obj.nServices = static_cast<ServiceFlags>(services_tmp));
  ------------------
  |  |  157|  4.99k|#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, typename std::remove_const<Type>::type& obj) { code; })
  ------------------
  448|   114k|        } else {
  449|   114k|            READWRITE(Using<CustomUintFormatter<8>>(obj.nServices));
  ------------------
  |  |  156|   114k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  450|   114k|        }
  451|       |        // Invoke V1/V2 serializer for CService parent object.
  452|   119k|        const auto ser_params{use_v2 ? CNetAddr::V2 : CNetAddr::V1};
  ------------------
  |  Branch (452:31): [True: 4.97k, False: 114k]
  ------------------
  453|   119k|        READWRITE(ser_params(AsBase<CService>(obj)));
  ------------------
  |  |  156|   119k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  454|   119k|    }
_ZN8CAddress16SerializationOpsI12ParamsStreamIR10DataStreamNS_9SerParamsEEKS_15ActionSerializeEEvRT0_RT_T1_:
  414|  1.53M|    {
  415|  1.53M|        bool use_v2;
  416|  1.53M|        auto& params = SER_PARAMS(SerParams);
  ------------------
  |  |  217|  1.53M|#define SER_PARAMS(type) (s.template GetParams<type>())
  ------------------
  417|  1.53M|        if (params.fmt == Format::Disk) {
  ------------------
  |  Branch (417:13): [True: 1.53M, False: 0]
  ------------------
  418|       |            // In the disk serialization format, the encoding (v1 or v2) is determined by a flag version
  419|       |            // that's part of the serialization itself. ADDRV2_FORMAT in the stream version only determines
  420|       |            // whether V2 is chosen/permitted at all.
  421|  1.53M|            uint32_t stored_format_version = DISK_VERSION_INIT;
  422|  1.53M|            if (params.enc == Encoding::V2) stored_format_version |= DISK_VERSION_ADDRV2;
  ------------------
  |  Branch (422:17): [True: 1.53M, False: 0]
  ------------------
  423|  1.53M|            READWRITE(stored_format_version);
  ------------------
  |  |  156|  1.53M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  424|  1.53M|            stored_format_version &= ~DISK_VERSION_IGNORE_MASK; // ignore low bits
  425|  1.53M|            if (stored_format_version == 0) {
  ------------------
  |  Branch (425:17): [True: 0, False: 1.53M]
  ------------------
  426|      0|                use_v2 = false;
  427|  1.53M|            } else if (stored_format_version == DISK_VERSION_ADDRV2 && params.enc == Encoding::V2) {
  ------------------
  |  Branch (427:24): [True: 1.53M, False: 0]
  |  Branch (427:72): [True: 1.53M, False: 0]
  ------------------
  428|       |                // Only support v2 deserialization if V2 is set.
  429|  1.53M|                use_v2 = true;
  430|  1.53M|            } else {
  431|      0|                throw std::ios_base::failure("Unsupported CAddress disk format version");
  432|      0|            }
  433|  1.53M|        } else {
  434|      0|            assert(params.fmt == Format::Network);
  435|       |            // In the network serialization format, the encoding (v1 or v2) is determined directly by
  436|       |            // the value of enc in the stream params, as no explicitly encoded version
  437|       |            // exists in the stream.
  438|      0|            use_v2 = params.enc == Encoding::V2;
  439|      0|        }
  440|       |
  441|  1.53M|        READWRITE(Using<LossyChronoFormatter<uint32_t>>(obj.nTime));
  ------------------
  |  |  156|  1.53M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  442|       |        // nServices is serialized as CompactSize in V2; as uint64_t in V1.
  443|  1.53M|        if (use_v2) {
  ------------------
  |  Branch (443:13): [True: 1.53M, False: 0]
  ------------------
  444|  1.53M|            uint64_t services_tmp;
  445|  1.53M|            SER_WRITE(obj, services_tmp = obj.nServices);
  ------------------
  |  |  158|  1.53M|#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
  ------------------
  446|  1.53M|            READWRITE(Using<CompactSizeFormatter<false>>(services_tmp));
  ------------------
  |  |  156|  1.53M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  447|  1.53M|            SER_READ(obj, obj.nServices = static_cast<ServiceFlags>(services_tmp));
  ------------------
  |  |  157|  1.53M|#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, typename std::remove_const<Type>::type& obj) { code; })
  ------------------
  448|  1.53M|        } else {
  449|      0|            READWRITE(Using<CustomUintFormatter<8>>(obj.nServices));
  ------------------
  |  |  156|      0|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  450|      0|        }
  451|       |        // Invoke V1/V2 serializer for CService parent object.
  452|  1.53M|        const auto ser_params{use_v2 ? CNetAddr::V2 : CNetAddr::V1};
  ------------------
  |  Branch (452:31): [True: 1.53M, False: 0]
  ------------------
  453|  1.53M|        READWRITE(ser_params(AsBase<CService>(obj)));
  ------------------
  |  |  156|  1.53M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  454|  1.53M|    }

_Z30MakeRandDeterministicDANGEROUSRK7uint256:
  671|  7.15k|{
  672|  7.15k|    GetRNGState().MakeDeterministic(seed);
  673|  7.15k|}
_Z12GetRandBytes4SpanIhE:
  677|  19.0k|{
  678|  19.0k|    g_used_g_prng = true;
  679|  19.0k|    ProcRand(bytes.data(), bytes.size(), RNGLevel::FAST, /*always_use_real_rng=*/false);
  680|  19.0k|}
_ZN17FastRandomContext10RandomSeedEv:
  695|  19.0k|{
  696|  19.0k|    uint256 seed = GetRandHash();
  697|  19.0k|    rng.SetKey(MakeByteSpan(seed));
  698|  19.0k|    requires_seed = false;
  699|  19.0k|}
_ZN17FastRandomContext6ReseedERK7uint256:
  710|  9.54k|{
  711|  9.54k|    FlushCache();
  712|  9.54k|    requires_seed = false;
  713|  9.54k|    rng = {MakeByteSpan(seed)};
  714|  9.54k|}
_ZN17FastRandomContextC2Eb:
  764|  28.6k|FastRandomContext::FastRandomContext(bool fDeterministic) noexcept : requires_seed(!fDeterministic), rng(ZERO_KEY)
  765|  28.6k|{
  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|  28.6k|}
random.cpp:_ZN12_GLOBAL__N_111GetRNGStateEv:
  526|  26.2k|{
  527|       |    // This idiom relies on the guarantee that static variable are initialized
  528|       |    // on first call, even when multiple parallel calls are permitted.
  529|  26.2k|    static std::vector<RNGState, secure_allocator<RNGState>> g_rng(1);
  530|  26.2k|    return g_rng[0];
  531|  26.2k|}
random.cpp:_ZN12_GLOBAL__N_18RNGState17MakeDeterministicERK7uint256:
  475|  7.15k|    {
  476|  7.15k|        LOCK(m_mutex);
  ------------------
  |  |  257|  7.15k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.15k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.15k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.15k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  477|  7.15k|        m_deterministic_prng.emplace(MakeByteSpan(seed));
  478|  7.15k|    }
random.cpp:_ZN12_GLOBAL__N_18ProcRandEPhiNS_8RNGLevelEb:
  638|  19.0k|{
  639|       |    // Make sure the RNG is initialized first (as all Seed* function possibly need hwrand to be available).
  640|  19.0k|    RNGState& rng = GetRNGState();
  641|       |
  642|  19.0k|    assert(num <= 32);
  643|       |
  644|  19.0k|    CSHA512 hasher;
  645|  19.0k|    switch (level) {
  ------------------
  |  Branch (645:13): [True: 0, False: 19.0k]
  ------------------
  646|  19.0k|    case RNGLevel::FAST:
  ------------------
  |  Branch (646:5): [True: 19.0k, False: 0]
  ------------------
  647|  19.0k|        SeedFast(hasher);
  648|  19.0k|        break;
  649|      0|    case RNGLevel::SLOW:
  ------------------
  |  Branch (649:5): [True: 0, False: 19.0k]
  ------------------
  650|      0|        SeedSlow(hasher, rng);
  651|      0|        break;
  652|      0|    case RNGLevel::PERIODIC:
  ------------------
  |  Branch (652:5): [True: 0, False: 19.0k]
  ------------------
  653|      0|        SeedPeriodic(hasher, rng);
  654|      0|        break;
  655|  19.0k|    }
  656|       |
  657|       |    // Combine with and update state
  658|  19.0k|    if (!rng.MixExtract(out, num, std::move(hasher), false, always_use_real_rng)) {
  ------------------
  |  Branch (658:9): [True: 0, False: 19.0k]
  ------------------
  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|  19.0k|}
random.cpp:_ZN12_GLOBAL__N_18SeedFastER7CSHA512:
  545|  19.0k|{
  546|  19.0k|    unsigned char buffer[32];
  547|       |
  548|       |    // Stack pointer to indirectly commit to thread/callstack
  549|  19.0k|    const unsigned char* ptr = buffer;
  550|  19.0k|    hasher.Write((const unsigned char*)&ptr, sizeof(ptr));
  551|       |
  552|       |    // Hardware randomness is very fast when available; use it always.
  553|  19.0k|    SeedHardwareFast(hasher);
  554|       |
  555|       |    // High-precision timestamp
  556|  19.0k|    SeedTimestamp(hasher);
  557|  19.0k|}
random.cpp:_ZN12_GLOBAL__N_116SeedHardwareFastER7CSHA512:
  259|  19.0k|void SeedHardwareFast(CSHA512& hasher) noexcept {
  260|  19.0k|#if defined(__x86_64__) || defined(__amd64__) || defined(__i386__)
  261|  19.0k|    if (g_rdrand_supported) {
  ------------------
  |  Branch (261:9): [True: 19.0k, False: 0]
  ------------------
  262|  19.0k|        uint64_t out = GetRdRand();
  263|  19.0k|        hasher.Write((const unsigned char*)&out, sizeof(out));
  264|  19.0k|        return;
  265|  19.0k|    }
  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|  19.0k|}
random.cpp:_ZN12_GLOBAL__N_19GetRdRandEv:
  126|  19.0k|{
  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|  19.0k|    uint64_t r1 = 0; // See above why we initialize to 0.
  146|  19.0k|    for (int i = 0; i < 10; ++i) {
  ------------------
  |  Branch (146:21): [True: 19.0k, False: 0]
  ------------------
  147|  19.0k|        __asm__ volatile (".byte 0x48, 0x0f, 0xc7, 0xf0; setc %1" : "=a"(r1), "=q"(ok) :: "cc"); // rdrand %rax
  148|  19.0k|        if (ok) break;
  ------------------
  |  Branch (148:13): [True: 19.0k, False: 0]
  ------------------
  149|  19.0k|    }
  150|  19.0k|    return r1;
  151|       |#else
  152|       |#error "RdRand is only supported on x86 and x86_64"
  153|       |#endif
  154|  19.0k|}
random.cpp:_ZN12_GLOBAL__N_113SeedTimestampER7CSHA512:
  539|  19.0k|{
  540|  19.0k|    int64_t perfcounter = GetPerformanceCounter();
  541|  19.0k|    hasher.Write((const unsigned char*)&perfcounter, sizeof(perfcounter));
  542|  19.0k|}
random.cpp:_ZN12_GLOBAL__N_121GetPerformanceCounterEv:
   65|  19.0k|{
   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|  19.0k|    __asm__ volatile ("rdtsc" : "=a"(r1), "=d"(r2)); // Constrain r1 to rax and r2 to rdx.
   77|  19.0k|    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|  19.0k|}
random.cpp:_ZN12_GLOBAL__N_18RNGState10MixExtractEPhmO7CSHA512bb:
  488|  19.0k|    {
  489|  19.0k|        assert(num <= 32);
  490|  19.0k|        unsigned char buf[64];
  491|  19.0k|        static_assert(sizeof(buf) == CSHA512::OUTPUT_SIZE, "Buffer needs to have hasher's output size");
  492|  19.0k|        bool ret;
  493|  19.0k|        {
  494|  19.0k|            LOCK(m_mutex);
  ------------------
  |  |  257|  19.0k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  19.0k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  19.0k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  19.0k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  495|  19.0k|            ret = (m_strongly_seeded |= strong_seed);
  496|       |            // Write the current state of the RNG into the hasher
  497|  19.0k|            hasher.Write(m_state, 32);
  498|       |            // Write a new counter number into the state
  499|  19.0k|            hasher.Write((const unsigned char*)&m_counter, sizeof(m_counter));
  500|  19.0k|            ++m_counter;
  501|       |            // Finalize the hasher
  502|  19.0k|            hasher.Finalize(buf);
  503|       |            // Store the last 32 bytes of the hash output as new RNG state.
  504|  19.0k|            memcpy(m_state, buf + 32, 32);
  505|       |            // Handle requests for deterministic randomness.
  506|  19.0k|            if (!always_use_real_rng && m_deterministic_prng.has_value()) [[unlikely]] {
  ------------------
  |  Branch (506:17): [True: 19.0k, False: 0]
  |  Branch (506:41): [True: 19.0k, False: 0]
  ------------------
  507|       |                // Overwrite the beginning of buf, which will be used for output.
  508|  19.0k|                m_deterministic_prng->Keystream(AsWritableBytes(Span{buf, num}));
  509|       |                // Do not require strong seeding for deterministic output.
  510|  19.0k|                ret = true;
  511|  19.0k|            }
  512|  19.0k|        }
  513|       |        // If desired, copy (up to) the first 32 bytes of the hash output as output.
  514|  19.0k|        if (num) {
  ------------------
  |  Branch (514:13): [True: 19.0k, False: 0]
  ------------------
  515|  19.0k|            assert(out != nullptr);
  516|  19.0k|            memcpy(out, buf, num);
  517|  19.0k|        }
  518|       |        // Best effort cleanup of internal state
  519|  19.0k|        hasher.Reset();
  520|  19.0k|        memory_cleanse(buf, 64);
  521|  19.0k|        return ret;
  522|  19.0k|    }

_ZN11RandomMixinI17FastRandomContextE9randrangeITkNSt3__18integralEiEET_S4_:
  255|  10.6M|    {
  256|  10.6M|        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max());
  257|  10.6M|        Assume(range > 0);
  ------------------
  |  |   97|  10.6M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  258|  10.6M|        uint64_t maxval = range - 1U;
  259|  10.6M|        int bits = std::bit_width(maxval);
  260|  10.6M|        while (true) {
  ------------------
  |  Branch (260:16): [Folded - Ignored]
  ------------------
  261|  10.6M|            uint64_t ret = Impl().randbits(bits);
  262|  10.6M|            if (ret <= maxval) return ret;
  ------------------
  |  Branch (262:17): [True: 10.6M, False: 0]
  ------------------
  263|  10.6M|        }
  264|  10.6M|    }
_ZN11RandomMixinI17FastRandomContextE4ImplEv:
  185|  14.5M|    RandomNumberGenerator auto& Impl() noexcept { return static_cast<T&>(*this); }
_ZN11RandomMixinI17FastRandomContextE8randbitsEi:
  205|  12.9M|    {
  206|  12.9M|        Assume(bits <= 64);
  ------------------
  |  |   97|  12.9M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  207|       |        // Requests for the full 64 bits are passed through.
  208|  12.9M|        if (bits == 64) return Impl().rand64();
  ------------------
  |  Branch (208:13): [True: 0, False: 12.9M]
  ------------------
  209|  12.9M|        uint64_t ret;
  210|  12.9M|        if (bits <= bitbuf_size) {
  ------------------
  |  Branch (210:13): [True: 11.3M, False: 1.59M]
  ------------------
  211|       |            // If there is enough entropy left in bitbuf, return its bottom bits bits.
  212|  11.3M|            ret = bitbuf;
  213|  11.3M|            bitbuf >>= bits;
  214|  11.3M|            bitbuf_size -= bits;
  215|  11.3M|        } 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.59M|            uint64_t gen = Impl().rand64();
  220|  1.59M|            ret = (gen << bitbuf_size) | bitbuf;
  221|  1.59M|            bitbuf = gen >> (bits - bitbuf_size);
  222|  1.59M|            bitbuf_size = 64 + bitbuf_size - bits;
  223|  1.59M|        }
  224|       |        // Return the bottom bits bits of ret.
  225|  12.9M|        return ret & ((uint64_t{1} << bits) - 1);
  226|  12.9M|    }
_ZN17FastRandomContext6rand64Ev:
  396|  1.61M|    {
  397|  1.61M|        if (requires_seed) RandomSeed();
  ------------------
  |  Branch (397:13): [True: 19.0k, False: 1.59M]
  ------------------
  398|  1.61M|        std::array<std::byte, 8> buf;
  399|  1.61M|        rng.Keystream(buf);
  400|  1.61M|        return ReadLE64(buf.data());
  401|  1.61M|    }
_Z11GetRandHashv:
  455|  19.0k|{
  456|  19.0k|    uint256 hash;
  457|  19.0k|    GetRandBytes(hash);
  458|  19.0k|    return hash;
  459|  19.0k|}
_ZN11RandomMixinI17FastRandomContextE8randboolEv:
  316|    913|    bool randbool() noexcept { return Impl().template randbits<1>(); }
_ZN11RandomMixinI17FastRandomContextE8randbitsILi1EEEmv:
  231|    913|    {
  232|    913|        static_assert(Bits >= 0 && Bits <= 64);
  233|       |        if constexpr (Bits == 64) {
  234|       |            return Impl().rand64();
  235|    913|        } else {
  236|    913|            uint64_t ret;
  237|    913|            if (Bits <= bitbuf_size) {
  ------------------
  |  Branch (237:17): [True: 899, False: 14]
  ------------------
  238|    899|                ret = bitbuf;
  239|    899|                bitbuf >>= Bits;
  240|    899|                bitbuf_size -= Bits;
  241|    899|            } else {
  242|     14|                uint64_t gen = Impl().rand64();
  243|     14|                ret = (gen << bitbuf_size) | bitbuf;
  244|     14|                bitbuf = gen >> (Bits - bitbuf_size);
  245|     14|                bitbuf_size = 64 + bitbuf_size - Bits;
  246|     14|            }
  247|    913|            constexpr uint64_t MASK = (uint64_t{1} << Bits) - 1;
  248|    913|            return ret & MASK;
  249|    913|        }
  250|    913|    }
_ZN11RandomMixinI17FastRandomContextE9randrangeITkNSt3__18integralEmEET_S4_:
  255|  1.62M|    {
  256|  1.62M|        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max());
  257|  1.62M|        Assume(range > 0);
  ------------------
  |  |   97|  1.62M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  258|  1.62M|        uint64_t maxval = range - 1U;
  259|  1.62M|        int bits = std::bit_width(maxval);
  260|  2.28M|        while (true) {
  ------------------
  |  Branch (260:16): [Folded - Ignored]
  ------------------
  261|  2.28M|            uint64_t ret = Impl().randbits(bits);
  262|  2.28M|            if (ret <= maxval) return ret;
  ------------------
  |  Branch (262:17): [True: 1.62M, False: 659k]
  ------------------
  263|  2.28M|        }
  264|  1.62M|    }
_ZN11RandomMixinI17FastRandomContextEC2Ev:
  195|  28.6k|    constexpr RandomMixin() noexcept = default;
_ZN11RandomMixinI17FastRandomContextE10FlushCacheEv:
  189|  9.54k|    {
  190|  9.54k|        bitbuf = 0;
  191|  9.54k|        bitbuf_size = 0;
  192|  9.54k|    }
_ZN11RandomMixinI17FastRandomContextE8randbitsILi30EEEmv:
  231|  10.5k|    {
  232|  10.5k|        static_assert(Bits >= 0 && Bits <= 64);
  233|       |        if constexpr (Bits == 64) {
  234|       |            return Impl().rand64();
  235|  10.5k|        } else {
  236|  10.5k|            uint64_t ret;
  237|  10.5k|            if (Bits <= bitbuf_size) {
  ------------------
  |  Branch (237:17): [True: 5.68k, False: 4.86k]
  ------------------
  238|  5.68k|                ret = bitbuf;
  239|  5.68k|                bitbuf >>= Bits;
  240|  5.68k|                bitbuf_size -= Bits;
  241|  5.68k|            } else {
  242|  4.86k|                uint64_t gen = Impl().rand64();
  243|  4.86k|                ret = (gen << bitbuf_size) | bitbuf;
  244|  4.86k|                bitbuf = gen >> (Bits - bitbuf_size);
  245|  4.86k|                bitbuf_size = 64 + bitbuf_size - Bits;
  246|  4.86k|            }
  247|  10.5k|            constexpr uint64_t MASK = (uint64_t{1} << Bits) - 1;
  248|  10.5k|            return ret & MASK;
  249|  10.5k|        }
  250|  10.5k|    }

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

_Z11UnserializeI10DataStreamR20AddrManDeterministicQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|  2.89k|{
  763|  2.89k|    a.Unserialize(is);
  764|  2.89k|}
_Z9SerializeI10DataStream7AddrManQ12SerializableIT0_T_EEvRS3_RKS2_:
  753|  7.15k|{
  754|  7.15k|    a.Serialize(os);
  755|  7.15k|}
_Z9SerializeI10DataStreamEvRT_h:
  258|  6.43M|template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
_Z14ser_writedata8I10DataStreamEvRT_h:
   55|  12.8M|{
   56|  12.8M|    s.write(AsBytes(Span{&obj, 1}));
   57|  12.8M|}
_Z9SerializeI10DataStreamhNSt3__19allocatorIhEEEvRT_RKNS1_6vectorIT0_T1_EE:
  846|  6.43M|{
  847|  6.43M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|  6.43M|        WriteCompactSize(os, v.size());
  849|  6.43M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (849:13): [True: 6.43M, False: 0]
  ------------------
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|       |    } else {
  859|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|       |    }
  861|  6.43M|}
_Z16WriteCompactSizeI10DataStreamEvRT_m:
  309|  6.43M|{
  310|  6.43M|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 6.43M, False: 0]
  ------------------
  311|  6.43M|    {
  312|  6.43M|        ser_writedata8(os, nSize);
  313|  6.43M|    }
  314|      0|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 0, False: 0]
  ------------------
  315|      0|    {
  316|      0|        ser_writedata8(os, 253);
  317|      0|        ser_writedata16(os, nSize);
  318|      0|    }
  319|      0|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 0, False: 0]
  ------------------
  320|      0|    {
  321|      0|        ser_writedata8(os, 254);
  322|      0|        ser_writedata32(os, nSize);
  323|      0|    }
  324|      0|    else
  325|      0|    {
  326|      0|        ser_writedata8(os, 255);
  327|      0|        ser_writedata64(os, nSize);
  328|      0|    }
  329|  6.43M|    return;
  330|  6.43M|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEC2ES1_RKS3_:
 1127|  6.44M|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER8AddrInfoQ14UnserializableIT0_T_EEvRS9_OS8_:
  762|   119k|{
  763|   119k|    a.Unserialize(is);
  764|   119k|}
_ZN8AddrInfo11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  228|   119k|    {                                                                                               \
  229|   119k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   119k|        Unser(s, *this);                                                                            \
  231|   119k|    }
_ZN8AddrInfo5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_RS_:
  180|   119k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJRS4_R8CNetAddr7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNSE_8durationIxNSD_5ratioILl1ELl1EEEEEEEERiEEEvRT_DpOT0_:
 1033|   119k|    {
 1034|   119k|        ::UnserializeMany(s, args...);
 1035|   119k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJRS3_R8CNetAddrR7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNSD_8durationIxNSC_5ratioILl1ELl1EEEEEEEERiEEvRT_DpOT0_:
 1001|   119k|{
 1002|   119k|    (::Unserialize(s, args), ...);
 1003|   119k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERS3_Q14UnserializableIT0_T_EEvRS8_OS7_:
  762|   119k|{
  763|   119k|    a.Unserialize(is);
  764|   119k|}
_ZN8CAddress11UnserializeI12ParamsStreamIR10DataStreamNS_9SerParamsEEEEvRT_:
  228|   119k|    {                                                                                               \
  229|   119k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   119k|        Unser(s, *this);                                                                            \
  231|   119k|    }
_ZN8CAddress5UnserI12ParamsStreamIR10DataStreamNS_9SerParamsEEEEvRT_RS_:
  180|   119k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZNK12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE9GetParamsIS3_EERKDav:
 1144|  1.65M|    {
 1145|  1.65M|        if constexpr (std::is_convertible_v<Params, P>) {
 1146|  1.65M|            return m_params;
 1147|       |        } else {
 1148|       |            return m_substream.template GetParams<P>();
 1149|       |        }
 1150|  1.65M|    }
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJRjEEEvRT_DpOT0_:
 1033|   119k|    {
 1034|   119k|        ::UnserializeMany(s, args...);
 1035|   119k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJRjEEvRT_DpOT0_:
 1001|   119k|{
 1002|   119k|    (::Unserialize(s, args), ...);
 1003|   119k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_Rj:
  277|   239k|template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); }
_Z14ser_readdata32I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEjRT_:
  102|  1.08M|{
  103|  1.08M|    uint32_t obj;
  104|  1.08M|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|  1.08M|    return le32toh_internal(obj);
  106|  1.08M|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE4readE4SpanISt4byteE:
 1136|  20.8M|    void read(Span<std::byte> dst) { GetStream().read(dst); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE9GetStreamEv:
 1154|  48.5M|    {
 1155|       |        if constexpr (ContainsStream<SubStream>) {
 1156|       |            return m_substream.GetStream();
 1157|  48.5M|        } else {
 1158|  48.5M|            return m_substream;
 1159|  48.5M|        }
 1160|  48.5M|    }
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNSB_8durationIxNSA_5ratioILl1ELl1EEEEEEEEEEEvRT_DpOT0_:
 1033|   119k|    {
 1034|   119k|        ::UnserializeMany(s, args...);
 1035|   119k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJR7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEEEvRT_DpOT0_:
 1001|   119k|{
 1002|   119k|    (::Unserialize(s, args), ...);
 1003|   119k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEQ14UnserializableIT0_T_EEvRSM_OSL_:
  762|   119k|{
  763|   119k|    a.Unserialize(is);
  764|   119k|}
_ZN7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  483|   119k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15ChronoFormatterIjLb1EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEENSt3__16chrono10time_pointI9NodeClockNS9_8durationIxNS8_5ratioILl1ELl1EEEEEEEEEvRT_RT0_:
  591|   119k|    {
  592|   119k|        U u;
  593|   119k|        s >> u;
  594|       |        // Lossy deserialization does not make sense, so force Wnarrowing
  595|   119k|        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
  596|   119k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRjEERS4_OT_:
 1134|   119k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
deserialize.cpp:_ZL5UsingI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE7WrapperIT_RT0_EOSE_:
  497|   119k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEEC2ESB_:
  481|   119k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN17ActionUnserialize8SerWriteI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERS4_ZNS4_16SerializationOpsIS6_S4_S_EEvRT0_RT_T1_EUlRS6_RKS4_E_EEvSC_OS9_OSD_:
 1045|  4.99k|    {
 1046|  4.99k|    }
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI20CompactSizeFormatterILb0EERmEEEEvRT_DpOT0_:
 1033|  4.99k|    {
 1034|  4.99k|        ::UnserializeMany(s, args...);
 1035|  4.99k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJR7WrapperI20CompactSizeFormatterILb0EERmEEEvRT_DpOT0_:
 1001|  4.99k|{
 1002|  4.99k|    (::Unserialize(s, args), ...);
 1003|  4.99k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI20CompactSizeFormatterILb0EERmEQ14UnserializableIT0_T_EEvRSD_OSC_:
  762|  4.99k|{
  763|  4.99k|    a.Unserialize(is);
  764|  4.99k|}
_ZN7WrapperI20CompactSizeFormatterILb0EERmE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  483|  4.99k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN20CompactSizeFormatterILb0EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEmEEvRT_RT0_:
  569|  4.99k|    {
  570|  4.99k|        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
  571|  4.99k|        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (571:13): [True: 23, False: 4.97k]
  |  Branch (571:50): [True: 0, False: 4.97k]
  ------------------
  572|      0|            throw std::ios_base::failure("CompactSize exceeds limit of type");
  573|      0|        }
  574|  4.99k|        v = n;
  575|  4.99k|    }
_Z15ReadCompactSizeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEmRT_b:
  340|  6.54M|{
  341|  6.54M|    uint8_t chSize = ser_readdata8(is);
  342|  6.54M|    uint64_t nSizeRet = 0;
  343|  6.54M|    if (chSize < 253)
  ------------------
  |  Branch (343:9): [True: 6.54M, False: 1.53k]
  ------------------
  344|  6.54M|    {
  345|  6.54M|        nSizeRet = chSize;
  346|  6.54M|    }
  347|  1.53k|    else if (chSize == 253)
  ------------------
  |  Branch (347:14): [True: 28, False: 1.50k]
  ------------------
  348|     28|    {
  349|     28|        nSizeRet = ser_readdata16(is);
  350|     28|        if (nSizeRet < 253)
  ------------------
  |  Branch (350:13): [True: 5, False: 23]
  ------------------
  351|      5|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|     28|    }
  353|  1.50k|    else if (chSize == 254)
  ------------------
  |  Branch (353:14): [True: 1.31k, False: 189]
  ------------------
  354|  1.31k|    {
  355|  1.31k|        nSizeRet = ser_readdata32(is);
  356|  1.31k|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (356:13): [True: 13, False: 1.30k]
  ------------------
  357|     13|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|  1.31k|    }
  359|    189|    else
  360|    189|    {
  361|    189|        nSizeRet = ser_readdata64(is);
  362|    189|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (362:13): [True: 30, False: 159]
  ------------------
  363|     30|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  364|    189|    }
  365|  6.54M|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (365:9): [True: 6.53M, False: 4.98k]
  |  Branch (365:24): [True: 75, False: 6.53M]
  ------------------
  366|     75|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  367|     75|    }
  368|  6.54M|    return nSizeRet;
  369|  6.54M|}
_Z13ser_readdata8I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEhRT_:
   84|  13.0M|{
   85|  13.0M|    uint8_t obj;
   86|  13.0M|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|  13.0M|    return obj;
   88|  13.0M|}
_Z14ser_readdata16I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEtRT_:
   90|     28|{
   91|     28|    uint16_t obj;
   92|     28|    s.read(AsWritableBytes(Span{&obj, 1}));
   93|     28|    return le16toh_internal(obj);
   94|     28|}
_Z14ser_readdata64I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEmRT_:
  114|   119k|{
  115|   119k|    uint64_t obj;
  116|   119k|    s.read(AsWritableBytes(Span{&obj, 1}));
  117|   119k|    return le64toh_internal(obj);
  118|   119k|}
deserialize.cpp:_ZL5UsingI20CompactSizeFormatterILb0EERmE7WrapperIT_RT0_EOS5_:
  497|  1.54M|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI20CompactSizeFormatterILb0EERmEC2ES2_:
  481|  1.54M|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN17ActionUnserialize7SerReadI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERS4_ZNS4_16SerializationOpsIS6_S4_S_EEvRT0_RT_T1_EUlRS6_S7_E_EEvSC_OS9_OSD_:
 1039|  4.97k|    {
 1040|  4.97k|        fn(s, std::forward<Type>(obj));
 1041|  4.97k|    }
_ZZN8CAddress16SerializationOpsI12ParamsStreamIR10DataStreamNS_9SerParamsEES_17ActionUnserializeEEvRT0_RT_T1_ENKUlRS5_RS_E_clESC_SD_:
  157|  4.97k|#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, typename std::remove_const<Type>::type& obj) { code; })
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsEEEEvRT_DpOT0_:
 1033|   114k|    {
 1034|   114k|        ::UnserializeMany(s, args...);
 1035|   114k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJR7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsEEEvRT_DpOT0_:
 1001|   114k|{
 1002|   114k|    (::Unserialize(s, args), ...);
 1003|   114k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsEQ14UnserializableIT0_T_EEvRSE_OSD_:
  762|   114k|{
  763|   114k|    a.Unserialize(is);
  764|   114k|}
_ZN7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  483|   114k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN19CustomUintFormatterILi8ELb0EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE12ServiceFlagsEEvRT_RT0_:
  547|   114k|    {
  548|   114k|        using U = typename std::conditional<std::is_enum<I>::value, std::underlying_type<I>, std::common_type<I>>::type::type;
  549|   114k|        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
  550|   114k|        uint64_t raw = 0;
  551|   114k|        if (BigEndian) {
  ------------------
  |  Branch (551:13): [Folded - Ignored]
  ------------------
  552|      0|            s.read(AsWritableBytes(Span{&raw, 1}).last(Bytes));
  553|      0|            v = static_cast<I>(be64toh_internal(raw));
  554|   114k|        } else {
  555|   114k|            s.read(AsWritableBytes(Span{&raw, 1}).first(Bytes));
  556|   114k|            v = static_cast<I>(le64toh_internal(raw));
  557|   114k|        }
  558|   114k|    }
deserialize.cpp:_ZL5UsingI19CustomUintFormatterILi8ELb0EER12ServiceFlagsE7WrapperIT_RT0_EOS6_:
  497|   114k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsEC2ES3_:
  481|   114k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceEEEEvRT_DpOT0_:
 1033|   119k|    {
 1034|   119k|        ::UnserializeMany(s, args...);
 1035|   119k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJR13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceEEEvRT_DpOT0_:
 1001|   119k|{
 1002|   119k|    (::Unserialize(s, args), ...);
 1003|   119k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceEQ14UnserializableIT0_T_EEvRSD_OSC_:
  762|   119k|{
  763|   119k|    a.Unserialize(is);
  764|   119k|}
_ZN13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
 1205|   119k|    {
 1206|   119k|        ParamsStream ss{s, m_params};
 1207|   119k|        ::Unserialize(ss, m_object);
 1208|   119k|    }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEC2ES5_RKS7_:
 1127|  1.65M|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEER8CServiceQ14UnserializableIT0_T_EEvRSD_OSC_:
  762|   119k|{
  763|   119k|    a.Unserialize(is);
  764|   119k|}
_ZN8CService11UnserializeI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  228|   119k|    {                                                                                               \
  229|   119k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   119k|        Unser(s, *this);                                                                            \
  231|   119k|    }
_ZN8CService5UnserI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_RS_:
  180|   119k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEJRS8_7WrapperI19CustomUintFormatterILi2ELb1EERtEEEEvRT_DpOT0_:
 1033|   119k|    {
 1034|   119k|        ::UnserializeMany(s, args...);
 1035|   119k|    }
_Z15UnserializeManyI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEJRS7_R7WrapperI19CustomUintFormatterILi2ELb1EERtEEEvRT_DpOT0_:
 1001|   119k|{
 1002|   119k|    (::Unserialize(s, args), ...);
 1003|   119k|}
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEERS7_Q14UnserializableIT0_T_EEvRSC_OSB_:
  762|   119k|{
  763|   119k|    a.Unserialize(is);
  764|   119k|}
_ZNK12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE9GetParamsIS7_EERKDav:
 1144|  1.65M|    {
 1145|  1.65M|        if constexpr (std::is_convertible_v<Params, P>) {
 1146|  1.65M|            return m_params;
 1147|       |        } else {
 1148|       |            return m_substream.template GetParams<P>();
 1149|       |        }
 1150|  1.65M|    }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEErsIRhEERS8_OT_:
 1134|  4.97k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEvRT_Rh:
  273|  4.97k|template<typename Stream> inline void Unserialize(Stream& s, uint8_t& a ) { a = ser_readdata8(s); }
_Z13ser_readdata8I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEhRT_:
   84|  9.92k|{
   85|  9.92k|    uint8_t obj;
   86|  9.92k|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|  9.92k|    return obj;
   88|  9.92k|}
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE4readE4SpanISt4byteE:
 1136|   245k|    void read(Span<std::byte> dst) { GetStream().read(dst); }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE9GetStreamEv:
 1154|  6.40M|    {
 1155|  6.40M|        if constexpr (ContainsStream<SubStream>) {
 1156|  6.40M|            return m_substream.GetStream();
 1157|       |        } else {
 1158|       |            return m_substream;
 1159|       |        }
 1160|  6.40M|    }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEErsI7WrapperI20CompactSizeFormatterILb1EERmEEERS8_OT_:
 1134|  4.95k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEER7WrapperI20CompactSizeFormatterILb1EERmEQ14UnserializableIT0_T_EEvRSH_OSG_:
  762|  4.95k|{
  763|  4.95k|    a.Unserialize(is);
  764|  4.95k|}
_ZN7WrapperI20CompactSizeFormatterILb1EERmE11UnserializeI12ParamsStreamIRS5_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  483|  4.95k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN20CompactSizeFormatterILb1EE5UnserI12ParamsStreamIRS2_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEmEEvRT_RT0_:
  569|  4.95k|    {
  570|  4.95k|        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
  571|  4.95k|        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (571:13): [True: 115, False: 4.83k]
  |  Branch (571:50): [True: 0, False: 4.83k]
  ------------------
  572|      0|            throw std::ios_base::failure("CompactSize exceeds limit of type");
  573|      0|        }
  574|  4.95k|        v = n;
  575|  4.95k|    }
_Z15ReadCompactSizeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEmRT_b:
  340|  4.95k|{
  341|  4.95k|    uint8_t chSize = ser_readdata8(is);
  342|  4.95k|    uint64_t nSizeRet = 0;
  343|  4.95k|    if (chSize < 253)
  ------------------
  |  Branch (343:9): [True: 4.79k, False: 160]
  ------------------
  344|  4.79k|    {
  345|  4.79k|        nSizeRet = chSize;
  346|  4.79k|    }
  347|    160|    else if (chSize == 253)
  ------------------
  |  Branch (347:14): [True: 29, False: 131]
  ------------------
  348|     29|    {
  349|     29|        nSizeRet = ser_readdata16(is);
  350|     29|        if (nSizeRet < 253)
  ------------------
  |  Branch (350:13): [True: 3, False: 26]
  ------------------
  351|      3|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|     29|    }
  353|    131|    else if (chSize == 254)
  ------------------
  |  Branch (353:14): [True: 38, False: 93]
  ------------------
  354|     38|    {
  355|     38|        nSizeRet = ser_readdata32(is);
  356|     38|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (356:13): [True: 6, False: 32]
  ------------------
  357|      6|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|     38|    }
  359|     93|    else
  360|     93|    {
  361|     93|        nSizeRet = ser_readdata64(is);
  362|     93|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (362:13): [True: 9, False: 84]
  ------------------
  363|      9|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  364|     93|    }
  365|  4.93k|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (365:9): [True: 4.91k, False: 20]
  |  Branch (365:24): [True: 77, False: 4.83k]
  ------------------
  366|     77|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  367|     77|    }
  368|  4.85k|    return nSizeRet;
  369|  4.93k|}
_Z14ser_readdata16I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEtRT_:
   90|     29|{
   91|     29|    uint16_t obj;
   92|     29|    s.read(AsWritableBytes(Span{&obj, 1}));
   93|     29|    return le16toh_internal(obj);
   94|     29|}
_Z14ser_readdata32I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEjRT_:
  102|     38|{
  103|     38|    uint32_t obj;
  104|     38|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|     38|    return le32toh_internal(obj);
  106|     38|}
_Z14ser_readdata64I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEmRT_:
  114|     79|{
  115|     79|    uint64_t obj;
  116|     79|    s.read(AsWritableBytes(Span{&obj, 1}));
  117|     79|    return le64toh_internal(obj);
  118|     79|}
deserialize.cpp:_ZL5UsingI20CompactSizeFormatterILb1EERmE7WrapperIT_RT0_EOS5_:
  497|  6.54M|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI20CompactSizeFormatterILb1EERmEC2ES2_:
  481|  6.54M|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEErsI4SpanIhEEERS8_OT_:
 1134|  1.97k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEETk9BasicBytehEvRT_4SpanIT0_E:
  283|  1.97k|template <typename Stream, BasicByte B> void Unserialize(Stream& s, Span<B> span) { s.read(AsWritableBytes(span)); }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE6ignoreEm:
 1137|  2.82k|    void ignore(size_t num) { GetStream().ignore(num); }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEErsIRA16_hEERS8_OT_:
 1134|   114k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEETk9BasicBytehLi16EEvRT_RAT1__T0_:
  280|   114k|template <typename Stream, BasicByte B, int N> void Unserialize(Stream& s, B (&a)[N]) { s.read(MakeWritableByteSpan(a)); }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEER7WrapperI19CustomUintFormatterILi2ELb1EERtEQ14UnserializableIT0_T_EEvRSH_OSG_:
  762|   119k|{
  763|   119k|    a.Unserialize(is);
  764|   119k|}
_ZN7WrapperI19CustomUintFormatterILi2ELb1EERtE11UnserializeI12ParamsStreamIRS5_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  483|   119k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN19CustomUintFormatterILi2ELb1EE5UnserI12ParamsStreamIRS2_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEtEEvRT_RT0_:
  547|   119k|    {
  548|   119k|        using U = typename std::conditional<std::is_enum<I>::value, std::underlying_type<I>, std::common_type<I>>::type::type;
  549|   119k|        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
  550|   119k|        uint64_t raw = 0;
  551|   119k|        if (BigEndian) {
  ------------------
  |  Branch (551:13): [Folded - Ignored]
  ------------------
  552|   119k|            s.read(AsWritableBytes(Span{&raw, 1}).last(Bytes));
  553|   119k|            v = static_cast<I>(be64toh_internal(raw));
  554|   119k|        } else {
  555|      0|            s.read(AsWritableBytes(Span{&raw, 1}).first(Bytes));
  556|      0|            v = static_cast<I>(le64toh_internal(raw));
  557|      0|        }
  558|   119k|    }
_Z6AsBaseI8CNetAddr8CServiceERT_RT0_:
  145|   119k|{
  146|   119k|    static_assert(std::is_base_of_v<Out, In>);
  147|   119k|    return x;
  148|   119k|}
deserialize.cpp:_ZL5UsingI19CustomUintFormatterILi2ELb1EERtE7WrapperIT_RT0_EOS5_:
  497|   119k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI19CustomUintFormatterILi2ELb1EERtEC2ES2_:
  481|   119k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZNK8CNetAddr9SerParamsclIR8CServiceEEDaOT_:
 1228|   119k|    {                                                                                    \
 1229|   119k|        return ParamsWrapper{*this, t};                                                  \
 1230|   119k|    }
_ZN13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceEC2ERKS1_RS2_:
 1195|   119k|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_Z6AsBaseI8CService8CAddressERT_RT0_:
  145|   119k|{
  146|   119k|    static_assert(std::is_base_of_v<Out, In>);
  147|   119k|    return x;
  148|   119k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER8CNetAddrQ14UnserializableIT0_T_EEvRS9_OS8_:
  762|  6.54M|{
  763|  6.54M|    a.Unserialize(is);
  764|  6.54M|}
_ZNK12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE9GetParamsIN8CNetAddr9SerParamsEEERKDav:
 1144|  8.08M|    {
 1145|  8.08M|        if constexpr (std::is_convertible_v<Params, P>) {
 1146|  8.08M|            return m_params;
 1147|       |        } else {
 1148|       |            return m_substream.template GetParams<P>();
 1149|       |        }
 1150|  8.08M|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRhEERS4_OT_:
 1134|  6.54M|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_Rh:
  273|  6.54M|template<typename Stream> inline void Unserialize(Stream& s, uint8_t& a ) { a = ser_readdata8(s); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsI7WrapperI20CompactSizeFormatterILb1EERmEEERS4_OT_:
 1134|  6.53M|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI20CompactSizeFormatterILb1EERmEQ14UnserializableIT0_T_EEvRSD_OSC_:
  762|  6.53M|{
  763|  6.53M|    a.Unserialize(is);
  764|  6.53M|}
_ZN7WrapperI20CompactSizeFormatterILb1EERmE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  483|  6.53M|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN20CompactSizeFormatterILb1EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEmEEvRT_RT0_:
  569|  6.53M|    {
  570|  6.53M|        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
  571|  6.53M|        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (571:13): [True: 106, False: 6.53M]
  |  Branch (571:50): [True: 0, False: 6.53M]
  ------------------
  572|      0|            throw std::ios_base::failure("CompactSize exceeds limit of type");
  573|      0|        }
  574|  6.53M|        v = n;
  575|  6.53M|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsI4SpanIhEEERS4_OT_:
 1134|  6.43M|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEETk9BasicBytehEvRT_4SpanIT0_E:
  283|  6.43M|template <typename Stream, BasicByte B> void Unserialize(Stream& s, Span<B> span) { s.read(AsWritableBytes(span)); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE6ignoreEm:
 1137|   106k|    void ignore(size_t num) { GetStream().ignore(num); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRA16_hEERS4_OT_:
 1134|  11.9k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEETk9BasicBytehLi16EEvRT_RAT1__T0_:
  280|  11.9k|template <typename Stream, BasicByte B, int N> void Unserialize(Stream& s, B (&a)[N]) { s.read(MakeWritableByteSpan(a)); }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEQ14UnserializableIT0_T_EEvRSM_OSL_:
  762|   118k|{
  763|   118k|    a.Unserialize(is);
  764|   118k|}
_ZN7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  483|   118k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15ChronoFormatterIlLb0EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEENSt3__16chrono10time_pointI9NodeClockNS9_8durationIxNS8_5ratioILl1ELl1EEEEEEEEEvRT_RT0_:
  591|   118k|    {
  592|   118k|        U u;
  593|   118k|        s >> u;
  594|       |        // Lossy deserialization does not make sense, so force Wnarrowing
  595|   118k|        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
  596|   118k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRlEERS4_OT_:
 1134|   118k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_Rl:
  278|   118k|template<typename Stream> inline void Unserialize(Stream& s, int64_t& a ) { a = ser_readdata64(s); }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_Ri:
  276|   844k|template<typename Stream> inline void Unserialize(Stream& s, int32_t& a ) { a = ser_readdata32(s); }
_Z6AsBaseI8CAddress8AddrInfoERT_RT0_:
  145|   119k|{
  146|   119k|    static_assert(std::is_base_of_v<Out, In>);
  147|   119k|    return x;
  148|   119k|}
_ZN7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEEC2ESB_:
  481|   119k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN7WrapperI20CompactSizeFormatterILb1EERKmEC2ES3_:
  481|   376k|    explicit Wrapper(T obj) : m_object(obj) {}
_Z6AsBaseI8CNetAddr8CServiceERKT_RKT0_:
  151|  1.53M|{
  152|  1.53M|    static_assert(std::is_base_of_v<Out, In>);
  153|  1.53M|    return x;
  154|  1.53M|}
deserialize.cpp:_ZL5UsingI19CustomUintFormatterILi2ELb1EERKtE7WrapperIT_RT0_EOS6_:
  497|  1.53M|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI19CustomUintFormatterILi2ELb1EERKtEC2ES3_:
  481|  1.53M|    explicit Wrapper(T obj) : m_object(obj) {}
_ZNK8CNetAddr9SerParamsclIRK8CServiceEEDaOT_:
 1228|  1.53M|    {                                                                                    \
 1229|  1.53M|        return ParamsWrapper{*this, t};                                                  \
 1230|  1.53M|    }
_ZN13ParamsWrapperIN8CNetAddr9SerParamsEK8CServiceEC2ERKS1_RS3_:
 1195|  1.53M|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEES3_Q12SerializableIT0_T_EEvRS7_RKS6_:
  753|  1.53M|{
  754|  1.53M|    a.Serialize(os);
  755|  1.53M|}
_ZNK8CAddress9SerializeI12ParamsStreamIR10DataStreamNS_9SerParamsEEEEvRT_:
  222|  1.53M|    {                                                                                               \
  223|  1.53M|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  1.53M|        Ser(s, *this);                                                                              \
  225|  1.53M|    }                                                                                               \
_ZN8CAddress3SerI12ParamsStreamIR10DataStreamNS_9SerParamsEEEEvRT_RKS_:
  178|  1.53M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJjEEEvRT_DpRKT0_:
 1013|  1.53M|    {
 1014|  1.53M|        ::SerializeMany(s, args...);
 1015|  1.53M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJjEEvRT_DpRKT0_:
  995|  1.53M|{
  996|  1.53M|    (::Serialize(s, args), ...);
  997|  1.53M|}
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_j:
  262|  3.07M|template<typename Stream> inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); }
_Z15ser_writedata32I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_j:
   69|  13.4M|{
   70|  13.4M|    obj = htole32_internal(obj);
   71|  13.4M|    s.write(AsBytes(Span{&obj, 1}));
   72|  13.4M|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE5writeE4SpanIKSt4byteE:
 1135|  21.2M|    void write(Span<const std::byte> src) { GetStream().write(src); }
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI15ChronoFormatterIjLb1EERKNSt3__16chrono10time_pointI9NodeClockNSB_8durationIxNSA_5ratioILl1ELl1EEEEEEEEEEEvRT_DpRKT0_:
 1013|  1.53M|    {
 1014|  1.53M|        ::SerializeMany(s, args...);
 1015|  1.53M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI15ChronoFormatterIjLb1EERKNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEEEvRT_DpRKT0_:
  995|  1.53M|{
  996|  1.53M|    (::Serialize(s, args), ...);
  997|  1.53M|}
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE7WrapperI15ChronoFormatterIjLb1EERKNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEQ12SerializableIT0_T_EEvRSM_RKSL_:
  753|  1.53M|{
  754|  1.53M|    a.Serialize(os);
  755|  1.53M|}
_ZNK7WrapperI15ChronoFormatterIjLb1EERKNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  482|  1.53M|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15ChronoFormatterIjLb1EE3SerI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEENSt3__16chrono10time_pointI9NodeClockNS9_8durationIxNS8_5ratioILl1ELl1EEEEEEEEEvRT_T0_:
  599|  1.53M|    {
  600|  1.53M|        if constexpr (LOSSY) {
  601|  1.53M|            s << U(tp.time_since_epoch().count());
  602|       |        } else {
  603|       |            s << U{tp.time_since_epoch().count()};
  604|       |        }
  605|  1.53M|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsIjEERS4_RKT_:
 1133|  1.53M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
deserialize.cpp:_ZL5UsingI15ChronoFormatterIjLb1EERKNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE7WrapperIT_RT0_EOSF_:
  497|  1.53M|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15ChronoFormatterIjLb1EERKNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEEC2ESC_:
  481|  1.53M|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN15ActionSerialize8SerWriteI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERKS4_ZNS4_16SerializationOpsIS6_S7_S_EEvRT0_RT_T1_EUlRS6_S8_E_EEvSD_OSA_OSE_:
 1024|  1.53M|    {
 1025|  1.53M|        fn(s, std::forward<Type>(obj));
 1026|  1.53M|    }
_ZZN8CAddress16SerializationOpsI12ParamsStreamIR10DataStreamNS_9SerParamsEEKS_15ActionSerializeEEvRT0_RT_T1_ENKUlRS5_RS6_E_clESD_SE_:
  158|  1.53M|#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI20CompactSizeFormatterILb0EERmEEEEvRT_DpRKT0_:
 1013|  1.53M|    {
 1014|  1.53M|        ::SerializeMany(s, args...);
 1015|  1.53M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI20CompactSizeFormatterILb0EERmEEEvRT_DpRKT0_:
  995|  1.53M|{
  996|  1.53M|    (::Serialize(s, args), ...);
  997|  1.53M|}
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE7WrapperI20CompactSizeFormatterILb0EERmEQ12SerializableIT0_T_EEvRSC_RKSB_:
  753|  1.53M|{
  754|  1.53M|    a.Serialize(os);
  755|  1.53M|}
_ZNK7WrapperI20CompactSizeFormatterILb0EERmE9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  482|  1.53M|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN20CompactSizeFormatterILb0EE3SerI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEmEEvRT_T0_:
  579|  1.53M|    {
  580|  1.53M|        static_assert(std::is_unsigned<I>::value, "CompactSize only supported for unsigned integers");
  581|  1.53M|        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(), "CompactSize only supports 64-bit integers and below");
  582|       |
  583|  1.53M|        WriteCompactSize<Stream>(s, v);
  584|  1.53M|    }
_Z16WriteCompactSizeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_m:
  309|  3.07M|{
  310|  3.07M|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 3.05M, False: 27.3k]
  ------------------
  311|  3.05M|    {
  312|  3.05M|        ser_writedata8(os, nSize);
  313|  3.05M|    }
  314|  27.3k|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 5.98k, False: 21.3k]
  ------------------
  315|  5.98k|    {
  316|  5.98k|        ser_writedata8(os, 253);
  317|  5.98k|        ser_writedata16(os, nSize);
  318|  5.98k|    }
  319|  21.3k|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 500, False: 20.8k]
  ------------------
  320|    500|    {
  321|    500|        ser_writedata8(os, 254);
  322|    500|        ser_writedata32(os, nSize);
  323|    500|    }
  324|  20.8k|    else
  325|  20.8k|    {
  326|  20.8k|        ser_writedata8(os, 255);
  327|  20.8k|        ser_writedata64(os, nSize);
  328|  20.8k|    }
  329|  3.07M|    return;
  330|  3.07M|}
_Z14ser_writedata8I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_h:
   55|  4.63M|{
   56|  4.63M|    s.write(AsBytes(Span{&obj, 1}));
   57|  4.63M|}
_Z15ser_writedata16I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_t:
   59|  5.98k|{
   60|  5.98k|    obj = htole16_internal(obj);
   61|  5.98k|    s.write(AsBytes(Span{&obj, 1}));
   62|  5.98k|}
_Z15ser_writedata64I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_m:
   79|  1.55M|{
   80|  1.55M|    obj = htole64_internal(obj);
   81|  1.55M|    s.write(AsBytes(Span{&obj, 1}));
   82|  1.55M|}
_ZN15ActionSerialize7SerReadI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERKS4_ZNS4_16SerializationOpsIS6_S7_S_EEvRT0_RT_T1_EUlRS6_RS4_E_EEvSD_OSA_OSE_:
 1019|  1.53M|    {
 1020|  1.53M|    }
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ13ParamsWrapperIN8CNetAddr9SerParamsEK8CServiceEEEEvRT_DpRKT0_:
 1013|  1.53M|    {
 1014|  1.53M|        ::SerializeMany(s, args...);
 1015|  1.53M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ13ParamsWrapperIN8CNetAddr9SerParamsEK8CServiceEEEvRT_DpRKT0_:
  995|  1.53M|{
  996|  1.53M|    (::Serialize(s, args), ...);
  997|  1.53M|}
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE13ParamsWrapperIN8CNetAddr9SerParamsEK8CServiceEQ12SerializableIT0_T_EEvRSD_RKSC_:
  753|  1.53M|{
  754|  1.53M|    a.Serialize(os);
  755|  1.53M|}
_ZNK13ParamsWrapperIN8CNetAddr9SerParamsEK8CServiceE9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
 1199|  1.53M|    {
 1200|  1.53M|        ParamsStream ss{s, m_params};
 1201|  1.53M|        ::Serialize(ss, m_object);
 1202|  1.53M|    }
_Z9SerializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE8CServiceQ12SerializableIT0_T_EEvRSC_RKSB_:
  753|  1.53M|{
  754|  1.53M|    a.Serialize(os);
  755|  1.53M|}
_ZNK8CService9SerializeI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  222|  1.53M|    {                                                                                               \
  223|  1.53M|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  1.53M|        Ser(s, *this);                                                                              \
  225|  1.53M|    }                                                                                               \
_ZN8CService3SerI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_RKS_:
  178|  1.53M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEJS8_7WrapperI19CustomUintFormatterILi2ELb1EERKtEEEEvRT_DpRKT0_:
 1013|  1.53M|    {
 1014|  1.53M|        ::SerializeMany(s, args...);
 1015|  1.53M|    }
_Z13SerializeManyI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEJS7_7WrapperI19CustomUintFormatterILi2ELb1EERKtEEEvRT_DpRKT0_:
  995|  1.53M|{
  996|  1.53M|    (::Serialize(s, args), ...);
  997|  1.53M|}
_Z9SerializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEES7_Q12SerializableIT0_T_EEvRSB_RKSA_:
  753|  1.53M|{
  754|  1.53M|    a.Serialize(os);
  755|  1.53M|}
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEElsIhEERS8_RKT_:
 1133|  1.53M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEvRT_h:
  258|  1.53M|template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
_Z14ser_writedata8I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEvRT_h:
   55|  3.07M|{
   56|  3.07M|    s.write(AsBytes(Span{&obj, 1}));
   57|  3.07M|}
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE5writeE4SpanIKSt4byteE:
 1135|  6.15M|    void write(Span<const std::byte> src) { GetStream().write(src); }
_Z16WriteCompactSizeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEvRT_m:
  309|  1.53M|{
  310|  1.53M|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 1.53M, False: 0]
  ------------------
  311|  1.53M|    {
  312|  1.53M|        ser_writedata8(os, nSize);
  313|  1.53M|    }
  314|      0|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 0, False: 0]
  ------------------
  315|      0|    {
  316|      0|        ser_writedata8(os, 253);
  317|      0|        ser_writedata16(os, nSize);
  318|      0|    }
  319|      0|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 0, False: 0]
  ------------------
  320|      0|    {
  321|      0|        ser_writedata8(os, 254);
  322|      0|        ser_writedata32(os, nSize);
  323|      0|    }
  324|      0|    else
  325|      0|    {
  326|      0|        ser_writedata8(os, 255);
  327|      0|        ser_writedata64(os, nSize);
  328|      0|    }
  329|  1.53M|    return;
  330|  1.53M|}
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEElsI9prevectorILj16EhjiEEERS8_RKT_:
 1133|  1.53M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEELj16EhEvRT_RK9prevectorIXT0_ET1_jiE:
  811|  1.53M|{
  812|  1.53M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  813|  1.53M|        WriteCompactSize(os, v.size());
  814|  1.53M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (814:13): [True: 1.53M, False: 0]
  ------------------
  815|       |    } else {
  816|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  817|       |    }
  818|  1.53M|}
_Z9SerializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE7WrapperI19CustomUintFormatterILi2ELb1EERKtEQ12SerializableIT0_T_EEvRSH_RKSG_:
  753|  1.53M|{
  754|  1.53M|    a.Serialize(os);
  755|  1.53M|}
_ZNK7WrapperI19CustomUintFormatterILi2ELb1EERKtE9SerializeI12ParamsStreamIRS6_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  482|  1.53M|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN19CustomUintFormatterILi2ELb1EE3SerI12ParamsStreamIRS2_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEtEEvRT_T0_:
  535|  1.53M|    {
  536|  1.53M|        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
  ------------------
  |  Branch (536:13): [True: 0, False: 1.53M]
  |  Branch (536:22): [True: 0, False: 1.53M]
  ------------------
  537|  1.53M|        if (BigEndian) {
  ------------------
  |  Branch (537:13): [Folded - Ignored]
  ------------------
  538|  1.53M|            uint64_t raw = htobe64_internal(v);
  539|  1.53M|            s.write(AsBytes(Span{&raw, 1}).last(Bytes));
  540|  1.53M|        } else {
  541|      0|            uint64_t raw = htole64_internal(v);
  542|      0|            s.write(AsBytes(Span{&raw, 1}).first(Bytes));
  543|      0|        }
  544|  1.53M|    }
_Z6AsBaseI8CService8CAddressERKT_RKT0_:
  151|  1.53M|{
  152|  1.53M|    static_assert(std::is_base_of_v<Out, In>);
  153|  1.53M|    return x;
  154|  1.53M|}
_Z15ser_writedata32I10HashWriterEvRT_j:
   69|  21.0M|{
   70|  21.0M|    obj = htole32_internal(obj);
   71|  21.0M|    s.write(AsBytes(Span{&obj, 1}));
   72|  21.0M|}
_ZNK8CAddress9SerParamsclIR8CNetAddrEEDaOT_:
 1228|  6.43M|    {                                                                                    \
 1229|  6.43M|        return ParamsWrapper{*this, t};                                                  \
 1230|  6.43M|    }
_ZN13ParamsWrapperIN8CAddress9SerParamsE8CNetAddrEC2ERKS1_RS2_:
 1195|  6.43M|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_Z11UnserializeI10DataStreamR13ParamsWrapperIN8CAddress9SerParamsE8CNetAddrEQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|  6.43M|{
  763|  6.43M|    a.Unserialize(is);
  764|  6.43M|}
_ZN13ParamsWrapperIN8CAddress9SerParamsE8CNetAddrE11UnserializeI10DataStreamEEvRT_:
 1205|  6.43M|    {
 1206|  6.43M|        ParamsStream ss{s, m_params};
 1207|  6.43M|        ::Unserialize(ss, m_object);
 1208|  6.43M|    }
_Z16WriteCompactSizeI10HashWriterEvRT_m:
  309|  35.0M|{
  310|  35.0M|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 35.0M, False: 68]
  ------------------
  311|  35.0M|    {
  312|  35.0M|        ser_writedata8(os, nSize);
  313|  35.0M|    }
  314|     68|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 68, False: 0]
  ------------------
  315|     68|    {
  316|     68|        ser_writedata8(os, 253);
  317|     68|        ser_writedata16(os, nSize);
  318|     68|    }
  319|      0|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 0, False: 0]
  ------------------
  320|      0|    {
  321|      0|        ser_writedata8(os, 254);
  322|      0|        ser_writedata32(os, nSize);
  323|      0|    }
  324|      0|    else
  325|      0|    {
  326|      0|        ser_writedata8(os, 255);
  327|      0|        ser_writedata64(os, nSize);
  328|      0|    }
  329|  35.0M|    return;
  330|  35.0M|}
_Z14ser_writedata8I10HashWriterEvRT_h:
   55|  56.3M|{
   56|  56.3M|    s.write(AsBytes(Span{&obj, 1}));
   57|  56.3M|}
_Z15ser_writedata16I10HashWriterEvRT_t:
   59|     68|{
   60|     68|    obj = htole16_internal(obj);
   61|     68|    s.write(AsBytes(Span{&obj, 1}));
   62|     68|}
_Z15ser_writedata64I10HashWriterEvRT_m:
   79|  4.86M|{
   80|  4.86M|    obj = htole64_internal(obj);
   81|  4.86M|    s.write(AsBytes(Span{&obj, 1}));
   82|  4.86M|}
_Z9SerializeI10HashWriterhNSt3__19allocatorIhEEEvRT_RKNS1_6vectorIT0_T1_EE:
  846|  35.0M|{
  847|  35.0M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|  35.0M|        WriteCompactSize(os, v.size());
  849|  35.0M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (849:13): [True: 35.0M, False: 0]
  ------------------
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|       |    } else {
  859|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|       |    }
  861|  35.0M|}
_Z9SerializeI10HashWriter7uint256Q12SerializableIT0_T_EEvRS3_RKS2_:
  753|  30.8M|{
  754|  30.8M|    a.Serialize(os);
  755|  30.8M|}
_Z9SerializeI10HashWriterTk9BasicByteKhEvRT_4SpanIT0_E:
  268|  30.8M|template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
_Z9SerializeI10HashWriterEvRT_m:
  264|  4.86M|template<typename Stream> inline void Serialize(Stream& s, uint64_t a) { ser_writedata64(s, a); }
_Z9SerializeI10HashWriterEvRT_h:
  258|  21.0M|template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
_Z9SerializeI10HashWriterEvRT_i:
  261|  21.0M|template<typename Stream> inline void Serialize(Stream& s, int32_t a ) { ser_writedata32(s, a); }
addrman.cpp:_ZL5UsingI20CompactSizeFormatterILb1EERKmE7WrapperIT_RT0_EOS6_:
  497|   376k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z6AsBaseI8CAddress8AddrInfoERKT_RKT0_:
  151|  1.53M|{
  152|  1.53M|    static_assert(std::is_base_of_v<Out, In>);
  153|  1.53M|    return x;
  154|  1.53M|}
addrman.cpp:_ZL5UsingI15ChronoFormatterIlLb0EERKNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE7WrapperIT_RT0_EOSF_:
  497|  1.53M|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15ChronoFormatterIlLb0EERKNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEEC2ESC_:
  481|  1.53M|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsIhEERS4_RKT_:
 1133|  1.55M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_h:
  258|  1.55M|template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsI7uint256EERS4_RKT_:
 1133|  14.3k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE7uint256Q12SerializableIT0_T_EEvRS8_RKS7_:
  753|  14.3k|{
  754|  14.3k|    a.Serialize(os);
  755|  14.3k|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsI4SpanIKhEEERS4_RKT_:
 1133|  14.3k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEETk9BasicByteKhEvRT_4SpanIT0_E:
  268|  14.3k|template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsIiEERS4_RKT_:
 1133|  8.84M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_i:
  261|  10.3M|template<typename Stream> inline void Serialize(Stream& s, int32_t a ) { ser_writedata32(s, a); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsI8AddrInfoEERS4_RKT_:
 1133|  1.53M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE8AddrInfoQ12SerializableIT0_T_EEvRS8_RKS7_:
  753|  1.53M|{
  754|  1.53M|    a.Serialize(os);
  755|  1.53M|}
_ZNK8AddrInfo9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  222|  1.53M|    {                                                                                               \
  223|  1.53M|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  1.53M|        Ser(s, *this);                                                                              \
  225|  1.53M|    }                                                                                               \
_ZN8AddrInfo3SerI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_RKS_:
  178|  1.53M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJS4_8CNetAddr7WrapperI15ChronoFormatterIlLb0EERKNSt3__16chrono10time_pointI9NodeClockNSC_8durationIxNSB_5ratioILl1ELl1EEEEEEEEiEEEvRT_DpRKT0_:
 1013|  1.53M|    {
 1014|  1.53M|        ::SerializeMany(s, args...);
 1015|  1.53M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJS3_8CNetAddr7WrapperI15ChronoFormatterIlLb0EERKNSt3__16chrono10time_pointI9NodeClockNSB_8durationIxNSA_5ratioILl1ELl1EEEEEEEEiEEvRT_DpRKT0_:
  995|  1.53M|{
  996|  1.53M|    (::Serialize(s, args), ...);
  997|  1.53M|}
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE8CNetAddrQ12SerializableIT0_T_EEvRS8_RKS7_:
  753|  1.53M|{
  754|  1.53M|    a.Serialize(os);
  755|  1.53M|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsI7WrapperI20CompactSizeFormatterILb1EERKmEEERS4_RKT_:
 1133|   376k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE7WrapperI20CompactSizeFormatterILb1EERKmEQ12SerializableIT0_T_EEvRSD_RKSC_:
  753|   376k|{
  754|   376k|    a.Serialize(os);
  755|   376k|}
_ZNK7WrapperI20CompactSizeFormatterILb1EERKmE9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  482|   376k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN20CompactSizeFormatterILb1EE3SerI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEmEEvRT_T0_:
  579|   376k|    {
  580|   376k|        static_assert(std::is_unsigned<I>::value, "CompactSize only supported for unsigned integers");
  581|   376k|        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(), "CompactSize only supports 64-bit integers and below");
  582|       |
  583|   376k|        WriteCompactSize<Stream>(s, v);
  584|   376k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsI9prevectorILj16EhjiEEERS4_RKT_:
 1133|  1.16M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEELj16EhEvRT_RK9prevectorIXT0_ET1_jiE:
  811|  1.16M|{
  812|  1.16M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  813|  1.16M|        WriteCompactSize(os, v.size());
  814|  1.16M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (814:13): [True: 1.16M, False: 0]
  ------------------
  815|       |    } else {
  816|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  817|       |    }
  818|  1.16M|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsIA16_hEERS4_RKT_:
 1133|   376k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEETk9BasicBytehLi16EEvRT_RAT1__KT0_:
  265|   376k|template <typename Stream, BasicByte B, int N> void Serialize(Stream& s, const B (&a)[N]) { s.write(MakeByteSpan(a)); }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE7WrapperI15ChronoFormatterIlLb0EERKNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEQ12SerializableIT0_T_EEvRSM_RKSL_:
  753|  1.53M|{
  754|  1.53M|    a.Serialize(os);
  755|  1.53M|}
_ZNK7WrapperI15ChronoFormatterIlLb0EERKNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  482|  1.53M|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15ChronoFormatterIlLb0EE3SerI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEENSt3__16chrono10time_pointI9NodeClockNS9_8durationIxNS8_5ratioILl1ELl1EEEEEEEEEvRT_T0_:
  599|  1.53M|    {
  600|       |        if constexpr (LOSSY) {
  601|       |            s << U(tp.time_since_epoch().count());
  602|  1.53M|        } else {
  603|  1.53M|            s << U{tp.time_since_epoch().count()};
  604|  1.53M|        }
  605|  1.53M|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsIlEERS4_RKT_:
 1133|  1.53M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_l:
  263|  1.53M|template<typename Stream> inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); }
addrman.cpp:_ZL5UsingI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEE7WrapperIT_RT0_EOS7_:
  497|  2.89k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEEC2ES4_:
  481|  2.89k|    explicit Wrapper(T obj) : m_object(obj) {}
addrman.cpp:_ZL5UsingI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE7WrapperIT_RT0_EOSE_:
  497|   119k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z11UnserializeI10DataStreamR7WrapperI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEEQ14UnserializableIT0_T_EEvRSA_OS9_:
  762|  2.89k|{
  763|  2.89k|    a.Unserialize(is);
  764|  2.89k|}
_ZN7WrapperI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEE11UnserializeI10DataStreamEEvRT_:
  483|  2.89k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN19CustomUintFormatterILi1ELb0EE5UnserI10DataStreamN11AddrManImpl6FormatEEEvRT_RT0_:
  547|  2.89k|    {
  548|  2.89k|        using U = typename std::conditional<std::is_enum<I>::value, std::underlying_type<I>, std::common_type<I>>::type::type;
  549|  2.89k|        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
  550|  2.89k|        uint64_t raw = 0;
  551|  2.89k|        if (BigEndian) {
  ------------------
  |  Branch (551:13): [Folded - Ignored]
  ------------------
  552|      0|            s.read(AsWritableBytes(Span{&raw, 1}).last(Bytes));
  553|      0|            v = static_cast<I>(be64toh_internal(raw));
  554|  2.89k|        } else {
  555|  2.89k|            s.read(AsWritableBytes(Span{&raw, 1}).first(Bytes));
  556|  2.89k|            v = static_cast<I>(le64toh_internal(raw));
  557|  2.89k|        }
  558|  2.89k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIR7uint256EERS4_OT_:
 1134|  1.94k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7uint256Q14UnserializableIT0_T_EEvRS9_OS8_:
  762|  1.94k|{
  763|  1.94k|    a.Unserialize(is);
  764|  1.94k|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRiEERS4_OT_:
 1134|   726k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIR8AddrInfoEERS4_OT_:
 1134|   119k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z9SerializeI10HashWriterbNSt3__19allocatorIbEEEvRT_RKNS1_6vectorIT0_T1_EE:
  846|  2.28k|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|  2.28k|    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|  2.28k|        WriteCompactSize(os, v.size());
  855|   149k|        for (bool elem : v) {
  ------------------
  |  Branch (855:24): [True: 149k, False: 2.28k]
  ------------------
  856|   149k|            ::Serialize(os, elem);
  857|   149k|        }
  858|       |    } else {
  859|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|       |    }
  861|  2.28k|}
_Z9SerializeI10HashWriterEvRT_b:
  285|   149k|template <typename Stream> inline void Serialize(Stream& s, bool a) { uint8_t f = a; ser_writedata8(s, f); }

_Z9UCharCastPKSt4byte:
  287|   148M|inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast<const unsigned char*>(c); }
_ZNK4SpanIKSt4byteE4lastEm:
  211|  1.53M|    {
  212|  1.53M|         ASSERT_IF_DEBUG(size() >= count);
  213|  1.53M|         return Span<C>(m_data + m_size - count, count);
  214|  1.53M|    }
_ZNK4SpanISt4byteE4lastEm:
  211|   119k|    {
  212|   119k|         ASSERT_IF_DEBUG(size() >= count);
  213|   119k|         return Span<C>(m_data + m_size - count, count);
  214|   119k|    }
_ZNK4SpanISt4byteE5firstEm:
  206|   117k|    {
  207|   117k|        ASSERT_IF_DEBUG(size() >= count);
  208|   117k|        return Span<C>(m_data, count);
  209|   117k|    }
_ZNK4SpanIKSt4byteE4sizeEv:
  187|   148M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKSt4byteE4dataEv:
  174|   148M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4sizeEv:
  187|   268M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKhE5beginEv:
  175|   519k|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKhE3endEv:
  176|   141k|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIhE4sizeEv:
  187|  19.0k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIhE4dataEv:
  174|  96.6M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4dataEv:
  174|  75.4M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE7subspanEmm:
  201|    554|    {
  202|    554|        ASSERT_IF_DEBUG(size() >= offset + count);
  203|    554|        return Span<C>(m_data + offset, count);
  204|    554|    }
_ZNK4SpanISt4byteE4sizeEv:
  187|  70.5M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanISt4byteE4dataEv:
  174|  21.3M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE7subspanEm:
  196|   254M|    {
  197|   254M|        ASSERT_IF_DEBUG(size() >= offset);
  198|   254M|        return Span<C>(m_data + offset, m_size - offset);
  199|   254M|    }
_ZNK4SpanIKSt4byteE5beginEv:
  175|  46.6M|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKSt4byteE3endEv:
  176|  46.6M|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanISt4byteE7subspanEm:
  196|  1.40M|    {
  197|  1.40M|        ASSERT_IF_DEBUG(size() >= offset);
  198|  1.40M|        return Span<C>(m_data + offset, m_size - offset);
  199|  1.40M|    }
_ZNK4SpanIKhE10size_bytesEv:
  188|  75.4M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIKhE4SpanIKSt4byteES1_IT_E:
  259|  75.4M|{
  260|  75.4M|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  75.4M|}
_Z12MakeByteSpanIRKNSt3__16vectorIhNS0_9allocatorIhEEEEE4SpanIKSt4byteEOT_:
  270|  41.5M|{
  271|  41.5M|    return AsBytes(Span{std::forward<V>(v)});
  272|  41.5M|}
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalISA_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISA_EE4sizeEEmEE5valueEDnE4typeE:
  172|  41.5M|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m:
  119|   196M|    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|  1.61M|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIjE4dataEv:
  174|  35.6M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIjE10size_bytesEv:
  188|  35.6M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIjE4SpanIKSt4byteES0_IT_E:
  259|  34.5M|{
  260|  34.5M|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  34.5M|}
_ZNK4SpanIhE10size_bytesEv:
  188|  96.5M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIhE4SpanIKSt4byteES0_IT_E:
  259|  76.9M|{
  260|  76.9M|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  76.9M|}
_ZNK4SpanItE4dataEv:
  174|  6.11k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanItE10size_bytesEv:
  188|  6.11k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesItE4SpanIKSt4byteES0_IT_E:
  259|  6.05k|{
  260|  6.05k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  6.05k|}
_ZNK4SpanImE4dataEv:
  174|  8.31M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanImE10size_bytesEv:
  188|  8.31M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesImE4SpanIKSt4byteES0_IT_E:
  259|  7.96M|{
  260|  7.96M|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  7.96M|}
_ZN4SpanIKhEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|   254M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  22.7M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E:
  264|  19.6M|{
  265|  19.6M|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  19.6M|}
_ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m:
  119|  90.0M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesItE4SpanISt4byteES0_IT_E:
  264|     57|{
  265|     57|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|     57|}
_ZN4SpanItEC2ItTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_tEE5valueEiE4typeELi0EEEPS4_m:
  119|  6.11k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIjE4SpanISt4byteES0_IT_E:
  264|  1.08M|{
  265|  1.08M|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  1.08M|}
_ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m:
  119|  35.6M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesImE4SpanISt4byteES0_IT_E:
  264|   355k|{
  265|   355k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|   355k|}
_ZN4SpanImEC2ImTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_mEE5valueEiE4typeELi0EEEPS4_m:
  119|  8.31M|    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|  28.6k|        : 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|  30.8M|        : m_data(other.data()), m_size(other.size()){}
_Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEE4SpanISt4byteEOT_:
  275|  1.94k|{
  276|  1.94k|    return AsWritableBytes(Span{std::forward<V>(v)});
  277|  1.94k|}
_ZN4SpanIhEC2INSt3__15arrayIhLm32EEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  165|  1.94k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2I7uint256EERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS7_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  172|  16.7k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIhEC2I7uint256EERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS3_EE5valuesr3std14is_convertibleIPA_NS5_14remove_pointerIDTcldtclsr3stdE7declvalIS4_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS4_EE4sizeEEmEE5valueEDnE4typeE:
  165|  38.1k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIhEC2I9prevectorILj16EhjiEEERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS6_14remove_pointerIDTcldtclsr3stdE7declvalIS5_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS5_EE4sizeEEmEE5valueEDnE4typeE:
  165|  6.43M|        : m_data(other.data()), m_size(other.size()){}
_Z20MakeWritableByteSpanIRA16_hE4SpanISt4byteEOT_:
  275|   126k|{
  276|   126k|    return AsWritableBytes(Span{std::forward<V>(v)});
  277|   126k|}
_ZN4SpanIhEC2ILi16EEERAT__h:
  151|   126k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZN4SpanIKhEC2ILi16EEERAT__S0_:
  151|   502k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_Z12MakeByteSpanIRK9prevectorILj16EhjiEE4SpanIKSt4byteEOT_:
  270|  2.70M|{
  271|  2.70M|    return AsBytes(Span{std::forward<V>(v)});
  272|  2.70M|}
_ZN4SpanIKhEC2I9prevectorILj16EhjiEEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS8_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  172|  15.3M|        : m_data(other.data()), m_size(other.size()){}
_Z12MakeByteSpanIRA16_KhE4SpanIKSt4byteEOT_:
  270|   376k|{
  271|   376k|    return AsBytes(Span{std::forward<V>(v)});
  272|   376k|}
_ZN4SpanIKhEC2ILi32EEERAT__S0_:
  151|  7.15k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZNK4SpanISt4byteE5beginEv:
  175|  1.63M|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKhE4lastEm:
  211|  1.28k|    {
  212|  1.28k|         ASSERT_IF_DEBUG(size() >= count);
  213|  1.28k|         return Span<C>(m_data + m_size - count, count);
  214|  1.28k|    }
_Z12MakeByteSpanIRK7uint256E4SpanIKSt4byteEOT_:
  270|  16.7k|{
  271|  16.7k|    return AsBytes(Span{std::forward<V>(v)});
  272|  16.7k|}
_Z12MakeByteSpanIR7uint256E4SpanIKSt4byteEOT_:
  270|  19.0k|{
  271|  19.0k|    return AsBytes(Span{std::forward<V>(v)});
  272|  19.0k|}
_ZNK4SpanISt4byteE5emptyEv:
  189|  3.26M|    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|   230k|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIKhE5frontEv:
  178|   254M|    {
  179|   254M|        ASSERT_IF_DEBUG(size() > 0);
  180|   254M|        return m_data[0];
  181|   254M|    }

_ZN10DataStreamC2E4SpanIKhE:
  165|  2.89k|    explicit DataStream(Span<const uint8_t> sp) : DataStream{AsBytes(sp)} {}
_ZN10DataStreamC2E4SpanIKSt4byteE:
  166|  2.89k|    explicit DataStream(Span<const value_type> sp) : vch(sp.data(), sp.data() + sp.size()) {}
_ZN10DataStream4readE4SpanISt4byteE:
  219|  21.0M|    {
  220|  21.0M|        if (dst.size() == 0) return;
  ------------------
  |  Branch (220:13): [True: 0, False: 21.0M]
  ------------------
  221|       |
  222|       |        // Read from the beginning of the buffer
  223|  21.0M|        auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
  224|  21.0M|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (224:13): [True: 0, False: 21.0M]
  |  Branch (224:43): [True: 866, False: 21.0M]
  ------------------
  225|    866|            throw std::ios_base::failure("DataStream::read(): end of data");
  226|    866|        }
  227|  21.0M|        memcpy(dst.data(), &vch[m_read_pos], dst.size());
  228|  21.0M|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (228:13): [True: 6.43M, False: 14.6M]
  ------------------
  229|  6.43M|            m_read_pos = 0;
  230|  6.43M|            vch.clear();
  231|  6.43M|            return;
  232|  6.43M|        }
  233|  14.6M|        m_read_pos = next_read_pos.value();
  234|  14.6M|    }
_ZN10DataStream6ignoreEm:
  237|   109k|    {
  238|       |        // Ignore from the beginning of the buffer
  239|   109k|        auto next_read_pos{CheckedAdd(m_read_pos, num_ignore)};
  240|   109k|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (240:13): [True: 0, False: 109k]
  |  Branch (240:43): [True: 54, False: 109k]
  ------------------
  241|     54|            throw std::ios_base::failure("DataStream::ignore(): end of data");
  242|     54|        }
  243|   109k|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (243:13): [True: 12, False: 109k]
  ------------------
  244|     12|            m_read_pos = 0;
  245|     12|            vch.clear();
  246|     12|            return;
  247|     12|        }
  248|   109k|        m_read_pos = next_read_pos.value();
  249|   109k|    }
_ZN10DataStream5writeE4SpanIKSt4byteE:
  252|  46.6M|    {
  253|       |        // Write to the end of the buffer
  254|  46.6M|        vch.insert(vch.end(), src.begin(), src.end());
  255|  46.6M|    }
_ZN10DataStreamC2Ev:
  164|  6.43M|    explicit DataStream() = default;
_ZN10DataStreamrsIR20AddrManDeterministicEERS_OT_:
  266|  2.89k|    {
  267|  2.89k|        ::Unserialize(*this, obj);
  268|  2.89k|        return (*this);
  269|  2.89k|    }
_ZN10DataStreamlsI7AddrManEERS_RKT_:
  259|  7.15k|    {
  260|  7.15k|        ::Serialize(*this, obj);
  261|  7.15k|        return (*this);
  262|  7.15k|    }
_ZN10DataStreamlsIhEERS_RKT_:
  259|  6.43M|    {
  260|  6.43M|        ::Serialize(*this, obj);
  261|  6.43M|        return (*this);
  262|  6.43M|    }
_ZN10DataStreamlsINSt3__16vectorIhNS1_9allocatorIhEEEEEERS_RKT_:
  259|  6.43M|    {
  260|  6.43M|        ::Serialize(*this, obj);
  261|  6.43M|        return (*this);
  262|  6.43M|    }
_ZN10DataStreamrsI13ParamsWrapperIN8CAddress9SerParamsE8CNetAddrEEERS_OT_:
  266|  6.43M|    {
  267|  6.43M|        ::Unserialize(*this, obj);
  268|  6.43M|        return (*this);
  269|  6.43M|    }
_ZN10DataStreamrsI7WrapperI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEEEERS_OT_:
  266|  2.89k|    {
  267|  2.89k|        ::Unserialize(*this, obj);
  268|  2.89k|        return (*this);
  269|  2.89k|    }

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

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

_Z17MaybeCheckNotHeldR14AnnotatedMixinINSt3__15mutexEE:
  247|  1.31M|inline Mutex& MaybeCheckNotHeld(Mutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; }
_ZZN20AddrManDeterministicC1ERK15NetGroupManagerR18FuzzedDataProvideriENKUlvE_clEv:
  301|  9.54k|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
  ------------------
  |  |  257|  9.54k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  9.54k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  9.54k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  9.54k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEEC2ERS3_PKcS7_ib:
  177|  1.30M|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  178|  1.30M|    {
  179|  1.30M|        if (fTry)
  ------------------
  |  Branch (179:13): [True: 0, False: 1.30M]
  ------------------
  180|      0|            TryEnter(pszName, pszFile, nLine);
  181|  1.30M|        else
  182|  1.30M|            Enter(pszName, pszFile, nLine);
  183|  1.30M|    }
_Z13EnterCriticalINSt3__15mutexEEvPKcS3_iPT_b:
   75|  1.30M|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_Z13LeaveCriticalv:
   76|  1.31M|inline void LeaveCritical() {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEE5EnterEPKcS6_i:
  157|  1.30M|    {
  158|  1.30M|        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|  1.30M|        Base::lock();
  164|  1.30M|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEED2Ev:
  197|  1.30M|    {
  198|  1.30M|        if (Base::owns_lock())
  ------------------
  |  Branch (198:13): [True: 1.30M, False: 0]
  ------------------
  199|  1.30M|            LeaveCritical();
  200|  1.30M|    }
_Z10DeleteLockPv:
   82|  9.55k|inline void DeleteLock(void* cs) {}
_Z17MaybeCheckNotHeldI14AnnotatedMixinINSt3__115recursive_mutexEEERT_S5_:
  253|  9.55k|inline MutexType& MaybeCheckNotHeld(MutexType& m) LOCKS_EXCLUDED(m) LOCK_RETURNED(m) { return m; }
_Z13EnterCriticalINSt3__115recursive_mutexEEvPKcS3_iPT_b:
   75|  9.55k|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEE5EnterEPKcS6_i:
  157|  9.55k|    {
  158|  9.55k|        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|  9.55k|        Base::lock();
  164|  9.55k|    }
_Z22AssertLockHeldInternalI14AnnotatedMixinINSt3__15mutexEEEvPKcS5_iPT_:
   79|   348M|inline void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, MutexType* cs) EXCLUSIVE_LOCKS_REQUIRED(cs) {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEEC2ERS3_PKcS7_ib:
  177|  9.55k|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  178|  9.55k|    {
  179|  9.55k|        if (fTry)
  ------------------
  |  Branch (179:13): [True: 0, False: 9.55k]
  ------------------
  180|      0|            TryEnter(pszName, pszFile, nLine);
  181|  9.55k|        else
  182|  9.55k|            Enter(pszName, pszFile, nLine);
  183|  9.55k|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEED2Ev:
  197|  9.55k|    {
  198|  9.55k|        if (Base::owns_lock())
  ------------------
  |  Branch (198:13): [True: 9.55k, False: 0]
  ------------------
  199|  9.55k|            LeaveCritical();
  200|  9.55k|    }
_ZN14AnnotatedMixinINSt3__15mutexEED2Ev:
   94|  9.55k|    ~AnnotatedMixin() {
   95|  9.55k|        DeleteLock((void*)this);
   96|  9.55k|    }
_ZN14AnnotatedMixinINSt3__115recursive_mutexEED2Ev:
   94|      2|    ~AnnotatedMixin() {
   95|      2|        DeleteLock((void*)this);
   96|      2|    }

_ZN18FuzzedDataProviderC2EPKhm:
   37|  7.15k|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIlEET_S1_S1_:
  205|   930k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|   930k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|   930k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|   930k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 930k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|   930k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|   930k|  uint64_t result = 0;
  215|   930k|  size_t offset = 0;
  216|       |
  217|  4.63M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 4.63M, False: 0]
  |  Branch (217:43): [True: 3.71M, False: 927k]
  ------------------
  218|  4.63M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 3.70M, False: 3.59k]
  ------------------
  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|  3.70M|    --remaining_bytes_;
  226|  3.70M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  3.70M|    offset += CHAR_BIT;
  228|  3.70M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|   930k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 930k, False: 0]
  ------------------
  232|   930k|    result = result % (range + 1);
  233|       |
  234|   930k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|   930k|}
_ZN18FuzzedDataProvider15ConsumeIntegralImEET_v:
  195|  37.5k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  37.5k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  37.5k|                                std::numeric_limits<T>::max());
  198|  37.5k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_:
  205|  13.2M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  13.2M|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  13.2M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  13.2M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 13.2M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  13.2M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  13.2M|  uint64_t result = 0;
  215|  13.2M|  size_t offset = 0;
  216|       |
  217|  26.7M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 26.6M, False: 35.5k]
  |  Branch (217:43): [True: 13.4M, False: 13.1M]
  ------------------
  218|  26.7M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 13.4M, False: 17.1k]
  ------------------
  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|  13.4M|    --remaining_bytes_;
  226|  13.4M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  13.4M|    offset += CHAR_BIT;
  228|  13.4M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  13.2M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 13.2M, False: 37.5k]
  ------------------
  232|  13.2M|    result = result % (range + 1);
  233|       |
  234|  13.2M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  13.2M|}
_ZN18FuzzedDataProvider15ConsumeIntegralIjEET_v:
  195|  5.47M|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  5.47M|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  5.47M|                                std::numeric_limits<T>::max());
  198|  5.47M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_:
  205|  5.47M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  5.47M|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  5.47M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  5.47M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 5.47M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  5.47M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  5.47M|  uint64_t result = 0;
  215|  5.47M|  size_t offset = 0;
  216|       |
  217|  27.3M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 21.8M, False: 5.47M]
  |  Branch (217:43): [True: 21.8M, False: 0]
  ------------------
  218|  27.3M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 21.8M, False: 2.28k]
  ------------------
  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|  21.8M|    --remaining_bytes_;
  226|  21.8M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  21.8M|    offset += CHAR_BIT;
  228|  21.8M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  5.47M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 5.47M, False: 0]
  ------------------
  232|  5.47M|    result = result % (range + 1);
  233|       |
  234|  5.47M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  5.47M|}
_ZN18FuzzedDataProvider15ConsumeIntegralItEET_v:
  195|  6.42M|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  6.42M|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  6.42M|                                std::numeric_limits<T>::max());
  198|  6.42M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeItEET_S1_S1_:
  205|  6.42M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  6.42M|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  6.42M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  6.42M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 6.42M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  6.42M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  6.42M|  uint64_t result = 0;
  215|  6.42M|  size_t offset = 0;
  216|       |
  217|  19.2M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 12.8M, False: 6.42M]
  |  Branch (217:43): [True: 12.8M, False: 0]
  ------------------
  218|  19.2M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 12.8M, False: 2.24k]
  ------------------
  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|  12.8M|    --remaining_bytes_;
  226|  12.8M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  12.8M|    offset += CHAR_BIT;
  228|  12.8M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  6.42M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 6.42M, False: 0]
  ------------------
  232|  6.42M|    result = result % (range + 1);
  233|       |
  234|  6.42M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  6.42M|}
_ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v:
  195|  12.3M|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  12.3M|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  12.3M|                                std::numeric_limits<T>::max());
  198|  12.3M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_:
  205|  12.3M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  12.3M|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  12.3M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  12.3M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 12.3M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  12.3M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  12.3M|  uint64_t result = 0;
  215|  12.3M|  size_t offset = 0;
  216|       |
  217|  24.6M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 12.3M, False: 12.2M]
  |  Branch (217:43): [True: 12.3M, False: 0]
  ------------------
  218|  24.6M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 12.2M, False: 79.7k]
  ------------------
  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|  12.2M|    --remaining_bytes_;
  226|  12.2M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  12.2M|    offset += CHAR_BIT;
  228|  12.2M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  12.3M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 12.3M, False: 0]
  ------------------
  232|  12.3M|    result = result % (range + 1);
  233|       |
  234|  12.3M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  12.3M|}
_ZN18FuzzedDataProvider20ConsumeBytesAsStringEm:
  137|  24.6k|inline std::string FuzzedDataProvider::ConsumeBytesAsString(size_t num_bytes) {
  138|  24.6k|  static_assert(sizeof(std::string::value_type) == sizeof(uint8_t),
  139|  24.6k|                "ConsumeBytesAsString cannot convert the data to a string.");
  140|       |
  141|  24.6k|  num_bytes = std::min(num_bytes, remaining_bytes_);
  142|  24.6k|  std::string result(
  143|  24.6k|      reinterpret_cast<const std::string::value_type *>(data_ptr_), num_bytes);
  144|  24.6k|  Advance(num_bytes);
  145|  24.6k|  return result;
  146|  24.6k|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm:
  153|  10.0k|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|  10.0k|  std::string result;
  161|       |
  162|       |  // Reserve the anticipated capacity to prevent several reallocations.
  163|  10.0k|  result.reserve(std::min(max_length, remaining_bytes_));
  164|  32.8M|  for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) {
  ------------------
  |  Branch (164:22): [True: 32.8M, False: 2.11k]
  |  Branch (164:40): [True: 32.8M, False: 15]
  ------------------
  165|  32.8M|    char next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  166|  32.8M|    Advance(1);
  167|  32.8M|    if (next == '\\' && remaining_bytes_ != 0) {
  ------------------
  |  Branch (167:9): [True: 8.48k, False: 32.8M]
  |  Branch (167:25): [True: 8.47k, False: 7]
  ------------------
  168|  8.47k|      next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  169|  8.47k|      Advance(1);
  170|  8.47k|      if (next != '\\')
  ------------------
  |  Branch (170:11): [True: 7.92k, False: 558]
  ------------------
  171|  7.92k|        break;
  172|  8.47k|    }
  173|  32.8M|    result += next;
  174|  32.8M|  }
  175|       |
  176|  10.0k|  result.shrink_to_fit();
  177|  10.0k|  return result;
  178|  10.0k|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEv:
  181|  10.0k|inline std::string FuzzedDataProvider::ConsumeRandomLengthString() {
  182|  10.0k|  return ConsumeRandomLengthString(remaining_bytes_);
  183|  10.0k|}
_ZN18FuzzedDataProvider11ConsumeBoolEv:
  289|  12.3M|inline bool FuzzedDataProvider::ConsumeBool() {
  290|  12.3M|  return 1 & ConsumeIntegral<uint8_t>();
  291|  12.3M|}
_ZN18FuzzedDataProvider14CopyAndAdvanceEPvm:
  339|  6.43M|                                               size_t num_bytes) {
  340|  6.43M|  std::memcpy(destination, data_ptr_, num_bytes);
  341|  6.43M|  Advance(num_bytes);
  342|  6.43M|}
_ZN18FuzzedDataProvider7AdvanceEm:
  344|  39.2M|inline void FuzzedDataProvider::Advance(size_t num_bytes) {
  345|  39.2M|  if (num_bytes > remaining_bytes_)
  ------------------
  |  Branch (345:7): [True: 0, False: 39.2M]
  ------------------
  346|      0|    abort();
  347|       |
  348|  39.2M|  data_ptr_ += num_bytes;
  349|  39.2M|  remaining_bytes_ -= num_bytes;
  350|  39.2M|}
_ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_:
  379|  32.8M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) {
  380|  32.8M|  static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types.");
  381|  32.8M|  static_assert(!std::numeric_limits<TU>::is_signed,
  382|  32.8M|                "Source type must be unsigned.");
  383|       |
  384|       |  // TODO(Dor1s): change to `if constexpr` once C++17 becomes mainstream.
  385|  32.8M|  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|  32.8M|  if (value <= std::numeric_limits<TS>::max()) {
  ------------------
  |  Branch (390:7): [True: 28.1M, False: 4.65M]
  ------------------
  391|  28.1M|    return static_cast<TS>(value);
  392|  28.1M|  } else {
  393|  4.65M|    constexpr auto TS_min = std::numeric_limits<TS>::min();
  394|  4.65M|    return TS_min + static_cast<TS>(value - TS_min);
  395|  4.65M|  }
  396|  32.8M|}
_ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEm:
  109|  6.43M|std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t num_bytes) {
  110|  6.43M|  num_bytes = std::min(num_bytes, remaining_bytes_);
  111|  6.43M|  return ConsumeBytes<T>(num_bytes, num_bytes);
  112|  6.43M|}
_ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEmm:
  353|  6.43M|std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t size, size_t num_bytes) {
  354|  6.43M|  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|  6.43M|  std::vector<T> result(size);
  363|  6.43M|  if (size == 0) {
  ------------------
  |  Branch (363:7): [True: 4.58k, False: 6.43M]
  ------------------
  364|  4.58k|    if (num_bytes != 0)
  ------------------
  |  Branch (364:9): [True: 0, False: 4.58k]
  ------------------
  365|      0|      abort();
  366|  4.58k|    return result;
  367|  4.58k|  }
  368|       |
  369|  6.43M|  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|  6.43M|  result.shrink_to_fit();
  375|  6.43M|  return result;
  376|  6.43M|}
_ZN18FuzzedDataProvider16PickValueInArrayI12ServiceFlagsLm7EEET_RAT0__KS2_:
  304|  5.49M|T FuzzedDataProvider::PickValueInArray(const T (&array)[size]) {
  305|  5.49M|  static_assert(size > 0, "The array must be non empty.");
  306|  5.49M|  return array[ConsumeIntegralInRange<size_t>(0, size - 1)];
  307|  5.49M|}
_ZN18FuzzedDataProvider16PickValueInArrayI7NetworkLm7EEET_RKNSt3__15arrayIS2_XT0_EEE:
  310|    462|T FuzzedDataProvider::PickValueInArray(const std::array<T, size> &array) {
  311|    462|  static_assert(size > 0, "The array must be non empty.");
  312|    462|  return array[ConsumeIntegralInRange<size_t>(0, size - 1)];
  313|    462|}

_Z19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
  116|  7.15k|{
  117|  7.15k|    SeedRandomStateForTest(SeedRand::ZEROS);
  118|  7.15k|    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
  119|  7.15k|    SetMockTime(ConsumeTime(fuzzed_data_provider));
  120|  7.15k|    NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
  121|  7.15k|    auto addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio());
  122|  7.15k|    if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (122:9): [True: 2.89k, False: 4.26k]
  ------------------
  123|  2.89k|        const std::vector<uint8_t> serialized_data{ConsumeRandomLengthByteVector(fuzzed_data_provider)};
  124|  2.89k|        DataStream ds{serialized_data};
  125|  2.89k|        try {
  126|  2.89k|            ds >> *addr_man_ptr;
  127|  2.89k|        } catch (const std::ios_base::failure&) {
  128|  2.39k|            addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio());
  129|  2.39k|        }
  130|  2.89k|    }
  131|  7.15k|    AddrManDeterministic& addr_man = *addr_man_ptr;
  132|  1.24M|    LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
  ------------------
  |  |   23|  1.24M|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 1.24M, False: 7.15k]
  |  |  |  Branch (23:49): [True: 1.24M, False: 4]
  |  |  ------------------
  ------------------
  133|  1.24M|        CallOneOf(
  134|  1.24M|            fuzzed_data_provider,
  135|  1.24M|            [&] {
  136|  1.24M|                addr_man.ResolveCollisions();
  137|  1.24M|            },
  138|  1.24M|            [&] {
  139|  1.24M|                (void)addr_man.SelectTriedCollision();
  140|  1.24M|            },
  141|  1.24M|            [&] {
  142|  1.24M|                std::vector<CAddress> addresses;
  143|  1.24M|                LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
  144|  1.24M|                    addresses.push_back(ConsumeAddress(fuzzed_data_provider));
  145|  1.24M|                }
  146|  1.24M|                auto net_addr = ConsumeNetAddr(fuzzed_data_provider);
  147|  1.24M|                auto time_penalty = std::chrono::seconds{ConsumeTime(fuzzed_data_provider, 0, 100000000)};
  148|  1.24M|                addr_man.Add(addresses, net_addr, time_penalty);
  149|  1.24M|            },
  150|  1.24M|            [&] {
  151|  1.24M|                auto addr = ConsumeService(fuzzed_data_provider);
  152|  1.24M|                auto time = NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}};
  153|  1.24M|                addr_man.Good(addr, time);
  154|  1.24M|            },
  155|  1.24M|            [&] {
  156|  1.24M|                auto addr = ConsumeService(fuzzed_data_provider);
  157|  1.24M|                auto count_failure = fuzzed_data_provider.ConsumeBool();
  158|  1.24M|                auto time = NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}};
  159|  1.24M|                addr_man.Attempt(addr, count_failure, time);
  160|  1.24M|            },
  161|  1.24M|            [&] {
  162|  1.24M|                auto addr = ConsumeService(fuzzed_data_provider);
  163|  1.24M|                auto time = NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}};
  164|  1.24M|                addr_man.Connected(addr, time);
  165|  1.24M|            },
  166|  1.24M|            [&] {
  167|  1.24M|                auto addr = ConsumeService(fuzzed_data_provider);
  168|  1.24M|                auto n_services = ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS);
  169|  1.24M|                addr_man.SetServices(addr, n_services);
  170|  1.24M|            });
  171|  1.24M|    }
  172|  7.15k|    const AddrMan& const_addr_man{addr_man};
  173|  7.15k|    std::optional<Network> network;
  174|  7.15k|    if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (174:9): [True: 462, False: 6.69k]
  ------------------
  175|    462|        network = fuzzed_data_provider.PickValueInArray(ALL_NETWORKS);
  176|    462|    }
  177|  7.15k|    auto max_addresses = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096);
  178|  7.15k|    auto max_pct = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 100);
  179|  7.15k|    auto filtered = fuzzed_data_provider.ConsumeBool();
  180|  7.15k|    (void)const_addr_man.GetAddr(max_addresses, max_pct, network, filtered);
  181|       |
  182|  7.15k|    std::unordered_set<Network> nets;
  183|  50.0k|    for (const auto& net : ALL_NETWORKS) {
  ------------------
  |  Branch (183:26): [True: 50.0k, False: 7.15k]
  ------------------
  184|  50.0k|        if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (184:13): [True: 3.78k, False: 46.3k]
  ------------------
  185|  3.78k|            nets.insert(net);
  186|  3.78k|        }
  187|  50.0k|    }
  188|  7.15k|    (void)const_addr_man.Select(fuzzed_data_provider.ConsumeBool(), nets);
  189|       |
  190|  7.15k|    std::optional<bool> in_new;
  191|  7.15k|    if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (191:9): [True: 505, False: 6.65k]
  ------------------
  192|    505|        in_new = fuzzed_data_provider.ConsumeBool();
  193|    505|    }
  194|  7.15k|    (void)const_addr_man.Size(network, in_new);
  195|  7.15k|    DataStream data_stream{};
  196|  7.15k|    data_stream << const_addr_man;
  197|  7.15k|}
addrman.cpp:_ZN12_GLOBAL__N_113GetCheckRatioEv:
   31|  9.54k|{
   32|  9.54k|    return std::clamp<int32_t>(g_setup->m_node.args->GetIntArg("-checkaddrman", 0), 0, 1000000);
   33|  9.54k|}
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv:
  135|  18.9k|            [&] {
  136|  18.9k|                addr_man.ResolveCollisions();
  137|  18.9k|            },
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_1clEv:
  138|   239k|            [&] {
  139|   239k|                (void)addr_man.SelectTriedCollision();
  140|   239k|            },
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_2clEv:
  141|  28.4k|            [&] {
  142|  28.4k|                std::vector<CAddress> addresses;
  143|  5.47M|                LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
  ------------------
  |  |   23|  5.50M|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 5.47M, False: 28.3k]
  |  |  |  Branch (23:49): [True: 5.47M, False: 60]
  |  |  ------------------
  ------------------
  144|  5.47M|                    addresses.push_back(ConsumeAddress(fuzzed_data_provider));
  145|  5.47M|                }
  146|  28.4k|                auto net_addr = ConsumeNetAddr(fuzzed_data_provider);
  147|  28.4k|                auto time_penalty = std::chrono::seconds{ConsumeTime(fuzzed_data_provider, 0, 100000000)};
  148|  28.4k|                addr_man.Add(addresses, net_addr, time_penalty);
  149|  28.4k|            },
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_3clEv:
  150|   886k|            [&] {
  151|   886k|                auto addr = ConsumeService(fuzzed_data_provider);
  152|   886k|                auto time = NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}};
  153|   886k|                addr_man.Good(addr, time);
  154|   886k|            },
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_4clEv:
  155|  4.80k|            [&] {
  156|  4.80k|                auto addr = ConsumeService(fuzzed_data_provider);
  157|  4.80k|                auto count_failure = fuzzed_data_provider.ConsumeBool();
  158|  4.80k|                auto time = NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}};
  159|  4.80k|                addr_man.Attempt(addr, count_failure, time);
  160|  4.80k|            },
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_5clEv:
  161|  3.27k|            [&] {
  162|  3.27k|                auto addr = ConsumeService(fuzzed_data_provider);
  163|  3.27k|                auto time = NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}};
  164|  3.27k|                addr_man.Connected(addr, time);
  165|  3.27k|            },
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_6clEv:
  166|  58.9k|            [&] {
  167|  58.9k|                auto addr = ConsumeService(fuzzed_data_provider);
  168|  58.9k|                auto n_services = ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS);
  169|  58.9k|                addr_man.SetServices(addr, n_services);
  170|  58.9k|            });

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

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

_Z28ConsumeRandomLengthBitVectorR18FuzzedDataProviderRKNSt3__18optionalImEE:
   69|  7.15k|{
   70|  7.15k|    return BytesToBits(ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length));
   71|  7.15k|}
_Z14ConsumeUInt256R18FuzzedDataProvider:
  172|  9.54k|{
  173|  9.54k|    const std::vector<uint8_t> v256 = fuzzed_data_provider.ConsumeBytes<uint8_t>(256 / 8);
  174|  9.54k|    if (v256.size() != 256 / 8) {
  ------------------
  |  Branch (174:9): [True: 1.72k, False: 7.82k]
  ------------------
  175|  1.72k|        return {};
  176|  1.72k|    }
  177|  7.82k|    return uint256{v256};
  178|  9.54k|}
_Z29ConsumeRandomLengthByteVectorIhENSt3__16vectorIT_NS0_9allocatorIS2_EEEER18FuzzedDataProviderRKNS0_8optionalImEE:
   58|  10.0k|{
   59|  10.0k|    static_assert(sizeof(B) == 1);
   60|  10.0k|    const std::string s = max_length ?
  ------------------
  |  Branch (60:27): [True: 0, False: 10.0k]
  ------------------
   61|      0|                              fuzzed_data_provider.ConsumeRandomLengthString(*max_length) :
   62|  10.0k|                              fuzzed_data_provider.ConsumeRandomLengthString();
   63|  10.0k|    std::vector<B> ret(s.size());
   64|  10.0k|    std::copy(s.begin(), s.end(), reinterpret_cast<char*>(ret.data()));
   65|  10.0k|    return ret;
   66|  10.0k|}
addrman.cpp:_Z9CallOneOfIJZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEE3$_0Z19addrman_fuzz_targetS3_E3$_1Z19addrman_fuzz_targetS3_E3$_2Z19addrman_fuzz_targetS3_E3$_3Z19addrman_fuzz_targetS3_E3$_4Z19addrman_fuzz_targetS3_E3$_5Z19addrman_fuzz_targetS3_E3$_6EEmR18FuzzedDataProviderDpT_:
   36|  1.24M|{
   37|  1.24M|    constexpr size_t call_size{sizeof...(callables)};
   38|  1.24M|    static_assert(call_size >= 1);
   39|  1.24M|    const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
   40|       |
   41|  1.24M|    size_t i{0};
   42|  8.68M|    ((i++ == call_index ? callables() : void()), ...);
  ------------------
  |  Branch (42:7): [True: 18.9k, False: 1.22M]
  |  Branch (42:7): [True: 239k, False: 1.00M]
  |  Branch (42:7): [True: 28.4k, False: 1.21M]
  |  Branch (42:7): [True: 886k, False: 353k]
  |  Branch (42:7): [True: 4.80k, False: 1.23M]
  |  Branch (42:7): [True: 3.27k, False: 1.23M]
  |  Branch (42:7): [True: 58.9k, False: 1.18M]
  ------------------
   43|  1.24M|    return call_size;
   44|  1.24M|}
_Z15ConsumeWeakEnumI12ServiceFlagsLm7EET_R18FuzzedDataProviderRAT0__KS1_:
  134|  5.53M|{
  135|  5.53M|    return fuzzed_data_provider.ConsumeBool() ?
  ------------------
  |  Branch (135:12): [True: 5.49M, False: 37.5k]
  ------------------
  136|  5.49M|               fuzzed_data_provider.PickValueInArray<WeakEnumType>(all_types) :
  137|  5.53M|               WeakEnumType(fuzzed_data_provider.ConsumeIntegral<typename std::underlying_type<WeakEnumType>::type>());
  138|  5.53M|}

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

_Z14ConsumeNetAddrR18FuzzedDataProviderP17FastRandomContext:
   29|  6.45M|{
   30|  6.45M|    struct NetAux {
   31|  6.45M|        Network net;
   32|  6.45M|        CNetAddr::BIP155Network bip155;
   33|  6.45M|        size_t len;
   34|  6.45M|    };
   35|       |
   36|  6.45M|    static constexpr std::array<NetAux, 6> nets{
   37|  6.45M|        NetAux{.net = Network::NET_IPV4, .bip155 = CNetAddr::BIP155Network::IPV4, .len = ADDR_IPV4_SIZE},
   38|  6.45M|        NetAux{.net = Network::NET_IPV6, .bip155 = CNetAddr::BIP155Network::IPV6, .len = ADDR_IPV6_SIZE},
   39|  6.45M|        NetAux{.net = Network::NET_ONION, .bip155 = CNetAddr::BIP155Network::TORV3, .len = ADDR_TORV3_SIZE},
   40|  6.45M|        NetAux{.net = Network::NET_I2P, .bip155 = CNetAddr::BIP155Network::I2P, .len = ADDR_I2P_SIZE},
   41|  6.45M|        NetAux{.net = Network::NET_CJDNS, .bip155 = CNetAddr::BIP155Network::CJDNS, .len = ADDR_CJDNS_SIZE},
   42|  6.45M|        NetAux{.net = Network::NET_INTERNAL, .bip155 = CNetAddr::BIP155Network{0}, .len = 0},
   43|  6.45M|    };
   44|       |
   45|  6.45M|    const size_t nets_index{rand == nullptr
  ------------------
  |  Branch (45:29): [True: 6.45M, False: 0]
  ------------------
   46|  6.45M|        ? fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, nets.size() - 1)
   47|  6.45M|        : static_cast<size_t>(rand->randrange(nets.size()))};
   48|       |
   49|  6.45M|    const auto& aux = nets[nets_index];
   50|       |
   51|  6.45M|    CNetAddr addr;
   52|       |
   53|  6.45M|    if (aux.net == Network::NET_INTERNAL) {
  ------------------
  |  Branch (53:9): [True: 24.6k, False: 6.43M]
  ------------------
   54|  24.6k|        if (rand == nullptr) {
  ------------------
  |  Branch (54:13): [True: 24.6k, False: 0]
  ------------------
   55|  24.6k|            addr.SetInternal(fuzzed_data_provider.ConsumeBytesAsString(32));
   56|  24.6k|        } else {
   57|      0|            const auto v = rand->randbytes(32);
   58|      0|            addr.SetInternal(std::string{v.begin(), v.end()});
   59|      0|        }
   60|  24.6k|        return addr;
   61|  24.6k|    }
   62|       |
   63|  6.43M|    DataStream s;
   64|       |
   65|  6.43M|    s << static_cast<uint8_t>(aux.bip155);
   66|       |
   67|  6.43M|    std::vector<uint8_t> addr_bytes;
   68|  6.43M|    if (rand == nullptr) {
  ------------------
  |  Branch (68:9): [True: 6.43M, False: 0]
  ------------------
   69|  6.43M|        addr_bytes = fuzzed_data_provider.ConsumeBytes<uint8_t>(aux.len);
   70|  6.43M|        addr_bytes.resize(aux.len);
   71|  6.43M|    } else {
   72|      0|        addr_bytes = rand->randbytes(aux.len);
   73|      0|    }
   74|  6.43M|    if (aux.net == NET_IPV6 && addr_bytes[0] == CJDNS_PREFIX) { // Avoid generating IPv6 addresses that look like CJDNS.
  ------------------
  |  Branch (74:9): [True: 4.08M, False: 2.34M]
  |  Branch (74:32): [True: 9.50k, False: 4.07M]
  ------------------
   75|  9.50k|        addr_bytes[0] = 0x55; // Just an arbitrary number, anything != CJDNS_PREFIX would do.
   76|  9.50k|    }
   77|  6.43M|    if (aux.net == NET_CJDNS) { // Avoid generating CJDNS addresses that don't start with CJDNS_PREFIX because those are !IsValid().
  ------------------
  |  Branch (77:9): [True: 3.68k, False: 6.42M]
  ------------------
   78|  3.68k|        addr_bytes[0] = CJDNS_PREFIX;
   79|  3.68k|    }
   80|  6.43M|    s << addr_bytes;
   81|       |
   82|  6.43M|    s >> CAddress::V2_NETWORK(addr);
   83|       |
   84|  6.43M|    return addr;
   85|  6.45M|}
_Z14ConsumeAddressR18FuzzedDataProvider:
   88|  5.47M|{
   89|  5.47M|    return {ConsumeService(fuzzed_data_provider), ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS), NodeSeconds{std::chrono::seconds{fuzzed_data_provider.ConsumeIntegral<uint32_t>()}}};
   90|  5.47M|}

_Z22ConsumeNetGroupManagerR18FuzzedDataProvider:
  202|  7.15k|{
  203|  7.15k|    std::vector<bool> asmap = ConsumeRandomLengthBitVector(fuzzed_data_provider);
  204|  7.15k|    if (!SanityCheckASMap(asmap, 128)) asmap.clear();
  ------------------
  |  Branch (204:9): [True: 4.93k, False: 2.22k]
  ------------------
  205|  7.15k|    return NetGroupManager(asmap);
  206|  7.15k|}
_ZN20AddrManDeterministicC2ERK15NetGroupManagerR18FuzzedDataProvideri:
   44|  9.54k|        : AddrMan(netgroupman, /*deterministic=*/true, check_ratio)
   45|  9.54k|    {
   46|  9.54k|        WITH_LOCK(m_impl->cs, m_impl->insecure_rand.Reseed(ConsumeUInt256(fuzzed_data_provider)));
  ------------------
  |  |  301|  9.54k|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
  ------------------
   47|  9.54k|    }
_Z14ConsumeServiceR18FuzzedDataProvider:
  214|  6.42M|{
  215|  6.42M|    return {ConsumeNetAddr(fuzzed_data_provider), fuzzed_data_provider.ConsumeIntegral<uint16_t>()};
  216|  6.42M|}

_Z22SeedRandomStateForTest8SeedRand:
   20|  7.15k|{
   21|  7.15k|    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|  7.15k|    static const auto g_ctx_seed = []() -> std::optional<uint256> {
   28|  7.15k|        if constexpr (G_FUZZING) return {};
   29|       |        // If RANDOM_CTX_SEED is set, use that as seed.
   30|  7.15k|        if (const char* num{std::getenv(RANDOM_CTX_SEED)}) {
   31|  7.15k|            if (auto num_parsed{uint256::FromUserHex(num)}) {
   32|  7.15k|                return *num_parsed;
   33|  7.15k|            } else {
   34|  7.15k|                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|  7.15k|                std::abort();
   36|  7.15k|            }
   37|  7.15k|        }
   38|       |        // Otherwise use a (truly) random value.
   39|  7.15k|        return GetRandHash();
   40|  7.15k|    }();
   41|       |
   42|  7.15k|    g_seeded_g_prng_zero = seedtype == SeedRand::ZEROS;
   43|  7.15k|    if constexpr (G_FUZZING) {
   44|  7.15k|        Assert(g_seeded_g_prng_zero); // Only SeedRandomStateForTest(SeedRand::ZEROS) is allowed in fuzz tests
  ------------------
  |  |   85|  7.15k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   45|  7.15k|        Assert(!g_used_g_prng);       // The global PRNG must not have been used before SeedRandomStateForTest(SeedRand::ZEROS)
  ------------------
  |  |   85|  7.15k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   46|  7.15k|    }
   47|  7.15k|    const uint256& seed{seedtype == SeedRand::FIXED_SEED ? g_ctx_seed.value() : uint256::ZERO};
  ------------------
  |  Branch (47:25): [True: 0, False: 7.15k]
  ------------------
   48|  7.15k|    LogInfo("Setting random seed for current tests to %s=%s\n", RANDOM_CTX_SEED, seed.GetHex());
  ------------------
  |  |  261|  7.15k|#define LogInfo(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  255|  7.15k|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  ------------------
  ------------------
   49|  7.15k|    MakeRandDeterministicDANGEROUS(seed);
   50|  7.15k|}

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

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

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

_ZN7uint256C2Eh:
  207|  9.54k|    constexpr explicit uint256(uint8_t v) : base_blob<256>(v) {}
_ZN7uint256C2E4SpanIKhE:
  208|  7.82k|    constexpr explicit uint256(Span<const unsigned char> vch) : base_blob<256>(vch) {}
_ZN9base_blobILj256EE5beginEv:
  115|   123M|    constexpr unsigned char* begin() { return m_data.data(); }
_ZNK9base_blobILj256EE6IsNullEv:
   49|    508|    {
   50|    508|        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
   51|    508|            return val == 0;
   52|    508|        });
   53|    508|    }
_ZN9base_blobILj256EE4sizeEv:
  121|  54.8k|    static constexpr unsigned int size() { return WIDTH; }
_ZNK9base_blobILj256EE7CompareERKS0_:
   64|     22|    constexpr int Compare(const base_blob& other) const { return std::memcmp(m_data.data(), other.m_data.data(), WIDTH); }
_ZeqRK9base_blobILj256EES2_:
   66|     22|    friend constexpr bool operator==(const base_blob& a, const base_blob& b) { return a.Compare(b) == 0; }
_ZN9base_blobILj256EE7SetNullEv:
   56|  9.54k|    {
   57|  9.54k|        std::fill(m_data.begin(), m_data.end(), 0);
   58|  9.54k|    }
_ZNK9base_blobILj256EE4dataEv:
  112|  16.7k|    constexpr const unsigned char* data() const { return m_data.data(); }
_ZN9base_blobILj256EE4dataEv:
  113|  38.1k|    constexpr unsigned char* data() { return m_data.data(); }
_ZN7uint256C2Ev:
  205|  30.8M|    constexpr uint256() = default;
_ZN9base_blobILj256EEC2Ev:
   35|  30.8M|    constexpr base_blob() : m_data() {}
_ZN9base_blobILj256EEC2E4SpanIKhE:
   41|  7.82k|    {
   42|  7.82k|        assert(vch.size() == WIDTH);
   43|  7.82k|        std::copy(vch.begin(), vch.end(), m_data.begin());
   44|  7.82k|    }
_ZZNK9base_blobILj256EE6IsNullEvENKUlhE_clEh:
   50|    961|        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
   51|    961|            return val == 0;
   52|    961|        });
_ZN9base_blobILj256EEC2Eh:
   38|  9.54k|    constexpr explicit base_blob(uint8_t v) : m_data{v} {}
_ZNK9base_blobILj256EE9SerializeI10HashWriterEEvRT_:
  127|  30.8M|    {
  128|  30.8M|        s << Span(m_data);
  129|  30.8M|    }
_ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  127|  14.3k|    {
  128|  14.3k|        s << Span(m_data);
  129|  14.3k|    }
_ZN9base_blobILj256EE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  133|  1.94k|    {
  134|  1.94k|        s.read(MakeWritableByteSpan(m_data));
  135|  1.94k|    }

_ZN8UniValueC2Ev:
   31|  9.54k|    UniValue() { typ = VNULL; }
_ZNK8UniValue6isNullEv:
   79|  9.54k|    bool isNull() const { return (typ == VNULL); }

_Z9InterpretRKNSt3__16vectorIbNS_9allocatorIbEEEES5_:
   89|  4.93M|{
   90|  4.93M|    std::vector<bool>::const_iterator pos = asmap.begin();
   91|  4.93M|    const std::vector<bool>::const_iterator endpos = asmap.end();
   92|  4.93M|    uint8_t bits = ip.size();
   93|  4.93M|    uint32_t default_asn = 0;
   94|  4.93M|    uint32_t jump, match, matchlen;
   95|  4.93M|    Instruction opcode;
   96|  10.7M|    while (pos != endpos) {
  ------------------
  |  Branch (96:12): [True: 10.7M, False: 0]
  ------------------
   97|  10.7M|        opcode = DecodeType(pos, endpos);
   98|  10.7M|        if (opcode == Instruction::RETURN) {
  ------------------
  |  Branch (98:13): [True: 4.35M, False: 6.36M]
  ------------------
   99|  4.35M|            default_asn = DecodeASN(pos, endpos);
  100|  4.35M|            if (default_asn == INVALID) break; // ASN straddles EOF
  ------------------
  |  Branch (100:17): [True: 0, False: 4.35M]
  ------------------
  101|  4.35M|            return default_asn;
  102|  6.36M|        } else if (opcode == Instruction::JUMP) {
  ------------------
  |  Branch (102:20): [True: 2.75M, False: 3.60M]
  ------------------
  103|  2.75M|            jump = DecodeJump(pos, endpos);
  104|  2.75M|            if (jump == INVALID) break; // Jump offset straddles EOF
  ------------------
  |  Branch (104:17): [True: 0, False: 2.75M]
  ------------------
  105|  2.75M|            if (bits == 0) break; // No input bits left
  ------------------
  |  Branch (105:17): [True: 0, False: 2.75M]
  ------------------
  106|  2.75M|            if (int64_t{jump} >= int64_t{endpos - pos}) break; // Jumping past EOF
  ------------------
  |  Branch (106:17): [True: 0, False: 2.75M]
  ------------------
  107|  2.75M|            if (ip[ip.size() - bits]) {
  ------------------
  |  Branch (107:17): [True: 1.44M, False: 1.31M]
  ------------------
  108|  1.44M|                pos += jump;
  109|  1.44M|            }
  110|  2.75M|            bits--;
  111|  3.60M|        } else if (opcode == Instruction::MATCH) {
  ------------------
  |  Branch (111:20): [True: 751k, False: 2.85M]
  ------------------
  112|   751k|            match = DecodeMatch(pos, endpos);
  113|   751k|            if (match == INVALID) break; // Match bits straddle EOF
  ------------------
  |  Branch (113:17): [True: 0, False: 751k]
  ------------------
  114|   751k|            matchlen = std::bit_width(match) - 1;
  115|   751k|            if (bits < matchlen) break; // Not enough input bits
  ------------------
  |  Branch (115:17): [True: 0, False: 751k]
  ------------------
  116|  1.35M|            for (uint32_t bit = 0; bit < matchlen; bit++) {
  ------------------
  |  Branch (116:36): [True: 1.17M, False: 174k]
  ------------------
  117|  1.17M|                if ((ip[ip.size() - bits]) != ((match >> (matchlen - 1 - bit)) & 1)) {
  ------------------
  |  Branch (117:21): [True: 577k, False: 601k]
  ------------------
  118|   577k|                    return default_asn;
  119|   577k|                }
  120|   601k|                bits--;
  121|   601k|            }
  122|  2.85M|        } else if (opcode == Instruction::DEFAULT) {
  ------------------
  |  Branch (122:20): [True: 2.85M, False: 0]
  ------------------
  123|  2.85M|            default_asn = DecodeASN(pos, endpos);
  124|  2.85M|            if (default_asn == INVALID) break; // ASN straddles EOF
  ------------------
  |  Branch (124:17): [True: 0, False: 2.85M]
  ------------------
  125|  2.85M|        } else {
  126|      0|            break; // Instruction straddles EOF
  127|      0|        }
  128|  10.7M|    }
  129|      0|    assert(false); // Reached EOF without RETURN, or aborted (see any of the breaks above) - should have been caught by SanityCheckASMap below
  130|      0|    return 0; // 0 is not a valid ASN
  131|      0|}
_Z16SanityCheckASMapRKNSt3__16vectorIbNS_9allocatorIbEEEEi:
  134|  7.15k|{
  135|  7.15k|    const std::vector<bool>::const_iterator begin = asmap.begin(), endpos = asmap.end();
  136|  7.15k|    std::vector<bool>::const_iterator pos = begin;
  137|  7.15k|    std::vector<std::pair<uint32_t, int>> jumps; // All future positions we may jump to (bit offset in asmap -> bits to consume left)
  138|  7.15k|    jumps.reserve(bits);
  139|  7.15k|    Instruction prevopcode = Instruction::JUMP;
  140|  7.15k|    bool had_incomplete_match = false;
  141|  22.3k|    while (pos != endpos) {
  ------------------
  |  Branch (141:12): [True: 19.0k, False: 3.25k]
  ------------------
  142|  19.0k|        uint32_t offset = pos - begin;
  143|  19.0k|        if (!jumps.empty() && offset >= jumps.back().first) return false; // There was a jump into the middle of the previous instruction
  ------------------
  |  Branch (143:13): [True: 5.54k, False: 13.5k]
  |  Branch (143:31): [True: 18, False: 5.52k]
  ------------------
  144|  19.0k|        Instruction opcode = DecodeType(pos, endpos);
  145|  19.0k|        if (opcode == Instruction::RETURN) {
  ------------------
  |  Branch (145:13): [True: 7.52k, False: 11.5k]
  ------------------
  146|  7.52k|            if (prevopcode == Instruction::DEFAULT) return false; // There should not be any RETURN immediately after a DEFAULT (could be combined into just RETURN)
  ------------------
  |  Branch (146:17): [True: 59, False: 7.46k]
  ------------------
  147|  7.46k|            uint32_t asn = DecodeASN(pos, endpos);
  148|  7.46k|            if (asn == INVALID) return false; // ASN straddles EOF
  ------------------
  |  Branch (148:17): [True: 419, False: 7.05k]
  ------------------
  149|  7.05k|            if (jumps.empty()) {
  ------------------
  |  Branch (149:17): [True: 2.71k, False: 4.33k]
  ------------------
  150|       |                // Nothing to execute anymore
  151|  2.71k|                if (endpos - pos > 7) return false; // Excessive padding
  ------------------
  |  Branch (151:21): [True: 406, False: 2.30k]
  ------------------
  152|  12.5k|                while (pos != endpos) {
  ------------------
  |  Branch (152:24): [True: 10.3k, False: 2.22k]
  ------------------
  153|  10.3k|                    if (*pos) return false; // Nonzero padding bit
  ------------------
  |  Branch (153:25): [True: 82, False: 10.2k]
  ------------------
  154|  10.2k|                    ++pos;
  155|  10.2k|                }
  156|  2.22k|                return true; // Sanely reached EOF
  157|  4.33k|            } else {
  158|       |                // Continue by pretending we jumped to the next instruction
  159|  4.33k|                offset = pos - begin;
  160|  4.33k|                if (offset != jumps.back().first) return false; // Unreachable code
  ------------------
  |  Branch (160:21): [True: 80, False: 4.25k]
  ------------------
  161|  4.25k|                bits = jumps.back().second; // Restore the number of bits we would have had left after this jump
  162|  4.25k|                jumps.pop_back();
  163|  4.25k|                prevopcode = Instruction::JUMP;
  164|  4.25k|            }
  165|  11.5k|        } else if (opcode == Instruction::JUMP) {
  ------------------
  |  Branch (165:20): [True: 4.81k, False: 6.69k]
  ------------------
  166|  4.81k|            uint32_t jump = DecodeJump(pos, endpos);
  167|  4.81k|            if (jump == INVALID) return false; // Jump offset straddles EOF
  ------------------
  |  Branch (167:17): [True: 54, False: 4.75k]
  ------------------
  168|  4.75k|            if (int64_t{jump} > int64_t{endpos - pos}) return false; // Jump out of range
  ------------------
  |  Branch (168:17): [True: 190, False: 4.56k]
  ------------------
  169|  4.56k|            if (bits == 0) return false; // Consuming bits past the end of the input
  ------------------
  |  Branch (169:17): [True: 1, False: 4.56k]
  ------------------
  170|  4.56k|            --bits;
  171|  4.56k|            uint32_t jump_offset = pos - begin + jump;
  172|  4.56k|            if (!jumps.empty() && jump_offset >= jumps.back().first) return false; // Intersecting jumps
  ------------------
  |  Branch (172:17): [True: 968, False: 3.59k]
  |  Branch (172:35): [True: 73, False: 895]
  ------------------
  173|  4.49k|            jumps.emplace_back(jump_offset, bits);
  174|  4.49k|            prevopcode = Instruction::JUMP;
  175|  6.69k|        } else if (opcode == Instruction::MATCH) {
  ------------------
  |  Branch (175:20): [True: 3.23k, False: 3.45k]
  ------------------
  176|  3.23k|            uint32_t match = DecodeMatch(pos, endpos);
  177|  3.23k|            if (match == INVALID) return false; // Match bits straddle EOF
  ------------------
  |  Branch (177:17): [True: 60, False: 3.17k]
  ------------------
  178|  3.17k|            int matchlen = std::bit_width(match) - 1;
  179|  3.17k|            if (prevopcode != Instruction::MATCH) had_incomplete_match = false;
  ------------------
  |  Branch (179:17): [True: 2.65k, False: 525]
  ------------------
  180|  3.17k|            if (matchlen < 8 && had_incomplete_match) return false; // Within a sequence of matches only at most one should be incomplete
  ------------------
  |  Branch (180:17): [True: 2.73k, False: 445]
  |  Branch (180:33): [True: 22, False: 2.70k]
  ------------------
  181|  3.15k|            had_incomplete_match = (matchlen < 8);
  182|  3.15k|            if (bits < matchlen) return false; // Consuming bits past the end of the input
  ------------------
  |  Branch (182:17): [True: 5, False: 3.14k]
  ------------------
  183|  3.14k|            bits -= matchlen;
  184|  3.14k|            prevopcode = Instruction::MATCH;
  185|  3.45k|        } else if (opcode == Instruction::DEFAULT) {
  ------------------
  |  Branch (185:20): [True: 3.40k, False: 53]
  ------------------
  186|  3.40k|            if (prevopcode == Instruction::DEFAULT) return false; // There should not be two successive DEFAULTs (they could be combined into one)
  ------------------
  |  Branch (186:17): [True: 29, False: 3.37k]
  ------------------
  187|  3.37k|            uint32_t asn = DecodeASN(pos, endpos);
  188|  3.37k|            if (asn == INVALID) return false; // ASN straddles EOF
  ------------------
  |  Branch (188:17): [True: 123, False: 3.25k]
  ------------------
  189|  3.25k|            prevopcode = Instruction::DEFAULT;
  190|  3.25k|        } else {
  191|     53|            return false; // Instruction straddles EOF
  192|     53|        }
  193|  19.0k|    }
  194|  3.25k|    return false; // Reached EOF without RETURN instruction
  195|  7.15k|}
asmap.cpp:_ZN12_GLOBAL__N_110DecodeTypeERNSt3__114__bit_iteratorINS0_6vectorIbNS0_9allocatorIbEEEELb1ELm0EEERKS6_:
   62|  10.7M|{
   63|  10.7M|    return Instruction(DecodeBits(bitpos, endpos, 0, TYPE_BIT_SIZES));
   64|  10.7M|}
asmap.cpp:_ZN12_GLOBAL__N_110DecodeBitsERNSt3__114__bit_iteratorINS0_6vectorIbNS0_9allocatorIbEEEELb1ELm0EEERKS6_hRKNS2_IhNS3_IhEEEE:
   25|  21.4M|{
   26|  21.4M|    uint32_t val = minval;
   27|  21.4M|    bool bit;
   28|  21.4M|    for (std::vector<uint8_t>::const_iterator bit_sizes_it = bit_sizes.begin();
   29|  39.6M|        bit_sizes_it != bit_sizes.end(); ++bit_sizes_it) {
  ------------------
  |  Branch (29:9): [True: 39.6M, False: 0]
  ------------------
   30|  39.6M|        if (bit_sizes_it + 1 != bit_sizes.end()) {
  ------------------
  |  Branch (30:13): [True: 35.9M, False: 3.70M]
  ------------------
   31|  35.9M|            if (bitpos == endpos) break;
  ------------------
  |  Branch (31:17): [True: 139, False: 35.9M]
  ------------------
   32|  35.9M|            bit = *bitpos;
   33|  35.9M|            bitpos++;
   34|  35.9M|        } else {
   35|  3.70M|            bit = 0;
   36|  3.70M|        }
   37|  39.6M|        if (bit) {
  ------------------
  |  Branch (37:13): [True: 18.2M, False: 21.4M]
  ------------------
   38|  18.2M|            val += (1 << *bit_sizes_it);
   39|  21.4M|        } else {
   40|   156M|            for (int b = 0; b < *bit_sizes_it; b++) {
  ------------------
  |  Branch (40:29): [True: 134M, False: 21.4M]
  ------------------
   41|   134M|                if (bitpos == endpos) return INVALID; // Reached EOF in mantissa
  ------------------
  |  Branch (41:21): [True: 570, False: 134M]
  ------------------
   42|   134M|                bit = *bitpos;
   43|   134M|                bitpos++;
   44|   134M|                val += bit << (*bit_sizes_it - 1 - b);
   45|   134M|            }
   46|  21.4M|            return val;
   47|  21.4M|        }
   48|  39.6M|    }
   49|    139|    return INVALID; // Reached EOF in exponent
   50|  21.4M|}
asmap.cpp:_ZN12_GLOBAL__N_19DecodeASNERNSt3__114__bit_iteratorINS0_6vectorIbNS0_9allocatorIbEEEELb1ELm0EEERKS6_:
   68|  7.22M|{
   69|  7.22M|    return DecodeBits(bitpos, endpos, 1, ASN_BIT_SIZES);
   70|  7.22M|}
asmap.cpp:_ZN12_GLOBAL__N_110DecodeJumpERNSt3__114__bit_iteratorINS0_6vectorIbNS0_9allocatorIbEEEELb1ELm0EEERKS6_:
   82|  2.76M|{
   83|  2.76M|    return DecodeBits(bitpos, endpos, 17, JUMP_BIT_SIZES);
   84|  2.76M|}
asmap.cpp:_ZN12_GLOBAL__N_111DecodeMatchERNSt3__114__bit_iteratorINS0_6vectorIbNS0_9allocatorIbEEEELb1ELm0EEERKS6_:
   75|   754k|{
   76|   754k|    return DecodeBits(bitpos, endpos, 2, MATCH_BIT_SIZES);
   77|   754k|}

_Z17ChainTypeToString9ChainType:
   12|  9.54k|{
   13|  9.54k|    switch (chain) {
  ------------------
  |  Branch (13:13): [True: 0, False: 9.54k]
  ------------------
   14|  9.54k|    case ChainType::MAIN:
  ------------------
  |  Branch (14:5): [True: 9.54k, False: 0]
  ------------------
   15|  9.54k|        return "main";
   16|      0|    case ChainType::TESTNET:
  ------------------
  |  Branch (16:5): [True: 0, False: 9.54k]
  ------------------
   17|      0|        return "test";
   18|      0|    case ChainType::TESTNET4:
  ------------------
  |  Branch (18:5): [True: 0, False: 9.54k]
  ------------------
   19|      0|        return "testnet4";
   20|      0|    case ChainType::SIGNET:
  ------------------
  |  Branch (20:5): [True: 0, False: 9.54k]
  ------------------
   21|      0|        return "signet";
   22|      0|    case ChainType::REGTEST:
  ------------------
  |  Branch (22:5): [True: 0, False: 9.54k]
  ------------------
   23|      0|        return "regtest";
   24|  9.54k|    }
   25|      0|    assert(false);
   26|      0|}

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

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

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

_ZN4util9HasPrefixI9prevectorILj16EhjiELm6EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|  8.16M|{
  248|  8.16M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 8.16M, False: 0]
  ------------------
  249|  8.16M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 1.93k, False: 8.16M]
  ------------------
  250|  8.16M|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm12EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|  37.8M|{
  248|  37.8M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 37.8M, False: 0]
  ------------------
  249|  37.8M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 5.02k, False: 37.8M]
  ------------------
  250|  37.8M|}
_ZN4util9HasPrefixI4SpanIKhELm12EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|   126k|{
  248|   126k|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 126k, False: 0]
  ------------------
  249|   126k|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 92, False: 126k]
  ------------------
  250|   126k|}
_ZN4util9HasPrefixI4SpanIKhELm6EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|   252k|{
  248|   252k|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 252k, False: 0]
  ------------------
  249|   252k|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 51, False: 252k]
  ------------------
  250|   252k|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm2EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|  19.5M|{
  248|  19.5M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 19.5M, False: 0]
  ------------------
  249|  19.5M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 2.28k, False: 19.5M]
  ------------------
  250|  19.5M|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm3EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|  83.9M|{
  248|  83.9M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 83.9M, False: 0]
  ------------------
  249|  83.9M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 4.85k, False: 83.9M]
  ------------------
  250|  83.9M|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm4EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|  57.0M|{
  248|  57.0M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 57.0M, False: 0]
  ------------------
  249|  57.0M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 2.93k, False: 57.0M]
  ------------------
  250|  57.0M|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm8EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|  38.0M|{
  248|  38.0M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 38.0M, False: 0]
  ------------------
  249|  38.0M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 695, False: 38.0M]
  ------------------
  250|  38.0M|}

_ZN9NodeClock3nowEv:
   27|  4.01M|{
   28|  4.01M|    const auto mocktime{g_mock_time.load(std::memory_order_relaxed)};
   29|  4.01M|    if (!mocktime.count()) {
  ------------------
  |  Branch (29:9): [True: 0, False: 4.01M]
  ------------------
   30|      0|        g_used_system_time = true;
   31|      0|    }
   32|  4.01M|    const auto ret{
   33|  4.01M|        mocktime.count() ?
  ------------------
  |  Branch (33:9): [True: 4.01M, False: 0]
  ------------------
   34|  4.01M|            mocktime :
   35|  4.01M|            std::chrono::system_clock::now().time_since_epoch()};
   36|  4.01M|    assert(ret > 0s);
   37|  4.01M|    return time_point{ret};
   38|  4.01M|};
_Z11SetMockTimel:
   40|  7.15k|void SetMockTime(int64_t nMockTimeIn) { SetMockTime(std::chrono::seconds{nMockTimeIn}); }
_Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   42|  14.3k|{
   43|  14.3k|    Assert(mock_time_in >= 0s);
  ------------------
  |  |   85|  14.3k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   44|  14.3k|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   45|  14.3k|}
_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|}

_Z15TicksSinceEpochINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEENS1_10time_pointI9NodeClockS5_EEEDaT0_:
   78|  23.5k|{
   79|  23.5k|    return Ticks<Duration>(t.time_since_epoch());
   80|  23.5k|}
_Z5TicksINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEES5_EDaT0_:
   73|  23.5k|{
   74|  23.5k|    return std::chrono::duration_cast<Dur1>(d).count();
   75|  23.5k|}
_Z3NowINSt3__16chrono10time_pointI9NodeClockNS1_8durationIxNS0_5ratioILl1ELl1EEEEEEEET_v:
  119|  2.44M|{
  120|  2.44M|    return std::chrono::time_point_cast<typename T::duration>(T::clock::now());
  121|  2.44M|}
_Z5TicksINSt3__16chrono8durationIdNS0_5ratioILl1ELl1000EEEEENS2_IxNS3_ILl1ELl1000000000EEEEEEDaT0_:
   73|    657|{
   74|    657|    return std::chrono::duration_cast<Dur1>(d).count();
   75|    657|}
_Z15TicksSinceEpochINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEENS1_10time_pointINS1_12system_clockES5_EEEDaT0_:
   78|      2|{
   79|      2|    return Ticks<Duration>(t.time_since_epoch());
   80|      2|}

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