_ZNK8AddrInfo14GetTriedBucketERK7uint256RK15NetGroupManager:
   30|   634k|{
   31|   634k|    uint64_t hash1 = (HashWriter{} << nKey << GetKey()).GetCheapHash();
   32|   634k|    uint64_t hash2 = (HashWriter{} << nKey << netgroupman.GetGroup(*this) << (hash1 % ADDRMAN_TRIED_BUCKETS_PER_GROUP)).GetCheapHash();
   33|   634k|    return hash2 % ADDRMAN_TRIED_BUCKET_COUNT;
   34|   634k|}
_ZNK8AddrInfo12GetNewBucketERK7uint256RK8CNetAddrRK15NetGroupManager:
   37|  4.32M|{
   38|  4.32M|    std::vector<unsigned char> vchSourceGroupKey = netgroupman.GetGroup(src);
   39|  4.32M|    uint64_t hash1 = (HashWriter{} << nKey << netgroupman.GetGroup(*this) << vchSourceGroupKey).GetCheapHash();
   40|  4.32M|    uint64_t hash2 = (HashWriter{} << nKey << vchSourceGroupKey << (hash1 % ADDRMAN_NEW_BUCKETS_PER_SOURCE_GROUP)).GetCheapHash();
   41|  4.32M|    return hash2 % ADDRMAN_NEW_BUCKET_COUNT;
   42|  4.32M|}
_ZNK8AddrInfo17GetBucketPositionERK7uint256bi:
   45|  10.1M|{
   46|  10.1M|    uint64_t hash1 = (HashWriter{} << nKey << (fNew ? uint8_t{'N'} : uint8_t{'K'}) << bucket << GetKey()).GetCheapHash();
  ------------------
  |  Branch (46:48): [True: 9.54M, False: 634k]
  ------------------
   47|  10.1M|    return hash1 % ADDRMAN_BUCKET_SIZE;
   48|  10.1M|}
_ZNK8AddrInfo10IsTerribleENSt3__16chrono10time_pointI9NodeClockNS1_8durationIxNS0_5ratioILl1ELl1EEEEEEE:
   51|  3.77M|{
   52|  3.77M|    if (now - m_last_try <= 1min) { // never remove things tried in the last minute
  ------------------
  |  Branch (52:9): [True: 34.3k, False: 3.74M]
  ------------------
   53|  34.3k|        return false;
   54|  34.3k|    }
   55|       |
   56|  3.74M|    if (nTime > now + 10min) { // came in a flying DeLorean
  ------------------
  |  Branch (56:9): [True: 2.85M, False: 886k]
  ------------------
   57|  2.85M|        return true;
   58|  2.85M|    }
   59|       |
   60|   886k|    if (now - nTime > ADDRMAN_HORIZON) { // not seen in recent history
  ------------------
  |  Branch (60:9): [True: 845k, False: 40.9k]
  ------------------
   61|   845k|        return true;
   62|   845k|    }
   63|       |
   64|  40.9k|    if (TicksSinceEpoch<std::chrono::seconds>(m_last_success) == 0 && nAttempts >= ADDRMAN_RETRIES) { // tried N times and never a success
  ------------------
  |  Branch (64:9): [True: 39.6k, False: 1.29k]
  |  Branch (64:71): [True: 20, False: 39.6k]
  ------------------
   65|     20|        return true;
   66|     20|    }
   67|       |
   68|  40.8k|    if (now - m_last_success > ADDRMAN_MIN_FAIL && nAttempts >= ADDRMAN_MAX_FAILURES) { // N successive failures in the last week
  ------------------
  |  Branch (68:9): [True: 40.4k, False: 450]
  |  Branch (68:9): [True: 15, False: 40.8k]
  |  Branch (68:52): [True: 15, False: 40.4k]
  ------------------
   69|     15|        return true;
   70|     15|    }
   71|       |
   72|  40.8k|    return false;
   73|  40.8k|}
_ZNK8AddrInfo9GetChanceENSt3__16chrono10time_pointI9NodeClockNS1_8durationIxNS0_5ratioILl1ELl1EEEEEEE:
   76|  11.6k|{
   77|  11.6k|    double fChance = 1.0;
   78|       |
   79|       |    // deprioritize very recent attempts away
   80|  11.6k|    if (now - m_last_try < 10min) {
  ------------------
  |  Branch (80:9): [True: 5.87k, False: 5.78k]
  ------------------
   81|  5.87k|        fChance *= 0.01;
   82|  5.87k|    }
   83|       |
   84|       |    // deprioritize 66% after each failed attempt, but at most 1/28th to avoid the search taking forever or overly penalizing outages.
   85|  11.6k|    fChance *= pow(0.66, std::min(nAttempts, 8));
   86|       |
   87|  11.6k|    return fChance;
   88|  11.6k|}
_ZN11AddrManImplC2ERK15NetGroupManagerbi:
   91|  9.68k|    : insecure_rand{deterministic}
   92|  9.68k|    , nKey{deterministic ? uint256{1} : insecure_rand.rand256()}
  ------------------
  |  Branch (92:12): [True: 9.68k, False: 0]
  ------------------
   93|  9.68k|    , m_consistency_check_ratio{consistency_check_ratio}
   94|  9.68k|    , m_netgroupman{netgroupman}
   95|  9.68k|{
   96|  9.91M|    for (auto& bucket : vvNew) {
  ------------------
  |  Branch (96:23): [True: 9.91M, False: 9.68k]
  ------------------
   97|   634M|        for (auto& entry : bucket) {
  ------------------
  |  Branch (97:26): [True: 634M, False: 9.91M]
  ------------------
   98|   634M|            entry = -1;
   99|   634M|        }
  100|  9.91M|    }
  101|  2.47M|    for (auto& bucket : vvTried) {
  ------------------
  |  Branch (101:23): [True: 2.47M, False: 9.68k]
  ------------------
  102|   158M|        for (auto& entry : bucket) {
  ------------------
  |  Branch (102:26): [True: 158M, False: 2.47M]
  ------------------
  103|   158M|            entry = -1;
  104|   158M|        }
  105|  2.47M|    }
  106|  9.68k|}
_ZN11AddrManImplD2Ev:
  109|  9.68k|{
  110|  9.68k|    nKey.SetNull();
  111|  9.68k|}
_ZN11AddrManImpl4FindERK8CServicePl:
  383|  5.96M|{
  384|  5.96M|    AssertLockHeld(cs);
  ------------------
  |  |  144|  5.96M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  385|       |
  386|  5.96M|    const auto it = mapAddr.find(addr);
  387|  5.96M|    if (it == mapAddr.end())
  ------------------
  |  Branch (387:9): [True: 4.52M, False: 1.43M]
  ------------------
  388|  4.52M|        return nullptr;
  389|  1.43M|    if (pnId)
  ------------------
  |  Branch (389:9): [True: 1.41M, False: 24.5k]
  ------------------
  390|  1.41M|        *pnId = (*it).second;
  391|  1.43M|    const auto it2 = mapInfo.find((*it).second);
  392|  1.43M|    if (it2 != mapInfo.end())
  ------------------
  |  Branch (392:9): [True: 1.43M, False: 0]
  ------------------
  393|  1.43M|        return &(*it2).second;
  394|      0|    return nullptr;
  395|  1.43M|}
_ZN11AddrManImpl6CreateERK8CAddressRK8CNetAddrPl:
  398|  4.02M|{
  399|  4.02M|    AssertLockHeld(cs);
  ------------------
  |  |  144|  4.02M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  400|       |
  401|  4.02M|    nid_type nId = nIdCount++;
  402|  4.02M|    mapInfo[nId] = AddrInfo(addr, addrSource);
  403|  4.02M|    mapAddr[addr] = nId;
  404|  4.02M|    mapInfo[nId].nRandomPos = vRandom.size();
  405|  4.02M|    vRandom.push_back(nId);
  406|  4.02M|    nNew++;
  407|  4.02M|    m_network_counts[addr.GetNetwork()].n_new++;
  408|  4.02M|    if (pnId)
  ------------------
  |  Branch (408:9): [True: 4.02M, False: 0]
  ------------------
  409|  4.02M|        *pnId = nId;
  410|  4.02M|    return &mapInfo[nId];
  411|  4.02M|}
_ZNK11AddrManImpl10SwapRandomEjj:
  414|  3.95M|{
  415|  3.95M|    AssertLockHeld(cs);
  ------------------
  |  |  144|  3.95M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  416|       |
  417|  3.95M|    if (nRndPos1 == nRndPos2)
  ------------------
  |  Branch (417:9): [True: 62.3k, False: 3.89M]
  ------------------
  418|  62.3k|        return;
  419|       |
  420|  3.95M|    assert(nRndPos1 < vRandom.size() && nRndPos2 < vRandom.size());
  ------------------
  |  Branch (420:5): [True: 3.89M, False: 0]
  |  Branch (420:5): [True: 3.89M, False: 0]
  |  Branch (420:5): [True: 3.89M, False: 0]
  ------------------
  421|       |
  422|  3.89M|    nid_type nId1 = vRandom[nRndPos1];
  423|  3.89M|    nid_type nId2 = vRandom[nRndPos2];
  424|       |
  425|  3.89M|    const auto it_1{mapInfo.find(nId1)};
  426|  3.89M|    const auto it_2{mapInfo.find(nId2)};
  427|  3.89M|    assert(it_1 != mapInfo.end());
  ------------------
  |  Branch (427:5): [True: 3.89M, False: 0]
  ------------------
  428|  3.89M|    assert(it_2 != mapInfo.end());
  ------------------
  |  Branch (428:5): [True: 3.89M, False: 0]
  ------------------
  429|       |
  430|  3.89M|    it_1->second.nRandomPos = nRndPos2;
  431|  3.89M|    it_2->second.nRandomPos = nRndPos1;
  432|       |
  433|  3.89M|    vRandom[nRndPos1] = nId2;
  434|  3.89M|    vRandom[nRndPos2] = nId1;
  435|  3.89M|}
_ZN11AddrManImpl6DeleteEl:
  438|  2.69M|{
  439|  2.69M|    AssertLockHeld(cs);
  ------------------
  |  |  144|  2.69M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  440|       |
  441|  2.69M|    assert(mapInfo.contains(nId));
  ------------------
  |  Branch (441:5): [True: 2.69M, False: 0]
  ------------------
  442|  2.69M|    AddrInfo& info = mapInfo[nId];
  443|  2.69M|    assert(!info.fInTried);
  ------------------
  |  Branch (443:5): [True: 2.69M, False: 0]
  ------------------
  444|  2.69M|    assert(info.nRefCount == 0);
  ------------------
  |  Branch (444:5): [True: 2.69M, False: 0]
  ------------------
  445|       |
  446|  2.69M|    SwapRandom(info.nRandomPos, vRandom.size() - 1);
  447|  2.69M|    m_network_counts[info.GetNetwork()].n_new--;
  448|  2.69M|    vRandom.pop_back();
  449|  2.69M|    mapAddr.erase(info);
  450|  2.69M|    mapInfo.erase(nId);
  451|  2.69M|    nNew--;
  452|  2.69M|}
_ZN11AddrManImpl8ClearNewEii:
  455|  4.04M|{
  456|  4.04M|    AssertLockHeld(cs);
  ------------------
  |  |  144|  4.04M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  457|       |
  458|       |    // if there is an entry in the specified bucket, delete it.
  459|  4.04M|    if (vvNew[nUBucket][nUBucketPos] != -1) {
  ------------------
  |  Branch (459:9): [True: 2.66M, False: 1.37M]
  ------------------
  460|  2.66M|        nid_type nIdDelete = vvNew[nUBucket][nUBucketPos];
  461|  2.66M|        AddrInfo& infoDelete = mapInfo[nIdDelete];
  462|  2.66M|        assert(infoDelete.nRefCount > 0);
  ------------------
  |  Branch (462:9): [True: 2.66M, False: 0]
  ------------------
  463|  2.66M|        infoDelete.nRefCount--;
  464|  2.66M|        vvNew[nUBucket][nUBucketPos] = -1;
  465|  2.66M|        LogDebug(BCLog::ADDRMAN, "Removed %s from new[%i][%i]\n", infoDelete.ToStringAddrPort(), nUBucket, nUBucketPos);
  ------------------
  |  |  143|  2.66M|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|  2.66M|    do {                                                                                      \
  |  |  |  |  137|  2.66M|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 2.66M]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|  2.66M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 2.66M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  466|  2.66M|        if (infoDelete.nRefCount == 0) {
  ------------------
  |  Branch (466:13): [True: 2.64M, False: 24.2k]
  ------------------
  467|  2.64M|            Delete(nIdDelete);
  468|  2.64M|        }
  469|  2.66M|    }
  470|  4.04M|}
_ZN11AddrManImpl9MakeTriedER8AddrInfol:
  473|  62.3k|{
  474|  62.3k|    AssertLockHeld(cs);
  ------------------
  |  |  144|  62.3k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  475|       |
  476|       |    // remove the entry from all new buckets
  477|  62.3k|    const int start_bucket{info.GetNewBucket(nKey, m_netgroupman)};
  478|  5.26M|    for (int n = 0; n < ADDRMAN_NEW_BUCKET_COUNT; ++n) {
  ------------------
  |  Branch (478:21): [True: 5.26M, False: 0]
  ------------------
  479|  5.26M|        const int bucket{(start_bucket + n) % ADDRMAN_NEW_BUCKET_COUNT};
  480|  5.26M|        const int pos{info.GetBucketPosition(nKey, true, bucket)};
  481|  5.26M|        if (vvNew[bucket][pos] == nId) {
  ------------------
  |  Branch (481:13): [True: 73.8k, False: 5.18M]
  ------------------
  482|  73.8k|            vvNew[bucket][pos] = -1;
  483|  73.8k|            info.nRefCount--;
  484|  73.8k|            if (info.nRefCount == 0) break;
  ------------------
  |  Branch (484:17): [True: 62.3k, False: 11.4k]
  ------------------
  485|  73.8k|        }
  486|  5.26M|    }
  487|  62.3k|    nNew--;
  488|  62.3k|    m_network_counts[info.GetNetwork()].n_new--;
  489|       |
  490|  62.3k|    assert(info.nRefCount == 0);
  ------------------
  |  Branch (490:5): [True: 62.3k, False: 0]
  ------------------
  491|       |
  492|       |    // which tried bucket to move the entry to
  493|  62.3k|    int nKBucket = info.GetTriedBucket(nKey, m_netgroupman);
  494|  62.3k|    int nKBucketPos = info.GetBucketPosition(nKey, false, nKBucket);
  495|       |
  496|       |    // first make space to add it (the existing tried entry there is moved to new, deleting whatever is there).
  497|  62.3k|    if (vvTried[nKBucket][nKBucketPos] != -1) {
  ------------------
  |  Branch (497:9): [True: 5.76k, False: 56.5k]
  ------------------
  498|       |        // find an item to evict
  499|  5.76k|        nid_type nIdEvict = vvTried[nKBucket][nKBucketPos];
  500|  5.76k|        assert(mapInfo.contains(nIdEvict));
  ------------------
  |  Branch (500:9): [True: 5.76k, False: 0]
  ------------------
  501|  5.76k|        AddrInfo& infoOld = mapInfo[nIdEvict];
  502|       |
  503|       |        // Remove the to-be-evicted item from the tried set.
  504|  5.76k|        infoOld.fInTried = false;
  505|  5.76k|        vvTried[nKBucket][nKBucketPos] = -1;
  506|  5.76k|        nTried--;
  507|  5.76k|        m_network_counts[infoOld.GetNetwork()].n_tried--;
  508|       |
  509|       |        // find which new bucket it belongs to
  510|  5.76k|        int nUBucket = infoOld.GetNewBucket(nKey, m_netgroupman);
  511|  5.76k|        int nUBucketPos = infoOld.GetBucketPosition(nKey, true, nUBucket);
  512|  5.76k|        ClearNew(nUBucket, nUBucketPos);
  513|  5.76k|        assert(vvNew[nUBucket][nUBucketPos] == -1);
  ------------------
  |  Branch (513:9): [True: 5.76k, False: 0]
  ------------------
  514|       |
  515|       |        // Enter it into the new set again.
  516|  5.76k|        infoOld.nRefCount = 1;
  517|  5.76k|        vvNew[nUBucket][nUBucketPos] = nIdEvict;
  518|  5.76k|        nNew++;
  519|  5.76k|        m_network_counts[infoOld.GetNetwork()].n_new++;
  520|  5.76k|        LogDebug(BCLog::ADDRMAN, "Moved %s from tried[%i][%i] to new[%i][%i] to make space\n",
  ------------------
  |  |  143|  5.76k|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|  5.76k|    do {                                                                                      \
  |  |  |  |  137|  5.76k|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 5.76k]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|  5.76k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 5.76k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  521|  5.76k|                 infoOld.ToStringAddrPort(), nKBucket, nKBucketPos, nUBucket, nUBucketPos);
  522|  5.76k|    }
  523|  62.3k|    assert(vvTried[nKBucket][nKBucketPos] == -1);
  ------------------
  |  Branch (523:5): [True: 62.3k, False: 0]
  ------------------
  524|       |
  525|  62.3k|    vvTried[nKBucket][nKBucketPos] = nId;
  526|  62.3k|    nTried++;
  527|  62.3k|    info.fInTried = true;
  528|  62.3k|    m_network_counts[info.GetNetwork()].n_tried++;
  529|  62.3k|}
_ZN11AddrManImpl9AddSingleERK8CAddressRK8CNetAddrNSt3__16chrono8durationIxNS6_5ratioILl1ELl1EEEEE:
  532|  5.12M|{
  533|  5.12M|    AssertLockHeld(cs);
  ------------------
  |  |  144|  5.12M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  534|       |
  535|  5.12M|    if (!addr.IsRoutable())
  ------------------
  |  Branch (535:9): [True: 62.5k, False: 5.06M]
  ------------------
  536|  62.5k|        return false;
  537|       |
  538|  5.06M|    nid_type nId;
  539|  5.06M|    AddrInfo* pinfo = Find(addr, &nId);
  540|       |
  541|       |    // Do not set a penalty for a source's self-announcement
  542|  5.06M|    if (addr == source) {
  ------------------
  |  Branch (542:9): [True: 86.8k, False: 4.97M]
  ------------------
  543|  86.8k|        time_penalty = 0s;
  544|  86.8k|    }
  545|       |
  546|  5.06M|    if (pinfo) {
  ------------------
  |  Branch (546:9): [True: 1.03M, False: 4.02M]
  ------------------
  547|       |        // periodically update nTime
  548|  1.03M|        const bool currently_online{NodeClock::now() - addr.nTime < 24h};
  549|  1.03M|        const auto update_interval{currently_online ? 1h : 24h};
  ------------------
  |  Branch (549:36): [True: 660k, False: 375k]
  ------------------
  550|  1.03M|        if (pinfo->nTime < addr.nTime - update_interval - time_penalty) {
  ------------------
  |  Branch (550:13): [True: 55.3k, False: 979k]
  ------------------
  551|  55.3k|            pinfo->nTime = std::max(NodeSeconds{0s}, addr.nTime - time_penalty);
  552|  55.3k|        }
  553|       |
  554|       |        // add services
  555|  1.03M|        pinfo->nServices = ServiceFlags(pinfo->nServices | addr.nServices);
  556|       |
  557|       |        // do not update if no new information is present
  558|  1.03M|        if (addr.nTime <= pinfo->nTime) {
  ------------------
  |  Branch (558:13): [True: 303k, False: 731k]
  ------------------
  559|   303k|            return false;
  560|   303k|        }
  561|       |
  562|       |        // do not update if the entry was already in the "tried" table
  563|   731k|        if (pinfo->fInTried)
  ------------------
  |  Branch (563:13): [True: 233k, False: 498k]
  ------------------
  564|   233k|            return false;
  565|       |
  566|       |        // do not update if the max reference count is reached
  567|   498k|        if (pinfo->nRefCount == ADDRMAN_NEW_BUCKETS_PER_ADDRESS)
  ------------------
  |  Branch (567:13): [True: 296, False: 498k]
  ------------------
  568|    296|            return false;
  569|       |
  570|       |        // stochastic test: previous nRefCount == N: 2^N times harder to increase it
  571|   498k|        if (pinfo->nRefCount > 0) {
  ------------------
  |  Branch (571:13): [True: 498k, False: 0]
  ------------------
  572|   498k|            const int nFactor{1 << pinfo->nRefCount};
  573|   498k|            if (insecure_rand.randrange(nFactor) != 0) return false;
  ------------------
  |  Branch (573:17): [True: 284k, False: 213k]
  ------------------
  574|   498k|        }
  575|  4.02M|    } else {
  576|  4.02M|        pinfo = Create(addr, source, &nId);
  577|  4.02M|        pinfo->nTime = std::max(NodeSeconds{0s}, pinfo->nTime - time_penalty);
  578|  4.02M|    }
  579|       |
  580|  4.23M|    int nUBucket = pinfo->GetNewBucket(nKey, source, m_netgroupman);
  581|  4.23M|    int nUBucketPos = pinfo->GetBucketPosition(nKey, true, nUBucket);
  582|  4.23M|    bool fInsert = vvNew[nUBucket][nUBucketPos] == -1;
  583|  4.23M|    if (vvNew[nUBucket][nUBucketPos] != nId) {
  ------------------
  |  Branch (583:9): [True: 4.08M, False: 151k]
  ------------------
  584|  4.08M|        if (!fInsert) {
  ------------------
  |  Branch (584:13): [True: 2.71M, False: 1.37M]
  ------------------
  585|  2.71M|            AddrInfo& infoExisting = mapInfo[vvNew[nUBucket][nUBucketPos]];
  586|  2.71M|            if (infoExisting.IsTerrible() || (infoExisting.nRefCount > 1 && pinfo->nRefCount == 0)) {
  ------------------
  |  Branch (586:17): [True: 2.66M, False: 49.9k]
  |  Branch (586:47): [True: 1.76k, False: 48.1k]
  |  Branch (586:77): [True: 1.18k, False: 581]
  ------------------
  587|       |                // Overwrite the existing new table entry.
  588|  2.66M|                fInsert = true;
  589|  2.66M|            }
  590|  2.71M|        }
  591|  4.08M|        if (fInsert) {
  ------------------
  |  Branch (591:13): [True: 4.03M, False: 48.7k]
  ------------------
  592|  4.03M|            ClearNew(nUBucket, nUBucketPos);
  593|  4.03M|            pinfo->nRefCount++;
  594|  4.03M|            vvNew[nUBucket][nUBucketPos] = nId;
  595|  4.03M|            const auto mapped_as{m_netgroupman.GetMappedAS(addr)};
  596|  4.03M|            LogDebug(BCLog::ADDRMAN, "Added %s%s to new[%i][%i]\n",
  ------------------
  |  |  143|  4.03M|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|  4.03M|    do {                                                                                      \
  |  |  |  |  137|  4.03M|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 4.03M]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (119:129): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|  4.03M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 4.03M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  597|  4.03M|                     addr.ToStringAddrPort(), (mapped_as ? strprintf(" mapped to AS%i", mapped_as) : ""), nUBucket, nUBucketPos);
  598|  4.03M|        } else {
  599|  48.7k|            if (pinfo->nRefCount == 0) {
  ------------------
  |  Branch (599:17): [True: 46.5k, False: 2.21k]
  ------------------
  600|  46.5k|                Delete(nId);
  601|  46.5k|            }
  602|  48.7k|        }
  603|  4.08M|    }
  604|  4.23M|    return fInsert;
  605|  5.06M|}
_ZN11AddrManImpl5Good_ERK8CServicebNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
  608|   773k|{
  609|   773k|    AssertLockHeld(cs);
  ------------------
  |  |  144|   773k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  610|       |
  611|   773k|    nid_type nId;
  612|       |
  613|   773k|    m_last_good = time;
  614|       |
  615|   773k|    AddrInfo* pinfo = Find(addr, &nId);
  616|       |
  617|       |    // if not found, bail out
  618|   773k|    if (!pinfo) return false;
  ------------------
  |  Branch (618:9): [True: 393k, False: 380k]
  ------------------
  619|       |
  620|   380k|    AddrInfo& info = *pinfo;
  621|       |
  622|       |    // update info
  623|   380k|    info.m_last_success = time;
  624|   380k|    info.m_last_try = time;
  625|   380k|    info.nAttempts = 0;
  626|       |    // nTime is not updated here, to avoid leaking information about
  627|       |    // currently-connected peers.
  628|       |
  629|       |    // if it is already in the tried set, don't do anything else
  630|   380k|    if (info.fInTried) return false;
  ------------------
  |  Branch (630:9): [True: 235k, False: 144k]
  ------------------
  631|       |
  632|       |    // if it is not in new, something bad happened
  633|   144k|    if (!Assume(info.nRefCount > 0)) return false;
  ------------------
  |  |  128|   144k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  |  Branch (633:9): [True: 0, False: 144k]
  ------------------
  634|       |
  635|       |
  636|       |    // which tried bucket to move the entry to
  637|   144k|    int tried_bucket = info.GetTriedBucket(nKey, m_netgroupman);
  638|   144k|    int tried_bucket_pos = info.GetBucketPosition(nKey, false, tried_bucket);
  639|       |
  640|       |    // Will moving this address into tried evict another entry?
  641|   144k|    if (test_before_evict && (vvTried[tried_bucket][tried_bucket_pos] != -1)) {
  ------------------
  |  Branch (641:9): [True: 139k, False: 5.76k]
  |  Branch (641:30): [True: 82.5k, False: 56.5k]
  ------------------
  642|  82.5k|        if (m_tried_collisions.size() < ADDRMAN_SET_TRIED_COLLISION_SIZE) {
  ------------------
  |  Branch (642:13): [True: 74.5k, False: 7.98k]
  ------------------
  643|  74.5k|            m_tried_collisions.insert(nId);
  644|  74.5k|        }
  645|       |        // Output the entry we'd be colliding with, for debugging purposes
  646|  82.5k|        auto colliding_entry = mapInfo.find(vvTried[tried_bucket][tried_bucket_pos]);
  647|  82.5k|        LogDebug(BCLog::ADDRMAN, "Collision with %s while attempting to move %s to tried table. Collisions=%d",
  ------------------
  |  |  143|  82.5k|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|  82.5k|    do {                                                                                      \
  |  |  |  |  137|  82.5k|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 82.5k]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (119:129): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|  82.5k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 82.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  648|  82.5k|                 colliding_entry != mapInfo.end() ? colliding_entry->second.ToStringAddrPort() : "<unknown-addr>",
  649|  82.5k|                 addr.ToStringAddrPort(),
  650|  82.5k|                 m_tried_collisions.size());
  651|  82.5k|        return false;
  652|  82.5k|    } else {
  653|       |        // move nId to the tried tables
  654|  62.3k|        MakeTried(info, nId);
  655|  62.3k|        const auto mapped_as{m_netgroupman.GetMappedAS(addr)};
  656|  62.3k|        LogDebug(BCLog::ADDRMAN, "Moved %s%s to tried[%i][%i]\n",
  ------------------
  |  |  143|  62.3k|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|  62.3k|    do {                                                                                      \
  |  |  |  |  137|  62.3k|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 62.3k]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (119:129): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|  62.3k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 62.3k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  657|  62.3k|                 addr.ToStringAddrPort(), (mapped_as ? strprintf(" mapped to AS%i", mapped_as) : ""), tried_bucket, tried_bucket_pos);
  658|  62.3k|        return true;
  659|  62.3k|    }
  660|   144k|}
_ZN11AddrManImpl4Add_ERKNSt3__16vectorI8CAddressNS0_9allocatorIS2_EEEERK8CNetAddrNS0_6chrono8durationIxNS0_5ratioILl1ELl1EEEEE:
  663|  38.6k|{
  664|  38.6k|    int added{0};
  665|  5.16M|    for (std::vector<CAddress>::const_iterator it = vAddr.begin(); it != vAddr.end(); it++) {
  ------------------
  |  Branch (665:68): [True: 5.12M, False: 38.6k]
  ------------------
  666|  5.12M|        added += AddSingle(*it, source, time_penalty) ? 1 : 0;
  ------------------
  |  Branch (666:18): [True: 4.03M, False: 1.08M]
  ------------------
  667|  5.12M|    }
  668|  38.6k|    if (added > 0) {
  ------------------
  |  Branch (668:9): [True: 29.1k, False: 9.56k]
  ------------------
  669|  29.1k|        LogDebug(BCLog::ADDRMAN, "Added %i addresses (of %i) from %s: %i tried, %i new\n", added, vAddr.size(), source.ToStringAddr(), nTried, nNew);
  ------------------
  |  |  143|  29.1k|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|  29.1k|    do {                                                                                      \
  |  |  |  |  137|  29.1k|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 29.1k]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|  29.1k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 29.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  670|  29.1k|    }
  671|  38.6k|    return added > 0;
  672|  38.6k|}
_ZN11AddrManImpl8Attempt_ERK8CServicebNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
  675|  21.0k|{
  676|  21.0k|    AssertLockHeld(cs);
  ------------------
  |  |  144|  21.0k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  677|       |
  678|  21.0k|    AddrInfo* pinfo = Find(addr);
  679|       |
  680|       |    // if not found, bail out
  681|  21.0k|    if (!pinfo)
  ------------------
  |  Branch (681:9): [True: 15.1k, False: 5.83k]
  ------------------
  682|  15.1k|        return;
  683|       |
  684|  5.83k|    AddrInfo& info = *pinfo;
  685|       |
  686|       |    // update info
  687|  5.83k|    info.m_last_try = time;
  688|  5.83k|    if (fCountFailure && info.m_last_count_attempt < m_last_good) {
  ------------------
  |  Branch (688:9): [True: 5.45k, False: 378]
  |  Branch (688:26): [True: 2.25k, False: 3.20k]
  ------------------
  689|  2.25k|        info.m_last_count_attempt = time;
  690|  2.25k|        info.nAttempts++;
  691|  2.25k|    }
  692|  5.83k|}
_ZNK11AddrManImpl7Select_EbRKNSt3__113unordered_setI7NetworkNS0_4hashIS2_EENS0_8equal_toIS2_EENS0_9allocatorIS2_EEEE:
  695|  7.16k|{
  696|  7.16k|    AssertLockHeld(cs);
  ------------------
  |  |  144|  7.16k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  697|       |
  698|  7.16k|    if (vRandom.empty()) return {};
  ------------------
  |  Branch (698:9): [True: 2.23k, False: 4.93k]
  ------------------
  699|       |
  700|  4.93k|    size_t new_count = nNew;
  701|  4.93k|    size_t tried_count = nTried;
  702|       |
  703|  4.93k|    if (!networks.empty()) {
  ------------------
  |  Branch (703:9): [True: 648, False: 4.28k]
  ------------------
  704|    648|        new_count = 0;
  705|    648|        tried_count = 0;
  706|  2.78k|        for (auto& network : networks) {
  ------------------
  |  Branch (706:28): [True: 2.78k, False: 648]
  ------------------
  707|  2.78k|            auto it = m_network_counts.find(network);
  708|  2.78k|            if (it == m_network_counts.end()) {
  ------------------
  |  Branch (708:17): [True: 1.54k, False: 1.24k]
  ------------------
  709|  1.54k|                continue;
  710|  1.54k|            }
  711|  1.24k|            auto counts = it->second;
  712|  1.24k|            new_count += counts.n_new;
  713|  1.24k|            tried_count += counts.n_tried;
  714|  1.24k|        }
  715|    648|    }
  716|       |
  717|  4.93k|    if (new_only && new_count == 0) return {};
  ------------------
  |  Branch (717:9): [True: 364, False: 4.57k]
  |  Branch (717:21): [True: 27, False: 337]
  ------------------
  718|  4.90k|    if (new_count + tried_count == 0) return {};
  ------------------
  |  Branch (718:9): [True: 37, False: 4.87k]
  ------------------
  719|       |
  720|       |    // Decide if we are going to search the new or tried table
  721|       |    // If either option is viable, use a 50% chance to choose
  722|  4.87k|    bool search_tried;
  723|  4.87k|    if (new_only || tried_count == 0) {
  ------------------
  |  Branch (723:9): [True: 337, False: 4.53k]
  |  Branch (723:21): [True: 3.30k, False: 1.23k]
  ------------------
  724|  3.63k|        search_tried = false;
  725|  3.63k|    } else if (new_count == 0) {
  ------------------
  |  Branch (725:16): [True: 275, False: 957]
  ------------------
  726|    275|        search_tried = true;
  727|    957|    } else {
  728|    957|        search_tried = insecure_rand.randbool();
  729|    957|    }
  730|       |
  731|  4.87k|    const int bucket_count{search_tried ? ADDRMAN_TRIED_BUCKET_COUNT : ADDRMAN_NEW_BUCKET_COUNT};
  ------------------
  |  Branch (731:28): [True: 786, False: 4.08k]
  ------------------
  732|       |
  733|       |    // Loop through the addrman table until we find an appropriate entry
  734|  4.87k|    double chance_factor = 1.0;
  735|  5.67M|    while (1) {
  ------------------
  |  Branch (735:12): [True: 5.67M, Folded]
  ------------------
  736|       |        // Pick a bucket, and an initial position in that bucket.
  737|  5.67M|        int bucket = insecure_rand.randrange(bucket_count);
  738|  5.67M|        int initial_position = insecure_rand.randrange(ADDRMAN_BUCKET_SIZE);
  739|       |
  740|       |        // Iterate over the positions of that bucket, starting at the initial one,
  741|       |        // and looping around.
  742|  5.67M|        int i, position;
  743|  5.67M|        nid_type node_id;
  744|   368M|        for (i = 0; i < ADDRMAN_BUCKET_SIZE; ++i) {
  ------------------
  |  Branch (744:21): [True: 362M, False: 5.66M]
  ------------------
  745|   362M|            position = (initial_position + i) % ADDRMAN_BUCKET_SIZE;
  746|   362M|            node_id = GetEntry(search_tried, bucket, position);
  747|   362M|            if (node_id != -1) {
  ------------------
  |  Branch (747:17): [True: 137k, False: 362M]
  ------------------
  748|   137k|                if (!networks.empty()) {
  ------------------
  |  Branch (748:21): [True: 127k, False: 10.3k]
  ------------------
  749|   127k|                    const auto it{mapInfo.find(node_id)};
  750|   127k|                    if (Assume(it != mapInfo.end()) && networks.contains(it->second.GetNetwork())) break;
  ------------------
  |  |  128|   254k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  |  |  ------------------
  |  |  |  Branch (128:21): [True: 127k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (750:25): [True: 1.33k, False: 125k]
  |  Branch (750:56): [True: 1.33k, False: 125k]
  ------------------
  751|   127k|                } else {
  752|  10.3k|                    break;
  753|  10.3k|                }
  754|   137k|            }
  755|   362M|        }
  756|       |
  757|       |        // If the bucket is entirely empty, start over with a (likely) different one.
  758|  5.67M|        if (i == ADDRMAN_BUCKET_SIZE) continue;
  ------------------
  |  Branch (758:13): [True: 5.66M, False: 11.6k]
  ------------------
  759|       |
  760|       |        // Find the entry to return.
  761|  11.6k|        const auto it_found{mapInfo.find(node_id)};
  762|  11.6k|        assert(it_found != mapInfo.end());
  ------------------
  |  Branch (762:9): [True: 11.6k, False: 0]
  ------------------
  763|  11.6k|        const AddrInfo& info{it_found->second};
  764|       |
  765|       |        // With probability GetChance() * chance_factor, return the entry.
  766|  11.6k|        if (insecure_rand.randbits<30>() < chance_factor * info.GetChance() * (1 << 30)) {
  ------------------
  |  Branch (766:13): [True: 4.87k, False: 6.78k]
  ------------------
  767|  4.87k|            LogDebug(BCLog::ADDRMAN, "Selected %s from %s\n", info.ToStringAddrPort(), search_tried ? "tried" : "new");
  ------------------
  |  |  143|  4.87k|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|  4.87k|    do {                                                                                      \
  |  |  |  |  137|  4.87k|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 4.87k]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (119:129): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|  4.87k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 4.87k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  768|  4.87k|            return {info, info.m_last_try};
  769|  4.87k|        }
  770|       |
  771|       |        // Otherwise start over with a (likely) different bucket, and increased chance factor.
  772|  6.78k|        chance_factor *= 1.2;
  773|  6.78k|    }
  774|  4.87k|}
_ZNK11AddrManImpl8GetEntryEbmm:
  777|   362M|{
  778|   362M|    AssertLockHeld(cs);
  ------------------
  |  |  144|   362M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  779|       |
  780|   362M|    if (use_tried) {
  ------------------
  |  Branch (780:9): [True: 57.0M, False: 305M]
  ------------------
  781|  57.0M|        if (Assume(position < ADDRMAN_BUCKET_SIZE) && Assume(bucket < ADDRMAN_TRIED_BUCKET_COUNT)) {
  ------------------
  |  |  128|   114M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  |  |  ------------------
  |  |  |  Branch (128:21): [True: 57.0M, False: 0]
  |  |  ------------------
  ------------------
                      if (Assume(position < ADDRMAN_BUCKET_SIZE) && Assume(bucket < ADDRMAN_TRIED_BUCKET_COUNT)) {
  ------------------
  |  |  128|  57.0M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  |  |  ------------------
  |  |  |  Branch (128:21): [True: 57.0M, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (781:13): [True: 57.0M, False: 0]
  ------------------
  782|  57.0M|            return vvTried[bucket][position];
  783|  57.0M|        }
  784|   305M|    } else {
  785|   305M|        if (Assume(position < ADDRMAN_BUCKET_SIZE) && Assume(bucket < ADDRMAN_NEW_BUCKET_COUNT)) {
  ------------------
  |  |  128|   611M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  |  |  ------------------
  |  |  |  Branch (128:21): [True: 305M, False: 0]
  |  |  ------------------
  ------------------
                      if (Assume(position < ADDRMAN_BUCKET_SIZE) && Assume(bucket < ADDRMAN_NEW_BUCKET_COUNT)) {
  ------------------
  |  |  128|   305M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  |  |  ------------------
  |  |  |  Branch (128:21): [True: 305M, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (785:13): [True: 305M, False: 0]
  ------------------
  786|   305M|            return vvNew[bucket][position];
  787|   305M|        }
  788|   305M|    }
  789|       |
  790|      0|    return -1;
  791|   362M|}
_ZNK11AddrManImpl8GetAddr_EmmNSt3__18optionalI7NetworkEEb:
  794|  7.16k|{
  795|  7.16k|    AssertLockHeld(cs);
  ------------------
  |  |  144|  7.16k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  796|  7.16k|    Assume(max_pct <= 100);
  ------------------
  |  |  128|  7.16k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  797|       |
  798|  7.16k|    size_t nNodes = vRandom.size();
  799|  7.16k|    if (max_pct != 0) {
  ------------------
  |  Branch (799:9): [True: 691, False: 6.47k]
  ------------------
  800|    691|        max_pct = std::min(max_pct, size_t{100});
  801|    691|        nNodes = max_pct * nNodes / 100;
  802|    691|    }
  803|  7.16k|    if (max_addresses != 0) {
  ------------------
  |  Branch (803:9): [True: 785, False: 6.38k]
  ------------------
  804|    785|        nNodes = std::min(nNodes, max_addresses);
  805|    785|    }
  806|       |
  807|       |    // gather a list of random nodes, skipping those of low quality
  808|  7.16k|    const auto now{Now<NodeSeconds>()};
  809|  7.16k|    std::vector<CAddress> addresses;
  810|  7.16k|    addresses.reserve(nNodes);
  811|  1.26M|    for (unsigned int n = 0; n < vRandom.size(); n++) {
  ------------------
  |  Branch (811:30): [True: 1.26M, False: 6.93k]
  ------------------
  812|  1.26M|        if (addresses.size() >= nNodes)
  ------------------
  |  Branch (812:13): [True: 236, False: 1.26M]
  ------------------
  813|    236|            break;
  814|       |
  815|  1.26M|        int nRndPos = insecure_rand.randrange(vRandom.size() - n) + n;
  816|  1.26M|        SwapRandom(n, nRndPos);
  817|  1.26M|        const auto it{mapInfo.find(vRandom[n])};
  818|  1.26M|        assert(it != mapInfo.end());
  ------------------
  |  Branch (818:9): [True: 1.26M, False: 0]
  ------------------
  819|       |
  820|  1.26M|        const AddrInfo& ai{it->second};
  821|       |
  822|       |        // Filter by network (optional)
  823|  1.26M|        if (network != std::nullopt && ai.GetNetClass() != network) continue;
  ------------------
  |  Branch (823:13): [True: 217k, False: 1.04M]
  |  Branch (823:13): [True: 202k, False: 1.05M]
  |  Branch (823:40): [True: 202k, False: 14.5k]
  ------------------
  824|       |
  825|       |        // Filter for quality
  826|  1.05M|        if (ai.IsTerrible(now) && filtered) continue;
  ------------------
  |  Branch (826:13): [True: 1.03M, False: 25.3k]
  |  Branch (826:35): [True: 87.8k, False: 945k]
  ------------------
  827|       |
  828|   970k|        addresses.push_back(ai);
  829|   970k|    }
  830|  7.16k|    LogDebug(BCLog::ADDRMAN, "GetAddr returned %d random addresses\n", addresses.size());
  ------------------
  |  |  143|  7.16k|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|  7.16k|    do {                                                                                      \
  |  |  |  |  137|  7.16k|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 7.16k]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|  7.16k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 7.16k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  831|  7.16k|    return addresses;
  832|  7.16k|}
_ZN11AddrManImpl10Connected_ERK8CServiceNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
  859|  31.7k|{
  860|  31.7k|    AssertLockHeld(cs);
  ------------------
  |  |  144|  31.7k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  861|       |
  862|  31.7k|    AddrInfo* pinfo = Find(addr);
  863|       |
  864|       |    // if not found, bail out
  865|  31.7k|    if (!pinfo)
  ------------------
  |  Branch (865:9): [True: 18.8k, False: 12.8k]
  ------------------
  866|  18.8k|        return;
  867|       |
  868|  12.8k|    AddrInfo& info = *pinfo;
  869|       |
  870|       |    // update info
  871|  12.8k|    const auto update_interval{20min};
  872|  12.8k|    if (time - info.nTime > update_interval) {
  ------------------
  |  Branch (872:9): [True: 1.34k, False: 11.5k]
  ------------------
  873|  1.34k|        info.nTime = time;
  874|  1.34k|    }
  875|  12.8k|}
_ZN11AddrManImpl12SetServices_ERK8CService12ServiceFlags:
  878|  80.0k|{
  879|  80.0k|    AssertLockHeld(cs);
  ------------------
  |  |  144|  80.0k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  880|       |
  881|  80.0k|    AddrInfo* pinfo = Find(addr);
  882|       |
  883|       |    // if not found, bail out
  884|  80.0k|    if (!pinfo)
  ------------------
  |  Branch (884:9): [True: 74.1k, False: 5.83k]
  ------------------
  885|  74.1k|        return;
  886|       |
  887|  5.83k|    AddrInfo& info = *pinfo;
  888|       |
  889|       |    // update info
  890|  5.83k|    info.nServices = nServices;
  891|  5.83k|}
_ZN11AddrManImpl18ResolveCollisions_Ev:
  894|  44.5k|{
  895|  44.5k|    AssertLockHeld(cs);
  ------------------
  |  |  144|  44.5k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  896|       |
  897|   112k|    for (std::set<nid_type>::iterator it = m_tried_collisions.begin(); it != m_tried_collisions.end();) {
  ------------------
  |  Branch (897:72): [True: 68.4k, False: 44.5k]
  ------------------
  898|  68.4k|        nid_type id_new = *it;
  899|       |
  900|  68.4k|        bool erase_collision = false;
  901|       |
  902|       |        // If id_new not found in mapInfo remove it from m_tried_collisions
  903|  68.4k|        if (!mapInfo.contains(id_new)) {
  ------------------
  |  Branch (903:13): [True: 221, False: 68.2k]
  ------------------
  904|    221|            erase_collision = true;
  905|  68.2k|        } else {
  906|  68.2k|            AddrInfo& info_new = mapInfo[id_new];
  907|       |
  908|       |            // Which tried bucket to move the entry to.
  909|  68.2k|            int tried_bucket = info_new.GetTriedBucket(nKey, m_netgroupman);
  910|  68.2k|            int tried_bucket_pos = info_new.GetBucketPosition(nKey, false, tried_bucket);
  911|  68.2k|            if (!info_new.IsValid()) { // id_new may no longer map to a valid address
  ------------------
  |  Branch (911:17): [True: 0, False: 68.2k]
  ------------------
  912|      0|                erase_collision = true;
  913|  68.2k|            } else {
  914|       |                // A pending tried collision implies that the destination tried slot
  915|       |                // remains occupied until we resolve it.
  916|  68.2k|                Assume(vvTried[tried_bucket][tried_bucket_pos] != -1);
  ------------------
  |  |  128|  68.2k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  917|       |
  918|       |                // Get the to-be-evicted address that is being tested
  919|  68.2k|                nid_type id_old = vvTried[tried_bucket][tried_bucket_pos];
  920|  68.2k|                AddrInfo& info_old = mapInfo[id_old];
  921|       |
  922|  68.2k|                const auto current_time{Now<NodeSeconds>()};
  923|       |
  924|       |                // Has successfully connected in last X hours
  925|  68.2k|                if (current_time - info_old.m_last_success < ADDRMAN_REPLACEMENT) {
  ------------------
  |  Branch (925:21): [True: 33.3k, False: 34.8k]
  ------------------
  926|  33.3k|                    erase_collision = true;
  927|  34.8k|                } else if (current_time - info_old.m_last_try < ADDRMAN_REPLACEMENT) { // attempted to connect and failed in last X hours
  ------------------
  |  Branch (927:28): [True: 514, False: 34.3k]
  ------------------
  928|       |
  929|       |                    // Give address at least 60 seconds to successfully connect
  930|    514|                    if (current_time - info_old.m_last_try > 60s) {
  ------------------
  |  Branch (930:25): [True: 1, False: 513]
  ------------------
  931|      1|                        LogDebug(BCLog::ADDRMAN, "Replacing %s with %s in tried table\n", info_old.ToStringAddrPort(), info_new.ToStringAddrPort());
  ------------------
  |  |  143|      1|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|      1|    do {                                                                                      \
  |  |  |  |  137|      1|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|      1|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  932|       |
  933|       |                        // Replaces an existing address already in the tried table with the new address
  934|      1|                        Good_(info_new, false, current_time);
  935|      1|                        erase_collision = true;
  936|      1|                    }
  937|  34.3k|                } else if (current_time - info_new.m_last_success > ADDRMAN_TEST_WINDOW) {
  ------------------
  |  Branch (937:28): [True: 5.76k, False: 28.5k]
  ------------------
  938|       |                    // If the collision hasn't resolved in some reasonable amount of time,
  939|       |                    // just evict the old entry -- we must not be able to
  940|       |                    // connect to it for some reason.
  941|  5.76k|                    LogDebug(BCLog::ADDRMAN, "Unable to test; replacing %s with %s in tried table anyway\n", info_old.ToStringAddrPort(), info_new.ToStringAddrPort());
  ------------------
  |  |  143|  5.76k|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|  5.76k|    do {                                                                                      \
  |  |  |  |  137|  5.76k|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 5.76k]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|  5.76k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 5.76k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  942|  5.76k|                    Good_(info_new, false, current_time);
  943|  5.76k|                    erase_collision = true;
  944|  5.76k|                }
  945|  68.2k|            }
  946|  68.2k|        }
  947|       |
  948|  68.4k|        if (erase_collision) {
  ------------------
  |  Branch (948:13): [True: 39.3k, False: 29.0k]
  ------------------
  949|  39.3k|            m_tried_collisions.erase(it++);
  950|  39.3k|        } else {
  951|  29.0k|            it++;
  952|  29.0k|        }
  953|  68.4k|    }
  954|  44.5k|}
_ZN11AddrManImpl21SelectTriedCollision_Ev:
  957|   460k|{
  958|   460k|    AssertLockHeld(cs);
  ------------------
  |  |  144|   460k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  959|       |
  960|   460k|    if (m_tried_collisions.size() == 0) return {};
  ------------------
  |  Branch (960:9): [True: 109k, False: 350k]
  ------------------
  961|       |
  962|   350k|    std::set<nid_type>::iterator it = m_tried_collisions.begin();
  963|       |
  964|       |    // Selects a random element from m_tried_collisions
  965|   350k|    std::advance(it, insecure_rand.randrange(m_tried_collisions.size()));
  966|   350k|    nid_type id_new = *it;
  967|       |
  968|       |    // If id_new not found in mapInfo remove it from m_tried_collisions
  969|   350k|    if (!mapInfo.contains(id_new)) {
  ------------------
  |  Branch (969:9): [True: 1.20k, False: 349k]
  ------------------
  970|  1.20k|        m_tried_collisions.erase(it);
  971|  1.20k|        return {};
  972|  1.20k|    }
  973|       |
  974|   349k|    const AddrInfo& newInfo = mapInfo[id_new];
  975|       |
  976|       |    // which tried bucket to move the entry to
  977|   349k|    int tried_bucket = newInfo.GetTriedBucket(nKey, m_netgroupman);
  978|   349k|    int tried_bucket_pos = newInfo.GetBucketPosition(nKey, false, tried_bucket);
  979|       |
  980|   349k|    Assume(vvTried[tried_bucket][tried_bucket_pos] != -1);
  ------------------
  |  |  128|   349k|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  981|   349k|    const AddrInfo& info_old = mapInfo[vvTried[tried_bucket][tried_bucket_pos]];
  982|   349k|    return {info_old, info_old.m_last_try};
  983|   350k|}
_ZNK11AddrManImpl5Size_ENSt3__18optionalI7NetworkEENS1_IbEE:
 1009|  7.16k|{
 1010|  7.16k|    AssertLockHeld(cs);
  ------------------
  |  |  144|  7.16k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
 1011|       |
 1012|  7.16k|    if (!net.has_value()) {
  ------------------
  |  Branch (1012:9): [True: 6.75k, False: 414]
  ------------------
 1013|  6.75k|        if (in_new.has_value()) {
  ------------------
  |  Branch (1013:13): [True: 150, False: 6.60k]
  ------------------
 1014|    150|            return *in_new ? nNew : nTried;
  ------------------
  |  Branch (1014:20): [True: 105, False: 45]
  ------------------
 1015|  6.60k|        } else {
 1016|  6.60k|            return vRandom.size();
 1017|  6.60k|        }
 1018|  6.75k|    }
 1019|    414|    if (auto it = m_network_counts.find(*net); it != m_network_counts.end()) {
  ------------------
  |  Branch (1019:48): [True: 161, False: 253]
  ------------------
 1020|    161|        auto net_count = it->second;
 1021|    161|        if (in_new.has_value()) {
  ------------------
  |  Branch (1021:13): [True: 120, False: 41]
  ------------------
 1022|    120|            return *in_new ? net_count.n_new : net_count.n_tried;
  ------------------
  |  Branch (1022:20): [True: 105, False: 15]
  ------------------
 1023|    120|        } else {
 1024|     41|            return net_count.n_new + net_count.n_tried;
 1025|     41|        }
 1026|    161|    }
 1027|    253|    return 0;
 1028|    414|}
_ZNK11AddrManImpl5CheckEv:
 1031|  2.93M|{
 1032|  2.93M|    AssertLockHeld(cs);
  ------------------
  |  |  144|  2.93M|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
 1033|       |
 1034|       |    // Run consistency checks 1 in m_consistency_check_ratio times if enabled
 1035|  2.93M|    if (m_consistency_check_ratio == 0) return;
  ------------------
  |  Branch (1035:9): [True: 2.93M, False: 0]
  ------------------
 1036|      0|    if (insecure_rand.randrange(m_consistency_check_ratio) >= 1) return;
  ------------------
  |  Branch (1036:9): [True: 0, False: 0]
  ------------------
 1037|       |
 1038|      0|    const int err{CheckAddrman()};
 1039|      0|    if (err) {
  ------------------
  |  Branch (1039:9): [True: 0, False: 0]
  ------------------
 1040|      0|        LogError("ADDRMAN CONSISTENCY CHECK FAILED!!! err=%i", err);
  ------------------
  |  |  127|      0|#define LogError(...) detail_LogWithSrcLoc(BCLog::LogFlags::ALL, util::log::Level::Error, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  ------------------
  ------------------
 1041|       |        assert(false);
  ------------------
  |  Branch (1041:9): [Folded, False: 0]
  ------------------
 1042|      0|    }
 1043|      0|}
_ZNK11AddrManImpl12CheckAddrmanEv:
 1046|    676|{
 1047|    676|    AssertLockHeld(cs);
  ------------------
  |  |  144|    676|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
 1048|       |
 1049|    676|    LOG_TIME_MILLIS_WITH_CATEGORY_MSG_ONCE(
  ------------------
  |  |  106|    676|    BCLog::Timer<std::chrono::milliseconds> BITCOIN_UNIQUE_NAME(logging_timer)(__func__, end_msg, log_category, /* msg_on_completion=*/false)
  |  |  ------------------
  |  |  |  |   11|    676|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|    676|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|    676|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1050|    676|        strprintf("new %i, tried %i, total %u", nNew, nTried, vRandom.size()), BCLog::ADDRMAN);
 1051|       |
 1052|    676|    std::unordered_set<nid_type> setTried;
 1053|    676|    std::unordered_map<nid_type, int> mapNew;
 1054|    676|    std::unordered_map<Network, NewTriedCount> local_counts;
 1055|       |
 1056|    676|    if (vRandom.size() != (size_t)(nTried + nNew))
  ------------------
  |  Branch (1056:9): [True: 0, False: 676]
  ------------------
 1057|      0|        return -7;
 1058|       |
 1059|  1.49k|    for (const auto& entry : mapInfo) {
  ------------------
  |  Branch (1059:28): [True: 1.49k, False: 527]
  ------------------
 1060|  1.49k|        nid_type n = entry.first;
 1061|  1.49k|        const AddrInfo& info = entry.second;
 1062|  1.49k|        if (info.fInTried) {
  ------------------
  |  Branch (1062:13): [True: 943, False: 552]
  ------------------
 1063|    943|            if (!TicksSinceEpoch<std::chrono::seconds>(info.m_last_success)) {
  ------------------
  |  Branch (1063:17): [True: 9, False: 934]
  ------------------
 1064|      9|                return -1;
 1065|      9|            }
 1066|    934|            if (info.nRefCount)
  ------------------
  |  Branch (1066:17): [True: 0, False: 934]
  ------------------
 1067|      0|                return -2;
 1068|    934|            setTried.insert(n);
 1069|    934|            local_counts[info.GetNetwork()].n_tried++;
 1070|    934|        } else {
 1071|    552|            if (info.nRefCount < 0 || info.nRefCount > ADDRMAN_NEW_BUCKETS_PER_ADDRESS)
  ------------------
  |  Branch (1071:17): [True: 0, False: 552]
  |  Branch (1071:39): [True: 0, False: 552]
  ------------------
 1072|      0|                return -3;
 1073|    552|            if (!info.nRefCount)
  ------------------
  |  Branch (1073:17): [True: 0, False: 552]
  ------------------
 1074|      0|                return -4;
 1075|    552|            mapNew[n] = info.nRefCount;
 1076|    552|            local_counts[info.GetNetwork()].n_new++;
 1077|    552|        }
 1078|  1.48k|        const auto it{mapAddr.find(info)};
 1079|  1.48k|        if (it == mapAddr.end() || it->second != n) {
  ------------------
  |  Branch (1079:13): [True: 5, False: 1.48k]
  |  Branch (1079:13): [True: 6, False: 1.48k]
  |  Branch (1079:36): [True: 1, False: 1.48k]
  ------------------
 1080|      6|            return -5;
 1081|      6|        }
 1082|  1.48k|        if (info.nRandomPos < 0 || (size_t)info.nRandomPos >= vRandom.size() || vRandom[info.nRandomPos] != n)
  ------------------
  |  Branch (1082:13): [True: 0, False: 1.48k]
  |  Branch (1082:36): [True: 0, False: 1.48k]
  |  Branch (1082:81): [True: 0, False: 1.48k]
  ------------------
 1083|      0|            return -14;
 1084|  1.48k|        if (info.m_last_try < NodeSeconds{0s}) {
  ------------------
  |  Branch (1084:13): [True: 0, False: 1.48k]
  ------------------
 1085|      0|            return -6;
 1086|      0|        }
 1087|  1.48k|        if (info.m_last_success < NodeSeconds{0s}) {
  ------------------
  |  Branch (1087:13): [True: 134, False: 1.34k]
  ------------------
 1088|    134|            return -8;
 1089|    134|        }
 1090|  1.48k|    }
 1091|       |
 1092|    527|    if (setTried.size() != (size_t)nTried)
  ------------------
  |  Branch (1092:9): [True: 0, False: 527]
  ------------------
 1093|      0|        return -9;
 1094|    527|    if (mapNew.size() != (size_t)nNew)
  ------------------
  |  Branch (1094:9): [True: 0, False: 527]
  ------------------
 1095|      0|        return -10;
 1096|       |
 1097|   135k|    for (int n = 0; n < ADDRMAN_TRIED_BUCKET_COUNT; n++) {
  ------------------
  |  Branch (1097:21): [True: 134k, False: 527]
  ------------------
 1098|  8.76M|        for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
  ------------------
  |  Branch (1098:25): [True: 8.63M, False: 134k]
  ------------------
 1099|  8.63M|            if (vvTried[n][i] != -1) {
  ------------------
  |  Branch (1099:17): [True: 661, False: 8.63M]
  ------------------
 1100|    661|                if (!setTried.contains(vvTried[n][i]))
  ------------------
  |  Branch (1100:21): [True: 0, False: 661]
  ------------------
 1101|      0|                    return -11;
 1102|    661|                const auto it{mapInfo.find(vvTried[n][i])};
 1103|    661|                if (it == mapInfo.end() || it->second.GetTriedBucket(nKey, m_netgroupman) != n) {
  ------------------
  |  Branch (1103:21): [True: 0, False: 661]
  |  Branch (1103:21): [True: 0, False: 661]
  |  Branch (1103:44): [True: 0, False: 661]
  ------------------
 1104|      0|                    return -17;
 1105|      0|                }
 1106|    661|                if (it->second.GetBucketPosition(nKey, false, n) != i) {
  ------------------
  |  Branch (1106:21): [True: 0, False: 661]
  ------------------
 1107|      0|                    return -18;
 1108|      0|                }
 1109|    661|                setTried.erase(vvTried[n][i]);
 1110|    661|            }
 1111|  8.63M|        }
 1112|   134k|    }
 1113|       |
 1114|   540k|    for (int n = 0; n < ADDRMAN_NEW_BUCKET_COUNT; n++) {
  ------------------
  |  Branch (1114:21): [True: 539k, False: 527]
  ------------------
 1115|  35.0M|        for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
  ------------------
  |  Branch (1115:25): [True: 34.5M, False: 539k]
  ------------------
 1116|  34.5M|            if (vvNew[n][i] != -1) {
  ------------------
  |  Branch (1116:17): [True: 701, False: 34.5M]
  ------------------
 1117|    701|                if (!mapNew.contains(vvNew[n][i]))
  ------------------
  |  Branch (1117:21): [True: 0, False: 701]
  ------------------
 1118|      0|                    return -12;
 1119|    701|                const auto it{mapInfo.find(vvNew[n][i])};
 1120|    701|                if (it == mapInfo.end() || it->second.GetBucketPosition(nKey, true, n) != i) {
  ------------------
  |  Branch (1120:21): [True: 0, False: 701]
  |  Branch (1120:21): [True: 0, False: 701]
  |  Branch (1120:44): [True: 0, False: 701]
  ------------------
 1121|      0|                    return -19;
 1122|      0|                }
 1123|    701|                if (--mapNew[vvNew[n][i]] == 0)
  ------------------
  |  Branch (1123:21): [True: 498, False: 203]
  ------------------
 1124|    498|                    mapNew.erase(vvNew[n][i]);
 1125|    701|            }
 1126|  34.5M|        }
 1127|   539k|    }
 1128|       |
 1129|    527|    if (setTried.size())
  ------------------
  |  Branch (1129:9): [True: 0, False: 527]
  ------------------
 1130|      0|        return -13;
 1131|    527|    if (mapNew.size())
  ------------------
  |  Branch (1131:9): [True: 0, False: 527]
  ------------------
 1132|      0|        return -15;
 1133|    527|    if (nKey.IsNull())
  ------------------
  |  Branch (1133:9): [True: 2, False: 525]
  ------------------
 1134|      2|        return -16;
 1135|       |
 1136|       |    // It's possible that m_network_counts may have all-zero entries that local_counts
 1137|       |    // doesn't have if addrs from a network were being added and then removed again in the past.
 1138|    525|    if (m_network_counts.size() < local_counts.size()) {
  ------------------
  |  Branch (1138:9): [True: 0, False: 525]
  ------------------
 1139|      0|        return -20;
 1140|      0|    }
 1141|    710|    for (const auto& [net, count] : m_network_counts) {
  ------------------
  |  Branch (1141:35): [True: 710, False: 525]
  ------------------
 1142|    710|        if (local_counts[net].n_new != count.n_new || local_counts[net].n_tried != count.n_tried) {
  ------------------
  |  Branch (1142:13): [True: 0, False: 710]
  |  Branch (1142:55): [True: 0, False: 710]
  ------------------
 1143|      0|            return -21;
 1144|      0|        }
 1145|    710|    }
 1146|       |
 1147|    525|    return 0;
 1148|    525|}
_ZNK11AddrManImpl4SizeENSt3__18optionalI7NetworkEENS1_IbEE:
 1151|  7.16k|{
 1152|  7.16k|    LOCK(cs);
  ------------------
  |  |  268|  7.16k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.16k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.16k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.16k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1153|  7.16k|    Check();
 1154|  7.16k|    auto ret = Size_(net, in_new);
 1155|  7.16k|    Check();
 1156|  7.16k|    return ret;
 1157|  7.16k|}
_ZN11AddrManImpl3AddERKNSt3__16vectorI8CAddressNS0_9allocatorIS2_EEEERK8CNetAddrNS0_6chrono8durationIxNS0_5ratioILl1ELl1EEEEE:
 1160|  38.6k|{
 1161|  38.6k|    LOCK(cs);
  ------------------
  |  |  268|  38.6k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  38.6k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  38.6k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  38.6k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1162|  38.6k|    Check();
 1163|  38.6k|    auto ret = Add_(vAddr, source, time_penalty);
 1164|  38.6k|    Check();
 1165|  38.6k|    return ret;
 1166|  38.6k|}
_ZN11AddrManImpl4GoodERK8CServiceNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
 1169|   767k|{
 1170|   767k|    LOCK(cs);
  ------------------
  |  |  268|   767k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|   767k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|   767k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|   767k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1171|   767k|    Check();
 1172|   767k|    auto ret = Good_(addr, /*test_before_evict=*/true, time);
 1173|   767k|    Check();
 1174|   767k|    return ret;
 1175|   767k|}
_ZN11AddrManImpl7AttemptERK8CServicebNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
 1178|  21.0k|{
 1179|  21.0k|    LOCK(cs);
  ------------------
  |  |  268|  21.0k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  21.0k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  21.0k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  21.0k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1180|  21.0k|    Check();
 1181|  21.0k|    Attempt_(addr, fCountFailure, time);
 1182|  21.0k|    Check();
 1183|  21.0k|}
_ZN11AddrManImpl17ResolveCollisionsEv:
 1186|  44.5k|{
 1187|  44.5k|    LOCK(cs);
  ------------------
  |  |  268|  44.5k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  44.5k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  44.5k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  44.5k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1188|  44.5k|    Check();
 1189|  44.5k|    ResolveCollisions_();
 1190|  44.5k|    Check();
 1191|  44.5k|}
_ZN11AddrManImpl20SelectTriedCollisionEv:
 1194|   460k|{
 1195|   460k|    LOCK(cs);
  ------------------
  |  |  268|   460k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|   460k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|   460k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|   460k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1196|   460k|    Check();
 1197|   460k|    auto ret = SelectTriedCollision_();
 1198|   460k|    Check();
 1199|   460k|    return ret;
 1200|   460k|}
_ZNK11AddrManImpl6SelectEbRKNSt3__113unordered_setI7NetworkNS0_4hashIS2_EENS0_8equal_toIS2_EENS0_9allocatorIS2_EEEE:
 1203|  7.16k|{
 1204|  7.16k|    LOCK(cs);
  ------------------
  |  |  268|  7.16k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.16k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.16k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.16k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1205|  7.16k|    Check();
 1206|  7.16k|    auto addrRet = Select_(new_only, networks);
 1207|  7.16k|    Check();
 1208|  7.16k|    return addrRet;
 1209|  7.16k|}
_ZNK11AddrManImpl7GetAddrEmmNSt3__18optionalI7NetworkEEb:
 1212|  7.16k|{
 1213|  7.16k|    LOCK(cs);
  ------------------
  |  |  268|  7.16k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.16k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.16k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.16k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1214|  7.16k|    Check();
 1215|  7.16k|    auto addresses = GetAddr_(max_addresses, max_pct, network, filtered);
 1216|  7.16k|    Check();
 1217|  7.16k|    return addresses;
 1218|  7.16k|}
_ZN11AddrManImpl9ConnectedERK8CServiceNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
 1230|  31.7k|{
 1231|  31.7k|    LOCK(cs);
  ------------------
  |  |  268|  31.7k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  31.7k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  31.7k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  31.7k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1232|  31.7k|    Check();
 1233|  31.7k|    Connected_(addr, time);
 1234|  31.7k|    Check();
 1235|  31.7k|}
_ZN11AddrManImpl11SetServicesERK8CService12ServiceFlags:
 1238|  80.0k|{
 1239|  80.0k|    LOCK(cs);
  ------------------
  |  |  268|  80.0k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  80.0k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  80.0k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  80.0k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1240|  80.0k|    Check();
 1241|  80.0k|    SetServices_(addr, nServices);
 1242|  80.0k|    Check();
 1243|  80.0k|}
_ZN7AddrManC2ERK15NetGroupManagerbi:
 1255|  9.68k|    : m_impl(std::make_unique<AddrManImpl>(netgroupman, deterministic, consistency_check_ratio)) {}
_ZN7AddrManD2Ev:
 1257|  9.68k|AddrMan::~AddrMan() = default;
_ZNK7AddrMan9SerializeI10DataStreamEEvRT_:
 1261|  7.16k|{
 1262|  7.16k|    m_impl->Serialize<Stream>(s_);
 1263|  7.16k|}
_ZN7AddrMan11UnserializeI10DataStreamEEvRT_:
 1267|  3.04k|{
 1268|  3.04k|    m_impl->Unserialize<Stream>(s_);
 1269|  3.04k|}
_ZNK7AddrMan4SizeENSt3__18optionalI7NetworkEENS1_IbEE:
 1280|  7.16k|{
 1281|  7.16k|    return m_impl->Size(net, in_new);
 1282|  7.16k|}
_ZN7AddrMan3AddERKNSt3__16vectorI8CAddressNS0_9allocatorIS2_EEEERK8CNetAddrNS0_6chrono8durationIxNS0_5ratioILl1ELl1EEEEE:
 1285|  38.6k|{
 1286|  38.6k|    return m_impl->Add(vAddr, source, time_penalty);
 1287|  38.6k|}
_ZN7AddrMan4GoodERK8CServiceNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
 1290|   767k|{
 1291|   767k|    return m_impl->Good(addr, time);
 1292|   767k|}
_ZN7AddrMan7AttemptERK8CServicebNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
 1295|  21.0k|{
 1296|  21.0k|    m_impl->Attempt(addr, fCountFailure, time);
 1297|  21.0k|}
_ZN7AddrMan17ResolveCollisionsEv:
 1300|  44.5k|{
 1301|  44.5k|    m_impl->ResolveCollisions();
 1302|  44.5k|}
_ZN7AddrMan20SelectTriedCollisionEv:
 1305|   460k|{
 1306|   460k|    return m_impl->SelectTriedCollision();
 1307|   460k|}
_ZNK7AddrMan6SelectEbRKNSt3__113unordered_setI7NetworkNS0_4hashIS2_EENS0_8equal_toIS2_EENS0_9allocatorIS2_EEEE:
 1310|  7.16k|{
 1311|  7.16k|    return m_impl->Select(new_only, networks);
 1312|  7.16k|}
_ZNK7AddrMan7GetAddrEmmNSt3__18optionalI7NetworkEEb:
 1315|  7.16k|{
 1316|  7.16k|    return m_impl->GetAddr(max_addresses, max_pct, network, filtered);
 1317|  7.16k|}
_ZN7AddrMan9ConnectedERK8CServiceNSt3__16chrono10time_pointI9NodeClockNS4_8durationIxNS3_5ratioILl1ELl1EEEEEEE:
 1325|  31.7k|{
 1326|  31.7k|    m_impl->Connected(addr, time);
 1327|  31.7k|}
_ZN7AddrMan11SetServicesERK8CService12ServiceFlags:
 1330|  80.0k|{
 1331|  80.0k|    m_impl->SetServices(addr, nServices);
 1332|  80.0k|}
_ZNK11AddrManImpl9SerializeI10DataStreamEEvRT_:
  115|  7.16k|{
  116|  7.16k|    LOCK(cs);
  ------------------
  |  |  268|  7.16k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.16k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.16k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.16k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  117|       |
  118|       |    /**
  119|       |     * Serialized format.
  120|       |     * * format version byte (@see `Format`)
  121|       |     * * lowest compatible format version byte. This is used to help old software decide
  122|       |     *   whether to parse the file. For example:
  123|       |     *   * Bitcoin Core version N knows how to parse up to format=3. If a new format=4 is
  124|       |     *     introduced in version N+1 that is compatible with format=3 and it is known that
  125|       |     *     version N will be able to parse it, then version N+1 will write
  126|       |     *     (format=4, lowest_compatible=3) in the first two bytes of the file, and so
  127|       |     *     version N will still try to parse it.
  128|       |     *   * Bitcoin Core version N+2 introduces a new incompatible format=5. It will write
  129|       |     *     (format=5, lowest_compatible=5) and so any versions that do not know how to parse
  130|       |     *     format=5 will not try to read the file.
  131|       |     * * nKey
  132|       |     * * nNew
  133|       |     * * nTried
  134|       |     * * number of "new" buckets XOR 2**30
  135|       |     * * all new addresses (total count: nNew)
  136|       |     * * all tried addresses (total count: nTried)
  137|       |     * * for each new bucket:
  138|       |     *   * number of elements
  139|       |     *   * for each element: index in the serialized "all new addresses"
  140|       |     * * asmap version
  141|       |     *
  142|       |     * 2**30 is xorred with the number of buckets to make addrman deserializer v0 detect it
  143|       |     * as incompatible. This is necessary because it did not check the version number on
  144|       |     * deserialization.
  145|       |     *
  146|       |     * vvNew, vvTried, mapInfo, mapAddr and vRandom are never encoded explicitly;
  147|       |     * they are instead reconstructed from the other information.
  148|       |     *
  149|       |     * This format is more complex, but significantly smaller (at most 1.5 MiB), and supports
  150|       |     * changes to the ADDRMAN_ parameters without breaking the on-disk structure.
  151|       |     *
  152|       |     * We don't use SERIALIZE_METHODS since the serialization and deserialization code has
  153|       |     * very little in common.
  154|       |     */
  155|       |
  156|       |    // Always serialize in the latest version (FILE_FORMAT).
  157|  7.16k|    ParamsStream s{s_, CAddress::V2_DISK};
  158|       |
  159|  7.16k|    s << static_cast<uint8_t>(FILE_FORMAT);
  160|       |
  161|       |    // Increment `lowest_compatible` iff a newly introduced format is incompatible with
  162|       |    // the previous one.
  163|  7.16k|    static constexpr uint8_t lowest_compatible = Format::V4_MULTIPORT;
  164|  7.16k|    s << static_cast<uint8_t>(INCOMPATIBILITY_BASE + lowest_compatible);
  165|       |
  166|  7.16k|    s << nKey;
  167|  7.16k|    s << nNew;
  168|  7.16k|    s << nTried;
  169|       |
  170|  7.16k|    int nUBuckets = ADDRMAN_NEW_BUCKET_COUNT ^ (1 << 30);
  171|  7.16k|    s << nUBuckets;
  172|  7.16k|    std::unordered_map<nid_type, int> mapUnkIds;
  173|  7.16k|    int nIds = 0;
  174|  1.33M|    for (const auto& entry : mapInfo) {
  ------------------
  |  Branch (174:28): [True: 1.33M, False: 7.16k]
  ------------------
  175|  1.33M|        mapUnkIds[entry.first] = nIds;
  176|  1.33M|        const AddrInfo& info = entry.second;
  177|  1.33M|        if (info.nRefCount) {
  ------------------
  |  Branch (177:13): [True: 1.27M, False: 57.2k]
  ------------------
  178|  1.27M|            assert(nIds != nNew); // this means nNew was wrong, oh ow
  ------------------
  |  Branch (178:13): [True: 1.27M, False: 0]
  ------------------
  179|  1.27M|            s << info;
  180|  1.27M|            nIds++;
  181|  1.27M|        }
  182|  1.33M|    }
  183|  7.16k|    nIds = 0;
  184|  1.33M|    for (const auto& entry : mapInfo) {
  ------------------
  |  Branch (184:28): [True: 1.33M, False: 7.16k]
  ------------------
  185|  1.33M|        const AddrInfo& info = entry.second;
  186|  1.33M|        if (info.fInTried) {
  ------------------
  |  Branch (186:13): [True: 57.2k, False: 1.27M]
  ------------------
  187|  57.2k|            assert(nIds != nTried); // this means nTried was wrong, oh ow
  ------------------
  |  Branch (187:13): [True: 57.2k, False: 0]
  ------------------
  188|  57.2k|            s << info;
  189|  57.2k|            nIds++;
  190|  57.2k|        }
  191|  1.33M|    }
  192|  7.34M|    for (int bucket = 0; bucket < ADDRMAN_NEW_BUCKET_COUNT; bucket++) {
  ------------------
  |  Branch (192:26): [True: 7.34M, False: 7.16k]
  ------------------
  193|  7.34M|        int nSize = 0;
  194|   477M|        for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
  ------------------
  |  Branch (194:25): [True: 469M, False: 7.34M]
  ------------------
  195|   469M|            if (vvNew[bucket][i] != -1)
  ------------------
  |  Branch (195:17): [True: 1.30M, False: 468M]
  ------------------
  196|  1.30M|                nSize++;
  197|   469M|        }
  198|  7.34M|        s << nSize;
  199|   477M|        for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
  ------------------
  |  Branch (199:25): [True: 469M, False: 7.34M]
  ------------------
  200|   469M|            if (vvNew[bucket][i] != -1) {
  ------------------
  |  Branch (200:17): [True: 1.30M, False: 468M]
  ------------------
  201|  1.30M|                int nIndex = mapUnkIds[vvNew[bucket][i]];
  202|  1.30M|                s << nIndex;
  203|  1.30M|            }
  204|   469M|        }
  205|  7.34M|    }
  206|       |    // Store asmap version after bucket entries so that it
  207|       |    // can be ignored by older clients for backward compatibility.
  208|  7.16k|    s << m_netgroupman.GetAsmapVersion();
  209|  7.16k|}
_ZN11AddrManImpl11UnserializeI10DataStreamEEvRT_:
  213|  3.04k|{
  214|  3.04k|    LOCK(cs);
  ------------------
  |  |  268|  3.04k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  3.04k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  3.04k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  3.04k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  215|       |
  216|  3.04k|    assert(vRandom.empty());
  ------------------
  |  Branch (216:5): [True: 3.04k, False: 0]
  ------------------
  217|       |
  218|  3.04k|    Format format;
  219|  3.04k|    s_ >> Using<CustomUintFormatter<1>>(format);
  220|       |
  221|  3.04k|    const auto ser_params = (format >= Format::V3_BIP155 ? CAddress::V2_DISK : CAddress::V1_DISK);
  ------------------
  |  Branch (221:30): [True: 1.80k, False: 1.23k]
  ------------------
  222|  3.04k|    ParamsStream s{s_, ser_params};
  223|       |
  224|  3.04k|    uint8_t compat;
  225|  3.04k|    s >> compat;
  226|  3.04k|    if (compat < INCOMPATIBILITY_BASE) {
  ------------------
  |  Branch (226:9): [True: 628, False: 2.41k]
  ------------------
  227|    628|        throw std::ios_base::failure(strprintf(
  ------------------
  |  | 1172|    628|#define strprintf tfm::format
  ------------------
  228|    628|            "Corrupted addrman database: The compat value (%u) "
  229|    628|            "is lower than the expected minimum value %u.",
  230|    628|            compat, INCOMPATIBILITY_BASE));
  231|    628|    }
  232|  2.41k|    const uint8_t lowest_compatible = compat - INCOMPATIBILITY_BASE;
  233|  2.41k|    if (lowest_compatible > FILE_FORMAT) {
  ------------------
  |  Branch (233:9): [True: 398, False: 2.01k]
  ------------------
  234|    398|        throw InvalidAddrManVersionError(strprintf(
  ------------------
  |  | 1172|    398|#define strprintf tfm::format
  ------------------
  235|    398|            "Unsupported format of addrman database: %u. It is compatible with formats >=%u, "
  236|    398|            "but the maximum supported by this version of %s is %u.",
  237|    398|            uint8_t{format}, lowest_compatible, CLIENT_NAME, uint8_t{FILE_FORMAT}));
  ------------------
  |  |  101|    398|#define CLIENT_NAME "Bitcoin Core"
  ------------------
  238|    398|    }
  239|       |
  240|  2.01k|    s >> nKey;
  241|  2.01k|    s >> nNew;
  242|  2.01k|    s >> nTried;
  243|  2.01k|    int nUBuckets = 0;
  244|  2.01k|    s >> nUBuckets;
  245|  2.01k|    if (format >= Format::V1_DETERMINISTIC) {
  ------------------
  |  Branch (245:9): [True: 1.10k, False: 908]
  ------------------
  246|  1.10k|        nUBuckets ^= (1 << 30);
  247|  1.10k|    }
  248|       |
  249|  2.01k|    if (nNew > ADDRMAN_NEW_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE || nNew < 0) {
  ------------------
  |  Branch (249:9): [True: 261, False: 1.75k]
  |  Branch (249:66): [True: 24, False: 1.72k]
  ------------------
  250|     58|        throw std::ios_base::failure(
  251|     58|                strprintf("Corrupt AddrMan serialization: nNew=%d, should be in [0, %d]",
  ------------------
  |  | 1172|     58|#define strprintf tfm::format
  ------------------
  252|     58|                    nNew,
  253|     58|                    ADDRMAN_NEW_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE));
  254|     58|    }
  255|       |
  256|  1.95k|    if (nTried > ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE || nTried < 0) {
  ------------------
  |  Branch (256:9): [True: 235, False: 1.72k]
  |  Branch (256:70): [True: 30, False: 1.69k]
  ------------------
  257|     38|        throw std::ios_base::failure(
  258|     38|                strprintf("Corrupt AddrMan serialization: nTried=%d, should be in [0, %d]",
  ------------------
  |  | 1172|     38|#define strprintf tfm::format
  ------------------
  259|     38|                    nTried,
  260|     38|                    ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE));
  261|     38|    }
  262|       |
  263|       |    // Deserialize entries from the new table.
  264|   113k|    for (int n = 0; n < nNew; n++) {
  ------------------
  |  Branch (264:21): [True: 111k, False: 1.91k]
  ------------------
  265|   111k|        AddrInfo& info = mapInfo[n];
  266|   111k|        s >> info;
  267|   111k|        mapAddr[info] = n;
  268|   111k|        info.nRandomPos = vRandom.size();
  269|   111k|        vRandom.push_back(n);
  270|   111k|        m_network_counts[info.GetNetwork()].n_new++;
  271|   111k|    }
  272|  1.91k|    nIdCount = nNew;
  273|       |
  274|       |    // Deserialize entries from the tried table.
  275|  1.91k|    int nLost = 0;
  276|  11.2k|    for (int n = 0; n < nTried; n++) {
  ------------------
  |  Branch (276:21): [True: 9.37k, False: 1.91k]
  ------------------
  277|  9.37k|        AddrInfo info;
  278|  9.37k|        s >> info;
  279|  9.37k|        int nKBucket = info.GetTriedBucket(nKey, m_netgroupman);
  280|  9.37k|        int nKBucketPos = info.GetBucketPosition(nKey, false, nKBucket);
  281|  9.37k|        if (info.IsValid()
  ------------------
  |  Branch (281:13): [True: 2.35k, False: 7.02k]
  ------------------
  282|  2.35k|                && vvTried[nKBucket][nKBucketPos] == -1) {
  ------------------
  |  Branch (282:20): [True: 1.73k, False: 613]
  ------------------
  283|  1.73k|            info.nRandomPos = vRandom.size();
  284|  1.73k|            info.fInTried = true;
  285|  1.73k|            vRandom.push_back(nIdCount);
  286|  1.73k|            mapInfo[nIdCount] = info;
  287|  1.73k|            mapAddr[info] = nIdCount;
  288|  1.73k|            vvTried[nKBucket][nKBucketPos] = nIdCount;
  289|  1.73k|            nIdCount++;
  290|  1.73k|            m_network_counts[info.GetNetwork()].n_tried++;
  291|  7.64k|        } else {
  292|  7.64k|            nLost++;
  293|  7.64k|        }
  294|  9.37k|    }
  295|  1.91k|    nTried -= nLost;
  296|       |
  297|       |    // Store positions in the new table buckets to apply later (if possible).
  298|       |    // An entry may appear in up to ADDRMAN_NEW_BUCKETS_PER_ADDRESS buckets,
  299|       |    // so we store all bucket-entry_index pairs to iterate through later.
  300|  1.91k|    std::vector<std::pair<int, int>> bucket_entries;
  301|       |
  302|  48.5k|    for (int bucket = 0; bucket < nUBuckets; ++bucket) {
  ------------------
  |  Branch (302:26): [True: 46.6k, False: 1.91k]
  ------------------
  303|  46.6k|        int num_entries{0};
  304|  46.6k|        s >> num_entries;
  305|   945k|        for (int n = 0; n < num_entries; ++n) {
  ------------------
  |  Branch (305:25): [True: 899k, False: 46.6k]
  ------------------
  306|   899k|            int entry_index{0};
  307|   899k|            s >> entry_index;
  308|   899k|            if (entry_index >= 0 && entry_index < nNew) {
  ------------------
  |  Branch (308:17): [True: 844k, False: 54.5k]
  |  Branch (308:37): [True: 606k, False: 238k]
  ------------------
  309|   606k|                bucket_entries.emplace_back(bucket, entry_index);
  310|   606k|            }
  311|   899k|        }
  312|  46.6k|    }
  313|       |
  314|       |    // If the bucket count and asmap version haven't changed, then attempt
  315|       |    // to restore the entries to the buckets/positions they were in before
  316|       |    // serialization.
  317|  1.91k|    uint256 supplied_asmap_version{m_netgroupman.GetAsmapVersion()};
  318|  1.91k|    uint256 serialized_asmap_version;
  319|  1.91k|    if (format >= Format::V2_ASMAP) {
  ------------------
  |  Branch (319:9): [True: 143, False: 1.77k]
  ------------------
  320|    143|        s >> serialized_asmap_version;
  321|    143|    }
  322|  1.91k|    const bool restore_bucketing{nUBuckets == ADDRMAN_NEW_BUCKET_COUNT &&
  ------------------
  |  Branch (322:34): [True: 39, False: 1.87k]
  ------------------
  323|     39|        serialized_asmap_version == supplied_asmap_version};
  ------------------
  |  Branch (323:9): [True: 37, False: 2]
  ------------------
  324|       |
  325|  1.91k|    if (!restore_bucketing) {
  ------------------
  |  Branch (325:9): [True: 639, False: 1.27k]
  ------------------
  326|    639|        LogDebug(BCLog::ADDRMAN, "Bucketing method was updated, re-bucketing addrman entries from disk\n");
  ------------------
  |  |  143|    639|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|    639|    do {                                                                                      \
  |  |  |  |  137|    639|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 639]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|    639|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 639]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  327|    639|    }
  328|       |
  329|  32.4k|    for (auto bucket_entry : bucket_entries) {
  ------------------
  |  Branch (329:28): [True: 32.4k, False: 1.91k]
  ------------------
  330|  32.4k|        int bucket{bucket_entry.first};
  331|  32.4k|        const int entry_index{bucket_entry.second};
  332|  32.4k|        AddrInfo& info = mapInfo[entry_index];
  333|       |
  334|       |        // Don't store the entry in the new bucket if it's not a valid address for our addrman
  335|  32.4k|        if (!info.IsValid()) continue;
  ------------------
  |  Branch (335:13): [True: 746, False: 31.7k]
  ------------------
  336|       |
  337|       |        // The entry shouldn't appear in more than
  338|       |        // ADDRMAN_NEW_BUCKETS_PER_ADDRESS. If it has already, just skip
  339|       |        // this bucket_entry.
  340|  31.7k|        if (info.nRefCount >= ADDRMAN_NEW_BUCKETS_PER_ADDRESS) continue;
  ------------------
  |  Branch (340:13): [True: 10.2k, False: 21.5k]
  ------------------
  341|       |
  342|  21.5k|        int bucket_position = info.GetBucketPosition(nKey, true, bucket);
  343|  21.5k|        if (restore_bucketing && vvNew[bucket][bucket_position] == -1) {
  ------------------
  |  Branch (343:13): [True: 13.4k, False: 8.09k]
  |  Branch (343:34): [True: 302, False: 13.1k]
  ------------------
  344|       |            // Bucketing has not changed, using existing bucket positions for the new table
  345|    302|            vvNew[bucket][bucket_position] = entry_index;
  346|    302|            ++info.nRefCount;
  347|  21.1k|        } else {
  348|       |            // In case the new table data cannot be used (bucket count wrong or new asmap),
  349|       |            // try to give them a reference based on their primary source address.
  350|  21.1k|            bucket = info.GetNewBucket(nKey, m_netgroupman);
  351|  21.1k|            bucket_position = info.GetBucketPosition(nKey, true, bucket);
  352|  21.1k|            if (vvNew[bucket][bucket_position] == -1) {
  ------------------
  |  Branch (352:17): [True: 543, False: 20.6k]
  ------------------
  353|    543|                vvNew[bucket][bucket_position] = entry_index;
  354|    543|                ++info.nRefCount;
  355|    543|            }
  356|  21.1k|        }
  357|  21.5k|    }
  358|       |
  359|       |    // Prune new entries with refcount 0 (as a result of collisions or invalid address).
  360|  1.91k|    int nLostUnk = 0;
  361|  8.02k|    for (auto it = mapInfo.cbegin(); it != mapInfo.cend(); ) {
  ------------------
  |  Branch (361:38): [True: 6.10k, False: 1.91k]
  ------------------
  362|  6.10k|        if (it->second.fInTried == false && it->second.nRefCount == 0) {
  ------------------
  |  Branch (362:13): [True: 4.99k, False: 1.10k]
  |  Branch (362:45): [True: 4.42k, False: 569]
  ------------------
  363|  4.42k|            const auto itCopy = it++;
  364|  4.42k|            Delete(itCopy->first);
  365|  4.42k|            ++nLostUnk;
  366|  4.42k|        } else {
  367|  1.67k|            ++it;
  368|  1.67k|        }
  369|  6.10k|    }
  370|  1.91k|    if (nLost + nLostUnk > 0) {
  ------------------
  |  Branch (370:9): [True: 277, False: 1.64k]
  ------------------
  371|    277|        LogDebug(BCLog::ADDRMAN, "addrman lost %i new and %i tried addresses due to collisions or invalid addresses\n", nLostUnk, nLost);
  ------------------
  |  |  143|    277|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|    277|    do {                                                                                      \
  |  |  |  |  137|    277|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 277]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|    277|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 277]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  372|    277|    }
  373|       |
  374|  1.91k|    const int check_code{CheckAddrman()};
  375|  1.91k|    if (check_code != 0) {
  ------------------
  |  Branch (375:9): [True: 151, False: 1.76k]
  ------------------
  376|    151|        throw std::ios_base::failure(strprintf(
  ------------------
  |  | 1172|    151|#define strprintf tfm::format
  ------------------
  377|    151|            "Corrupt data. Consistency check failed with code %s",
  378|    151|            check_code));
  379|    151|    }
  380|  1.91k|}

_ZN26InvalidAddrManVersionErrorC2ENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   49|    398|    InvalidAddrManVersionError(std::string msg) : std::ios_base::failure(msg) { }

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

_ZN11ArgsManagerD2Ev:
  130|      4|ArgsManager::~ArgsManager() = default;
_ZNK11ArgsManager6GetArgITkNSt3__18integralElEET_RKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES2_:
  544|  9.68k|{
  545|  9.68k|    return GetArg<Int>(strArg).value_or(nDefault);
  546|  9.68k|}
_ZNK11ArgsManager6GetArgITkNSt3__18integralElEENS1_8optionalIT_EERKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  550|  9.68k|{
  551|  9.68k|    const common::SettingsValue value = GetSetting(strArg);
  552|  9.68k|    return SettingTo<Int>(value);
  553|  9.68k|}
_Z9SettingToITkNSt3__18integralElENS0_8optionalIT_EERK8UniValue:
  557|  9.68k|{
  558|  9.68k|    if (value.isNull()) return std::nullopt;
  ------------------
  |  Branch (558:9): [True: 9.68k, False: 0]
  ------------------
  559|      0|    if (value.isFalse()) return 0;
  ------------------
  |  Branch (559:9): [True: 0, False: 0]
  ------------------
  560|      0|    if (value.isTrue()) return 1;
  ------------------
  |  Branch (560:9): [True: 0, False: 0]
  ------------------
  561|      0|    if (value.isNum()) return value.getInt<Int>();
  ------------------
  |  Branch (561:9): [True: 0, False: 0]
  ------------------
  562|      0|    return LocaleIndependentAtoi<Int>(value.get_str());
  563|      0|}
_ZN11ArgsManager11ForceSetArgERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES8_:
  628|      2|{
  629|      2|    LOCK(cs_args);
  ------------------
  |  |  268|      2|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  630|      2|    m_settings.forced_settings[SettingName(strArg)] = strValue;
  631|      2|}
_ZN11ArgsManager9ClearArgsEv:
  694|      2|{
  695|      2|    LOCK(cs_args);
  ------------------
  |  |  268|      2|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  696|      2|    m_settings = {};
  697|      2|    m_available_args.clear();
  698|      2|    m_command_args.clear();
  699|      2|    m_network_only_args.clear();
  700|      2|    m_config_sections.clear();
  701|      2|}
_ZNK11ArgsManager17UseDefaultSectionERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  957|  9.68k|{
  958|  9.68k|    AssertLockHeld(cs_args);
  ------------------
  |  |  144|  9.68k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  959|  9.68k|    return m_network == ChainTypeToString(ChainType::MAIN) || !m_network_only_args.contains(arg);
  ------------------
  |  Branch (959:12): [True: 0, False: 9.68k]
  |  Branch (959:63): [True: 9.68k, False: 0]
  ------------------
  960|  9.68k|}
_ZNK11ArgsManager11GetSetting_ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  963|  9.68k|{
  964|  9.68k|    AssertLockHeld(cs_args);
  ------------------
  |  |  144|  9.68k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  965|  9.68k|    return common::GetSetting(
  966|  9.68k|        m_settings, m_network, SettingName(arg), !UseDefaultSection(arg),
  967|  9.68k|        /*ignore_nonpersistent=*/false, /*get_chain_type=*/false);
  968|  9.68k|}
_ZNK11ArgsManager10GetSettingERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  971|  9.68k|{
  972|  9.68k|    LOCK(cs_args);
  ------------------
  |  |  268|  9.68k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  9.68k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  9.68k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  9.68k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  973|  9.68k|    return GetSetting_(arg);
  974|  9.68k|}
args.cpp:_ZL11SettingNameRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE:
   63|  9.68k|{
   64|  9.68k|    return arg.size() > 0 && arg[0] == '-' ? arg.substr(1) : arg;
  ------------------
  |  Branch (64:12): [True: 9.68k, False: 0]
  |  Branch (64:30): [True: 9.68k, False: 0]
  ------------------
   65|  9.68k|}

_ZNK11ArgsManager9GetIntArgERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEl:
  323|  9.68k|    int64_t GetIntArg(const std::string& strArg, int64_t nDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args) { return GetArg<int64_t>(strArg, nDefault); }

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

_ZN6common7FindKeyIRKNSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_6vectorI8UniValueNS6_ISA_EEEENS1_4lessIS8_EENS6_INS1_4pairIKS8_SC_EEEEEERSG_EEDTadcldtfp_2atfp0_EEOT_OT0_:
  110|  9.68k|{
  111|  9.68k|    auto it = map.find(key);
  112|  9.68k|    return it == map.end() ? nullptr : &it->second;
  ------------------
  |  Branch (112:12): [True: 9.68k, False: 0]
  ------------------
  113|  9.68k|}
_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_:
  110|  9.68k|{
  111|  9.68k|    auto it = map.find(key);
  112|  9.68k|    return it == map.end() ? nullptr : &it->second;
  ------------------
  |  Branch (112:12): [True: 9.68k, False: 0]
  ------------------
  113|  9.68k|}
_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_:
  110|  9.68k|{
  111|  9.68k|    auto it = map.find(key);
  112|  9.68k|    return it == map.end() ? nullptr : &it->second;
  ------------------
  |  Branch (112:12): [True: 9.68k, False: 0]
  ------------------
  113|  9.68k|}
_ZN6common7FindKeyIRKNSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE8UniValueNS1_4lessIS8_EENS6_INS1_4pairIKS8_S9_EEEEEERSD_EEDTadcldtfp_2atfp0_EEOT_OT0_:
  110|  19.3k|{
  111|  19.3k|    auto it = map.find(key);
  112|  19.3k|    return it == map.end() ? nullptr : &it->second;
  ------------------
  |  Branch (112:12): [True: 19.3k, False: 0]
  ------------------
  113|  19.3k|}

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

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

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

_ZN8ChaCha20C2ENSt3__14spanIKSt4byteLm18446744073709551615EEE:
   90|  45.9k|    ChaCha20(std::span<const std::byte> key) noexcept : m_aligned(key) {}

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

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

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

_ZN16sha256_x86_shani9TransformEPjPKhm:
   82|  50.5M|{
   83|  50.5M|    __m128i m0, m1, m2, m3, s0, s1, so0, so1;
   84|       |
   85|       |    /* Load state */
   86|  50.5M|    s0 = _mm_loadu_si128((const __m128i*)s);
   87|  50.5M|    s1 = _mm_loadu_si128((const __m128i*)(s + 4));
   88|  50.5M|    Shuffle(s0, s1);
   89|       |
   90|   101M|    while (blocks--) {
  ------------------
  |  Branch (90:12): [True: 50.5M, False: 50.5M]
  ------------------
   91|       |        /* Remember old state */
   92|  50.5M|        so0 = s0;
   93|  50.5M|        so1 = s1;
   94|       |
   95|       |        /* Load data and transform */
   96|  50.5M|        m0 = Load(chunk);
   97|  50.5M|        QuadRound(s0, s1, m0, 0xe9b5dba5b5c0fbcfull, 0x71374491428a2f98ull);
   98|  50.5M|        m1 = Load(chunk + 16);
   99|  50.5M|        QuadRound(s0, s1, m1, 0xab1c5ed5923f82a4ull, 0x59f111f13956c25bull);
  100|  50.5M|        ShiftMessageA(m0, m1);
  101|  50.5M|        m2 = Load(chunk + 32);
  102|  50.5M|        QuadRound(s0, s1, m2, 0x550c7dc3243185beull, 0x12835b01d807aa98ull);
  103|  50.5M|        ShiftMessageA(m1, m2);
  104|  50.5M|        m3 = Load(chunk + 48);
  105|  50.5M|        QuadRound(s0, s1, m3, 0xc19bf1749bdc06a7ull, 0x80deb1fe72be5d74ull);
  106|  50.5M|        ShiftMessageB(m2, m3, m0);
  107|  50.5M|        QuadRound(s0, s1, m0, 0x240ca1cc0fc19dc6ull, 0xefbe4786E49b69c1ull);
  108|  50.5M|        ShiftMessageB(m3, m0, m1);
  109|  50.5M|        QuadRound(s0, s1, m1, 0x76f988da5cb0a9dcull, 0x4a7484aa2de92c6full);
  110|  50.5M|        ShiftMessageB(m0, m1, m2);
  111|  50.5M|        QuadRound(s0, s1, m2, 0xbf597fc7b00327c8ull, 0xa831c66d983e5152ull);
  112|  50.5M|        ShiftMessageB(m1, m2, m3);
  113|  50.5M|        QuadRound(s0, s1, m3, 0x1429296706ca6351ull, 0xd5a79147c6e00bf3ull);
  114|  50.5M|        ShiftMessageB(m2, m3, m0);
  115|  50.5M|        QuadRound(s0, s1, m0, 0x53380d134d2c6dfcull, 0x2e1b213827b70a85ull);
  116|  50.5M|        ShiftMessageB(m3, m0, m1);
  117|  50.5M|        QuadRound(s0, s1, m1, 0x92722c8581c2c92eull, 0x766a0abb650a7354ull);
  118|  50.5M|        ShiftMessageB(m0, m1, m2);
  119|  50.5M|        QuadRound(s0, s1, m2, 0xc76c51A3c24b8b70ull, 0xa81a664ba2bfe8a1ull);
  120|  50.5M|        ShiftMessageB(m1, m2, m3);
  121|  50.5M|        QuadRound(s0, s1, m3, 0x106aa070f40e3585ull, 0xd6990624d192e819ull);
  122|  50.5M|        ShiftMessageB(m2, m3, m0);
  123|  50.5M|        QuadRound(s0, s1, m0, 0x34b0bcb52748774cull, 0x1e376c0819a4c116ull);
  124|  50.5M|        ShiftMessageB(m3, m0, m1);
  125|  50.5M|        QuadRound(s0, s1, m1, 0x682e6ff35b9cca4full, 0x4ed8aa4a391c0cb3ull);
  126|  50.5M|        ShiftMessageC(m0, m1, m2);
  127|  50.5M|        QuadRound(s0, s1, m2, 0x8cc7020884c87814ull, 0x78a5636f748f82eeull);
  128|  50.5M|        ShiftMessageC(m1, m2, m3);
  129|  50.5M|        QuadRound(s0, s1, m3, 0xc67178f2bef9A3f7ull, 0xa4506ceb90befffaull);
  130|       |
  131|       |        /* Combine with old state */
  132|  50.5M|        s0 = _mm_add_epi32(s0, so0);
  133|  50.5M|        s1 = _mm_add_epi32(s1, so1);
  134|       |
  135|       |        /* Advance */
  136|  50.5M|        chunk += 64;
  137|  50.5M|    }
  138|       |
  139|  50.5M|    Unshuffle(s0, s1);
  140|  50.5M|    _mm_storeu_si128((__m128i*)s, s0);
  141|  50.5M|    _mm_storeu_si128((__m128i*)(s + 4), s1);
  142|  50.5M|}
sha256_x86_shani.cpp:_ZN12_GLOBAL__N_17ShuffleERDv2_xS1_:
   54|  50.5M|{
   55|  50.5M|    const __m128i t1 = _mm_shuffle_epi32(s0, 0xB1);
   56|  50.5M|    const __m128i t2 = _mm_shuffle_epi32(s1, 0x1B);
   57|  50.5M|    s0 = _mm_alignr_epi8(t1, t2, 0x08);
   58|       |    s1 = _mm_blend_epi16(t2, t1, 0xF0);
   59|  50.5M|}
sha256_x86_shani.cpp:_ZN12_GLOBAL__N_14LoadEPKh:
   70|   202M|{
   71|   202M|    return _mm_shuffle_epi8(_mm_loadu_si128((const __m128i*)in), _mm_load_si128((const __m128i*)MASK));
   72|   202M|}
sha256_x86_shani.cpp:_ZN12_GLOBAL__N_19QuadRoundERDv2_xS1_S0_mm:
   31|   808M|{
   32|   808M|    const __m128i msg = _mm_add_epi32(m, _mm_set_epi64x(k1, k0));
   33|   808M|    state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
   34|       |    state0 = _mm_sha256rnds2_epu32(state0, state1, _mm_shuffle_epi32(msg, 0x0e));
   35|   808M|}
sha256_x86_shani.cpp:_ZN12_GLOBAL__N_113ShiftMessageAERDv2_xS0_:
   38|   606M|{
   39|   606M|    m0 = _mm_sha256msg1_epu32(m0, m1);
   40|   606M|}
sha256_x86_shani.cpp:_ZN12_GLOBAL__N_113ShiftMessageBERDv2_xS0_S1_:
   48|   505M|{
   49|   505M|    ShiftMessageC(m0, m1, m2);
   50|   505M|    ShiftMessageA(m0, m1);
   51|   505M|}
sha256_x86_shani.cpp:_ZN12_GLOBAL__N_113ShiftMessageCERDv2_xS0_S1_:
   43|   606M|{
   44|       |    m2 = _mm_sha256msg2_epu32(_mm_add_epi32(m2, _mm_alignr_epi8(m1, m0, 4)), m1);
   45|   606M|}
sha256_x86_shani.cpp:_ZN12_GLOBAL__N_19UnshuffleERDv2_xS1_:
   62|  50.5M|{
   63|  50.5M|    const __m128i t1 = _mm_shuffle_epi32(s0, 0x1B);
   64|  50.5M|    const __m128i t2 = _mm_shuffle_epi32(s1, 0xB1);
   65|  50.5M|    s0 = _mm_blend_epi16(t1, t2, 0xF0);
   66|       |    s1 = _mm_alignr_epi8(t2, t1, 0x08);
   67|  50.5M|}

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

_ZN10CSipHasherC2Emm:
   12|  12.7M|CSipHasher::CSipHasher(uint64_t k0, uint64_t k1) : m_state{k0, k1} {}
_ZN10CSipHasher5WriteEm:
   15|  25.4M|{
   16|  25.4M|    assert(m_count % 8 == 0);
  ------------------
  |  Branch (16:5): [True: 25.4M, False: 0]
  ------------------
   17|  25.4M|    m_state.Compress2(data);
   18|  25.4M|    m_count += 8;
   19|  25.4M|    return *this;
   20|  25.4M|}
_ZN10CSipHasher5WriteENSt3__14spanIKhLm18446744073709551615EEE:
   23|  12.7M|{
   24|  12.7M|    SipHashState state{m_state.Copy()};
   25|  12.7M|    uint64_t t{m_tmp};
   26|  12.7M|    uint8_t c{m_count};
   27|       |
   28|   239M|    while (data.size() > 0) {
  ------------------
  |  Branch (28:12): [True: 226M, False: 12.7M]
  ------------------
   29|   226M|        t |= uint64_t{data.front()} << (8 * (c % 8));
   30|   226M|        c++;
   31|   226M|        if ((c & 7) == 0) {
  ------------------
  |  Branch (31:13): [True: 28.2M, False: 198M]
  ------------------
   32|  28.2M|            state.Compress2(t);
   33|  28.2M|            t = 0;
   34|  28.2M|        }
   35|   226M|        data = data.subspan(1);
   36|   226M|    }
   37|       |
   38|  12.7M|    m_state = state;
   39|  12.7M|    m_count = c;
   40|  12.7M|    m_tmp = t;
   41|       |
   42|  12.7M|    return *this;
   43|  12.7M|}
_ZNK10CSipHasher8FinalizeEv:
   46|  12.7M|{
   47|  12.7M|    return m_state.Copy()
   48|  12.7M|                  .Compress2(m_tmp | (uint64_t{m_count} << 56))
   49|  12.7M|                  .Finalize4();
   50|  12.7M|}

_ZN12SipHashStateC2Emmmm:
   28|  38.1M|    ALWAYS_INLINE SipHashState(uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3) noexcept : m_v0{v0}, m_v1{v1}, m_v2{v2}, m_v3{v3} {}
_ZN12SipHashState8SipRoundEv:
   35|   183M|    {
   36|   183M|        m_v0 += m_v1; m_v1 = std::rotl(m_v1, 13); m_v1 ^= m_v0;
   37|   183M|        m_v0 = std::rotl(m_v0, 32);
   38|   183M|        m_v2 += m_v3; m_v3 = std::rotl(m_v3, 16); m_v3 ^= m_v2;
   39|   183M|        m_v0 += m_v3; m_v3 = std::rotl(m_v3, 21); m_v3 ^= m_v0;
   40|   183M|        m_v2 += m_v1; m_v1 = std::rotl(m_v1, 17); m_v1 ^= m_v2;
   41|   183M|        m_v2 = std::rotl(m_v2, 32);
   42|   183M|    }
_ZN12SipHashStateC2Emm:
   46|  12.7M|    explicit ALWAYS_INLINE SipHashState(uint64_t k0, uint64_t k1) noexcept : SipHashState{C0 ^ k0, C1 ^ k1, C2 ^ k0, C3 ^ k1} {}
_ZNK12SipHashState4CopyEv:
   48|  25.4M|    ALWAYS_INLINE SipHashState Copy() const noexcept { return {m_v0, m_v1, m_v2, m_v3}; }
_ZN12SipHashState9Compress2Em:
   68|  66.4M|    {
   69|  66.4M|        m_v3 ^= data;
   70|  66.4M|        SipRound();
   71|  66.4M|        SipRound();
   72|  66.4M|        m_v0 ^= data;
   73|  66.4M|        return *this;
   74|  66.4M|    }
_ZN12SipHashState9Finalize4Ev:
   77|  12.7M|    {
   78|  12.7M|        m_v2 ^= FINALIZER;
   79|  12.7M|        SipRound();
   80|  12.7M|        SipRound();
   81|  12.7M|        SipRound();
   82|  12.7M|        SipRound();
   83|  12.7M|        return m_v0 ^ m_v1 ^ m_v2 ^ m_v3;
   84|  12.7M|    }

_ZN10HashWriterlsINSt3__14spanIKSt4byteLm18446744073709551615EEEEERS_RKT_:
  150|  2.20k|    {
  151|  2.20k|        ::Serialize(*this, obj);
  152|  2.20k|        return *this;
  153|  2.20k|    }
_ZN10HashWriter12GetCheapHashEv:
  143|  20.1M|    inline uint64_t GetCheapHash() {
  144|  20.1M|        uint256 result = GetHash();
  145|  20.1M|        return ReadLE64(result.begin());
  146|  20.1M|    }
_ZN10HashWriterlsImEERS_RKT_:
  150|  4.96M|    {
  151|  4.96M|        ::Serialize(*this, obj);
  152|  4.96M|        return *this;
  153|  4.96M|    }
_ZN9ChainCodeD2Ev:
   28|      2|    ~ChainCode() { memory_cleanse(data(), size()); }
_ZN10HashWriterlsINSt3__16vectorIhNS1_9allocatorIhEEEEEERS_RKT_:
  150|  24.4M|    {
  151|  24.4M|        ::Serialize(*this, obj);
  152|  24.4M|        return *this;
  153|  24.4M|    }
_ZN10HashWriterlsINSt3__14spanIKhLm32EEEEERS_RKT_:
  150|  20.1M|    {
  151|  20.1M|        ::Serialize(*this, obj);
  152|  20.1M|        return *this;
  153|  20.1M|    }
_ZN10HashWriterlsIiEERS_RKT_:
  150|  10.1M|    {
  151|  10.1M|        ::Serialize(*this, obj);
  152|  10.1M|        return *this;
  153|  10.1M|    }
_ZN10HashWriter7GetHashEv:
  123|  20.1M|    uint256 GetHash() {
  124|  20.1M|        uint256 result;
  125|  20.1M|        ctx.Finalize(result.begin());
  126|  20.1M|        ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin());
  127|  20.1M|        return result;
  128|  20.1M|    }
_ZN10HashWriterlsI7uint256EERS_RKT_:
  150|  20.1M|    {
  151|  20.1M|        ::Serialize(*this, obj);
  152|  20.1M|        return *this;
  153|  20.1M|    }
_ZN10HashWriterlsIhEERS_RKT_:
  150|  10.1M|    {
  151|  10.1M|        ::Serialize(*this, obj);
  152|  10.1M|        return *this;
  153|  10.1M|    }
_ZN10HashWriter5writeENSt3__14spanIKSt4byteLm18446744073709551615EEE:
  115|  94.3M|    {
  116|  94.3M|        ctx.Write(UCharCast(src.data()), src.size());
  117|  94.3M|    }

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

_ZN11ECC_ContextD2Ev:
  501|      2|{
  502|      2|    ECC_Stop();
  503|      2|}
key.cpp:_ZL8ECC_Stopv:
  486|      2|static void ECC_Stop() {
  487|      2|    secp256k1_context *ctx = secp256k1_context_sign;
  488|      2|    secp256k1_context_sign = nullptr;
  489|       |
  490|      2|    if (ctx) {
  ------------------
  |  Branch (490:9): [True: 2, False: 0]
  ------------------
  491|      2|        secp256k1_context_destroy(ctx);
  492|      2|    }
  493|      2|}

_Z11LogInstancev:
   27|  6.92M|{
   28|       |/**
   29|       | * NOTE: the logger instances is leaked on exit. This is ugly, but will be
   30|       | * cleaned up by the OS/libc. Defining a logger as a global object doesn't work
   31|       | * since the order of destruction of static/global objects is undefined.
   32|       | * Consider if the logger gets destroyed, and then some later destructor calls
   33|       | * LogInfo, maybe indirectly, and you get a core dump at shutdown trying to
   34|       | * access the logger. When the shutdown sequence is fully audited and tested,
   35|       | * explicit destruction of these objects can be implemented by changing this
   36|       | * from a raw pointer to a std::unique_ptr.
   37|       | * Since the ~Logger() destructor is never called, the Logger class and all
   38|       | * its subclasses must have implicitly-defined destructors.
   39|       | *
   40|       | * This method of initialization was originally introduced in
   41|       | * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c.
   42|       | */
   43|  6.92M|    static BCLog::Logger* g_logger{new BCLog::Logger()};
   44|  6.92M|    return *g_logger;
   45|  6.92M|}
_ZN5BCLog6Logger20DisconnectTestLoggerEv:
  104|      2|{
  105|      2|    STDLOCK(m_cs);
  ------------------
  |  |   41|      2|#define STDLOCK(cs) StdMutex::Guard BITCOIN_UNIQUE_NAME(criticalblock){StdMutex::CheckNotHeld(cs)}
  |  |  ------------------
  |  |  |  |   11|      2|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  106|      2|    m_buffering = true;
  107|      2|    if (m_fileout != nullptr) fclose(m_fileout);
  ------------------
  |  Branch (107:9): [True: 0, False: 2]
  ------------------
  108|      2|    m_fileout = nullptr;
  109|      2|    m_print_callbacks.clear();
  110|      2|    m_max_buffer_memusage = DEFAULT_MAX_LOG_BUFFER;
  111|      2|    m_cur_buffer_memusage = 0;
  112|      2|    m_buffer_lines_discarded = 0;
  113|      2|    m_msgs_before_open.clear();
  114|      2|}
_ZNK5BCLog6Logger15WillLogCategoryENS_8LogFlagsE:
  157|  6.90M|{
  158|  6.90M|    return (m_categories.load(std::memory_order_relaxed) & category) != 0;
  159|  6.90M|}
_ZNK5BCLog6Logger20WillLogCategoryLevelENS_8LogFlagsEN4util3log5LevelE:
  162|  6.90M|{
  163|       |    // Log messages at Info, Warning and Error level unconditionally, so that
  164|       |    // important troubleshooting information doesn't get lost.
  165|  6.90M|    if (level >= BCLog::Level::Info) return true;
  ------------------
  |  Branch (165:9): [True: 0, False: 6.90M]
  ------------------
  166|       |
  167|  6.90M|    if (!WillLogCategory(category)) return false;
  ------------------
  |  Branch (167:9): [True: 6.90M, False: 0]
  ------------------
  168|       |
  169|      0|    STDLOCK(m_cs);
  ------------------
  |  |   41|      0|#define STDLOCK(cs) StdMutex::Guard BITCOIN_UNIQUE_NAME(criticalblock){StdMutex::CheckNotHeld(cs)}
  |  |  ------------------
  |  |  |  |   11|      0|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      0|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      0|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  170|      0|    const auto it{m_category_log_levels.find(category)};
  171|      0|    return level >= (it == m_category_log_levels.end() ? LogLevel() : it->second);
  ------------------
  |  Branch (171:22): [True: 0, False: 0]
  ------------------
  172|  6.90M|}
_ZN4util3log14ShouldDebugLogEm:
  620|  6.90M|{
  621|  6.90M|    return LogInstance().WillLogCategoryLevel(static_cast<BCLog::LogFlags>(category), util::log::Level::Debug);
  622|  6.90M|}
_ZN4util3log3LogENS0_5EntryE:
  630|  12.1k|{
  631|  12.1k|    BCLog::Logger& logger{LogInstance()};
  632|  12.1k|    if (logger.Enabled()) {
  ------------------
  |  Branch (632:9): [True: 0, False: 12.1k]
  ------------------
  633|      0|        logger.LogPrint(std::move(entry));
  634|      0|    }
  635|  12.1k|}

_ZNK5BCLog6Logger7EnabledEv:
  185|  12.1k|        {
  186|  12.1k|            STDLOCK(m_cs);
  ------------------
  |  |   41|  12.1k|#define STDLOCK(cs) StdMutex::Guard BITCOIN_UNIQUE_NAME(criticalblock){StdMutex::CheckNotHeld(cs)}
  |  |  ------------------
  |  |  |  |   11|  12.1k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  12.1k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  12.1k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  187|  12.1k|            return m_buffering || m_print_to_console || m_print_to_file || !m_print_callbacks.empty();
  ------------------
  |  Branch (187:20): [True: 0, False: 12.1k]
  |  Branch (187:35): [True: 0, False: 12.1k]
  |  Branch (187:57): [True: 0, False: 12.1k]
  |  Branch (187:76): [True: 0, False: 12.1k]
  ------------------
  188|  12.1k|        }

_ZN5BCLog5TimerINSt3__16chrono8durationIxNS1_5ratioILl1ELl1000EEEEEEC2ENS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEESD_NS_8LogFlagsEb:
   33|    676|        : m_prefix(std::move(prefix)),
   34|    676|          m_title(std::move(end_msg)),
   35|    676|          m_log_category(log_category),
   36|    676|          m_message_on_completion(msg_on_completion)
   37|    676|    {
   38|    676|        this->Log(strprintf("%s started", m_title));
  ------------------
  |  | 1172|    676|#define strprintf tfm::format
  ------------------
   39|    676|        m_start_t = std::chrono::steady_clock::now();
   40|    676|    }
_ZN5BCLog5TimerINSt3__16chrono8durationIxNS1_5ratioILl1ELl1000EEEEEE3LogERKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   52|  1.35k|    {
   53|  1.35k|        const std::string full_msg = this->LogMsg(msg);
   54|       |
   55|  1.35k|        if (m_log_category == BCLog::LogFlags::ALL) {
  ------------------
  |  Branch (55:13): [True: 0, False: 1.35k]
  ------------------
   56|      0|            LogInfo("%s\n", full_msg);
  ------------------
  |  |  125|      0|#define LogInfo(...) detail_LogWithSrcLoc(BCLog::LogFlags::ALL, util::log::Level::Info, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  ------------------
  ------------------
   57|  1.35k|        } else {
   58|  1.35k|            LogDebug(m_log_category, "%s\n", full_msg);
  ------------------
  |  |  143|  1.35k|#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, util::log::ShouldDebugLog, util::log::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  136|  1.35k|    do {                                                                                      \
  |  |  |  |  137|  1.35k|        if (shouldlog(category)) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (137:13): [True: 0, False: 1.35k]
  |  |  |  |  ------------------
  |  |  |  |  138|      0|            detail_LogWithSrcLoc((category), (level), util::log::NO_RATE_LIMIT, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  139|      0|        }                                                                                     \
  |  |  |  |  140|  1.35k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:14): [Folded, False: 1.35k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   59|  1.35k|        }
   60|  1.35k|    }
_ZN5BCLog5TimerINSt3__16chrono8durationIxNS1_5ratioILl1ELl1000EEEEEE6LogMsgERKNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   63|  1.35k|    {
   64|  1.35k|        const auto end_time{std::chrono::steady_clock::now()};
   65|  1.35k|        if (!m_start_t) {
  ------------------
  |  Branch (65:13): [True: 676, False: 676]
  ------------------
   66|    676|            return strprintf("%s: %s", m_prefix, msg);
  ------------------
  |  | 1172|    676|#define strprintf tfm::format
  ------------------
   67|    676|        }
   68|    676|        const auto duration{end_time - *m_start_t};
   69|       |
   70|       |        if constexpr (std::is_same_v<TimeType, std::chrono::microseconds>) {
   71|       |            return strprintf("%s: %s (%iμs)", m_prefix, msg, Ticks<std::chrono::microseconds>(duration));
   72|    676|        } else if constexpr (std::is_same_v<TimeType, std::chrono::milliseconds>) {
   73|    676|            return strprintf("%s: %s (%.2fms)", m_prefix, msg, Ticks<MillisecondsDouble>(duration));
  ------------------
  |  | 1172|    676|#define strprintf tfm::format
  ------------------
   74|       |        } else if constexpr (std::is_same_v<TimeType, std::chrono::seconds>) {
   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|    676|    }
_ZN5BCLog5TimerINSt3__16chrono8durationIxNS1_5ratioILl1ELl1000EEEEEED2Ev:
   43|    676|    {
   44|    676|        if (m_message_on_completion) {
  ------------------
  |  Branch (44:13): [True: 0, False: 676]
  ------------------
   45|      0|            this->Log(strprintf("%s completed", m_title));
  ------------------
  |  | 1172|      0|#define strprintf tfm::format
  ------------------
   46|    676|        } else {
   47|    676|            this->Log("completed");
   48|    676|        }
   49|    676|    }

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

_ZNK8CNetAddr16GetBIP155NetworkEv:
   28|  2.52M|{
   29|  2.52M|    switch (m_net) {
  ------------------
  |  Branch (29:13): [True: 2.52M, False: 0]
  ------------------
   30|   432k|    case NET_IPV4:
  ------------------
  |  Branch (30:5): [True: 432k, False: 2.08M]
  ------------------
   31|   432k|        return BIP155Network::IPV4;
   32|  1.41M|    case NET_IPV6:
  ------------------
  |  Branch (32:5): [True: 1.41M, False: 1.11M]
  ------------------
   33|  1.41M|        return BIP155Network::IPV6;
   34|   208k|    case NET_ONION:
  ------------------
  |  Branch (34:5): [True: 208k, False: 2.31M]
  ------------------
   35|   208k|        return BIP155Network::TORV3;
   36|   444k|    case NET_I2P:
  ------------------
  |  Branch (36:5): [True: 444k, False: 2.07M]
  ------------------
   37|   444k|        return BIP155Network::I2P;
   38|  23.5k|    case NET_CJDNS:
  ------------------
  |  Branch (38:5): [True: 23.5k, False: 2.49M]
  ------------------
   39|  23.5k|        return BIP155Network::CJDNS;
   40|      0|    case NET_INTERNAL:   // should have been handled before calling this function
  ------------------
  |  Branch (40:5): [True: 0, False: 2.52M]
  ------------------
   41|      0|    case NET_UNROUTABLE: // m_net is never and should not be set to NET_UNROUTABLE
  ------------------
  |  Branch (41:5): [True: 0, False: 2.52M]
  ------------------
   42|      0|    case NET_MAX:        // m_net is never and should not be set to NET_MAX
  ------------------
  |  Branch (42:5): [True: 0, False: 2.52M]
  ------------------
   43|      0|        assert(false);
  ------------------
  |  Branch (43:9): [Folded, False: 0]
  ------------------
   44|  2.52M|    } // no default case, so the compiler can warn about missing cases
   45|       |
   46|  2.52M|    assert(false);
  ------------------
  |  Branch (46:5): [Folded, False: 0]
  ------------------
   47|      0|}
_ZN8CNetAddr23SetNetFromBIP155NetworkEhm:
   50|  6.15M|{
   51|  6.15M|    switch (possible_bip155_net) {
  ------------------
  |  Branch (51:13): [True: 6.04M, False: 115k]
  ------------------
   52|  97.4k|    case BIP155Network::IPV4:
  ------------------
  |  Branch (52:5): [True: 97.4k, False: 6.06M]
  ------------------
   53|  97.4k|        if (address_size == ADDR_IPV4_SIZE) {
  ------------------
  |  Branch (53:13): [True: 97.4k, False: 8]
  ------------------
   54|  97.4k|            m_net = NET_IPV4;
   55|  97.4k|            return true;
   56|  97.4k|        }
   57|      8|        throw std::ios_base::failure(
   58|      8|            strprintf("BIP155 IPv4 address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|      8|#define strprintf tfm::format
  ------------------
   59|      8|                      ADDR_IPV4_SIZE));
   60|  4.90M|    case BIP155Network::IPV6:
  ------------------
  |  Branch (60:5): [True: 4.90M, False: 1.25M]
  ------------------
   61|  4.90M|        if (address_size == ADDR_IPV6_SIZE) {
  ------------------
  |  Branch (61:13): [True: 4.90M, False: 8]
  ------------------
   62|  4.90M|            m_net = NET_IPV6;
   63|  4.90M|            return true;
   64|  4.90M|        }
   65|      8|        throw std::ios_base::failure(
   66|      8|            strprintf("BIP155 IPv6 address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|      8|#define strprintf tfm::format
  ------------------
   67|      8|                      ADDR_IPV6_SIZE));
   68|  31.1k|    case BIP155Network::TORV3:
  ------------------
  |  Branch (68:5): [True: 31.1k, False: 6.12M]
  ------------------
   69|  31.1k|        if (address_size == ADDR_TORV3_SIZE) {
  ------------------
  |  Branch (69:13): [True: 31.0k, False: 6]
  ------------------
   70|  31.0k|            m_net = NET_ONION;
   71|  31.0k|            return true;
   72|  31.0k|        }
   73|      6|        throw std::ios_base::failure(
   74|      6|            strprintf("BIP155 TORv3 address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|      6|#define strprintf tfm::format
  ------------------
   75|      6|                      ADDR_TORV3_SIZE));
   76|   995k|    case BIP155Network::I2P:
  ------------------
  |  Branch (76:5): [True: 995k, False: 5.16M]
  ------------------
   77|   995k|        if (address_size == ADDR_I2P_SIZE) {
  ------------------
  |  Branch (77:13): [True: 995k, False: 4]
  ------------------
   78|   995k|            m_net = NET_I2P;
   79|   995k|            return true;
   80|   995k|        }
   81|      4|        throw std::ios_base::failure(
   82|      4|            strprintf("BIP155 I2P address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|      4|#define strprintf tfm::format
  ------------------
   83|      4|                      ADDR_I2P_SIZE));
   84|  12.5k|    case BIP155Network::CJDNS:
  ------------------
  |  Branch (84:5): [True: 12.5k, False: 6.14M]
  ------------------
   85|  12.5k|        if (address_size == ADDR_CJDNS_SIZE) {
  ------------------
  |  Branch (85:13): [True: 12.5k, False: 8]
  ------------------
   86|  12.5k|            m_net = NET_CJDNS;
   87|  12.5k|            return true;
   88|  12.5k|        }
   89|      8|        throw std::ios_base::failure(
   90|      8|            strprintf("BIP155 CJDNS address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|      8|#define strprintf tfm::format
  ------------------
   91|      8|                      ADDR_CJDNS_SIZE));
   92|  6.15M|    }
   93|       |
   94|       |    // Don't throw on addresses with unknown network ids (maybe from the future).
   95|       |    // Instead silently drop them and have the unserialization code consume
   96|       |    // subsequent ones which may be known to us.
   97|   115k|    return false;
   98|  6.15M|}
_ZN8CNetAddrC2Ev:
  105|  14.4M|CNetAddr::CNetAddr() = default;
_ZN8CNetAddr13SetLegacyIPv6ENSt3__14spanIKhLm18446744073709551615EEE:
  139|   121k|{
  140|   121k|    assert(ipv6.size() == ADDR_IPV6_SIZE);
  ------------------
  |  Branch (140:5): [True: 121k, False: 0]
  ------------------
  141|       |
  142|   121k|    size_t skip{0};
  143|       |
  144|   121k|    if (HasPrefix(ipv6, IPV4_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (144:9): [True: 136, False: 121k]
  ------------------
  145|       |        // IPv4-in-IPv6
  146|    136|        m_net = NET_IPV4;
  147|    136|        skip = sizeof(IPV4_IN_IPV6_PREFIX);
  148|   121k|    } else if (HasPrefix(ipv6, TORV2_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (148:16): [True: 53, False: 121k]
  ------------------
  149|       |        // TORv2-in-IPv6 (unsupported). Unserialize as !IsValid(), thus ignoring them.
  150|       |        // Mimic a default-constructed CNetAddr object which is !IsValid() and thus
  151|       |        // will not be gossiped, but continue reading next addresses from the stream.
  152|     53|        m_net = NET_IPV6;
  153|     53|        m_addr.assign(ADDR_IPV6_SIZE, 0x0);
  154|     53|        return;
  155|   121k|    } else if (HasPrefix(ipv6, INTERNAL_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (155:16): [True: 98, False: 121k]
  ------------------
  156|       |        // Internal-in-IPv6
  157|     98|        m_net = NET_INTERNAL;
  158|     98|        skip = sizeof(INTERNAL_IN_IPV6_PREFIX);
  159|   121k|    } else {
  160|       |        // IPv6
  161|   121k|        m_net = NET_IPV6;
  162|   121k|    }
  163|       |
  164|   121k|    m_addr.assign(ipv6.begin() + skip, ipv6.end());
  165|   121k|}
_ZN8CNetAddr11SetInternalERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  174|  22.7k|{
  175|  22.7k|    if (name.empty()) {
  ------------------
  |  Branch (175:9): [True: 14, False: 22.7k]
  ------------------
  176|     14|        return false;
  177|     14|    }
  178|  22.7k|    m_net = NET_INTERNAL;
  179|  22.7k|    unsigned char hash[32] = {};
  180|  22.7k|    CSHA256().Write((const unsigned char*)name.data(), name.size()).Finalize(hash);
  181|  22.7k|    m_addr.assign(hash, hash + ADDR_INTERNAL_SIZE);
  182|  22.7k|    return true;
  183|  22.7k|}
_ZNK8CNetAddr9IsRFC1918Ev:
  312|  61.3M|{
  313|  61.3M|    return IsIPv4() && (
  ------------------
  |  Branch (313:12): [True: 3.32M, False: 57.9M]
  ------------------
  314|  3.32M|        m_addr[0] == 10 ||
  ------------------
  |  Branch (314:9): [True: 5.22k, False: 3.32M]
  ------------------
  315|  3.32M|        (m_addr[0] == 192 && m_addr[1] == 168) ||
  ------------------
  |  Branch (315:10): [True: 36.0k, False: 3.28M]
  |  Branch (315:30): [True: 228, False: 35.8k]
  ------------------
  316|  3.32M|        (m_addr[0] == 172 && m_addr[1] >= 16 && m_addr[1] <= 31));
  ------------------
  |  Branch (316:10): [True: 18.2k, False: 3.30M]
  |  Branch (316:30): [True: 17.6k, False: 599]
  |  Branch (316:49): [True: 3.28k, False: 14.3k]
  ------------------
  317|  61.3M|}
_ZNK8CNetAddr9IsRFC2544Ev:
  320|  61.3M|{
  321|  61.3M|    return IsIPv4() && m_addr[0] == 198 && (m_addr[1] == 18 || m_addr[1] == 19);
  ------------------
  |  Branch (321:12): [True: 3.31M, False: 57.9M]
  |  Branch (321:24): [True: 16.5k, False: 3.30M]
  |  Branch (321:45): [True: 211, False: 16.3k]
  |  Branch (321:64): [True: 48, False: 16.3k]
  ------------------
  322|  61.3M|}
_ZNK8CNetAddr9IsRFC3927Ev:
  325|  61.3M|{
  326|  61.3M|    return IsIPv4() && HasPrefix(m_addr, std::array<uint8_t, 2>{169, 254});
  ------------------
  |  Branch (326:12): [True: 3.31M, False: 57.9M]
  |  Branch (326:24): [True: 258, False: 3.31M]
  ------------------
  327|  61.3M|}
_ZNK8CNetAddr9IsRFC6598Ev:
  330|  61.3M|{
  331|  61.3M|    return IsIPv4() && m_addr[0] == 100 && m_addr[1] >= 64 && m_addr[1] <= 127;
  ------------------
  |  Branch (331:12): [True: 3.31M, False: 57.9M]
  |  Branch (331:24): [True: 21.4k, False: 3.29M]
  |  Branch (331:44): [True: 20.6k, False: 754]
  |  Branch (331:63): [True: 1.76k, False: 18.8k]
  ------------------
  332|  61.3M|}
_ZNK8CNetAddr9IsRFC5737Ev:
  335|  61.3M|{
  336|  61.3M|    return IsIPv4() && (HasPrefix(m_addr, std::array<uint8_t, 3>{192, 0, 2}) ||
  ------------------
  |  Branch (336:12): [True: 3.31M, False: 57.9M]
  |  Branch (336:25): [True: 247, False: 3.31M]
  ------------------
  337|  3.31M|                        HasPrefix(m_addr, std::array<uint8_t, 3>{198, 51, 100}) ||
  ------------------
  |  Branch (337:25): [True: 245, False: 3.31M]
  ------------------
  338|  3.31M|                        HasPrefix(m_addr, std::array<uint8_t, 3>{203, 0, 113}));
  ------------------
  |  Branch (338:25): [True: 25, False: 3.31M]
  ------------------
  339|  61.3M|}
_ZNK8CNetAddr9IsRFC3849Ev:
  342|  62.2M|{
  343|  62.2M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 4>{0x20, 0x01, 0x0D, 0xB8});
  ------------------
  |  Branch (343:12): [True: 44.4M, False: 17.8M]
  |  Branch (343:24): [True: 360, False: 44.4M]
  ------------------
  344|  62.2M|}
_ZNK8CNetAddr9IsRFC3964Ev:
  347|  26.2M|{
  348|  26.2M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 2>{0x20, 0x02});
  ------------------
  |  Branch (348:12): [True: 20.1M, False: 6.10M]
  |  Branch (348:24): [True: 1.60k, False: 20.1M]
  ------------------
  349|  26.2M|}
_ZNK8CNetAddr9IsRFC6052Ev:
  352|  26.2M|{
  353|  26.2M|    return IsIPv6() &&
  ------------------
  |  Branch (353:12): [True: 20.1M, False: 6.10M]
  ------------------
  354|  20.1M|           HasPrefix(m_addr, std::array<uint8_t, 12>{0x00, 0x64, 0xFF, 0x9B, 0x00, 0x00,
  ------------------
  |  Branch (354:12): [True: 1.73k, False: 20.1M]
  ------------------
  355|  20.1M|                                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00});
  356|  26.2M|}
_ZNK8CNetAddr9IsRFC4380Ev:
  359|  26.2M|{
  360|  26.2M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 4>{0x20, 0x01, 0x00, 0x00});
  ------------------
  |  Branch (360:12): [True: 20.1M, False: 6.10M]
  |  Branch (360:24): [True: 3.44k, False: 20.1M]
  ------------------
  361|  26.2M|}
_ZNK8CNetAddr9IsRFC4862Ev:
  364|  61.3M|{
  365|  61.3M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 8>{0xFE, 0x80, 0x00, 0x00,
  ------------------
  |  Branch (365:12): [True: 44.3M, False: 16.9M]
  |  Branch (365:24): [True: 4.97k, False: 44.3M]
  ------------------
  366|  44.3M|                                                                0x00, 0x00, 0x00, 0x00});
  367|  61.3M|}
_ZNK8CNetAddr9IsRFC4193Ev:
  370|  61.3M|{
  371|  61.3M|    return IsIPv6() && (m_addr[0] & 0xFE) == 0xFC;
  ------------------
  |  Branch (371:12): [True: 44.3M, False: 16.9M]
  |  Branch (371:24): [True: 84.1k, False: 44.2M]
  ------------------
  372|  61.3M|}
_ZNK8CNetAddr9IsRFC6145Ev:
  375|  26.2M|{
  376|  26.2M|    return IsIPv6() &&
  ------------------
  |  Branch (376:12): [True: 20.1M, False: 6.10M]
  ------------------
  377|  20.1M|           HasPrefix(m_addr, std::array<uint8_t, 12>{0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  ------------------
  |  Branch (377:12): [True: 1.60k, False: 20.1M]
  ------------------
  378|  20.1M|                                                     0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00});
  379|  26.2M|}
_ZNK8CNetAddr9IsRFC4843Ev:
  382|  61.2M|{
  383|  61.2M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 3>{0x20, 0x01, 0x00}) &&
  ------------------
  |  Branch (383:12): [True: 44.2M, False: 16.9M]
  |  Branch (383:24): [True: 5.41k, False: 44.2M]
  ------------------
  384|  5.41k|           (m_addr[3] & 0xF0) == 0x10;
  ------------------
  |  Branch (384:12): [True: 402, False: 5.01k]
  ------------------
  385|  61.2M|}
_ZNK8CNetAddr9IsRFC7343Ev:
  388|  61.2M|{
  389|  61.2M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 3>{0x20, 0x01, 0x00}) &&
  ------------------
  |  Branch (389:12): [True: 44.2M, False: 16.9M]
  |  Branch (389:24): [True: 5.01k, False: 44.2M]
  ------------------
  390|  5.01k|           (m_addr[3] & 0xF0) == 0x20;
  ------------------
  |  Branch (390:12): [True: 270, False: 4.74k]
  ------------------
  391|  61.2M|}
_ZNK8CNetAddr7IsHeNetEv:
  394|  1.98M|{
  395|  1.98M|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 4>{0x20, 0x01, 0x04, 0x70});
  ------------------
  |  Branch (395:12): [True: 1.98M, False: 0]
  |  Branch (395:24): [True: 596, False: 1.98M]
  ------------------
  396|  1.98M|}
_ZNK8CNetAddr7IsLocalEv:
  399|  66.2M|{
  400|       |    // IPv4 loopback (127.0.0.0/8 or 0.0.0.0/8)
  401|  66.2M|    if (IsIPv4() && (m_addr[0] == 127 || m_addr[0] == 0)) {
  ------------------
  |  Branch (401:9): [True: 4.09M, False: 62.1M]
  |  Branch (401:22): [True: 4.30k, False: 4.09M]
  |  Branch (401:42): [True: 396k, False: 3.69M]
  ------------------
  402|   401k|        return true;
  403|   401k|    }
  404|       |
  405|       |    // IPv6 loopback (::1/128)
  406|  65.8M|    static const unsigned char pchLocal[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
  407|  65.8M|    if (IsIPv6() && memcmp(m_addr.data(), pchLocal, sizeof(pchLocal)) == 0) {
  ------------------
  |  Branch (407:9): [True: 46.2M, False: 19.6M]
  |  Branch (407:21): [True: 873, False: 46.2M]
  ------------------
  408|    873|        return true;
  409|    873|    }
  410|       |
  411|  65.8M|    return false;
  412|  65.8M|}
_ZNK8CNetAddr7IsValidEv:
  425|  62.4M|{
  426|       |    // unspecified IPv6 address (::/128)
  427|  62.4M|    unsigned char ipNone6[16] = {};
  428|  62.4M|    if (IsIPv6() && memcmp(m_addr.data(), ipNone6, sizeof(ipNone6)) == 0) {
  ------------------
  |  Branch (428:9): [True: 44.6M, False: 17.8M]
  |  Branch (428:21): [True: 213k, False: 44.4M]
  ------------------
  429|   213k|        return false;
  430|   213k|    }
  431|       |
  432|  62.2M|    if (IsCJDNS() && !HasCJDNSPrefix()) {
  ------------------
  |  Branch (432:9): [True: 718k, False: 61.5M]
  |  Branch (432:22): [True: 248, False: 718k]
  ------------------
  433|    248|        return false;
  434|    248|    }
  435|       |
  436|       |    // documentation IPv6 address
  437|  62.2M|    if (IsRFC3849())
  ------------------
  |  Branch (437:9): [True: 360, False: 62.2M]
  ------------------
  438|    360|        return false;
  439|       |
  440|  62.2M|    if (IsInternal())
  ------------------
  |  Branch (440:9): [True: 15.8k, False: 62.2M]
  ------------------
  441|  15.8k|        return false;
  442|       |
  443|  62.2M|    if (IsIPv4()) {
  ------------------
  |  Branch (443:9): [True: 4.12M, False: 58.0M]
  ------------------
  444|  4.12M|        const uint32_t addr = ReadBE32(m_addr.data());
  445|  4.12M|        if (addr == INADDR_ANY || addr == INADDR_NONE) {
  ------------------
  |  Branch (445:13): [True: 743k, False: 3.37M]
  |  Branch (445:35): [True: 51.3k, False: 3.32M]
  ------------------
  446|   794k|            return false;
  447|   794k|        }
  448|  4.12M|    }
  449|       |
  450|  61.4M|    return true;
  451|  62.2M|}
_ZNK8CNetAddr10IsRoutableEv:
  463|  62.3M|{
  464|  62.3M|    return IsValid() && !(IsRFC1918() || IsRFC2544() || IsRFC3927() || IsRFC4862() || IsRFC6598() || IsRFC5737() || IsRFC4193() || IsRFC4843() || IsRFC7343() || IsLocal() || IsInternal());
  ------------------
  |  Branch (464:12): [True: 61.3M, False: 1.01M]
  |  Branch (464:27): [True: 8.74k, False: 61.3M]
  |  Branch (464:42): [True: 259, False: 61.3M]
  |  Branch (464:57): [True: 258, False: 61.3M]
  |  Branch (464:72): [True: 4.97k, False: 61.3M]
  |  Branch (464:87): [True: 1.76k, False: 61.3M]
  |  Branch (464:102): [True: 517, False: 61.3M]
  |  Branch (464:117): [True: 84.1k, False: 61.2M]
  |  Branch (464:132): [True: 402, False: 61.2M]
  |  Branch (464:147): [True: 270, False: 61.2M]
  |  Branch (464:162): [True: 21.4k, False: 61.2M]
  |  Branch (464:175): [True: 0, False: 61.2M]
  ------------------
  465|  62.3M|}
_ZNK8CNetAddr10IsInternalEv:
  473|   156M|{
  474|   156M|   return m_net == NET_INTERNAL;
  475|   156M|}
_ZNK8CNetAddr18IsAddrV1CompatibleEv:
  478|  21.8M|{
  479|  21.8M|    switch (m_net) {
  ------------------
  |  Branch (479:13): [True: 21.8M, False: 0]
  ------------------
  480|   484k|    case NET_IPV4:
  ------------------
  |  Branch (480:5): [True: 484k, False: 21.4M]
  ------------------
  481|  15.3M|    case NET_IPV6:
  ------------------
  |  Branch (481:5): [True: 14.8M, False: 7.07M]
  ------------------
  482|  15.6M|    case NET_INTERNAL:
  ------------------
  |  Branch (482:5): [True: 372k, False: 21.5M]
  ------------------
  483|  15.6M|        return true;
  484|   599k|    case NET_ONION:
  ------------------
  |  Branch (484:5): [True: 599k, False: 21.2M]
  ------------------
  485|  6.09M|    case NET_I2P:
  ------------------
  |  Branch (485:5): [True: 5.49M, False: 16.4M]
  ------------------
  486|  6.21M|    case NET_CJDNS:
  ------------------
  |  Branch (486:5): [True: 123k, False: 21.7M]
  ------------------
  487|  6.21M|        return false;
  488|      0|    case NET_UNROUTABLE: // m_net is never and should not be set to NET_UNROUTABLE
  ------------------
  |  Branch (488:5): [True: 0, False: 21.8M]
  ------------------
  489|      0|    case NET_MAX:        // m_net is never and should not be set to NET_MAX
  ------------------
  |  Branch (489:5): [True: 0, False: 21.8M]
  ------------------
  490|      0|        assert(false);
  ------------------
  |  Branch (490:9): [Folded, False: 0]
  ------------------
  491|  21.8M|    } // no default case, so the compiler can warn about missing cases
  492|       |
  493|  21.8M|    assert(false);
  ------------------
  |  Branch (493:5): [Folded, False: 0]
  ------------------
  494|      0|}
_ZNK8CNetAddr10GetNetworkEv:
  497|  7.09M|{
  498|  7.09M|    if (IsInternal())
  ------------------
  |  Branch (498:9): [True: 416, False: 7.09M]
  ------------------
  499|    416|        return NET_INTERNAL;
  500|       |
  501|  7.09M|    if (!IsRoutable())
  ------------------
  |  Branch (501:9): [True: 111k, False: 6.98M]
  ------------------
  502|   111k|        return NET_UNROUTABLE;
  503|       |
  504|  6.98M|    return m_net;
  505|  7.09M|}
_ZeqRK8CNetAddrS1_:
  604|  9.30M|{
  605|  9.30M|    return a.m_net == b.m_net && a.m_addr == b.m_addr;
  ------------------
  |  Branch (605:12): [True: 6.43M, False: 2.86M]
  |  Branch (605:34): [True: 4.32M, False: 2.10M]
  ------------------
  606|  9.30M|}
_ZNK8CNetAddr13HasLinkedIPv4Ev:
  653|  27.9M|{
  654|  27.9M|    return IsRoutable() && (IsIPv4() || IsRFC6145() || IsRFC6052() || IsRFC3964() || IsRFC4380());
  ------------------
  |  Branch (654:12): [True: 27.9M, False: 0]
  |  Branch (654:29): [True: 1.68M, False: 26.2M]
  |  Branch (654:41): [True: 1.13k, False: 26.2M]
  |  Branch (654:56): [True: 1.19k, False: 26.2M]
  |  Branch (654:71): [True: 1.13k, False: 26.2M]
  |  Branch (654:86): [True: 2.35k, False: 26.2M]
  ------------------
  655|  27.9M|}
_ZNK8CNetAddr13GetLinkedIPv4Ev:
  658|   627k|{
  659|   627k|    if (IsIPv4()) {
  ------------------
  |  Branch (659:9): [True: 625k, False: 2.57k]
  ------------------
  660|   625k|        return ReadBE32(m_addr.data());
  661|   625k|    } else if (IsRFC6052() || IsRFC6145()) {
  ------------------
  |  Branch (661:16): [True: 542, False: 2.03k]
  |  Branch (661:31): [True: 470, False: 1.56k]
  ------------------
  662|       |        // mapped IPv4, SIIT translated IPv4: the IPv4 address is the last 4 bytes of the address
  663|  1.01k|        return ReadBE32(std::span{m_addr}.last(ADDR_IPV4_SIZE).data());
  664|  1.56k|    } else if (IsRFC3964()) {
  ------------------
  |  Branch (664:16): [True: 473, False: 1.09k]
  ------------------
  665|       |        // 6to4 tunneled IPv4: the IPv4 address is in bytes 2-6
  666|    473|        return ReadBE32(std::span{m_addr}.subspan(2, ADDR_IPV4_SIZE).data());
  667|  1.09k|    } else if (IsRFC4380()) {
  ------------------
  |  Branch (667:16): [True: 1.09k, False: 0]
  ------------------
  668|       |        // Teredo tunneled IPv4: the IPv4 address is in the last 4 bytes of the address, but bitflipped
  669|  1.09k|        return ~ReadBE32(std::span{m_addr}.last(ADDR_IPV4_SIZE).data());
  670|  1.09k|    }
  671|   627k|    assert(false);
  ------------------
  |  Branch (671:5): [Folded, False: 0]
  ------------------
  672|      0|}
_ZNK8CNetAddr11GetNetClassEv:
  675|  18.6M|{
  676|       |    // Make sure that if we return NET_IPV6, then IsIPv6() is true. The callers expect that.
  677|       |
  678|       |    // Check for "internal" first because such addresses are also !IsRoutable()
  679|       |    // and we don't want to return NET_UNROUTABLE in that case.
  680|  18.6M|    if (IsInternal()) {
  ------------------
  |  Branch (680:9): [True: 745k, False: 17.9M]
  ------------------
  681|   745k|        return NET_INTERNAL;
  682|   745k|    }
  683|  17.9M|    if (!IsRoutable()) {
  ------------------
  |  Branch (683:9): [True: 897k, False: 17.0M]
  ------------------
  684|   897k|        return NET_UNROUTABLE;
  685|   897k|    }
  686|  17.0M|    if (HasLinkedIPv4()) {
  ------------------
  |  Branch (686:9): [True: 1.06M, False: 15.9M]
  ------------------
  687|  1.06M|        return NET_IPV4;
  688|  1.06M|    }
  689|  15.9M|    return m_net;
  690|  17.0M|}
_ZNK8CNetAddr12GetAddrBytesEv:
  693|  21.8M|{
  694|  21.8M|    if (IsAddrV1Compatible()) {
  ------------------
  |  Branch (694:9): [True: 15.6M, False: 6.21M]
  ------------------
  695|  15.6M|        uint8_t serialized[V1_SERIALIZATION_SIZE];
  696|  15.6M|        SerializeV1Array(serialized);
  697|  15.6M|        return {std::begin(serialized), std::end(serialized)};
  698|  15.6M|    }
  699|  6.21M|    return std::vector<unsigned char>(m_addr.begin(), m_addr.end());
  700|  21.8M|}
_ZN8CServiceC2Ev:
  780|  4.26M|CService::CService() : port(0)
  781|  4.26M|{
  782|  4.26M|}
_ZN8CServiceC2ERK8CNetAddrt:
  784|  6.02M|CService::CService(const CNetAddr& cip, uint16_t portIn) : CNetAddr(cip), port(portIn)
  785|  6.02M|{
  786|  6.02M|}
_ZeqRK8CServiceS1_:
  841|  4.24M|{
  842|  4.24M|    return static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) && a.port == b.port;
  ------------------
  |  Branch (842:12): [True: 4.24M, False: 0]
  |  Branch (842:68): [True: 4.24M, False: 0]
  ------------------
  843|  4.24M|}
_ZNK8CService6GetKeyEv:
  896|  10.8M|{
  897|  10.8M|    auto key = GetAddrBytes();
  898|  10.8M|    key.push_back(port / 0x100); // most significant byte of our port
  899|  10.8M|    key.push_back(port & 0x0FF); // least significant byte of our port
  900|  10.8M|    return key;
  901|  10.8M|}

_ZNK8CNetAddr14HasCJDNSPrefixEv:
  178|   718k|    [[nodiscard]] bool HasCJDNSPrefix() const { return m_addr[0] == CJDNS_PREFIX; }
_ZN12CServiceHashC2Ev:
  575|  9.68k|        : m_salt_k0{FastRandomContext().rand64()},
  576|  9.68k|          m_salt_k1{FastRandomContext().rand64()}
  577|  9.68k|    {
  578|  9.68k|    }
_ZN8CService16SerializationOpsI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEKS_15ActionSerializeEEvRT0_RT_T1_:
  563|  1.33M|    {
  564|  1.33M|        READWRITE(AsBase<CNetAddr>(obj), Using<BigEndianFormatter<2>>(obj.port));
  ------------------
  |  |  148|  1.33M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  565|  1.33M|    }
_ZNK8CNetAddr9SerializeI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  239|  1.33M|    {
  240|  1.33M|        if (s.template GetParams<SerParams>().enc == Encoding::V2) {
  ------------------
  |  Branch (240:13): [True: 1.33M, False: 0]
  ------------------
  241|  1.33M|            SerializeV2Stream(s);
  242|  1.33M|        } else {
  243|      0|            SerializeV1Stream(s);
  244|      0|        }
  245|  1.33M|    }
_ZNK8CNetAddr17SerializeV2StreamI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  376|  1.33M|    {
  377|  1.33M|        if (IsInternal()) {
  ------------------
  |  Branch (377:13): [True: 0, False: 1.33M]
  ------------------
  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);
  ------------------
  |  |  495|      0|#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
  ------------------
  382|      0|            SerializeV1Stream(s);
  383|      0|            return;
  384|      0|        }
  385|       |
  386|  1.33M|        s << static_cast<uint8_t>(GetBIP155Network());
  387|  1.33M|        s << m_addr;
  388|  1.33M|    }
_ZNK8CNetAddr9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  239|  1.33M|    {
  240|  1.33M|        if (s.template GetParams<SerParams>().enc == Encoding::V2) {
  ------------------
  |  Branch (240:13): [True: 1.33M, False: 0]
  ------------------
  241|  1.33M|            SerializeV2Stream(s);
  242|  1.33M|        } else {
  243|      0|            SerializeV1Stream(s);
  244|      0|        }
  245|  1.33M|    }
_ZNK8CNetAddr17SerializeV2StreamI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  376|  1.33M|    {
  377|  1.33M|        if (IsInternal()) {
  ------------------
  |  Branch (377:13): [True: 148k, False: 1.18M]
  ------------------
  378|       |            // Serialize NET_INTERNAL as embedded in IPv6. We need to
  379|       |            // serialize such addresses from addrman.
  380|   148k|            s << static_cast<uint8_t>(BIP155Network::IPV6);
  381|   148k|            s << COMPACTSIZE(ADDR_IPV6_SIZE);
  ------------------
  |  |  495|   148k|#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
  ------------------
  382|   148k|            SerializeV1Stream(s);
  383|   148k|            return;
  384|   148k|        }
  385|       |
  386|  1.18M|        s << static_cast<uint8_t>(GetBIP155Network());
  387|  1.18M|        s << m_addr;
  388|  1.18M|    }
_ZNK8CNetAddr17SerializeV1StreamI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  363|   148k|    {
  364|   148k|        uint8_t serialized[V1_SERIALIZATION_SIZE];
  365|       |
  366|   148k|        SerializeV1Array(serialized);
  367|       |
  368|   148k|        s << serialized;
  369|   148k|    }
_ZN8CNetAddr11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  252|  6.15M|    {
  253|  6.15M|        if (s.template GetParams<SerParams>().enc == Encoding::V2) {
  ------------------
  |  Branch (253:13): [True: 6.14M, False: 10.5k]
  ------------------
  254|  6.14M|            UnserializeV2Stream(s);
  255|  6.14M|        } else {
  256|  10.5k|            UnserializeV1Stream(s);
  257|  10.5k|        }
  258|  6.15M|    }
_ZN8CNetAddr19UnserializeV2StreamI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  424|  6.14M|    {
  425|  6.14M|        uint8_t bip155_net;
  426|  6.14M|        s >> bip155_net;
  427|       |
  428|  6.14M|        size_t address_size;
  429|  6.14M|        s >> COMPACTSIZE(address_size);
  ------------------
  |  |  495|  6.14M|#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
  ------------------
  430|       |
  431|  6.14M|        if (address_size > MAX_ADDRV2_SIZE) {
  ------------------
  |  Branch (431:13): [True: 32, False: 6.14M]
  ------------------
  432|     32|            throw std::ios_base::failure(strprintf(
  ------------------
  |  | 1172|     32|#define strprintf tfm::format
  ------------------
  433|     32|                "Address too long: %u > %u", address_size, MAX_ADDRV2_SIZE));
  434|     32|        }
  435|       |
  436|  6.14M|        m_scope_id = 0;
  437|       |
  438|  6.14M|        if (SetNetFromBIP155Network(bip155_net, address_size)) {
  ------------------
  |  Branch (438:13): [True: 6.03M, False: 109k]
  ------------------
  439|  6.03M|            m_addr.resize(address_size);
  440|  6.03M|            s >> std::span{m_addr};
  441|       |
  442|  6.03M|            if (m_net != NET_IPV6) {
  ------------------
  |  Branch (442:17): [True: 1.13M, False: 4.90M]
  ------------------
  443|  1.13M|                return;
  444|  1.13M|            }
  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.90M|            if (util::HasPrefix(m_addr, INTERNAL_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (451:17): [True: 1.06k, False: 4.90M]
  ------------------
  452|  1.06k|                m_net = NET_INTERNAL;
  453|  1.06k|                memmove(m_addr.data(), m_addr.data() + INTERNAL_IN_IPV6_PREFIX.size(),
  454|  1.06k|                        ADDR_INTERNAL_SIZE);
  455|  1.06k|                m_addr.resize(ADDR_INTERNAL_SIZE);
  456|  1.06k|                return;
  457|  1.06k|            }
  458|       |
  459|  4.90M|            if (!util::HasPrefix(m_addr, IPV4_IN_IPV6_PREFIX) &&
  ------------------
  |  Branch (459:17): [True: 4.90M, False: 974]
  ------------------
  460|  4.90M|                !util::HasPrefix(m_addr, TORV2_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (460:17): [True: 4.90M, False: 261]
  ------------------
  461|  4.90M|                return;
  462|  4.90M|            }
  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.90M|        } else {
  467|       |            // If we receive an unknown BIP155 network id (from the future?) then
  468|       |            // ignore the address - unserialize as !IsValid().
  469|   109k|            s.ignore(address_size);
  470|   109k|        }
  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|   110k|        m_net = NET_IPV6;
  475|   110k|        m_addr.assign(ADDR_IPV6_SIZE, 0x0);
  476|   110k|    }
_ZN8CNetAddr19UnserializeV1StreamI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  411|  10.5k|    {
  412|  10.5k|        uint8_t serialized[V1_SERIALIZATION_SIZE];
  413|       |
  414|  10.5k|        s >> serialized;
  415|       |
  416|  10.5k|        UnserializeV1Array(serialized);
  417|  10.5k|    }
_ZN8CNetAddr18UnserializeV1ArrayERA16_h:
  400|   121k|    {
  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|   121k|        SetLegacyIPv6(arr);
  404|   121k|    }
_ZNK8CNetAddr16SerializeV1ArrayERA16_h:
  325|  15.8M|    {
  326|  15.8M|        size_t prefix_size;
  327|       |
  328|  15.8M|        switch (m_net) {
  ------------------
  |  Branch (328:17): [True: 15.8M, False: 0]
  ------------------
  329|  14.8M|        case NET_IPV6:
  ------------------
  |  Branch (329:9): [True: 14.8M, False: 1.00M]
  ------------------
  330|  14.8M|            assert(m_addr.size() == sizeof(arr));
  ------------------
  |  Branch (330:13): [True: 14.8M, False: 0]
  ------------------
  331|  14.8M|            memcpy(arr, m_addr.data(), m_addr.size());
  332|  14.8M|            return;
  333|   484k|        case NET_IPV4:
  ------------------
  |  Branch (333:9): [True: 484k, False: 15.3M]
  ------------------
  334|   484k|            prefix_size = sizeof(IPV4_IN_IPV6_PREFIX);
  335|   484k|            assert(prefix_size + m_addr.size() == sizeof(arr));
  ------------------
  |  Branch (335:13): [True: 484k, False: 0]
  ------------------
  336|   484k|            memcpy(arr, IPV4_IN_IPV6_PREFIX.data(), prefix_size);
  337|   484k|            memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
  338|   484k|            return;
  339|   520k|        case NET_INTERNAL:
  ------------------
  |  Branch (339:9): [True: 520k, False: 15.3M]
  ------------------
  340|   520k|            prefix_size = sizeof(INTERNAL_IN_IPV6_PREFIX);
  341|   520k|            assert(prefix_size + m_addr.size() == sizeof(arr));
  ------------------
  |  Branch (341:13): [True: 520k, False: 0]
  ------------------
  342|   520k|            memcpy(arr, INTERNAL_IN_IPV6_PREFIX.data(), prefix_size);
  343|   520k|            memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
  344|   520k|            return;
  345|      0|        case NET_ONION:
  ------------------
  |  Branch (345:9): [True: 0, False: 15.8M]
  ------------------
  346|      0|        case NET_I2P:
  ------------------
  |  Branch (346:9): [True: 0, False: 15.8M]
  ------------------
  347|      0|        case NET_CJDNS:
  ------------------
  |  Branch (347:9): [True: 0, False: 15.8M]
  ------------------
  348|      0|            break;
  349|      0|        case NET_UNROUTABLE:
  ------------------
  |  Branch (349:9): [True: 0, False: 15.8M]
  ------------------
  350|      0|        case NET_MAX:
  ------------------
  |  Branch (350:9): [True: 0, False: 15.8M]
  ------------------
  351|      0|            assert(false);
  ------------------
  |  Branch (351:13): [Folded, False: 0]
  ------------------
  352|  15.8M|        } // 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|    }
_ZN8CService16SerializationOpsI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEES_17ActionUnserializeEEvRT0_RT_T1_:
  563|   120k|    {
  564|   120k|        READWRITE(AsBase<CNetAddr>(obj), Using<BigEndianFormatter<2>>(obj.port));
  ------------------
  |  |  148|   120k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  565|   120k|    }
_ZN8CNetAddr11UnserializeI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  252|   120k|    {
  253|   120k|        if (s.template GetParams<SerParams>().enc == Encoding::V2) {
  ------------------
  |  Branch (253:13): [True: 9.66k, False: 110k]
  ------------------
  254|  9.66k|            UnserializeV2Stream(s);
  255|   110k|        } else {
  256|   110k|            UnserializeV1Stream(s);
  257|   110k|        }
  258|   120k|    }
_ZN8CNetAddr19UnserializeV2StreamI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  424|  9.66k|    {
  425|  9.66k|        uint8_t bip155_net;
  426|  9.66k|        s >> bip155_net;
  427|       |
  428|  9.66k|        size_t address_size;
  429|  9.66k|        s >> COMPACTSIZE(address_size);
  ------------------
  |  |  495|  9.66k|#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
  ------------------
  430|       |
  431|  9.66k|        if (address_size > MAX_ADDRV2_SIZE) {
  ------------------
  |  Branch (431:13): [True: 28, False: 9.64k]
  ------------------
  432|     28|            throw std::ios_base::failure(strprintf(
  ------------------
  |  | 1172|     28|#define strprintf tfm::format
  ------------------
  433|     28|                "Address too long: %u > %u", address_size, MAX_ADDRV2_SIZE));
  434|     28|        }
  435|       |
  436|  9.64k|        m_scope_id = 0;
  437|       |
  438|  9.64k|        if (SetNetFromBIP155Network(bip155_net, address_size)) {
  ------------------
  |  Branch (438:13): [True: 3.19k, False: 6.45k]
  ------------------
  439|  3.19k|            m_addr.resize(address_size);
  440|  3.19k|            s >> std::span{m_addr};
  441|       |
  442|  3.19k|            if (m_net != NET_IPV6) {
  ------------------
  |  Branch (442:17): [True: 1.18k, False: 2.00k]
  ------------------
  443|  1.18k|                return;
  444|  1.18k|            }
  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|  2.00k|            if (util::HasPrefix(m_addr, INTERNAL_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (451:17): [True: 350, False: 1.65k]
  ------------------
  452|    350|                m_net = NET_INTERNAL;
  453|    350|                memmove(m_addr.data(), m_addr.data() + INTERNAL_IN_IPV6_PREFIX.size(),
  454|    350|                        ADDR_INTERNAL_SIZE);
  455|    350|                m_addr.resize(ADDR_INTERNAL_SIZE);
  456|    350|                return;
  457|    350|            }
  458|       |
  459|  1.65k|            if (!util::HasPrefix(m_addr, IPV4_IN_IPV6_PREFIX) &&
  ------------------
  |  Branch (459:17): [True: 1.52k, False: 131]
  ------------------
  460|  1.52k|                !util::HasPrefix(m_addr, TORV2_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (460:17): [True: 1.01k, False: 513]
  ------------------
  461|  1.01k|                return;
  462|  1.01k|            }
  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|  6.45k|        } else {
  467|       |            // If we receive an unknown BIP155 network id (from the future?) then
  468|       |            // ignore the address - unserialize as !IsValid().
  469|  6.45k|            s.ignore(address_size);
  470|  6.45k|        }
  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|  7.09k|        m_net = NET_IPV6;
  475|  7.09k|        m_addr.assign(ADDR_IPV6_SIZE, 0x0);
  476|  7.09k|    }
_ZN8CNetAddr19UnserializeV1StreamI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  411|   110k|    {
  412|   110k|        uint8_t serialized[V1_SERIALIZATION_SIZE];
  413|       |
  414|   110k|        s >> serialized;
  415|       |
  416|   110k|        UnserializeV1Array(serialized);
  417|   110k|    }
_ZNK8CNetAddr6IsIPv4Ev:
  158|   463M|    [[nodiscard]] bool IsIPv4() const { return m_net == NET_IPV4; } // IPv4 mapped address (::FFFF:0:0/96, 0.0.0.0/0)
_ZNK12CServiceHashclERK8CService:
  583|  12.7M|    {
  584|  12.7M|        CSipHasher hasher(m_salt_k0, m_salt_k1);
  585|  12.7M|        hasher.Write(a.m_net);
  586|  12.7M|        hasher.Write(a.port);
  587|  12.7M|        hasher.Write(a.m_addr);
  588|  12.7M|        return static_cast<size_t>(hasher.Finalize());
  589|  12.7M|    }
_ZNK8CNetAddr5IsTorEv:
  175|  3.84M|    [[nodiscard]] bool IsTor() const { return m_net == NET_ONION; }
_ZNK8CNetAddr5IsI2PEv:
  176|  3.28M|    [[nodiscard]] bool IsI2P() const { return m_net == NET_I2P; }
_ZNK8CNetAddr7IsCJDNSEv:
  177|  64.3M|    [[nodiscard]] bool IsCJDNS() const { return m_net == NET_CJDNS; }
_ZNK8CNetAddr6IsIPv6Ev:
  159|   548M|    [[nodiscard]] bool IsIPv6() const { return m_net == NET_IPV6; } // IPv6 address (not mapped IPv4, not Tor)

_ZNK15NetGroupManager15GetAsmapVersionEv:
   15|  7.85k|{
   16|  7.85k|    return AsmapVersion(m_asmap);
   17|  7.85k|}
_ZNK15NetGroupManager8GetGroupERK8CNetAddr:
   20|  9.29M|{
   21|  9.29M|    std::vector<unsigned char> vchRet;
   22|       |    // If non-empty asmap is supplied and the address is IPv4/IPv6,
   23|       |    // return ASN to be used for bucketing.
   24|  9.29M|    uint32_t asn = GetMappedAS(address);
   25|  9.29M|    if (asn != 0) { // Either asmap was empty, or address has non-asmappable net class (e.g. TOR).
  ------------------
  |  Branch (25:9): [True: 4.23M, False: 5.05M]
  ------------------
   26|  4.23M|        vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in the same bucket
   27|  21.1M|        for (int i = 0; i < 4; i++) {
  ------------------
  |  Branch (27:25): [True: 16.9M, False: 4.23M]
  ------------------
   28|  16.9M|            vchRet.push_back((asn >> (8 * i)) & 0xFF);
   29|  16.9M|        }
   30|  4.23M|        return vchRet;
   31|  4.23M|    }
   32|       |
   33|  5.05M|    vchRet.push_back(address.GetNetClass());
   34|  5.05M|    int nStartByte{0};
   35|  5.05M|    int nBits{0};
   36|       |
   37|  5.05M|    if (address.IsLocal()) {
  ------------------
  |  Branch (37:9): [True: 380k, False: 4.67M]
  ------------------
   38|       |        // all local addresses belong to the same group
   39|  4.67M|    } else if (address.IsInternal()) {
  ------------------
  |  Branch (39:16): [True: 372k, False: 4.29M]
  ------------------
   40|       |        // All internal-usage addresses get their own group.
   41|       |        // Skip over the INTERNAL_IN_IPV6_PREFIX returned by CAddress::GetAddrBytes().
   42|   372k|        nStartByte = INTERNAL_IN_IPV6_PREFIX.size();
   43|   372k|        nBits = ADDR_INTERNAL_SIZE * 8;
   44|  4.29M|    } else if (!address.IsRoutable()) {
  ------------------
  |  Branch (44:16): [True: 68.4k, False: 4.23M]
  ------------------
   45|       |        // all other unroutable addresses belong to the same group
   46|  4.23M|    } else if (address.HasLinkedIPv4()) {
  ------------------
  |  Branch (46:16): [True: 384k, False: 3.84M]
  ------------------
   47|       |        // IPv4 addresses (and mapped IPv4 addresses) use /16 groups
   48|   384k|        uint32_t ipv4 = address.GetLinkedIPv4();
   49|   384k|        vchRet.push_back((ipv4 >> 24) & 0xFF);
   50|   384k|        vchRet.push_back((ipv4 >> 16) & 0xFF);
   51|   384k|        return vchRet;
   52|  3.84M|    } else if (address.IsTor() || address.IsI2P()) {
  ------------------
  |  Branch (52:16): [True: 556k, False: 3.28M]
  |  Branch (52:35): [True: 1.19M, False: 2.09M]
  ------------------
   53|  1.74M|        nBits = 4;
   54|  2.09M|    } else if (address.IsCJDNS()) {
  ------------------
  |  Branch (54:16): [True: 112k, False: 1.98M]
  ------------------
   55|       |        // Treat in the same way as Tor and I2P because the address in all of
   56|       |        // them is "random" bytes (derived from a public key). However in CJDNS
   57|       |        // the first byte is a constant (see CJDNS_PREFIX), so the random bytes
   58|       |        // come after it. Thus skip the constant 8 bits at the start.
   59|   112k|        nBits = 12;
   60|  1.98M|    } else if (address.IsHeNet()) {
  ------------------
  |  Branch (60:16): [True: 596, False: 1.98M]
  ------------------
   61|       |        // for he.net, use /36 groups
   62|    596|        nBits = 36;
   63|  1.98M|    } else {
   64|       |        // for the rest of the IPv6 network, use /32 groups
   65|  1.98M|        nBits = 32;
   66|  1.98M|    }
   67|       |
   68|       |    // Push our address onto vchRet.
   69|  4.66M|    auto addr_bytes = address.GetAddrBytes();
   70|  4.66M|    const size_t num_bytes = nBits / 8;
   71|  4.66M|    vchRet.insert(vchRet.end(), addr_bytes.begin() + nStartByte, addr_bytes.begin() + nStartByte + num_bytes);
   72|  4.66M|    nBits %= 8;
   73|       |    // ...for the last byte, push nBits and for the rest of the byte push 1's
   74|  4.66M|    if (nBits > 0) {
  ------------------
  |  Branch (74:9): [True: 1.86M, False: 2.80M]
  ------------------
   75|  1.86M|        assert(num_bytes < addr_bytes.size());
  ------------------
  |  Branch (75:9): [True: 1.86M, False: 0]
  ------------------
   76|  1.86M|        vchRet.push_back(addr_bytes[num_bytes + nStartByte] | ((1 << (8 - nBits)) - 1));
   77|  1.86M|    }
   78|       |
   79|  4.66M|    return vchRet;
   80|  4.66M|}
_ZNK15NetGroupManager11GetMappedASERK8CNetAddr:
   83|  13.3M|{
   84|  13.3M|    uint32_t net_class = address.GetNetClass();
   85|  13.3M|    if (m_asmap.empty() || (net_class != NET_IPV4 && net_class != NET_IPV6)) {
  ------------------
  |  Branch (85:9): [True: 4.95M, False: 8.43M]
  |  Branch (85:29): [True: 8.19M, False: 243k]
  |  Branch (85:54): [True: 1.78M, False: 6.40M]
  ------------------
   86|  6.74M|        return 0; // Indicates not found, safe because AS0 is reserved per RFC7607.
   87|  6.74M|    }
   88|  6.65M|    std::vector<std::byte> ip_bytes(16);
   89|  6.65M|    if (address.HasLinkedIPv4()) {
  ------------------
  |  Branch (89:9): [True: 243k, False: 6.40M]
  ------------------
   90|       |        // For lookup, treat as if it was just an IPv4 address (IPV4_IN_IPV6_PREFIX + IPv4 bits)
   91|   243k|        std::copy_n(std::as_bytes(std::span{IPV4_IN_IPV6_PREFIX}).begin(),
   92|   243k|                    IPV4_IN_IPV6_PREFIX.size(), ip_bytes.begin());
   93|   243k|        uint32_t ipv4 = address.GetLinkedIPv4();
   94|  1.21M|        for (int i = 0; i < 4; ++i) {
  ------------------
  |  Branch (94:25): [True: 973k, False: 243k]
  ------------------
   95|   973k|            ip_bytes[12 + i] = std::byte((ipv4 >> (24 - i * 8)) & 0xFF);
   96|   973k|        }
   97|  6.40M|    } else {
   98|       |        // Use all 128 bits of the IPv6 address otherwise
   99|  6.40M|        assert(address.IsIPv6());
  ------------------
  |  Branch (99:9): [True: 6.40M, False: 0]
  ------------------
  100|  6.40M|        auto addr_bytes = address.GetAddrBytes();
  101|  6.40M|        assert(addr_bytes.size() == ip_bytes.size());
  ------------------
  |  Branch (101:9): [True: 6.40M, False: 0]
  ------------------
  102|  6.40M|        std::copy_n(std::as_bytes(std::span{addr_bytes}).begin(),
  103|  6.40M|                    addr_bytes.size(), ip_bytes.begin());
  104|  6.40M|    }
  105|  6.65M|    uint32_t mapped_as = Interpret(m_asmap, ip_bytes);
  106|  6.65M|    return mapped_as;
  107|  6.65M|}

_ZN15NetGroupManager15WithLoadedAsmapEONSt3__16vectorISt4byteNS0_9allocatorIS2_EEEE:
   28|  2.16k|    static NetGroupManager WithLoadedAsmap(std::vector<std::byte>&& asmap) {
   29|  2.16k|        return NetGroupManager(std::span{asmap}, std::move(asmap));
   30|  2.16k|    }
_ZN15NetGroupManagerC2ENSt3__14spanIKSt4byteLm18446744073709551615EEEONS0_6vectorIS2_NS0_9allocatorIS2_EEEE:
   97|  7.16k|        : m_asmap{embedded_asmap},
   98|  7.16k|          m_loaded_asmap{std::move(loaded_asmap)}
   99|  7.16k|    {
  100|       |        assert(m_loaded_asmap.empty() || m_asmap.data() == m_loaded_asmap.data());
  ------------------
  |  Branch (100:9): [True: 5.00k, False: 2.16k]
  |  Branch (100:9): [True: 2.16k, False: 0]
  |  Branch (100:9): [True: 7.16k, False: 0]
  ------------------
  101|  7.16k|    }
_ZN15NetGroupManager7NoAsmapEv:
   32|  5.00k|    static NetGroupManager NoAsmap() {
   33|  5.00k|        return NetGroupManager({}, {});
   34|  5.00k|    }

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

_ZNK9prevectorILj16EhjiEeqERKS0_:
  429|  6.43M|    constexpr bool operator==(const prevector& other) const {
  430|  6.43M|        return std::ranges::equal(*this, other);
  431|  6.43M|    }
_ZN9prevectorILj16EhjiEC2EjRKh:
  202|  14.4M|    explicit prevector(size_type n, const T& val) {
  203|  14.4M|        change_capacity(n);
  204|  14.4M|        _size += n;
  205|  14.4M|        fill(item_ptr(0), n, val);
  206|  14.4M|    }
_ZN9prevectorILj16EhjiE6assignITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEEvT_S7_:
  186|   121k|    void assign(InputIterator first, InputIterator last) {
  187|   121k|        size_type n = last - first;
  188|   121k|        clear();
  189|   121k|        if (capacity() < n) {
  ------------------
  |  Branch (189:13): [True: 0, False: 121k]
  ------------------
  190|      0|            change_capacity(n);
  191|      0|        }
  192|   121k|        _size += n;
  193|   121k|        fill(item_ptr(0), first, last);
  194|   121k|    }
_ZN9prevectorILj16EhjiE4fillITkNSt3__114input_iteratorENS2_11__wrap_iterIPKhEEEEvPhT_S8_:
  167|   121k|    void fill(T* dst, InputIterator first, InputIterator last) {
  168|  2.06M|        while (first != last) {
  ------------------
  |  Branch (168:16): [True: 1.93M, False: 121k]
  ------------------
  169|  1.93M|            new(static_cast<void*>(dst)) T(*first);
  170|  1.93M|            ++dst;
  171|  1.93M|            ++first;
  172|  1.93M|        }
  173|   121k|    }
_ZN9prevectorILj16EhjiE6assignITkNSt3__114input_iteratorEPhEEvT_S4_:
  186|  22.7k|    void assign(InputIterator first, InputIterator last) {
  187|  22.7k|        size_type n = last - first;
  188|  22.7k|        clear();
  189|  22.7k|        if (capacity() < n) {
  ------------------
  |  Branch (189:13): [True: 0, False: 22.7k]
  ------------------
  190|      0|            change_capacity(n);
  191|      0|        }
  192|  22.7k|        _size += n;
  193|  22.7k|        fill(item_ptr(0), first, last);
  194|  22.7k|    }
_ZN9prevectorILj16EhjiE4fillITkNSt3__114input_iteratorEPhEEvS3_T_S4_:
  167|  22.7k|    void fill(T* dst, InputIterator first, InputIterator last) {
  168|   250k|        while (first != last) {
  ------------------
  |  Branch (168:16): [True: 227k, False: 22.7k]
  ------------------
  169|   227k|            new(static_cast<void*>(dst)) T(*first);
  170|   227k|            ++dst;
  171|   227k|            ++first;
  172|   227k|        }
  173|  22.7k|    }
_ZNK9prevectorILj16EhjiEixEj:
  272|  69.9M|    const T& operator[](size_type pos) const {
  273|  69.9M|        return *item_ptr(pos);
  274|  69.9M|    }
_ZNK9prevectorILj16EhjiE14const_iteratorptEv:
   90|   325M|        const T* operator->() const { return ptr; }
_ZN9prevectorILj16EhjiE4dataEv:
  464|  6.04M|    value_type* data() {
  465|  6.04M|        return item_ptr(0);
  466|  6.04M|    }
_ZN9prevectorILj16EhjiE6assignEjRKh:
  176|   117k|    void assign(size_type n, const T& val) {
  177|   117k|        clear();
  178|   117k|        if (capacity() < n) {
  ------------------
  |  Branch (178:13): [True: 0, False: 117k]
  ------------------
  179|      0|            change_capacity(n);
  180|      0|        }
  181|   117k|        _size += n;
  182|   117k|        fill(item_ptr(0), n, val);
  183|   117k|    }
_ZNK9prevectorILj16EhjiE5emptyEv:
  251|  2.52M|    bool empty() const {
  252|  2.52M|        return size() == 0;
  253|  2.52M|    }
_ZNK9prevectorILj16EhjiE4dataEv:
  468|   126M|    const value_type* data() const {
  469|   126M|        return item_ptr(0);
  470|   126M|    }
_ZN9prevectorILj16EhjiEaSERKS0_:
  229|  3.47k|    prevector& operator=(const prevector<N, T, Size, Diff>& other) {
  230|  3.47k|        if (&other == this) {
  ------------------
  |  Branch (230:13): [True: 0, False: 3.47k]
  ------------------
  231|      0|            return *this;
  232|      0|        }
  233|  3.47k|        assign(other.begin(), other.end());
  234|  3.47k|        return *this;
  235|  3.47k|    }
_ZN9prevectorILj16EhjiE6assignITkNSt3__114input_iteratorENS0_14const_iteratorEEEvT_S4_:
  186|  3.47k|    void assign(InputIterator first, InputIterator last) {
  187|  3.47k|        size_type n = last - first;
  188|  3.47k|        clear();
  189|  3.47k|        if (capacity() < n) {
  ------------------
  |  Branch (189:13): [True: 480, False: 2.99k]
  ------------------
  190|    480|            change_capacity(n);
  191|    480|        }
  192|  3.47k|        _size += n;
  193|  3.47k|        fill(item_ptr(0), first, last);
  194|  3.47k|    }
_ZmiN9prevectorILj16EhjiE14const_iteratorES1_:
   96|  6.21M|        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
_ZN9prevectorILj16EhjiE5clearEv:
  303|   264k|    void clear() {
  304|   264k|        resize(0);
  305|   264k|    }
_ZN9prevectorILj16EhjiE6resizeEj:
  276|  6.30M|    void resize(size_type new_size) {
  277|  6.30M|        size_type cur_size = size();
  278|  6.30M|        if (cur_size == new_size) {
  ------------------
  |  Branch (278:13): [True: 4.91M, False: 1.39M]
  ------------------
  279|  4.91M|            return;
  280|  4.91M|        }
  281|  1.39M|        if (cur_size > new_size) {
  ------------------
  |  Branch (281:13): [True: 363k, False: 1.02M]
  ------------------
  282|   363k|            erase(item_ptr(new_size), end());
  283|   363k|            return;
  284|   363k|        }
  285|  1.02M|        if (new_size > capacity()) {
  ------------------
  |  Branch (285:13): [True: 1.02M, False: 0]
  ------------------
  286|  1.02M|            change_capacity(new_size);
  287|  1.02M|        }
  288|  1.02M|        ptrdiff_t increase = new_size - cur_size;
  289|  1.02M|        fill(item_ptr(cur_size), increase);
  290|  1.02M|        _size += increase;
  291|  1.02M|    }
_ZN9prevectorILj16EhjiE5eraseENS0_8iteratorES1_:
  368|   363k|    iterator erase(iterator first, iterator last) {
  369|       |        // Erase is not allowed to the change the object's capacity. That means
  370|       |        // that when starting with an indirectly allocated prevector with
  371|       |        // size and capacity > N, the result may be a still indirectly allocated
  372|       |        // prevector with size <= N and capacity > N. A shrink_to_fit() call is
  373|       |        // necessary to switch to the (more efficient) directly allocated
  374|       |        // representation (with capacity N and size <= N).
  375|   363k|        iterator p = first;
  376|   363k|        char* endp = (char*)&(*end());
  377|   363k|        _size -= last - p;
  378|   363k|        memmove(&(*first), &(*last), endp - ((char*)(&(*last))));
  379|   363k|        return first;
  380|   363k|    }
_ZNK9prevectorILj16EhjiE8iteratordeEv:
   61|  2.18M|        T& operator*() const { return *ptr; }
_ZmiN9prevectorILj16EhjiE8iteratorES1_:
   68|   363k|        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
_ZN9prevectorILj16EhjiE8iteratorC2EPh:
   60|  1.09M|        iterator(T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj16EhjiE3endEv:
  257|   727k|    iterator end() { return iterator(item_ptr(size())); }
_ZN9prevectorILj16EhjiE4fillEPhlRKh:
  162|  15.6M|    void fill(T* dst, ptrdiff_t count, const T& value = T{}) {
  163|  15.6M|        std::fill_n(dst, count, value);
  164|  15.6M|    }
_ZNK9prevectorILj16EhjiE8capacityEv:
  260|  1.29M|    size_t capacity() const {
  261|  1.29M|        if (is_direct()) {
  ------------------
  |  Branch (261:13): [True: 1.29M, False: 0]
  ------------------
  262|  1.29M|            return N;
  263|  1.29M|        } else {
  264|      0|            return _union.indirect_contents.capacity;
  265|      0|        }
  266|  1.29M|    }
_ZN9prevectorILj16EhjiEC2EOS0_:
  224|  12.6M|        : _union(std::move(other._union)), _size(other._size)
  225|  12.6M|    {
  226|  12.6M|        other._size = 0;
  227|  12.6M|    }
_ZN9prevectorILj16EhjiEC2ERKS0_:
  216|  33.0M|    prevector(const prevector<N, T, Size, Diff>& other) {
  217|  33.0M|        size_type n = other.size();
  218|  33.0M|        change_capacity(n);
  219|  33.0M|        _size += n;
  220|  33.0M|        fill(item_ptr(0), other.begin(),  other.end());
  221|  33.0M|    }
_ZNK9prevectorILj16EhjiE4sizeEv:
  247|   456M|    size_type size() const {
  248|   456M|        return is_direct() ? _size : _size - N - 1;
  ------------------
  |  Branch (248:16): [True: 432M, False: 24.5M]
  ------------------
  249|   456M|    }
_ZNK9prevectorILj16EhjiE9is_directEv:
  126|  1.21G|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj16EhjiE15change_capacityEj:
  128|  48.5M|    void change_capacity(size_type new_capacity) {
  129|  48.5M|        if (new_capacity <= N) {
  ------------------
  |  Branch (129:13): [True: 42.2M, False: 6.27M]
  ------------------
  130|  42.2M|            if (!is_direct()) {
  ------------------
  |  Branch (130:17): [True: 0, False: 42.2M]
  ------------------
  131|      0|                T* indirect = indirect_ptr(0);
  132|      0|                T* src = indirect;
  133|      0|                T* dst = direct_ptr(0);
  134|      0|                memcpy(dst, src, size() * sizeof(T));
  135|      0|                free(indirect);
  136|      0|                _size -= N + 1;
  137|      0|            }
  138|  42.2M|        } else {
  139|  6.27M|            if (!is_direct()) {
  ------------------
  |  Branch (139:17): [True: 0, False: 6.27M]
  ------------------
  140|       |                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
  141|       |                    success. These should instead use an allocator or new/delete so that handlers
  142|       |                    are called as necessary, but performance would be slightly degraded by doing so. */
  143|      0|                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
  144|      0|                assert(_union.indirect_contents.indirect);
  ------------------
  |  Branch (144:17): [True: 0, False: 0]
  ------------------
  145|      0|                _union.indirect_contents.capacity = new_capacity;
  146|  6.27M|            } else {
  147|  6.27M|                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
  148|  6.27M|                assert(new_indirect);
  ------------------
  |  Branch (148:17): [True: 6.27M, False: 0]
  ------------------
  149|  6.27M|                T* src = direct_ptr(0);
  150|  6.27M|                T* dst = reinterpret_cast<T*>(new_indirect);
  151|  6.27M|                memcpy(dst, src, size() * sizeof(T));
  152|  6.27M|                _union.indirect_contents.indirect = new_indirect;
  153|  6.27M|                _union.indirect_contents.capacity = new_capacity;
  154|  6.27M|                _size += N + 1;
  155|  6.27M|            }
  156|  6.27M|        }
  157|  48.5M|    }
_ZN9prevectorILj16EhjiE12indirect_ptrEi:
  124|  7.30M|    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
_ZN9prevectorILj16EhjiE10direct_ptrEi:
  122|  54.9M|    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
_ZN9prevectorILj16EhjiE4fillITkNSt3__114input_iteratorENS0_14const_iteratorEEEvPhT_S5_:
  167|  33.0M|    void fill(T* dst, InputIterator first, InputIterator last) {
  168|   628M|        while (first != last) {
  ------------------
  |  Branch (168:16): [True: 595M, False: 33.0M]
  ------------------
  169|   595M|            new(static_cast<void*>(dst)) T(*first);
  170|   595M|            ++dst;
  171|   595M|            ++first;
  172|   595M|        }
  173|  33.0M|    }
_ZNK9prevectorILj16EhjiE14const_iteratoreqES1_:
  102|   628M|        bool operator==(const_iterator x) const { return ptr == x.ptr; }
_ZNK9prevectorILj16EhjiE14const_iteratordeEv:
   89|   607M|        const T& operator*() const { return *ptr; }
_ZN9prevectorILj16EhjiE14const_iteratorppEv:
   92|   595M|        const_iterator& operator++() { ptr++; return *this; }
_ZN9prevectorILj16EhjiE8item_ptrEi:
  159|  55.9M|    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (159:47): [True: 48.6M, False: 7.30M]
  ------------------
_ZNK9prevectorILj16EhjiE5beginEv:
  256|   339M|    const_iterator begin() const { return const_iterator(item_ptr(0)); }
_ZNK9prevectorILj16EhjiE8item_ptrEi:
  160|   588M|    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (160:59): [True: 560M, False: 28.3M]
  ------------------
_ZNK9prevectorILj16EhjiE10direct_ptrEi:
  123|   560M|    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
_ZNK9prevectorILj16EhjiE12indirect_ptrEi:
  125|  28.3M|    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
_ZN9prevectorILj16EhjiE14const_iteratorC2EPKh:
   87|   391M|        const_iterator(const T* ptr_) : ptr(ptr_) {}
_ZNK9prevectorILj16EhjiE3endEv:
  258|  52.1M|    const_iterator end() const { return const_iterator(item_ptr(size())); }
_ZN9prevectorILj16EhjiED2Ev:
  422|  60.1M|    ~prevector() {
  423|  60.1M|        if (!is_direct()) {
  ------------------
  |  Branch (423:13): [True: 6.27M, False: 53.9M]
  ------------------
  424|  6.27M|            free(_union.indirect_contents.indirect);
  425|  6.27M|            _union.indirect_contents.indirect = nullptr;
  426|  6.27M|        }
  427|  60.1M|    }
_ZN9prevectorILj16EhjiEaSEOS0_:
  237|  8.05M|    prevector& operator=(prevector<N, T, Size, Diff>&& other) noexcept {
  238|  8.05M|        if (!is_direct()) {
  ------------------
  |  Branch (238:13): [True: 0, False: 8.05M]
  ------------------
  239|      0|            free(_union.indirect_contents.indirect);
  240|      0|        }
  241|  8.05M|        _union = std::move(other._union);
  242|  8.05M|        _size = other._size;
  243|  8.05M|        other._size = 0;
  244|  8.05M|        return *this;
  245|  8.05M|    }
_ZNK9prevectorILj36EhjiE9is_directEv:
  126|     20|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj36EhjiED2Ev:
  422|     20|    ~prevector() {
  423|     20|        if (!is_direct()) {
  ------------------
  |  Branch (423:13): [True: 4, False: 16]
  ------------------
  424|      4|            free(_union.indirect_contents.indirect);
  425|      4|            _union.indirect_contents.indirect = nullptr;
  426|      4|        }
  427|     20|    }

_ZN8CAddress16SerializationOpsI12ParamsStreamIR10DataStreamNS_9SerParamsEEKS_15ActionSerializeEEvRT0_RT_T1_:
  434|  1.33M|    {
  435|  1.33M|        bool use_v2;
  436|  1.33M|        auto& params = SER_PARAMS(SerParams);
  ------------------
  |  |  209|  1.33M|#define SER_PARAMS(type) (s.template GetParams<type>())
  ------------------
  437|  1.33M|        if (params.fmt == Format::Disk) {
  ------------------
  |  Branch (437:13): [True: 1.33M, False: 0]
  ------------------
  438|       |            // In the disk serialization format, the encoding (v1 or v2) is determined by a flag version
  439|       |            // that's part of the serialization itself. ADDRV2_FORMAT in the stream version only determines
  440|       |            // whether V2 is chosen/permitted at all.
  441|  1.33M|            uint32_t stored_format_version = DISK_VERSION_INIT;
  442|  1.33M|            if (params.enc == Encoding::V2) stored_format_version |= DISK_VERSION_ADDRV2;
  ------------------
  |  Branch (442:17): [True: 1.33M, False: 0]
  ------------------
  443|  1.33M|            READWRITE(stored_format_version);
  ------------------
  |  |  148|  1.33M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  444|  1.33M|            stored_format_version &= ~DISK_VERSION_IGNORE_MASK; // ignore low bits
  445|  1.33M|            if (stored_format_version == 0) {
  ------------------
  |  Branch (445:17): [True: 0, False: 1.33M]
  ------------------
  446|      0|                use_v2 = false;
  447|  1.33M|            } else if (stored_format_version == DISK_VERSION_ADDRV2 && params.enc == Encoding::V2) {
  ------------------
  |  Branch (447:24): [True: 1.33M, False: 0]
  |  Branch (447:72): [True: 1.33M, False: 0]
  ------------------
  448|       |                // Only support v2 deserialization if V2 is set.
  449|  1.33M|                use_v2 = true;
  450|  1.33M|            } else {
  451|      0|                throw std::ios_base::failure("Unsupported CAddress disk format version");
  452|      0|            }
  453|  1.33M|        } else {
  454|      0|            assert(params.fmt == Format::Network);
  ------------------
  |  Branch (454:13): [True: 0, False: 0]
  ------------------
  455|       |            // In the network serialization format, the encoding (v1 or v2) is determined directly by
  456|       |            // the value of enc in the stream params, as no explicitly encoded version
  457|       |            // exists in the stream.
  458|      0|            use_v2 = params.enc == Encoding::V2;
  459|      0|        }
  460|       |
  461|  1.33M|        READWRITE(Using<LossyChronoFormatter<uint32_t>>(obj.nTime));
  ------------------
  |  |  148|  1.33M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  462|       |        // nServices is serialized as CompactSize in V2; as uint64_t in V1.
  463|  1.33M|        if (use_v2) {
  ------------------
  |  Branch (463:13): [True: 1.33M, False: 0]
  ------------------
  464|  1.33M|            uint64_t services_tmp;
  465|  1.33M|            SER_WRITE(obj, services_tmp = obj.nServices);
  ------------------
  |  |  150|  1.33M|#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
  ------------------
  466|  1.33M|            READWRITE(Using<CompactSizeFormatter<false>>(services_tmp));
  ------------------
  |  |  148|  1.33M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  467|  1.33M|            SER_READ(obj, obj.nServices = static_cast<ServiceFlags>(services_tmp));
  ------------------
  |  |  149|  1.33M|#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
  ------------------
  468|  1.33M|        } else {
  469|      0|            READWRITE(Using<CustomUintFormatter<8>>(obj.nServices));
  ------------------
  |  |  148|      0|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  470|      0|        }
  471|       |        // Invoke V1/V2 serializer for CService parent object.
  472|  1.33M|        const auto ser_params{use_v2 ? CNetAddr::V2 : CNetAddr::V1};
  ------------------
  |  Branch (472:31): [True: 1.33M, False: 0]
  ------------------
  473|  1.33M|        READWRITE(ser_params(AsBase<CService>(obj)));
  ------------------
  |  |  148|  1.33M|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  474|  1.33M|    }
_ZN8CAddress16SerializationOpsI12ParamsStreamIR10DataStreamNS_9SerParamsEES_17ActionUnserializeEEvRT0_RT_T1_:
  434|   120k|    {
  435|   120k|        bool use_v2;
  436|   120k|        auto& params = SER_PARAMS(SerParams);
  ------------------
  |  |  209|   120k|#define SER_PARAMS(type) (s.template GetParams<type>())
  ------------------
  437|   120k|        if (params.fmt == Format::Disk) {
  ------------------
  |  Branch (437:13): [True: 120k, False: 0]
  ------------------
  438|       |            // In the disk serialization format, the encoding (v1 or v2) is determined by a flag version
  439|       |            // that's part of the serialization itself. ADDRV2_FORMAT in the stream version only determines
  440|       |            // whether V2 is chosen/permitted at all.
  441|   120k|            uint32_t stored_format_version = DISK_VERSION_INIT;
  442|   120k|            if (params.enc == Encoding::V2) stored_format_version |= DISK_VERSION_ADDRV2;
  ------------------
  |  Branch (442:17): [True: 110k, False: 10.6k]
  ------------------
  443|   120k|            READWRITE(stored_format_version);
  ------------------
  |  |  148|   120k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  444|   120k|            stored_format_version &= ~DISK_VERSION_IGNORE_MASK; // ignore low bits
  445|   120k|            if (stored_format_version == 0) {
  ------------------
  |  Branch (445:17): [True: 110k, False: 9.92k]
  ------------------
  446|   110k|                use_v2 = false;
  447|   110k|            } else if (stored_format_version == DISK_VERSION_ADDRV2 && params.enc == Encoding::V2) {
  ------------------
  |  Branch (447:24): [True: 9.69k, False: 228]
  |  Branch (447:72): [True: 9.69k, False: 1]
  ------------------
  448|       |                // Only support v2 deserialization if V2 is set.
  449|  9.69k|                use_v2 = true;
  450|  9.69k|            } else {
  451|    229|                throw std::ios_base::failure("Unsupported CAddress disk format version");
  452|    229|            }
  453|   120k|        } else {
  454|      0|            assert(params.fmt == Format::Network);
  ------------------
  |  Branch (454:13): [True: 0, False: 0]
  ------------------
  455|       |            // In the network serialization format, the encoding (v1 or v2) is determined directly by
  456|       |            // the value of enc in the stream params, as no explicitly encoded version
  457|       |            // exists in the stream.
  458|      0|            use_v2 = params.enc == Encoding::V2;
  459|      0|        }
  460|       |
  461|   120k|        READWRITE(Using<LossyChronoFormatter<uint32_t>>(obj.nTime));
  ------------------
  |  |  148|   120k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  462|       |        // nServices is serialized as CompactSize in V2; as uint64_t in V1.
  463|   120k|        if (use_v2) {
  ------------------
  |  Branch (463:13): [True: 9.68k, False: 110k]
  ------------------
  464|  9.68k|            uint64_t services_tmp;
  465|  9.68k|            SER_WRITE(obj, services_tmp = obj.nServices);
  ------------------
  |  |  150|  9.68k|#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
  ------------------
  466|  9.68k|            READWRITE(Using<CompactSizeFormatter<false>>(services_tmp));
  ------------------
  |  |  148|  9.68k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  467|  9.68k|            SER_READ(obj, obj.nServices = static_cast<ServiceFlags>(services_tmp));
  ------------------
  |  |  149|  9.68k|#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
  ------------------
  468|   110k|        } else {
  469|   110k|            READWRITE(Using<CustomUintFormatter<8>>(obj.nServices));
  ------------------
  |  |  148|   110k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  470|   110k|        }
  471|       |        // Invoke V1/V2 serializer for CService parent object.
  472|   120k|        const auto ser_params{use_v2 ? CNetAddr::V2 : CNetAddr::V1};
  ------------------
  |  Branch (472:31): [True: 9.66k, False: 110k]
  ------------------
  473|   120k|        READWRITE(ser_params(AsBase<CService>(obj)));
  ------------------
  |  |  148|   120k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  474|   120k|    }
_ZN8CAddressC2E8CService12ServiceFlagsNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEE:
  418|  5.12M|    CAddress(CService ipIn, ServiceFlags nServicesIn, NodeSeconds time) : CService{ipIn}, nTime{time}, nServices{nServicesIn} {};
_ZN8CAddressC2Ev:
  416|  4.26M|    CAddress() : CService{} {};

_Z30MakeRandDeterministicDANGEROUSRK7uint256:
  596|  7.16k|{
  597|  7.16k|    GetRNGState().MakeDeterministic(seed);
  598|  7.16k|}
_Z12GetRandBytesNSt3__14spanIhLm18446744073709551615EEE:
  602|  19.3k|{
  603|  19.3k|    g_used_g_prng = true;
  604|  19.3k|    ProcRand(bytes.data(), bytes.size(), RNGLevel::FAST, /*always_use_real_rng=*/false);
  605|  19.3k|}
_ZN17FastRandomContext10RandomSeedEv:
  620|  19.3k|{
  621|  19.3k|    uint256 seed = GetRandHash();
  622|  19.3k|    rng.SetKey(MakeByteSpan(seed));
  623|  19.3k|    requires_seed = false;
  624|  19.3k|}
_ZN17FastRandomContext6ReseedERK7uint256:
  635|  9.68k|{
  636|  9.68k|    FlushCache();
  637|  9.68k|    requires_seed = false;
  638|  9.68k|    rng = {MakeByteSpan(seed)};
  639|  9.68k|}
_ZN17FastRandomContextC2Eb:
  689|  29.0k|FastRandomContext::FastRandomContext(bool fDeterministic) noexcept : requires_seed(!fDeterministic), rng(ZERO_KEY)
  690|  29.0k|{
  691|       |    // Note that despite always initializing with ZERO_KEY, requires_seed is set to true if not
  692|       |    // fDeterministic. That means the rng will be reinitialized with a secure random key upon first
  693|       |    // use.
  694|  29.0k|}
random.cpp:_ZN12_GLOBAL__N_111GetRNGStateEv:
  451|  26.5k|{
  452|       |    // This idiom relies on the guarantee that static variable are initialized
  453|       |    // on first call, even when multiple parallel calls are permitted.
  454|  26.5k|    static std::vector<RNGState, secure_allocator<RNGState>> g_rng(1);
  455|  26.5k|    return g_rng[0];
  456|  26.5k|}
random.cpp:_ZN12_GLOBAL__N_18RNGStateD2Ev:
  367|      2|    ~RNGState() = default;
random.cpp:_ZN12_GLOBAL__N_18RNGState17MakeDeterministicERK7uint256:
  400|  7.16k|    {
  401|  7.16k|        LOCK(m_mutex);
  ------------------
  |  |  268|  7.16k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.16k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.16k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.16k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  402|  7.16k|        m_deterministic_prng.emplace(MakeByteSpan(seed));
  403|  7.16k|    }
random.cpp:_ZN12_GLOBAL__N_18ProcRandEPhiNS_8RNGLevelEb:
  563|  19.3k|{
  564|       |    // Make sure the RNG is initialized first (as all Seed* function possibly need hwrand to be available).
  565|  19.3k|    RNGState& rng = GetRNGState();
  566|       |
  567|  19.3k|    assert(num <= 32);
  ------------------
  |  Branch (567:5): [True: 19.3k, False: 0]
  ------------------
  568|       |
  569|  19.3k|    CSHA512 hasher;
  570|  19.3k|    switch (level) {
  ------------------
  |  Branch (570:13): [True: 19.3k, False: 0]
  ------------------
  571|  19.3k|    case RNGLevel::FAST:
  ------------------
  |  Branch (571:5): [True: 19.3k, False: 0]
  ------------------
  572|  19.3k|        SeedFast(hasher);
  573|  19.3k|        break;
  574|      0|    case RNGLevel::SLOW:
  ------------------
  |  Branch (574:5): [True: 0, False: 19.3k]
  ------------------
  575|      0|        SeedSlow(hasher, rng);
  576|      0|        break;
  577|      0|    case RNGLevel::PERIODIC:
  ------------------
  |  Branch (577:5): [True: 0, False: 19.3k]
  ------------------
  578|      0|        SeedPeriodic(hasher, rng);
  579|      0|        break;
  580|  19.3k|    }
  581|       |
  582|       |    // Combine with and update state
  583|  19.3k|    if (!rng.MixExtract(out, num, std::move(hasher), false, always_use_real_rng)) {
  ------------------
  |  Branch (583:9): [True: 0, False: 19.3k]
  ------------------
  584|       |        // On the first invocation, also seed with SeedStartup().
  585|      0|        CSHA512 startup_hasher;
  586|      0|        SeedStartup(startup_hasher, rng);
  587|      0|        rng.MixExtract(out, num, std::move(startup_hasher), true, always_use_real_rng);
  588|      0|    }
  589|  19.3k|}
random.cpp:_ZN12_GLOBAL__N_18SeedFastER7CSHA512:
  470|  19.3k|{
  471|  19.3k|    unsigned char buffer[32];
  472|       |
  473|       |    // Stack pointer to indirectly commit to thread/callstack
  474|  19.3k|    const unsigned char* ptr = buffer;
  475|  19.3k|    hasher.Write((const unsigned char*)&ptr, sizeof(ptr));
  476|       |
  477|       |    // Hardware randomness is very fast when available; use it always.
  478|  19.3k|    SeedHardwareFast(hasher);
  479|       |
  480|       |    // High-precision timestamp
  481|  19.3k|    SeedTimestamp(hasher);
  482|  19.3k|}
random.cpp:_ZN12_GLOBAL__N_116SeedHardwareFastER7CSHA512:
  199|  19.3k|void SeedHardwareFast(CSHA512& hasher) noexcept {
  200|  19.3k|#if defined(__x86_64__) || defined(__amd64__) || defined(__i386__)
  201|  19.3k|    if (g_rdrand_supported) {
  ------------------
  |  Branch (201:9): [True: 19.3k, False: 0]
  ------------------
  202|  19.3k|        uint64_t out = GetRdRand();
  203|  19.3k|        hasher.Write((const unsigned char*)&out, sizeof(out));
  204|  19.3k|        return;
  205|  19.3k|    }
  206|  19.3k|#endif
  207|  19.3k|}
random.cpp:_ZN12_GLOBAL__N_19GetRdRandEv:
  122|  19.3k|{
  123|       |    // RdRand may very rarely fail. Invoke it up to 10 times in a loop to reduce this risk.
  124|       |#ifdef __i386__
  125|       |    uint8_t ok = 0;
  126|       |    // Initialize to 0 to silence a compiler warning that r1 or r2 may be used
  127|       |    // uninitialized. Even if rdrand fails (!ok) it will set the output to 0,
  128|       |    // but there is no way that the compiler could know that.
  129|       |    uint32_t r1 = 0, r2 = 0;
  130|       |    for (int i = 0; i < 10; ++i) {
  131|       |        __asm__ volatile (".byte 0x0f, 0xc7, 0xf0; setc %1" : "=a"(r1), "=q"(ok) :: "cc"); // rdrand %eax
  132|       |        if (ok) break;
  133|       |    }
  134|       |    for (int i = 0; i < 10; ++i) {
  135|       |        __asm__ volatile (".byte 0x0f, 0xc7, 0xf0; setc %1" : "=a"(r2), "=q"(ok) :: "cc"); // rdrand %eax
  136|       |        if (ok) break;
  137|       |    }
  138|       |    return (((uint64_t)r2) << 32) | r1;
  139|       |#elif defined(__x86_64__) || defined(__amd64__)
  140|       |    uint8_t ok = 0;
  141|  19.3k|    uint64_t r1 = 0; // See above why we initialize to 0.
  142|  19.3k|    for (int i = 0; i < 10; ++i) {
  ------------------
  |  Branch (142:21): [True: 19.3k, False: 0]
  ------------------
  143|  19.3k|        __asm__ volatile (".byte 0x48, 0x0f, 0xc7, 0xf0; setc %1" : "=a"(r1), "=q"(ok) :: "cc"); // rdrand %rax
  144|  19.3k|        if (ok) break;
  ------------------
  |  Branch (144:13): [True: 19.3k, False: 0]
  ------------------
  145|  19.3k|    }
  146|  19.3k|    return r1;
  147|       |#else
  148|       |#error "RdRand is only supported on x86 and x86_64"
  149|       |#endif
  150|  19.3k|}
random.cpp:_ZN12_GLOBAL__N_113SeedTimestampER7CSHA512:
  464|  19.3k|{
  465|  19.3k|    int64_t perfcounter = GetPerformanceCounter();
  466|  19.3k|    hasher.Write((const unsigned char*)&perfcounter, sizeof(perfcounter));
  467|  19.3k|}
random.cpp:_ZN12_GLOBAL__N_121GetPerformanceCounterEv:
   61|  19.3k|{
   62|       |    // Read the hardware time stamp counter when available.
   63|       |    // See https://en.wikipedia.org/wiki/Time_Stamp_Counter for more information.
   64|       |#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
   65|       |    return __rdtsc();
   66|       |#elif !defined(_MSC_VER) && defined(__i386__)
   67|       |    uint64_t r = 0;
   68|       |    __asm__ volatile ("rdtsc" : "=A"(r)); // Constrain the r variable to the eax:edx pair.
   69|       |    return r;
   70|       |#elif !defined(_MSC_VER) && (defined(__x86_64__) || defined(__amd64__))
   71|       |    uint64_t r1 = 0, r2 = 0;
   72|  19.3k|    __asm__ volatile ("rdtsc" : "=a"(r1), "=d"(r2)); // Constrain r1 to rax and r2 to rdx.
   73|  19.3k|    return (r2 << 32) | r1;
   74|       |#else
   75|       |    // Fall back to using standard library clock (usually microsecond or nanosecond precision)
   76|       |    return std::chrono::high_resolution_clock::now().time_since_epoch().count();
   77|       |#endif
   78|  19.3k|}
random.cpp:_ZN12_GLOBAL__N_18RNGState10MixExtractEPhmO7CSHA512bb:
  413|  19.3k|    {
  414|  19.3k|        assert(num <= 32);
  ------------------
  |  Branch (414:9): [True: 19.3k, False: 0]
  ------------------
  415|  19.3k|        unsigned char buf[64];
  416|  19.3k|        static_assert(sizeof(buf) == CSHA512::OUTPUT_SIZE, "Buffer needs to have hasher's output size");
  417|  19.3k|        bool ret;
  418|  19.3k|        {
  419|  19.3k|            LOCK(m_mutex);
  ------------------
  |  |  268|  19.3k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  19.3k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  19.3k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  19.3k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  420|  19.3k|            ret = (m_strongly_seeded |= strong_seed);
  421|       |            // Write the current state of the RNG into the hasher
  422|  19.3k|            hasher.Write(m_state, 32);
  423|       |            // Write a new counter number into the state
  424|  19.3k|            hasher.Write((const unsigned char*)&m_counter, sizeof(m_counter));
  425|  19.3k|            ++m_counter;
  426|       |            // Finalize the hasher
  427|  19.3k|            hasher.Finalize(buf);
  428|       |            // Store the last 32 bytes of the hash output as new RNG state.
  429|  19.3k|            memcpy(m_state, buf + 32, 32);
  430|       |            // Handle requests for deterministic randomness.
  431|  19.3k|            if (!always_use_real_rng && m_deterministic_prng.has_value()) [[unlikely]] {
  ------------------
  |  Branch (431:17): [True: 19.3k, False: 0]
  |  Branch (431:41): [True: 19.3k, False: 0]
  ------------------
  432|       |                // Overwrite the beginning of buf, which will be used for output.
  433|  19.3k|                m_deterministic_prng->Keystream(std::as_writable_bytes(std::span{buf, num}));
  434|       |                // Do not require strong seeding for deterministic output.
  435|  19.3k|                ret = true;
  436|  19.3k|            }
  437|  19.3k|        }
  438|       |        // If desired, copy (up to) the first 32 bytes of the hash output as output.
  439|  19.3k|        if (num) {
  ------------------
  |  Branch (439:13): [True: 19.3k, False: 0]
  ------------------
  440|  19.3k|            assert(out != nullptr);
  ------------------
  |  Branch (440:13): [True: 19.3k, False: 0]
  ------------------
  441|  19.3k|            memcpy(out, buf, num);
  442|  19.3k|        }
  443|       |        // Best effort cleanup of internal state
  444|  19.3k|        hasher.Reset();
  445|  19.3k|        memory_cleanse(buf, 64);
  446|  19.3k|        return ret;
  447|  19.3k|    }

_ZN11RandomMixinI17FastRandomContextEC2Ev:
  195|  29.0k|    constexpr RandomMixin() noexcept = default;
_ZN11RandomMixinI17FastRandomContextE10FlushCacheEv:
  189|  9.68k|    {
  190|  9.68k|        bitbuf = 0;
  191|  9.68k|        bitbuf_size = 0;
  192|  9.68k|    }
_ZN11RandomMixinI17FastRandomContextE8randboolEv:
  325|    957|    bool randbool() noexcept { return Impl().template randbits<1>(); }
_ZN11RandomMixinI17FastRandomContextE8randbitsILi1EEEmv:
  231|    957|    {
  232|    957|        static_assert(Bits >= 0 && Bits <= 64);
  233|       |        if constexpr (Bits == 64) {
  234|       |            return Impl().rand64();
  235|    957|        } else {
  236|    957|            uint64_t ret;
  237|    957|            if (Bits <= bitbuf_size) {
  ------------------
  |  Branch (237:17): [True: 937, False: 20]
  ------------------
  238|    937|                ret = bitbuf;
  239|    937|                bitbuf >>= Bits;
  240|    937|                bitbuf_size -= Bits;
  241|    937|            } else {
  242|     20|                uint64_t gen = Impl().rand64();
  243|     20|                ret = (gen << bitbuf_size) | bitbuf;
  244|     20|                bitbuf = gen >> (Bits - bitbuf_size);
  245|     20|                bitbuf_size = 64 + bitbuf_size - Bits;
  246|     20|            }
  247|    957|            constexpr uint64_t MASK = (uint64_t{1} << Bits) - 1;
  248|    957|            return ret & MASK;
  249|    957|        }
  250|    957|    }
_ZN11RandomMixinI17FastRandomContextE8randbitsILi30EEEmv:
  231|  11.6k|    {
  232|  11.6k|        static_assert(Bits >= 0 && Bits <= 64);
  233|       |        if constexpr (Bits == 64) {
  234|       |            return Impl().rand64();
  235|  11.6k|        } else {
  236|  11.6k|            uint64_t ret;
  237|  11.6k|            if (Bits <= bitbuf_size) {
  ------------------
  |  Branch (237:17): [True: 6.11k, False: 5.54k]
  ------------------
  238|  6.11k|                ret = bitbuf;
  239|  6.11k|                bitbuf >>= Bits;
  240|  6.11k|                bitbuf_size -= Bits;
  241|  6.11k|            } else {
  242|  5.54k|                uint64_t gen = Impl().rand64();
  243|  5.54k|                ret = (gen << bitbuf_size) | bitbuf;
  244|  5.54k|                bitbuf = gen >> (Bits - bitbuf_size);
  245|  5.54k|                bitbuf_size = 64 + bitbuf_size - Bits;
  246|  5.54k|            }
  247|  11.6k|            constexpr uint64_t MASK = (uint64_t{1} << Bits) - 1;
  248|  11.6k|            return ret & MASK;
  249|  11.6k|        }
  250|  11.6k|    }
_ZN11RandomMixinI17FastRandomContextE9randrangeITkNSt3__18integralEmEET_S4_:
  255|  1.61M|    {
  256|  1.61M|        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max());
  257|  1.61M|        Assume(range > 0);
  ------------------
  |  |  128|  1.61M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  258|  1.61M|        uint64_t maxval = range - 1U;
  259|  1.61M|        int bits = std::bit_width(maxval);
  260|  2.20M|        while (true) {
  ------------------
  |  Branch (260:16): [True: 2.20M, Folded]
  ------------------
  261|  2.20M|            uint64_t ret = Impl().randbits(bits);
  262|  2.20M|            if (ret <= maxval) return ret;
  ------------------
  |  Branch (262:17): [True: 1.61M, False: 593k]
  ------------------
  263|  2.20M|        }
  264|  1.61M|    }
_Z11GetRandHashv:
  464|  19.3k|{
  465|  19.3k|    uint256 hash;
  466|  19.3k|    GetRandBytes(hash);
  467|  19.3k|    return hash;
  468|  19.3k|}
_ZN11RandomMixinI17FastRandomContextE4ImplEv:
  185|  15.7M|    RandomNumberGenerator auto& Impl() noexcept { return static_cast<T&>(*this); }
_ZN11RandomMixinI17FastRandomContextE8randbitsEi:
  205|  14.0M|    {
  206|  14.0M|        Assume(bits <= 64);
  ------------------
  |  |  128|  14.0M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  207|       |        // Requests for the full 64 bits are passed through.
  208|  14.0M|        if (bits == 64) return Impl().rand64();
  ------------------
  |  Branch (208:13): [True: 0, False: 14.0M]
  ------------------
  209|  14.0M|        uint64_t ret;
  210|  14.0M|        if (bits <= bitbuf_size) {
  ------------------
  |  Branch (210:13): [True: 12.3M, False: 1.72M]
  ------------------
  211|       |            // If there is enough entropy left in bitbuf, return its bottom bits bits.
  212|  12.3M|            ret = bitbuf;
  213|  12.3M|            bitbuf >>= bits;
  214|  12.3M|            bitbuf_size -= bits;
  215|  12.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.72M|            uint64_t gen = Impl().rand64();
  220|  1.72M|            ret = (gen << bitbuf_size) | bitbuf;
  221|  1.72M|            bitbuf = gen >> (bits - bitbuf_size);
  222|  1.72M|            bitbuf_size = 64 + bitbuf_size - bits;
  223|  1.72M|        }
  224|       |        // Return the bottom bits bits of ret.
  225|  14.0M|        return ret & ((uint64_t{1} << bits) - 1);
  226|  14.0M|    }
_ZN17FastRandomContext6rand64Ev:
  405|  1.74M|    {
  406|  1.74M|        if (requires_seed) RandomSeed();
  ------------------
  |  Branch (406:13): [True: 19.3k, False: 1.72M]
  ------------------
  407|  1.74M|        std::array<std::byte, 8> buf;
  408|  1.74M|        rng.Keystream(buf);
  409|  1.74M|        return ReadLE64(buf.data());
  410|  1.74M|    }
_ZN11RandomMixinI17FastRandomContextE9randrangeITkNSt3__18integralEiEET_S4_:
  255|  11.8M|    {
  256|  11.8M|        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max());
  257|  11.8M|        Assume(range > 0);
  ------------------
  |  |  128|  11.8M|#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
  ------------------
  258|  11.8M|        uint64_t maxval = range - 1U;
  259|  11.8M|        int bits = std::bit_width(maxval);
  260|  11.8M|        while (true) {
  ------------------
  |  Branch (260:16): [True: 11.8M, Folded]
  ------------------
  261|  11.8M|            uint64_t ret = Impl().randbits(bits);
  262|  11.8M|            if (ret <= maxval) return ret;
  ------------------
  |  Branch (262:17): [True: 11.8M, False: 0]
  ------------------
  263|  11.8M|        }
  264|  11.8M|    }

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

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

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

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_explicit(a, sizeof(secp256k1_fe));
   23|      2|}

secp256k1.c:secp256k1_ge_clear:
  343|      2|static void secp256k1_ge_clear(secp256k1_ge *r) {
  344|      2|    secp256k1_memclear_explicit(r, sizeof(secp256k1_ge));
  345|      2|}

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

secp256k1_context_preallocated_destroy:
  178|      2|void secp256k1_context_preallocated_destroy(secp256k1_context* ctx) {
  179|      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)) { \
  |  |  ------------------
  |  |  |  |  146|      4|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (146:21): [True: 0, False: 2]
  |  |  |  |  |  Branch (146:39): [True: 0, False: 2]
  |  |  |  |  |  Branch (146: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, False: 2]
  |  |  ------------------
  ------------------
  180|       |
  181|       |    /* Defined as noop */
  182|      2|    if (ctx == NULL) {
  ------------------
  |  Branch (182:9): [True: 0, False: 2]
  ------------------
  183|      0|        return;
  184|      0|    }
  185|       |
  186|      2|    secp256k1_ecmult_gen_context_clear(&ctx->ecmult_gen_ctx);
  187|      2|}
secp256k1_context_destroy:
  189|      2|void secp256k1_context_destroy(secp256k1_context* ctx) {
  190|      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)) { \
  |  |  ------------------
  |  |  |  |  146|      4|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (146:21): [True: 0, False: 2]
  |  |  |  |  |  Branch (146:39): [True: 0, False: 2]
  |  |  |  |  |  Branch (146: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, False: 2]
  |  |  ------------------
  ------------------
  191|       |
  192|       |    /* Defined as noop */
  193|      2|    if (ctx == NULL) {
  ------------------
  |  Branch (193:9): [True: 0, False: 2]
  ------------------
  194|      0|        return;
  195|      0|    }
  196|       |
  197|      2|    secp256k1_context_preallocated_destroy(ctx);
  198|      2|    free(ctx);
  199|      2|}
secp256k1.c:secp256k1_context_is_proper:
   83|      4|static int secp256k1_context_is_proper(const secp256k1_context* ctx) {
   84|      4|    return secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx);
   85|      4|}

secp256k1.c:secp256k1_memclear_explicit:
  268|      6|static SECP256K1_INLINE void secp256k1_memclear_explicit(void *ptr, size_t len) {
  269|       |    /* The current implementation zeroes, but callers must not rely on this */
  270|      6|    secp256k1_memzero_explicit(ptr, len);
  271|       |#ifdef VERIFY
  272|       |    SECP256K1_CHECKMEM_UNDEFINE(ptr, len);
  273|       |#endif
  274|      6|}
secp256k1.c:secp256k1_memzero_explicit:
  236|      6|static SECP256K1_INLINE void secp256k1_memzero_explicit(void *ptr, size_t len) {
  237|       |#if defined(_MSC_VER)
  238|       |    /* SecureZeroMemory is guaranteed not to be optimized out by MSVC. */
  239|       |    SecureZeroMemory(ptr, len);
  240|       |#elif defined(__GNUC__)
  241|       |    /* We use a memory barrier that scares the compiler away from optimizing out the memset.
  242|       |     *
  243|       |     * Quoting Adam Langley <agl@google.com> in commit ad1907fe73334d6c696c8539646c21b11178f20f
  244|       |     * in BoringSSL (ISC License):
  245|       |     *    As best as we can tell, this is sufficient to break any optimisations that
  246|       |     *    might try to eliminate "superfluous" memsets.
  247|       |     * This method is used in memzero_explicit() the Linux kernel, too. Its advantage is that it
  248|       |     * is pretty efficient, because the compiler can still implement the memset() efficiently,
  249|       |     * just not remove it entirely. See "Dead Store Elimination (Still) Considered Harmful" by
  250|       |     * Yang et al. (USENIX Security 2017) for more background.
  251|       |     */
  252|      6|    memset(ptr, 0, len);
  253|      6|    __asm__ __volatile__("" : : "r"(ptr) : "memory");
  254|       |#else
  255|       |    void *(*volatile const volatile_memset)(void *, int, size_t) = memset;
  256|       |    volatile_memset(ptr, 0, len);
  257|       |#endif
  258|      6|}

_Z9SerializeI10DataStream7AddrManQ12SerializableIT0_T_EEvRS3_RKS2_:
  767|  7.16k|{
  768|  7.16k|    a.Serialize(os);
  769|  7.16k|}
_Z11UnserializeI10DataStreamR20AddrManDeterministicQ14UnserializableIT0_T_EEvRS4_OS3_:
  776|  3.04k|{
  777|  3.04k|    a.Unserialize(is);
  778|  3.04k|}
deserialize.cpp:_ZL5UsingI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE7WrapperIT_RT0_EOSE_:
  491|   120k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
deserialize.cpp:_ZL5UsingI20CompactSizeFormatterILb0EERmE7WrapperIT_RT0_EOS5_:
  491|  1.34M|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
deserialize.cpp:_ZL5UsingI19CustomUintFormatterILi8ELb0EER12ServiceFlagsE7WrapperIT_RT0_EOS6_:
  491|   110k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
deserialize.cpp:_ZL5UsingI20CompactSizeFormatterILb1EERmE7WrapperIT_RT0_EOS5_:
  491|  9.65k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
deserialize.cpp:_ZL5UsingI19CustomUintFormatterILi2ELb1EERtE7WrapperIT_RT0_EOS5_:
  491|   120k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
deserialize.cpp:_ZL5UsingI19CustomUintFormatterILi2ELb1EERKtE7WrapperIT_RT0_EOS6_:
  491|  1.33M|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
deserialize.cpp:_ZL5UsingI15ChronoFormatterIjLb1EERKNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE7WrapperIT_RT0_EOSF_:
  491|  1.33M|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZNK8CAddress9SerParamsclIR8CNetAddrEEDaOT_:
 1282|  6.03M|    {                                                                                    \
 1283|  6.03M|        return ParamsWrapper{*this, t};                                                  \
 1284|  6.03M|    }
_ZN13ParamsWrapperIN8CAddress9SerParamsE8CNetAddrEC2ERKS1_RS2_:
 1249|  6.03M|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_Z11UnserializeI10DataStreamR13ParamsWrapperIN8CAddress9SerParamsE8CNetAddrEQ14UnserializableIT0_T_EEvRS8_OS7_:
  776|  6.03M|{
  777|  6.03M|    a.Unserialize(is);
  778|  6.03M|}
_ZN13ParamsWrapperIN8CAddress9SerParamsE8CNetAddrE11UnserializeI10DataStreamEEvRT_:
 1259|  6.03M|    {
 1260|  6.03M|        ParamsStream ss{s, m_params};
 1261|  6.03M|        ::Unserialize(ss, m_object);
 1262|  6.03M|    }
_Z9SerializeI10HashWriterTk9BasicByteKSt4byteEvRT_NSt3__14spanIT0_Lm18446744073709551615EEE:
  261|  2.20k|template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
addrman.cpp:_ZL5UsingI20CompactSizeFormatterILb1EERKmE7WrapperIT_RT0_EOS6_:
  491|   148k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z6AsBaseI8CAddress8AddrInfoERKT_RKT0_:
  143|  1.33M|{
  144|  1.33M|    static_assert(std::is_base_of_v<Out, In>);
  145|  1.33M|    return x;
  146|  1.33M|}
addrman.cpp:_ZL5UsingI15ChronoFormatterIlLb0EERKNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE7WrapperIT_RT0_EOSF_:
  491|  1.33M|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15ChronoFormatterIlLb0EERKNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEEC2ESC_:
  475|  1.33M|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsIhEERS4_RKT_:
 1187|  1.34M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_h:
  250|  1.34M|template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
_Z14ser_writedata8I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_h:
   58|  4.01M|{
   59|  4.01M|    s.write(std::as_bytes(std::span{&obj, 1}));
   60|  4.01M|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE5writeENSt3__14spanIKSt4byteLm18446744073709551615EEE:
 1189|  19.4M|    void write(std::span<const std::byte> src) { GetStream().write(src); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsI7uint256EERS4_RKT_:
 1187|  14.3k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE7uint256Q12SerializableIT0_T_EEvRS8_RKS7_:
  767|  14.3k|{
  768|  14.3k|    a.Serialize(os);
  769|  14.3k|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsINSt3__14spanIKhLm32EEEEERS4_RKT_:
 1187|  14.3k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEETk9BasicByteKhLm32EEvRT_NSt3__14spanIT0_XT1_EEE:
  260|  14.3k|template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsIiEERS4_RKT_:
 1187|  8.66M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_i:
  253|  9.99M|template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
_Z15ser_writedata32I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_j:
   67|  12.6M|{
   68|  12.6M|    obj = htole32_internal(obj);
   69|  12.6M|    s.write(std::as_bytes(std::span{&obj, 1}));
   70|  12.6M|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsI8AddrInfoEERS4_RKT_:
 1187|  1.33M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE8AddrInfoQ12SerializableIT0_T_EEvRS8_RKS7_:
  767|  1.33M|{
  768|  1.33M|    a.Serialize(os);
  769|  1.33M|}
_ZNK8AddrInfo9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  214|  1.33M|    {                                                                                               \
  215|  1.33M|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|  1.33M|        Ser(s, *this);                                                                              \
  217|  1.33M|    }                                                                                               \
_ZN8AddrInfo3SerI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_RKS_:
  170|  1.33M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJS4_8CNetAddr7WrapperI15ChronoFormatterIlLb0EERKNSt3__16chrono10time_pointI9NodeClockNSC_8durationIxNSB_5ratioILl1ELl1EEEEEEEEiEEEvRT_DpRKT0_:
 1066|  1.33M|    {
 1067|  1.33M|        ::SerializeMany(s, args...);
 1068|  1.33M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJS3_8CNetAddr7WrapperI15ChronoFormatterIlLb0EERKNSt3__16chrono10time_pointI9NodeClockNSB_8durationIxNSA_5ratioILl1ELl1EEEEEEEEiEEvRT_DpRKT0_:
 1048|  1.33M|{
 1049|  1.33M|    (::Serialize(s, args), ...);
 1050|  1.33M|}
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEES3_Q12SerializableIT0_T_EEvRS7_RKS6_:
  767|  1.33M|{
  768|  1.33M|    a.Serialize(os);
  769|  1.33M|}
_ZNK8CAddress9SerializeI12ParamsStreamIR10DataStreamNS_9SerParamsEEEEvRT_:
  214|  1.33M|    {                                                                                               \
  215|  1.33M|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|  1.33M|        Ser(s, *this);                                                                              \
  217|  1.33M|    }                                                                                               \
_ZN8CAddress3SerI12ParamsStreamIR10DataStreamNS_9SerParamsEEEEvRT_RKS_:
  170|  1.33M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJjEEEvRT_DpRKT0_:
 1066|  1.33M|    {
 1067|  1.33M|        ::SerializeMany(s, args...);
 1068|  1.33M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJjEEvRT_DpRKT0_:
 1048|  1.33M|{
 1049|  1.33M|    (::Serialize(s, args), ...);
 1050|  1.33M|}
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_j:
  254|  2.66M|template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI15ChronoFormatterIjLb1EERKNSt3__16chrono10time_pointI9NodeClockNSB_8durationIxNSA_5ratioILl1ELl1EEEEEEEEEEEvRT_DpRKT0_:
 1066|  1.33M|    {
 1067|  1.33M|        ::SerializeMany(s, args...);
 1068|  1.33M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI15ChronoFormatterIjLb1EERKNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEEEvRT_DpRKT0_:
 1048|  1.33M|{
 1049|  1.33M|    (::Serialize(s, args), ...);
 1050|  1.33M|}
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE7WrapperI15ChronoFormatterIjLb1EERKNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEQ12SerializableIT0_T_EEvRSM_RKSL_:
  767|  1.33M|{
  768|  1.33M|    a.Serialize(os);
  769|  1.33M|}
_ZNK7WrapperI15ChronoFormatterIjLb1EERKNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  476|  1.33M|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15ChronoFormatterIjLb1EE3SerI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEENSt3__16chrono10time_pointI9NodeClockNS9_8durationIxNS8_5ratioILl1ELl1EEEEEEEEEvRT_T0_:
  594|  1.33M|    {
  595|  1.33M|        if constexpr (LOSSY) {
  596|  1.33M|            s << U(tp.time_since_epoch().count());
  597|       |        } else {
  598|       |            s << U{tp.time_since_epoch().count()};
  599|       |        }
  600|  1.33M|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsIjEERS4_RKT_:
 1187|  1.33M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_ZN15ActionSerialize8SerWriteI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERKS4_ZNS4_16SerializationOpsIS6_S7_S_EEvRT0_RT_T1_EUlRS6_S8_E_EEvSD_OSA_OSE_:
 1077|  1.33M|    {
 1078|  1.33M|        fn(s, std::forward<Type>(obj));
 1079|  1.33M|    }
_ZZN8CAddress16SerializationOpsI12ParamsStreamIR10DataStreamNS_9SerParamsEEKS_15ActionSerializeEEvRT0_RT_T1_ENKUlRS5_RS6_E_clESD_SE_:
  150|  1.33M|#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI20CompactSizeFormatterILb0EERmEEEEvRT_DpRKT0_:
 1066|  1.33M|    {
 1067|  1.33M|        ::SerializeMany(s, args...);
 1068|  1.33M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI20CompactSizeFormatterILb0EERmEEEvRT_DpRKT0_:
 1048|  1.33M|{
 1049|  1.33M|    (::Serialize(s, args), ...);
 1050|  1.33M|}
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE7WrapperI20CompactSizeFormatterILb0EERmEQ12SerializableIT0_T_EEvRSC_RKSB_:
  767|  1.33M|{
  768|  1.33M|    a.Serialize(os);
  769|  1.33M|}
_ZNK7WrapperI20CompactSizeFormatterILb0EERmE9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  476|  1.33M|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN20CompactSizeFormatterILb0EE3SerI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEmEEvRT_T0_:
  574|  1.33M|    {
  575|  1.33M|        static_assert(std::is_unsigned_v<I>, "CompactSize only supported for unsigned integers");
  576|  1.33M|        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(), "CompactSize only supports 64-bit integers and below");
  577|       |
  578|  1.33M|        WriteCompactSize<Stream>(s, v);
  579|  1.33M|    }
_Z16WriteCompactSizeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_m:
  303|  2.66M|{
  304|  2.66M|    if (nSize < 253)
  ------------------
  |  Branch (304:9): [True: 2.62M, False: 41.1k]
  ------------------
  305|  2.62M|    {
  306|  2.62M|        ser_writedata8(os, nSize);
  307|  2.62M|    }
  308|  41.1k|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (308:14): [True: 27.1k, False: 14.0k]
  ------------------
  309|  27.1k|    {
  310|  27.1k|        ser_writedata8(os, 253);
  311|  27.1k|        ser_writedata16(os, nSize);
  312|  27.1k|    }
  313|  14.0k|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (313:14): [True: 452, False: 13.5k]
  ------------------
  314|    452|    {
  315|    452|        ser_writedata8(os, 254);
  316|    452|        ser_writedata32(os, nSize);
  317|    452|    }
  318|  13.5k|    else
  319|  13.5k|    {
  320|  13.5k|        ser_writedata8(os, 255);
  321|  13.5k|        ser_writedata64(os, nSize);
  322|  13.5k|    }
  323|  2.66M|    return;
  324|  2.66M|}
_Z15ser_writedata16I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_t:
   62|  27.1k|{
   63|  27.1k|    obj = htole16_internal(obj);
   64|  27.1k|    s.write(std::as_bytes(std::span{&obj, 1}));
   65|  27.1k|}
_Z15ser_writedata64I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_m:
   77|  1.34M|{
   78|  1.34M|    obj = htole64_internal(obj);
   79|  1.34M|    s.write(std::as_bytes(std::span{&obj, 1}));
   80|  1.34M|}
_ZN15ActionSerialize7SerReadI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERKS4_ZNS4_16SerializationOpsIS6_S7_S_EEvRT0_RT_T1_EUlRS6_RS4_E_EEvSD_OSA_OSE_:
 1072|  1.33M|    {
 1073|  1.33M|    }
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ13ParamsWrapperIN8CNetAddr9SerParamsEK8CServiceEEEEvRT_DpRKT0_:
 1066|  1.33M|    {
 1067|  1.33M|        ::SerializeMany(s, args...);
 1068|  1.33M|    }
_Z13SerializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ13ParamsWrapperIN8CNetAddr9SerParamsEK8CServiceEEEvRT_DpRKT0_:
 1048|  1.33M|{
 1049|  1.33M|    (::Serialize(s, args), ...);
 1050|  1.33M|}
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE13ParamsWrapperIN8CNetAddr9SerParamsEK8CServiceEQ12SerializableIT0_T_EEvRSD_RKSC_:
  767|  1.33M|{
  768|  1.33M|    a.Serialize(os);
  769|  1.33M|}
_ZNK13ParamsWrapperIN8CNetAddr9SerParamsEK8CServiceE9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
 1253|  1.33M|    {
 1254|  1.33M|        ParamsStream ss{s, m_params};
 1255|  1.33M|        ::Serialize(ss, m_object);
 1256|  1.33M|    }
_Z9SerializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE8CServiceQ12SerializableIT0_T_EEvRSC_RKSB_:
  767|  1.33M|{
  768|  1.33M|    a.Serialize(os);
  769|  1.33M|}
_ZNK8CService9SerializeI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  214|  1.33M|    {                                                                                               \
  215|  1.33M|        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
  216|  1.33M|        Ser(s, *this);                                                                              \
  217|  1.33M|    }                                                                                               \
_ZN8CService3SerI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_RKS_:
  170|  1.33M|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEJS8_7WrapperI19CustomUintFormatterILi2ELb1EERKtEEEEvRT_DpRKT0_:
 1066|  1.33M|    {
 1067|  1.33M|        ::SerializeMany(s, args...);
 1068|  1.33M|    }
_Z13SerializeManyI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEJS7_7WrapperI19CustomUintFormatterILi2ELb1EERKtEEEvRT_DpRKT0_:
 1048|  1.33M|{
 1049|  1.33M|    (::Serialize(s, args), ...);
 1050|  1.33M|}
_Z9SerializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEES7_Q12SerializableIT0_T_EEvRSB_RKSA_:
  767|  1.33M|{
  768|  1.33M|    a.Serialize(os);
  769|  1.33M|}
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEElsIhEERS8_RKT_:
 1187|  1.33M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEvRT_h:
  250|  1.33M|template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
_Z14ser_writedata8I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEvRT_h:
   58|  2.66M|{
   59|  2.66M|    s.write(std::as_bytes(std::span{&obj, 1}));
   60|  2.66M|}
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE5writeENSt3__14spanIKSt4byteLm18446744073709551615EEE:
 1189|  5.33M|    void write(std::span<const std::byte> src) { GetStream().write(src); }
_Z16WriteCompactSizeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEvRT_m:
  303|  1.33M|{
  304|  1.33M|    if (nSize < 253)
  ------------------
  |  Branch (304:9): [True: 1.33M, False: 0]
  ------------------
  305|  1.33M|    {
  306|  1.33M|        ser_writedata8(os, nSize);
  307|  1.33M|    }
  308|      0|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (308:14): [True: 0, False: 0]
  ------------------
  309|      0|    {
  310|      0|        ser_writedata8(os, 253);
  311|      0|        ser_writedata16(os, nSize);
  312|      0|    }
  313|      0|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (313:14): [True: 0, False: 0]
  ------------------
  314|      0|    {
  315|      0|        ser_writedata8(os, 254);
  316|      0|        ser_writedata32(os, nSize);
  317|      0|    }
  318|      0|    else
  319|      0|    {
  320|      0|        ser_writedata8(os, 255);
  321|      0|        ser_writedata64(os, nSize);
  322|      0|    }
  323|  1.33M|    return;
  324|  1.33M|}
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEElsI9prevectorILj16EhjiEEERS8_RKT_:
 1187|  1.33M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEELj16EhEvRT_RK9prevectorIXT0_ET1_jiE:
  864|  1.33M|{
  865|  1.33M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  866|  1.33M|        WriteCompactSize(os, v.size());
  867|  1.33M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (867:13): [True: 1.33M, False: 0]
  ------------------
  868|       |    } else {
  869|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  870|       |    }
  871|  1.33M|}
_Z9SerializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE7WrapperI19CustomUintFormatterILi2ELb1EERKtEQ12SerializableIT0_T_EEvRSH_RKSG_:
  767|  1.33M|{
  768|  1.33M|    a.Serialize(os);
  769|  1.33M|}
_ZNK7WrapperI19CustomUintFormatterILi2ELb1EERKtE9SerializeI12ParamsStreamIRS6_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  476|  1.33M|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN19CustomUintFormatterILi2ELb1EE3SerI12ParamsStreamIRS2_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEtEEvRT_T0_:
  530|  1.33M|    {
  531|  1.33M|        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
  ------------------
  |  Branch (531:13): [True: 0, False: 1.33M]
  |  Branch (531:22): [True: 0, False: 1.33M]
  ------------------
  532|  1.33M|        if (BigEndian) {
  ------------------
  |  Branch (532:13): [True: 1.33M, Folded]
  ------------------
  533|  1.33M|            uint64_t raw = htobe64_internal(v);
  534|  1.33M|            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
  535|  1.33M|        } else {
  536|      0|            uint64_t raw = htole64_internal(v);
  537|      0|            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
  538|      0|        }
  539|  1.33M|    }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE8CNetAddrQ12SerializableIT0_T_EEvRS8_RKS7_:
  767|  1.33M|{
  768|  1.33M|    a.Serialize(os);
  769|  1.33M|}
_ZNK12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE9GetParamsIN8CNetAddr9SerParamsEEERKDav:
 1198|  7.49M|    {
 1199|  7.49M|        if constexpr (std::is_convertible_v<Params, P>) {
 1200|  7.49M|            return m_params;
 1201|       |        } else {
 1202|       |            return m_substream.template GetParams<P>();
 1203|       |        }
 1204|  7.49M|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsI7WrapperI20CompactSizeFormatterILb1EERKmEEERS4_RKT_:
 1187|   148k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE7WrapperI20CompactSizeFormatterILb1EERKmEQ12SerializableIT0_T_EEvRSD_RKSC_:
  767|   148k|{
  768|   148k|    a.Serialize(os);
  769|   148k|}
_ZNK7WrapperI20CompactSizeFormatterILb1EERKmE9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  476|   148k|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN20CompactSizeFormatterILb1EE3SerI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEmEEvRT_T0_:
  574|   148k|    {
  575|   148k|        static_assert(std::is_unsigned_v<I>, "CompactSize only supported for unsigned integers");
  576|   148k|        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(), "CompactSize only supports 64-bit integers and below");
  577|       |
  578|   148k|        WriteCompactSize<Stream>(s, v);
  579|   148k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsI9prevectorILj16EhjiEEERS4_RKT_:
 1187|  1.18M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEELj16EhEvRT_RK9prevectorIXT0_ET1_jiE:
  864|  1.18M|{
  865|  1.18M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  866|  1.18M|        WriteCompactSize(os, v.size());
  867|  1.18M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (867:13): [True: 1.18M, False: 0]
  ------------------
  868|       |    } else {
  869|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  870|       |    }
  871|  1.18M|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsIA16_hEERS4_RKT_:
 1187|   148k|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEETk9BasicBytehLm16EEvRT_RAT1__KT0_:
  258|   148k|template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE7WrapperI15ChronoFormatterIlLb0EERKNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEQ12SerializableIT0_T_EEvRSM_RKSL_:
  767|  1.33M|{
  768|  1.33M|    a.Serialize(os);
  769|  1.33M|}
_ZNK7WrapperI15ChronoFormatterIlLb0EERKNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  476|  1.33M|    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
_ZN15ChronoFormatterIlLb0EE3SerI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEENSt3__16chrono10time_pointI9NodeClockNS9_8durationIxNS8_5ratioILl1ELl1EEEEEEEEEvRT_T0_:
  594|  1.33M|    {
  595|       |        if constexpr (LOSSY) {
  596|       |            s << U(tp.time_since_epoch().count());
  597|  1.33M|        } else {
  598|  1.33M|            s << U{tp.time_since_epoch().count()};
  599|  1.33M|        }
  600|  1.33M|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEElsIlEERS4_RKT_:
 1187|  1.33M|    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
_Z9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_l:
  255|  1.33M|template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
addrman.cpp:_ZL5UsingI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEE7WrapperIT_RT0_EOS7_:
  491|  3.04k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEEC2ES4_:
  475|  3.04k|    explicit Wrapper(T obj) : m_object(obj) {}
_Z6AsBaseI8CAddress8AddrInfoERT_RT0_:
  137|   120k|{
  138|   120k|    static_assert(std::is_base_of_v<Out, In>);
  139|   120k|    return x;
  140|   120k|}
addrman.cpp:_ZL5UsingI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE7WrapperIT_RT0_EOSE_:
  491|   120k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEEC2ESB_:
  475|   120k|    explicit Wrapper(T obj) : m_object(obj) {}
_Z11UnserializeI10DataStreamR7WrapperI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEEQ14UnserializableIT0_T_EEvRSA_OS9_:
  776|  3.04k|{
  777|  3.04k|    a.Unserialize(is);
  778|  3.04k|}
_ZN7WrapperI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEE11UnserializeI10DataStreamEEvRT_:
  477|  3.04k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN19CustomUintFormatterILi1ELb0EE5UnserI10DataStreamN11AddrManImpl6FormatEEEvRT_RT0_:
  542|  3.04k|    {
  543|  3.04k|        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
  544|  3.04k|        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
  545|  3.04k|        uint64_t raw = 0;
  546|  3.04k|        if (BigEndian) {
  ------------------
  |  Branch (546:13): [Folded, False: 3.04k]
  ------------------
  547|      0|            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
  548|      0|            v = static_cast<I>(be64toh_internal(raw));
  549|  3.04k|        } else {
  550|  3.04k|            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
  551|  3.04k|            v = static_cast<I>(le64toh_internal(raw));
  552|  3.04k|        }
  553|  3.04k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRhEERS4_OT_:
 1188|  6.15M|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_Rh:
  266|  6.15M|template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIR7uint256EERS4_OT_:
 1188|  1.95k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7uint256Q14UnserializableIT0_T_EEvRS9_OS8_:
  776|  1.95k|{
  777|  1.95k|    a.Unserialize(is);
  778|  1.95k|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRiEERS4_OT_:
 1188|   951k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_Ri:
  269|  1.07M|template <typename Stream> void Unserialize(Stream& s, int32_t& a)   { a = int32_t(ser_readdata32(s)); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIR8AddrInfoEERS4_OT_:
 1188|   120k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER8AddrInfoQ14UnserializableIT0_T_EEvRS9_OS8_:
  776|   120k|{
  777|   120k|    a.Unserialize(is);
  778|   120k|}
_ZN8AddrInfo11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  220|   120k|    {                                                                                               \
  221|   120k|        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
  222|   120k|        Unser(s, *this);                                                                            \
  223|   120k|    }
_ZN8AddrInfo5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_RS_:
  172|   120k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJRS4_R8CNetAddr7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNSE_8durationIxNSD_5ratioILl1ELl1EEEEEEEERiEEEvRT_DpOT0_:
 1086|   120k|    {
 1087|   120k|        ::UnserializeMany(s, args...);
 1088|   120k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJRS3_R8CNetAddrR7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNSD_8durationIxNSC_5ratioILl1ELl1EEEEEEEERiEEvRT_DpOT0_:
 1054|   120k|{
 1055|   120k|    (::Unserialize(s, args), ...);
 1056|   120k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER8CNetAddrQ14UnserializableIT0_T_EEvRS9_OS8_:
  776|  6.15M|{
  777|  6.15M|    a.Unserialize(is);
  778|  6.15M|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsI7WrapperI20CompactSizeFormatterILb1EERmEEERS4_OT_:
 1188|  6.14M|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI20CompactSizeFormatterILb1EERmEQ14UnserializableIT0_T_EEvRSD_OSC_:
  776|  6.14M|{
  777|  6.14M|    a.Unserialize(is);
  778|  6.14M|}
_ZN7WrapperI20CompactSizeFormatterILb1EERmE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  477|  6.14M|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN20CompactSizeFormatterILb1EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEmEEvRT_RT0_:
  564|  6.14M|    {
  565|  6.14M|        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
  566|  6.14M|        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (566:13): [True: 101, False: 6.14M]
  |  Branch (566:50): [True: 0, False: 6.14M]
  ------------------
  567|      0|            throw std::ios_base::failure("CompactSize exceeds limit of type");
  568|      0|        }
  569|  6.14M|        v = n;
  570|  6.14M|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsINSt3__14spanIhLm18446744073709551615EEEEERS4_OT_:
 1188|  6.03M|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEETk9BasicBytehEvRT_NSt3__14spanIT0_Lm18446744073709551615EEE:
  277|  6.03M|template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE6ignoreEm:
 1191|   109k|    void ignore(size_t num) { GetStream().ignore(num); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRA16_hEERS4_OT_:
 1188|  10.5k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEETk9BasicBytehLm16EEvRT_RAT1__T0_:
  274|  10.5k|template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEQ14UnserializableIT0_T_EEvRSM_OSL_:
  776|   120k|{
  777|   120k|    a.Unserialize(is);
  778|   120k|}
_ZN7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  477|   120k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15ChronoFormatterIlLb0EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEENSt3__16chrono10time_pointI9NodeClockNS9_8durationIxNS8_5ratioILl1ELl1EEEEEEEEEvRT_RT0_:
  586|   120k|    {
  587|   120k|        U u;
  588|   120k|        s >> u;
  589|       |        // Lossy deserialization does not make sense, so force Wnarrowing
  590|   120k|        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
  591|   120k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRlEERS4_OT_:
 1188|   120k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_Rl:
  271|   120k|template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
net.cpp:_ZL5UsingI20CompactSizeFormatterILb1EERmE7WrapperIT_RT0_EOS5_:
  491|  6.14M|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsEC2ES3_:
  475|   110k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN7WrapperI20CompactSizeFormatterILb1EERmEC2ES2_:
  475|  6.15M|    explicit Wrapper(T obj) : m_object(obj) {}
_Z6AsBaseI8CNetAddr8CServiceERT_RT0_:
  137|   120k|{
  138|   120k|    static_assert(std::is_base_of_v<Out, In>);
  139|   120k|    return x;
  140|   120k|}
_ZN7WrapperI19CustomUintFormatterILi2ELb1EERtEC2ES2_:
  475|   120k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZNK8CNetAddr9SerParamsclIR8CServiceEEDaOT_:
 1282|   120k|    {                                                                                    \
 1283|   120k|        return ParamsWrapper{*this, t};                                                  \
 1284|   120k|    }
_ZN13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceEC2ERKS1_RS2_:
 1249|   120k|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_ZN7WrapperI20CompactSizeFormatterILb1EERKmEC2ES3_:
  475|   148k|    explicit Wrapper(T obj) : m_object(obj) {}
_Z6AsBaseI8CNetAddr8CServiceERKT_RKT0_:
  143|  1.33M|{
  144|  1.33M|    static_assert(std::is_base_of_v<Out, In>);
  145|  1.33M|    return x;
  146|  1.33M|}
_ZN7WrapperI19CustomUintFormatterILi2ELb1EERKtEC2ES3_:
  475|  1.33M|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEC2ES1_RKS3_:
 1181|  6.04M|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_Z15ReadCompactSizeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEmRT_b:
  334|  6.15M|{
  335|  6.15M|    uint8_t chSize = ser_readdata8(is);
  336|  6.15M|    uint64_t nSizeRet = 0;
  337|  6.15M|    if (chSize < 253)
  ------------------
  |  Branch (337:9): [True: 6.15M, False: 1.27k]
  ------------------
  338|  6.15M|    {
  339|  6.15M|        nSizeRet = chSize;
  340|  6.15M|    }
  341|  1.27k|    else if (chSize == 253)
  ------------------
  |  Branch (341:14): [True: 424, False: 849]
  ------------------
  342|    424|    {
  343|    424|        nSizeRet = ser_readdata16(is);
  344|    424|        if (nSizeRet < 253)
  ------------------
  |  Branch (344:13): [True: 5, False: 419]
  ------------------
  345|      5|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  346|    424|    }
  347|    849|    else if (chSize == 254)
  ------------------
  |  Branch (347:14): [True: 619, False: 230]
  ------------------
  348|    619|    {
  349|    619|        nSizeRet = ser_readdata32(is);
  350|    619|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (350:13): [True: 7, False: 612]
  ------------------
  351|      7|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|    619|    }
  353|    230|    else
  354|    230|    {
  355|    230|        nSizeRet = ser_readdata64(is);
  356|    230|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (356:13): [True: 27, False: 203]
  ------------------
  357|     27|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|    230|    }
  359|  6.15M|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (359:9): [True: 6.14M, False: 9.68k]
  |  Branch (359:24): [True: 67, False: 6.14M]
  ------------------
  360|     67|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  361|     67|    }
  362|  6.15M|    return nSizeRet;
  363|  6.15M|}
_Z13ser_readdata8I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEhRT_:
   82|  12.3M|{
   83|  12.3M|    uint8_t obj;
   84|  12.3M|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   85|  12.3M|    return obj;
   86|  12.3M|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE4readENSt3__14spanISt4byteLm18446744073709551615EEE:
 1190|  19.9M|    void read(std::span<std::byte> dst) { GetStream().read(dst); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE9GetStreamEv:
 1208|  45.0M|    {
 1209|       |        if constexpr (ContainsStream<SubStream>) {
 1210|       |            return m_substream.GetStream();
 1211|  45.0M|        } else {
 1212|  45.0M|            return m_substream;
 1213|  45.0M|        }
 1214|  45.0M|    }
_Z14ser_readdata16I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEtRT_:
   88|    424|{
   89|    424|    uint16_t obj;
   90|    424|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   91|    424|    return le16toh_internal(obj);
   92|    424|}
_Z14ser_readdata32I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEjRT_:
   94|  1.31M|{
   95|  1.31M|    uint32_t obj;
   96|  1.31M|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   97|  1.31M|    return le32toh_internal(obj);
   98|  1.31M|}
_Z14ser_readdata64I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEmRT_:
  106|   120k|{
  107|   120k|    uint64_t obj;
  108|   120k|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
  109|   120k|    return le64toh_internal(obj);
  110|   120k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERS3_Q14UnserializableIT0_T_EEvRS8_OS7_:
  776|   120k|{
  777|   120k|    a.Unserialize(is);
  778|   120k|}
_ZN8CAddress11UnserializeI12ParamsStreamIR10DataStreamNS_9SerParamsEEEEvRT_:
  220|   120k|    {                                                                                               \
  221|   120k|        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
  222|   120k|        Unser(s, *this);                                                                            \
  223|   120k|    }
_ZN8CAddress5UnserI12ParamsStreamIR10DataStreamNS_9SerParamsEEEEvRT_RS_:
  172|   120k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZNK12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE9GetParamsIS3_EERKDav:
 1198|  1.45M|    {
 1199|  1.45M|        if constexpr (std::is_convertible_v<Params, P>) {
 1200|  1.45M|            return m_params;
 1201|       |        } else {
 1202|       |            return m_substream.template GetParams<P>();
 1203|       |        }
 1204|  1.45M|    }
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJRjEEEvRT_DpOT0_:
 1086|   120k|    {
 1087|   120k|        ::UnserializeMany(s, args...);
 1088|   120k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJRjEEvRT_DpOT0_:
 1054|   120k|{
 1055|   120k|    (::Unserialize(s, args), ...);
 1056|   120k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_Rj:
  270|   241k|template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNSB_8durationIxNSA_5ratioILl1ELl1EEEEEEEEEEEvRT_DpOT0_:
 1086|   120k|    {
 1087|   120k|        ::UnserializeMany(s, args...);
 1088|   120k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJR7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEEEvRT_DpOT0_:
 1054|   120k|{
 1055|   120k|    (::Unserialize(s, args), ...);
 1056|   120k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEQ14UnserializableIT0_T_EEvRSM_OSL_:
  776|   120k|{
  777|   120k|    a.Unserialize(is);
  778|   120k|}
_ZN7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  477|   120k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15ChronoFormatterIjLb1EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEENSt3__16chrono10time_pointI9NodeClockNS9_8durationIxNS8_5ratioILl1ELl1EEEEEEEEEvRT_RT0_:
  586|   120k|    {
  587|   120k|        U u;
  588|   120k|        s >> u;
  589|       |        // Lossy deserialization does not make sense, so force Wnarrowing
  590|   120k|        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
  591|   120k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRjEERS4_OT_:
 1188|   120k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_ZN7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEEC2ESB_:
  475|   120k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN17ActionUnserialize8SerWriteI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERS4_ZNS4_16SerializationOpsIS6_S4_S_EEvRT0_RT_T1_EUlRS6_RKS4_E_EEvSC_OS9_OSD_:
 1098|  9.68k|    {
 1099|  9.68k|    }
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI20CompactSizeFormatterILb0EERmEEEEvRT_DpOT0_:
 1086|  9.68k|    {
 1087|  9.68k|        ::UnserializeMany(s, args...);
 1088|  9.68k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJR7WrapperI20CompactSizeFormatterILb0EERmEEEvRT_DpOT0_:
 1054|  9.68k|{
 1055|  9.68k|    (::Unserialize(s, args), ...);
 1056|  9.68k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI20CompactSizeFormatterILb0EERmEQ14UnserializableIT0_T_EEvRSD_OSC_:
  776|  9.68k|{
  777|  9.68k|    a.Unserialize(is);
  778|  9.68k|}
_ZN7WrapperI20CompactSizeFormatterILb0EERmE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  477|  9.68k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN20CompactSizeFormatterILb0EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEmEEvRT_RT0_:
  564|  9.68k|    {
  565|  9.68k|        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
  566|  9.68k|        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (566:13): [True: 20, False: 9.66k]
  |  Branch (566:50): [True: 0, False: 9.66k]
  ------------------
  567|      0|            throw std::ios_base::failure("CompactSize exceeds limit of type");
  568|      0|        }
  569|  9.68k|        v = n;
  570|  9.68k|    }
_ZN7WrapperI20CompactSizeFormatterILb0EERmEC2ES2_:
  475|  1.34M|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN17ActionUnserialize7SerReadI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERS4_ZNS4_16SerializationOpsIS6_S4_S_EEvRT0_RT_T1_EUlRS6_S7_E_EEvSC_OS9_OSD_:
 1092|  9.66k|    {
 1093|  9.66k|        fn(s, std::forward<Type>(obj));
 1094|  9.66k|    }
_ZZN8CAddress16SerializationOpsI12ParamsStreamIR10DataStreamNS_9SerParamsEES_17ActionUnserializeEEvRT0_RT_T1_ENKUlRS5_RS_E_clESC_SD_:
  149|  9.66k|#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsEEEEvRT_DpOT0_:
 1086|   110k|    {
 1087|   110k|        ::UnserializeMany(s, args...);
 1088|   110k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJR7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsEEEvRT_DpOT0_:
 1054|   110k|{
 1055|   110k|    (::Unserialize(s, args), ...);
 1056|   110k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsEQ14UnserializableIT0_T_EEvRSE_OSD_:
  776|   110k|{
  777|   110k|    a.Unserialize(is);
  778|   110k|}
_ZN7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  477|   110k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN19CustomUintFormatterILi8ELb0EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE12ServiceFlagsEEvRT_RT0_:
  542|   110k|    {
  543|   110k|        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
  544|   110k|        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
  545|   110k|        uint64_t raw = 0;
  546|   110k|        if (BigEndian) {
  ------------------
  |  Branch (546:13): [Folded, False: 110k]
  ------------------
  547|      0|            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
  548|      0|            v = static_cast<I>(be64toh_internal(raw));
  549|   110k|        } else {
  550|   110k|            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
  551|   110k|            v = static_cast<I>(le64toh_internal(raw));
  552|   110k|        }
  553|   110k|    }
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceEEEEvRT_DpOT0_:
 1086|   120k|    {
 1087|   120k|        ::UnserializeMany(s, args...);
 1088|   120k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJR13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceEEEvRT_DpOT0_:
 1054|   120k|{
 1055|   120k|    (::Unserialize(s, args), ...);
 1056|   120k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceEQ14UnserializableIT0_T_EEvRSD_OSC_:
  776|   120k|{
  777|   120k|    a.Unserialize(is);
  778|   120k|}
_ZN13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
 1259|   120k|    {
 1260|   120k|        ParamsStream ss{s, m_params};
 1261|   120k|        ::Unserialize(ss, m_object);
 1262|   120k|    }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEC2ES5_RKS7_:
 1181|  1.45M|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEER8CServiceQ14UnserializableIT0_T_EEvRSD_OSC_:
  776|   120k|{
  777|   120k|    a.Unserialize(is);
  778|   120k|}
_ZN8CService11UnserializeI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  220|   120k|    {                                                                                               \
  221|   120k|        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
  222|   120k|        Unser(s, *this);                                                                            \
  223|   120k|    }
_ZN8CService5UnserI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_RS_:
  172|   120k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEJRS8_7WrapperI19CustomUintFormatterILi2ELb1EERtEEEEvRT_DpOT0_:
 1086|   120k|    {
 1087|   120k|        ::UnserializeMany(s, args...);
 1088|   120k|    }
_Z15UnserializeManyI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEJRS7_R7WrapperI19CustomUintFormatterILi2ELb1EERtEEEvRT_DpOT0_:
 1054|   120k|{
 1055|   120k|    (::Unserialize(s, args), ...);
 1056|   120k|}
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEERS7_Q14UnserializableIT0_T_EEvRSC_OSB_:
  776|   120k|{
  777|   120k|    a.Unserialize(is);
  778|   120k|}
_ZNK12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE9GetParamsIS7_EERKDav:
 1198|  1.45M|    {
 1199|  1.45M|        if constexpr (std::is_convertible_v<Params, P>) {
 1200|  1.45M|            return m_params;
 1201|       |        } else {
 1202|       |            return m_substream.template GetParams<P>();
 1203|       |        }
 1204|  1.45M|    }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEErsIRhEERS8_OT_:
 1188|  9.66k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEvRT_Rh:
  266|  9.66k|template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
_Z13ser_readdata8I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEhRT_:
   82|  19.3k|{
   83|  19.3k|    uint8_t obj;
   84|  19.3k|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   85|  19.3k|    return obj;
   86|  19.3k|}
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE4readENSt3__14spanISt4byteLm18446744073709551615EEE:
 1190|   253k|    void read(std::span<std::byte> dst) { GetStream().read(dst); }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE9GetStreamEv:
 1208|  5.59M|    {
 1209|  5.59M|        if constexpr (ContainsStream<SubStream>) {
 1210|  5.59M|            return m_substream.GetStream();
 1211|       |        } else {
 1212|       |            return m_substream;
 1213|       |        }
 1214|  5.59M|    }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEErsI7WrapperI20CompactSizeFormatterILb1EERmEEERS8_OT_:
 1188|  9.65k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEER7WrapperI20CompactSizeFormatterILb1EERmEQ14UnserializableIT0_T_EEvRSH_OSG_:
  776|  9.65k|{
  777|  9.65k|    a.Unserialize(is);
  778|  9.65k|}
_ZN7WrapperI20CompactSizeFormatterILb1EERmE11UnserializeI12ParamsStreamIRS5_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  477|  9.65k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN20CompactSizeFormatterILb1EE5UnserI12ParamsStreamIRS2_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEmEEvRT_RT0_:
  564|  9.65k|    {
  565|  9.65k|        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
  566|  9.65k|        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (566:13): [True: 122, False: 9.53k]
  |  Branch (566:50): [True: 0, False: 9.53k]
  ------------------
  567|      0|            throw std::ios_base::failure("CompactSize exceeds limit of type");
  568|      0|        }
  569|  9.65k|        v = n;
  570|  9.65k|    }
_Z15ReadCompactSizeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEmRT_b:
  334|  9.65k|{
  335|  9.65k|    uint8_t chSize = ser_readdata8(is);
  336|  9.65k|    uint64_t nSizeRet = 0;
  337|  9.65k|    if (chSize < 253)
  ------------------
  |  Branch (337:9): [True: 9.46k, False: 191]
  ------------------
  338|  9.46k|    {
  339|  9.46k|        nSizeRet = chSize;
  340|  9.46k|    }
  341|    191|    else if (chSize == 253)
  ------------------
  |  Branch (341:14): [True: 54, False: 137]
  ------------------
  342|     54|    {
  343|     54|        nSizeRet = ser_readdata16(is);
  344|     54|        if (nSizeRet < 253)
  ------------------
  |  Branch (344:13): [True: 3, False: 51]
  ------------------
  345|      3|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  346|     54|    }
  347|    137|    else if (chSize == 254)
  ------------------
  |  Branch (347:14): [True: 41, False: 96]
  ------------------
  348|     41|    {
  349|     41|        nSizeRet = ser_readdata32(is);
  350|     41|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (350:13): [True: 6, False: 35]
  ------------------
  351|      6|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|     41|    }
  353|     96|    else
  354|     96|    {
  355|     96|        nSizeRet = ser_readdata64(is);
  356|     96|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (356:13): [True: 13, False: 83]
  ------------------
  357|     13|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|     96|    }
  359|  9.63k|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (359:9): [True: 9.61k, False: 20]
  |  Branch (359:24): [True: 80, False: 9.53k]
  ------------------
  360|     80|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  361|     80|    }
  362|  9.55k|    return nSizeRet;
  363|  9.63k|}
_Z14ser_readdata16I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEtRT_:
   88|     54|{
   89|     54|    uint16_t obj;
   90|     54|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   91|     54|    return le16toh_internal(obj);
   92|     54|}
_Z14ser_readdata32I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEjRT_:
   94|     41|{
   95|     41|    uint32_t obj;
   96|     41|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
   97|     41|    return le32toh_internal(obj);
   98|     41|}
_Z14ser_readdata64I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEmRT_:
  106|     85|{
  107|     85|    uint64_t obj;
  108|     85|    s.read(std::as_writable_bytes(std::span{&obj, 1}));
  109|     85|    return le64toh_internal(obj);
  110|     85|}
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEErsINSt3__14spanIhLm18446744073709551615EEEEERS8_OT_:
 1188|  3.19k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEETk9BasicBytehEvRT_NSt3__14spanIT0_Lm18446744073709551615EEE:
  277|  3.19k|template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE6ignoreEm:
 1191|  6.29k|    void ignore(size_t num) { GetStream().ignore(num); }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEErsIRA16_hEERS8_OT_:
 1188|   110k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEETk9BasicBytehLm16EEvRT_RAT1__T0_:
  274|   110k|template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEER7WrapperI19CustomUintFormatterILi2ELb1EERtEQ14UnserializableIT0_T_EEvRSH_OSG_:
  776|   120k|{
  777|   120k|    a.Unserialize(is);
  778|   120k|}
_ZN7WrapperI19CustomUintFormatterILi2ELb1EERtE11UnserializeI12ParamsStreamIRS5_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  477|   120k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN19CustomUintFormatterILi2ELb1EE5UnserI12ParamsStreamIRS2_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEtEEvRT_RT0_:
  542|   120k|    {
  543|   120k|        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
  544|   120k|        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
  545|   120k|        uint64_t raw = 0;
  546|   120k|        if (BigEndian) {
  ------------------
  |  Branch (546:13): [True: 120k, Folded]
  ------------------
  547|   120k|            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
  548|   120k|            v = static_cast<I>(be64toh_internal(raw));
  549|   120k|        } else {
  550|      0|            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
  551|      0|            v = static_cast<I>(le64toh_internal(raw));
  552|      0|        }
  553|   120k|    }
_Z6AsBaseI8CService8CAddressERT_RT0_:
  137|   120k|{
  138|   120k|    static_assert(std::is_base_of_v<Out, In>);
  139|   120k|    return x;
  140|   120k|}
_ZN7WrapperI15ChronoFormatterIjLb1EERKNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEEC2ESC_:
  475|  1.33M|    explicit Wrapper(T obj) : m_object(obj) {}
_ZNK8CNetAddr9SerParamsclIRK8CServiceEEDaOT_:
 1282|  1.33M|    {                                                                                    \
 1283|  1.33M|        return ParamsWrapper{*this, t};                                                  \
 1284|  1.33M|    }
_ZN13ParamsWrapperIN8CNetAddr9SerParamsEK8CServiceEC2ERKS1_RS3_:
 1249|  1.33M|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_Z6AsBaseI8CService8CAddressERKT_RKT0_:
  143|  1.33M|{
  144|  1.33M|    static_assert(std::is_base_of_v<Out, In>);
  145|  1.33M|    return x;
  146|  1.33M|}
_Z9SerializeI10HashWriterEvRT_m:
  256|  4.96M|template <typename Stream> void Serialize(Stream& s, uint64_t a)  { ser_writedata64(s, a); }
_Z9SerializeI10DataStreamhNSt3__19allocatorIhEEEvRT_RKNS1_6vectorIT0_T1_EE:
  899|  6.03M|{
  900|  6.03M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|  6.03M|        WriteCompactSize(os, v.size());
  902|  6.03M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (902:13): [True: 6.03M, False: 0]
  ------------------
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|       |    } else {
  912|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|       |    }
  914|  6.03M|}
_Z9SerializeI10DataStreamEvRT_h:
  250|  6.03M|template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
_Z14ser_writedata8I10DataStreamEvRT_h:
   58|  12.0M|{
   59|  12.0M|    s.write(std::as_bytes(std::span{&obj, 1}));
   60|  12.0M|}
_Z16WriteCompactSizeI10DataStreamEvRT_m:
  303|  6.03M|{
  304|  6.03M|    if (nSize < 253)
  ------------------
  |  Branch (304:9): [True: 6.03M, False: 0]
  ------------------
  305|  6.03M|    {
  306|  6.03M|        ser_writedata8(os, nSize);
  307|  6.03M|    }
  308|      0|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (308:14): [True: 0, False: 0]
  ------------------
  309|      0|    {
  310|      0|        ser_writedata8(os, 253);
  311|      0|        ser_writedata16(os, nSize);
  312|      0|    }
  313|      0|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (313:14): [True: 0, False: 0]
  ------------------
  314|      0|    {
  315|      0|        ser_writedata8(os, 254);
  316|      0|        ser_writedata32(os, nSize);
  317|      0|    }
  318|      0|    else
  319|      0|    {
  320|      0|        ser_writedata8(os, 255);
  321|      0|        ser_writedata64(os, nSize);
  322|      0|    }
  323|  6.03M|    return;
  324|  6.03M|}
_Z15ser_writedata64I10HashWriterEvRT_m:
   77|  4.96M|{
   78|  4.96M|    obj = htole64_internal(obj);
   79|  4.96M|    s.write(std::as_bytes(std::span{&obj, 1}));
   80|  4.96M|}
_Z16WriteCompactSizeI10HashWriterEvRT_m:
  303|  24.4M|{
  304|  24.4M|    if (nSize < 253)
  ------------------
  |  Branch (304:9): [True: 24.4M, False: 0]
  ------------------
  305|  24.4M|    {
  306|  24.4M|        ser_writedata8(os, nSize);
  307|  24.4M|    }
  308|      0|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (308:14): [True: 0, False: 0]
  ------------------
  309|      0|    {
  310|      0|        ser_writedata8(os, 253);
  311|      0|        ser_writedata16(os, nSize);
  312|      0|    }
  313|      0|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (313:14): [True: 0, False: 0]
  ------------------
  314|      0|    {
  315|      0|        ser_writedata8(os, 254);
  316|      0|        ser_writedata32(os, nSize);
  317|      0|    }
  318|      0|    else
  319|      0|    {
  320|      0|        ser_writedata8(os, 255);
  321|      0|        ser_writedata64(os, nSize);
  322|      0|    }
  323|  24.4M|    return;
  324|  24.4M|}
_Z14ser_writedata8I10HashWriterEvRT_h:
   58|  34.6M|{
   59|  34.6M|    s.write(std::as_bytes(std::span{&obj, 1}));
   60|  34.6M|}
_Z15ser_writedata32I10HashWriterEvRT_j:
   67|  10.1M|{
   68|  10.1M|    obj = htole32_internal(obj);
   69|  10.1M|    s.write(std::as_bytes(std::span{&obj, 1}));
   70|  10.1M|}
_Z9SerializeI10HashWriterhNSt3__19allocatorIhEEEvRT_RKNS1_6vectorIT0_T1_EE:
  899|  24.4M|{
  900|  24.4M|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  901|  24.4M|        WriteCompactSize(os, v.size());
  902|  24.4M|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (902:13): [True: 24.4M, False: 0]
  ------------------
  903|       |    } else if constexpr (std::is_same_v<T, bool>) {
  904|       |        // A special case for std::vector<bool>, as dereferencing
  905|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  906|       |        // due to std::vector's special casing for bool arguments.
  907|       |        WriteCompactSize(os, v.size());
  908|       |        for (bool elem : v) {
  909|       |            ::Serialize(os, elem);
  910|       |        }
  911|       |    } else {
  912|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  913|       |    }
  914|  24.4M|}
_Z9SerializeI10HashWriterTk9BasicByteKhLm32EEvRT_NSt3__14spanIT0_XT1_EEE:
  260|  20.1M|template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
_Z9SerializeI10HashWriterEvRT_i:
  253|  10.1M|template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
_Z9SerializeI10HashWriter7uint256Q12SerializableIT0_T_EEvRS3_RKS2_:
  767|  20.1M|{
  768|  20.1M|    a.Serialize(os);
  769|  20.1M|}
_Z9SerializeI10HashWriterEvRT_h:
  250|  10.1M|template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }

_Z20MakeWritableByteSpanIRA16_hEDaOT_:
   90|   121k|{
   91|   121k|    return std::as_writable_bytes(std::span{std::forward<V>(v)});
   92|   121k|}
_Z12MakeByteSpanI9prevectorILj16EhjiEEDaRKT_:
   85|  2.52M|{
   86|  2.52M|    return std::as_bytes(std::span{v});
   87|  2.52M|}
_Z12MakeByteSpanIA16_hEDaRKT_:
   85|   148k|{
   86|   148k|    return std::as_bytes(std::span{v});
   87|   148k|}
_Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEEDaOT_:
   90|  1.95k|{
   91|  1.95k|    return std::as_writable_bytes(std::span{std::forward<V>(v)});
   92|  1.95k|}
_Z12MakeByteSpanINSt3__16vectorIhNS0_9allocatorIhEEEEEDaRKT_:
   85|  30.4M|{
   86|  30.4M|    return std::as_bytes(std::span{v});
   87|  30.4M|}
_Z12MakeByteSpanI7uint256EDaRKT_:
   85|  36.2k|{
   86|  36.2k|    return std::as_bytes(std::span{v});
   87|  36.2k|}
_Z9UCharCastPKSt4byte:
  102|  94.3M|inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast<const unsigned char*>(c); }

_ZN10DataStreamlsI7AddrManEERS_RKT_:
  252|  7.16k|    {
  253|  7.16k|        ::Serialize(*this, obj);
  254|  7.16k|        return (*this);
  255|  7.16k|    }
_ZN10DataStreamrsIR20AddrManDeterministicEERS_OT_:
  259|  3.04k|    {
  260|  3.04k|        ::Unserialize(*this, obj);
  261|  3.04k|        return (*this);
  262|  3.04k|    }
_ZN10DataStreamrsI13ParamsWrapperIN8CAddress9SerParamsE8CNetAddrEEERS_OT_:
  259|  6.03M|    {
  260|  6.03M|        ::Unserialize(*this, obj);
  261|  6.03M|        return (*this);
  262|  6.03M|    }
_ZN10DataStreamrsI7WrapperI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEEEERS_OT_:
  259|  3.04k|    {
  260|  3.04k|        ::Unserialize(*this, obj);
  261|  3.04k|        return (*this);
  262|  3.04k|    }
_ZN10DataStreamC2ENSt3__14spanIKhLm18446744073709551615EEE:
  183|  3.04k|    explicit DataStream(std::span<const uint8_t> sp) : DataStream{std::as_bytes(sp)} {}
_ZN10DataStreamC2ENSt3__14spanIKSt4byteLm18446744073709551615EEE:
  184|  3.04k|    explicit DataStream(std::span<const value_type> sp) : vch(sp.data(), sp.data() + sp.size()) {}
_ZN10DataStreamlsINSt3__16vectorIhNS1_9allocatorIhEEEEEERS_RKT_:
  252|  6.03M|    {
  253|  6.03M|        ::Serialize(*this, obj);
  254|  6.03M|        return (*this);
  255|  6.03M|    }
_ZN10DataStream5writeENSt3__14spanIKSt4byteLm18446744073709551615EEE:
  245|  42.8M|    {
  246|       |        // Write to the end of the buffer
  247|  42.8M|        vch.insert(vch.end(), src.begin(), src.end());
  248|  42.8M|    }
_ZN10DataStream5clearEv:
  204|  6.04M|    void clear()                                     { vch.clear(); m_read_pos = 0; }
_ZN10DataStreamC2Ev:
  182|  6.04M|    explicit DataStream() = default;
_ZN10DataStreamlsIhEERS_RKT_:
  252|  6.03M|    {
  253|  6.03M|        ::Serialize(*this, obj);
  254|  6.03M|        return (*this);
  255|  6.03M|    }
_ZN10DataStream4readENSt3__14spanISt4byteLm18446744073709551615EEE:
  212|  20.1M|    {
  213|  20.1M|        if (dst.size() == 0) return;
  ------------------
  |  Branch (213:13): [True: 0, False: 20.1M]
  ------------------
  214|       |
  215|       |        // Read from the beginning of the buffer
  216|  20.1M|        auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
  217|  20.1M|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (217:13): [True: 0, False: 20.1M]
  |  Branch (217:43): [True: 784, False: 20.1M]
  ------------------
  218|    784|            throw std::ios_base::failure("DataStream::read(): end of data");
  219|    784|        }
  220|  20.1M|        memcpy(dst.data(), &vch[m_read_pos], dst.size());
  221|  20.1M|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (221:13): [True: 6.04M, False: 14.1M]
  ------------------
  222|       |            // If fully consumed, reset to empty state.
  223|  6.04M|            clear();
  224|  6.04M|            return;
  225|  6.04M|        }
  226|  14.1M|        m_read_pos = next_read_pos.value();
  227|  14.1M|    }
_ZN10DataStream6ignoreEm:
  230|   115k|    {
  231|       |        // Ignore from the beginning of the buffer
  232|   115k|        auto next_read_pos{CheckedAdd(m_read_pos, num_ignore)};
  233|   115k|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (233:13): [True: 0, False: 115k]
  |  Branch (233:43): [True: 54, False: 115k]
  ------------------
  234|     54|            throw std::ios_base::failure("DataStream::ignore(): end of data");
  235|     54|        }
  236|   115k|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (236:13): [True: 10, False: 115k]
  ------------------
  237|       |            // If all bytes are ignored, reset to empty state.
  238|     10|            clear();
  239|     10|            return;
  240|     10|        }
  241|   115k|        m_read_pos = next_read_pos.value();
  242|   115k|    }

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

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

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

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

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

_ZZN20AddrManDeterministicC1ERK15NetGroupManagerR18FuzzedDataProvideriENKUlvE_clEv:
  299|  9.68k|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
  ------------------
  |  |  268|  9.68k|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  9.68k|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  9.68k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  9.68k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
_Z22AssertLockHeldInternalI14AnnotatedMixinINSt3__15mutexEEEvPKcS5_iPT_:
   71|   393M|inline void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, MutexType* cs) EXCLUSIVE_LOCKS_REQUIRED(cs) {}
_ZN14AnnotatedMixinINSt3__115recursive_mutexEED2Ev:
   96|      2|    ~AnnotatedMixin() {
   97|      2|        DeleteLock((void*)this);
   98|      2|    }
_ZN14AnnotatedMixinINSt3__15mutexEED2Ev:
   96|  9.75k|    ~AnnotatedMixin() {
   97|  9.75k|        DeleteLock((void*)this);
   98|  9.75k|    }
_Z10DeleteLockPv:
   74|  9.75k|inline void DeleteLock(void* cs) {}
_Z17MaybeCheckNotHeldR14AnnotatedMixinINSt3__15mutexEE:
  258|  1.53M|inline Mutex& MaybeCheckNotHeld(Mutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEEC2ERS3_PKcS7_ib:
  181|  1.52M|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  182|  1.52M|    {
  183|  1.52M|        if (fTry)
  ------------------
  |  Branch (183:13): [True: 0, False: 1.52M]
  ------------------
  184|      0|            TryEnter(pszName, pszFile, nLine);
  185|  1.52M|        else
  186|  1.52M|            Enter(pszName, pszFile, nLine);
  187|  1.52M|    }
_Z13EnterCriticalINSt3__15mutexEEvPKcS3_iPT_b:
   67|  1.52M|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_Z13LeaveCriticalv:
   68|  1.52M|inline void LeaveCritical() {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEE5EnterEPKcS6_i:
  159|  1.52M|    {
  160|  1.52M|        EnterCritical(pszName, pszFile, nLine, Base::mutex());
  161|       |#ifdef DEBUG_LOCKCONTENTION
  162|       |        if (!Base::try_lock()) {
  163|       |            ContendedLock(pszName, pszFile, nLine, static_cast<Base&>(*this));
  164|       |        }
  165|       |#else
  166|  1.52M|        Base::lock();
  167|  1.52M|#endif
  168|  1.52M|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEED2Ev:
  201|  1.52M|    {
  202|  1.52M|        if (Base::owns_lock())
  ------------------
  |  Branch (202:13): [True: 1.52M, False: 0]
  ------------------
  203|  1.52M|            LeaveCritical();
  204|  1.52M|    }

_ZN18FuzzedDataProvider16PickValueInArrayI7NetworkLm7EEET_RKNSt3__15arrayIS2_XT0_EEE:
  310|    414|T FuzzedDataProvider::PickValueInArray(const std::array<T, size> &array) {
  311|    414|  static_assert(size > 0, "The array must be non empty.");
  312|    414|  return array[ConsumeIntegralInRange<size_t>(0, size - 1)];
  313|    414|}
_ZN18FuzzedDataProvider15ConsumeIntegralItEET_v:
  195|  6.02M|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  6.02M|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  6.02M|                                std::numeric_limits<T>::max());
  198|  6.02M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeItEET_S1_S1_:
  205|  6.02M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  6.02M|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|  6.02M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  6.02M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 6.02M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  6.02M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  6.02M|  uint64_t result = 0;
  215|  6.02M|  size_t offset = 0;
  216|       |
  217|  18.0M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 12.0M, False: 6.02M]
  |  Branch (217:43): [True: 12.0M, False: 0]
  ------------------
  218|  12.0M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 12.0M, False: 2.37k]
  ------------------
  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.0M|    --remaining_bytes_;
  226|  12.0M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  12.0M|    offset += CHAR_BIT;
  228|  12.0M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  6.02M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 6.02M, False: 0]
  ------------------
  232|  6.02M|    result = result % (range + 1);
  233|       |
  234|  6.02M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  6.02M|}
_ZN18FuzzedDataProvider15ConsumeIntegralImEET_v:
  195|  37.6k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  37.6k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  37.6k|                                std::numeric_limits<T>::max());
  198|  37.6k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIjEET_v:
  195|  5.12M|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  5.12M|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  5.12M|                                std::numeric_limits<T>::max());
  198|  5.12M|}
_ZN18FuzzedDataProviderC2EPKhm:
   37|  7.16k|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider11ConsumeBoolEv:
  289|  11.9M|inline bool FuzzedDataProvider::ConsumeBool() {
  290|  11.9M|  return 1 & ConsumeIntegral<uint8_t>();
  291|  11.9M|}
_ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v:
  195|  11.9M|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  11.9M|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  11.9M|                                std::numeric_limits<T>::max());
  198|  11.9M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_:
  205|  11.9M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  11.9M|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|  11.9M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  11.9M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 11.9M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  11.9M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  11.9M|  uint64_t result = 0;
  215|  11.9M|  size_t offset = 0;
  216|       |
  217|  23.7M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 11.9M, False: 11.8M]
  |  Branch (217:43): [True: 11.9M, False: 0]
  ------------------
  218|  11.9M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 11.8M, False: 81.5k]
  ------------------
  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|  11.8M|    --remaining_bytes_;
  226|  11.8M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  11.8M|    offset += CHAR_BIT;
  228|  11.8M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  11.9M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 11.9M, False: 0]
  ------------------
  232|  11.9M|    result = result % (range + 1);
  233|       |
  234|  11.9M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  11.9M|}
_ZN18FuzzedDataProvider20ConsumeBytesAsStringEm:
  137|  22.7k|inline std::string FuzzedDataProvider::ConsumeBytesAsString(size_t num_bytes) {
  138|  22.7k|  static_assert(sizeof(std::string::value_type) == sizeof(uint8_t),
  139|  22.7k|                "ConsumeBytesAsString cannot convert the data to a string.");
  140|       |
  141|  22.7k|  num_bytes = std::min(num_bytes, remaining_bytes_);
  142|  22.7k|  std::string result(
  143|  22.7k|      reinterpret_cast<const std::string::value_type *>(data_ptr_), num_bytes);
  144|  22.7k|  Advance(num_bytes);
  145|  22.7k|  return result;
  146|  22.7k|}
_ZN18FuzzedDataProvider16PickValueInArrayI12ServiceFlagsLm7EEET_RAT0__KS2_:
  304|  5.16M|T FuzzedDataProvider::PickValueInArray(const T (&array)[size]) {
  305|  5.16M|  static_assert(size > 0, "The array must be non empty.");
  306|  5.16M|  return array[ConsumeIntegralInRange<size_t>(0, size - 1)];
  307|  5.16M|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm:
  153|  10.2k|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.2k|  std::string result;
  161|       |
  162|       |  // Reserve the anticipated capacity to prevent several reallocations.
  163|  10.2k|  result.reserve(std::min(max_length, remaining_bytes_));
  164|  29.5M|  for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) {
  ------------------
  |  Branch (164:22): [True: 29.5M, False: 1.92k]
  |  Branch (164:40): [True: 29.5M, False: 28]
  ------------------
  165|  29.5M|    char next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  166|  29.5M|    Advance(1);
  167|  29.5M|    if (next == '\\' && remaining_bytes_ != 0) {
  ------------------
  |  Branch (167:9): [True: 9.18k, False: 29.5M]
  |  Branch (167:25): [True: 9.17k, False: 8]
  ------------------
  168|  9.17k|      next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  169|  9.17k|      Advance(1);
  170|  9.17k|      if (next != '\\')
  ------------------
  |  Branch (170:11): [True: 8.25k, False: 920]
  ------------------
  171|  8.25k|        break;
  172|  9.17k|    }
  173|  29.5M|    result += next;
  174|  29.5M|  }
  175|       |
  176|  10.2k|  result.shrink_to_fit();
  177|  10.2k|  return result;
  178|  10.2k|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEv:
  181|  10.2k|inline std::string FuzzedDataProvider::ConsumeRandomLengthString() {
  182|  10.2k|  return ConsumeRandomLengthString(remaining_bytes_);
  183|  10.2k|}
_ZN18FuzzedDataProvider14CopyAndAdvanceEPvm:
  338|  6.04M|                                               size_t num_bytes) {
  339|  6.04M|  std::memcpy(destination, data_ptr_, num_bytes);
  340|  6.04M|  Advance(num_bytes);
  341|  6.04M|}
_ZN18FuzzedDataProvider7AdvanceEm:
  343|  35.6M|inline void FuzzedDataProvider::Advance(size_t num_bytes) {
  344|  35.6M|  if (num_bytes > remaining_bytes_)
  ------------------
  |  Branch (344:7): [True: 0, False: 35.6M]
  ------------------
  345|      0|    abort();
  346|       |
  347|  35.6M|  data_ptr_ += num_bytes;
  348|  35.6M|  remaining_bytes_ -= num_bytes;
  349|  35.6M|}
_ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_:
  378|  29.5M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) {
  379|  29.5M|  static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types.");
  380|  29.5M|  static_assert(!std::numeric_limits<TU>::is_signed,
  381|  29.5M|                "Source type must be unsigned.");
  382|       |
  383|       |  if constexpr (std::numeric_limits<TS>::is_modulo)
  384|       |    return static_cast<TS>(value);
  385|       |
  386|       |  // Avoid using implementation-defined unsigned to signed conversions.
  387|       |  // To learn more, see https://stackoverflow.com/questions/13150449.
  388|  29.5M|  constexpr auto TS_max = static_cast<TU>(std::numeric_limits<TS>::max());
  389|  29.5M|  if (value <= TS_max) {
  ------------------
  |  Branch (389:7): [True: 23.6M, False: 5.94M]
  ------------------
  390|  23.6M|    return static_cast<TS>(value);
  391|  23.6M|  } else {
  392|  5.94M|    constexpr auto TS_min = std::numeric_limits<TS>::min();
  393|  5.94M|    return TS_min + static_cast<TS>(value - TS_min);
  394|  5.94M|  }
  395|  29.5M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_:
  205|  12.7M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  12.7M|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|  12.7M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  12.7M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 12.7M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  12.7M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  12.7M|  uint64_t result = 0;
  215|  12.7M|  size_t offset = 0;
  216|       |
  217|  25.6M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 25.6M, False: 35.5k]
  |  Branch (217:43): [True: 12.9M, False: 12.6M]
  ------------------
  218|  12.9M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 12.9M, False: 17.6k]
  ------------------
  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.9M|    --remaining_bytes_;
  226|  12.9M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  12.9M|    offset += CHAR_BIT;
  228|  12.9M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  12.7M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 12.6M, False: 37.6k]
  ------------------
  232|  12.6M|    result = result % (range + 1);
  233|       |
  234|  12.7M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  12.7M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_:
  205|  5.12M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  5.12M|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|  5.12M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  5.12M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 5.12M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  5.12M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  5.12M|  uint64_t result = 0;
  215|  5.12M|  size_t offset = 0;
  216|       |
  217|  25.6M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 20.4M, False: 5.12M]
  |  Branch (217:43): [True: 20.4M, False: 0]
  ------------------
  218|  20.4M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 20.4M, False: 2.29k]
  ------------------
  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|  20.4M|    --remaining_bytes_;
  226|  20.4M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  20.4M|    offset += CHAR_BIT;
  228|  20.4M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  5.12M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 5.12M, False: 0]
  ------------------
  232|  5.12M|    result = result % (range + 1);
  233|       |
  234|  5.12M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  5.12M|}
_ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEm:
  109|  6.04M|std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t num_bytes) {
  110|  6.04M|  num_bytes = std::min(num_bytes, remaining_bytes_);
  111|  6.04M|  return ConsumeBytes<T>(num_bytes, num_bytes);
  112|  6.04M|}
_ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEmm:
  352|  6.04M|std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t size, size_t num_bytes) {
  353|  6.04M|  static_assert(sizeof(T) == sizeof(uint8_t), "Incompatible data type.");
  354|       |
  355|       |  // The point of using the size-based constructor below is to increase the
  356|       |  // odds of having a vector object with capacity being equal to the length.
  357|       |  // That part is always implementation specific, but at least both libc++ and
  358|       |  // libstdc++ allocate the requested number of bytes in that constructor,
  359|       |  // which seems to be a natural choice for other implementations as well.
  360|       |  // To increase the odds even more, we also call |shrink_to_fit| below.
  361|  6.04M|  std::vector<T> result(size);
  362|  6.04M|  if (size == 0) {
  ------------------
  |  Branch (362:7): [True: 4.56k, False: 6.04M]
  ------------------
  363|  4.56k|    if (num_bytes != 0)
  ------------------
  |  Branch (363:9): [True: 0, False: 4.56k]
  ------------------
  364|      0|      abort();
  365|  4.56k|    return result;
  366|  4.56k|  }
  367|       |
  368|  6.04M|  CopyAndAdvance(result.data(), num_bytes);
  369|       |
  370|       |  // Even though |shrink_to_fit| is also implementation specific, we expect it
  371|       |  // to provide an additional assurance in case vector's constructor allocated
  372|       |  // a buffer which is larger than the actual amount of data we put inside it.
  373|  6.04M|  result.shrink_to_fit();
  374|  6.04M|  return result;
  375|  6.04M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIxEET_S1_S1_:
  205|   866k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|   866k|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|   866k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|   866k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 866k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|   866k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|   866k|  uint64_t result = 0;
  215|   866k|  size_t offset = 0;
  216|       |
  217|  4.31M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 4.31M, False: 0]
  |  Branch (217:43): [True: 3.45M, False: 862k]
  ------------------
  218|  3.45M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 3.45M, False: 3.72k]
  ------------------
  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.45M|    --remaining_bytes_;
  226|  3.45M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  3.45M|    offset += CHAR_BIT;
  228|  3.45M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|   866k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 866k, False: 0]
  ------------------
  232|   866k|    result = result % (range + 1);
  233|       |
  234|   866k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|   866k|}

_Z19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
  117|  7.16k|{
  118|  7.16k|    SeedRandomStateForTest(SeedRand::ZEROS);
  119|  7.16k|    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
  120|  7.16k|    FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
  121|  7.16k|    NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
  122|  7.16k|    auto addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio());
  123|  7.16k|    if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (123:9): [True: 3.04k, False: 4.12k]
  ------------------
  124|  3.04k|        const std::vector<uint8_t> serialized_data{ConsumeRandomLengthByteVector(fuzzed_data_provider)};
  125|  3.04k|        DataStream ds{serialized_data};
  126|  3.04k|        try {
  127|  3.04k|            ds >> *addr_man_ptr;
  128|  3.04k|        } catch (const std::ios_base::failure&) {
  129|  2.51k|            addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio());
  130|  2.51k|        }
  131|  3.04k|    }
  132|  7.16k|    AddrManDeterministic& addr_man = *addr_man_ptr;
  133|  1.44M|    LIMITED_WHILE (fuzzed_data_provider.ConsumeBool(), 10000) {
  ------------------
  |  |   23|  1.45M|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 1.44M, False: 7.15k]
  |  |  |  Branch (23:49): [True: 1.44M, False: 9]
  |  |  ------------------
  ------------------
  134|  1.44M|        CallOneOf(
  135|  1.44M|            fuzzed_data_provider,
  136|  1.44M|            [&] {
  137|  1.44M|                addr_man.ResolveCollisions();
  138|  1.44M|            },
  139|  1.44M|            [&] {
  140|  1.44M|                (void)addr_man.SelectTriedCollision();
  141|  1.44M|            },
  142|  1.44M|            [&] {
  143|  1.44M|                std::vector<CAddress> addresses;
  144|  1.44M|                LIMITED_WHILE (fuzzed_data_provider.ConsumeBool(), 10000) {
  145|  1.44M|                    addresses.push_back(ConsumeAddress(fuzzed_data_provider));
  146|  1.44M|                }
  147|  1.44M|                auto net_addr = ConsumeNetAddr(fuzzed_data_provider);
  148|  1.44M|                auto time_penalty = ConsumeDuration<std::chrono::seconds>(fuzzed_data_provider, /*min=*/0s, /*max=*/100000000s);
  149|  1.44M|                addr_man.Add(addresses, net_addr, time_penalty);
  150|  1.44M|            },
  151|  1.44M|            [&] {
  152|  1.44M|                auto addr = ConsumeService(fuzzed_data_provider);
  153|  1.44M|                auto time = ConsumeTime(fuzzed_data_provider);
  154|  1.44M|                addr_man.Good(addr, time);
  155|  1.44M|            },
  156|  1.44M|            [&] {
  157|  1.44M|                auto addr = ConsumeService(fuzzed_data_provider);
  158|  1.44M|                auto count_failure = fuzzed_data_provider.ConsumeBool();
  159|  1.44M|                auto time = ConsumeTime(fuzzed_data_provider);
  160|  1.44M|                addr_man.Attempt(addr, count_failure, time);
  161|  1.44M|            },
  162|  1.44M|            [&] {
  163|  1.44M|                auto addr = ConsumeService(fuzzed_data_provider);
  164|  1.44M|                auto time = ConsumeTime(fuzzed_data_provider);
  165|  1.44M|                addr_man.Connected(addr, time);
  166|  1.44M|            },
  167|  1.44M|            [&] {
  168|  1.44M|                auto addr = ConsumeService(fuzzed_data_provider);
  169|  1.44M|                auto n_services = ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS);
  170|  1.44M|                addr_man.SetServices(addr, n_services);
  171|  1.44M|            });
  172|  1.44M|    }
  173|  7.16k|    const AddrMan& const_addr_man{addr_man};
  174|  7.16k|    std::optional<Network> network;
  175|  7.16k|    if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (175:9): [True: 414, False: 6.75k]
  ------------------
  176|    414|        network = fuzzed_data_provider.PickValueInArray(ALL_NETWORKS);
  177|    414|    }
  178|  7.16k|    auto max_addresses = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096);
  179|  7.16k|    auto max_pct = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 100);
  180|  7.16k|    auto filtered = fuzzed_data_provider.ConsumeBool();
  181|  7.16k|    (void)const_addr_man.GetAddr(max_addresses, max_pct, network, filtered);
  182|       |
  183|  7.16k|    std::unordered_set<Network> nets;
  184|  50.1k|    for (const auto& net : ALL_NETWORKS) {
  ------------------
  |  Branch (184:26): [True: 50.1k, False: 7.16k]
  ------------------
  185|  50.1k|        if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (185:13): [True: 3.18k, False: 46.9k]
  ------------------
  186|  3.18k|            nets.insert(net);
  187|  3.18k|        }
  188|  50.1k|    }
  189|  7.16k|    (void)const_addr_man.Select(fuzzed_data_provider.ConsumeBool(), nets);
  190|       |
  191|  7.16k|    std::optional<bool> in_new;
  192|  7.16k|    if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (192:9): [True: 407, False: 6.76k]
  ------------------
  193|    407|        in_new = fuzzed_data_provider.ConsumeBool();
  194|    407|    }
  195|  7.16k|    (void)const_addr_man.Size(network, in_new);
  196|  7.16k|    DataStream data_stream{};
  197|  7.16k|    data_stream << const_addr_man;
  198|  7.16k|}
addrman.cpp:_ZN12_GLOBAL__N_113GetCheckRatioEv:
   32|  9.68k|{
   33|  9.68k|    return std::clamp<int32_t>(g_setup->m_node.args->GetIntArg("-checkaddrman", 0), 0, 1000000);
   34|  9.68k|}
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv:
  136|  44.5k|            [&] {
  137|  44.5k|                addr_man.ResolveCollisions();
  138|  44.5k|            },
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_1clEv:
  139|   460k|            [&] {
  140|   460k|                (void)addr_man.SelectTriedCollision();
  141|   460k|            },
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_2clEv:
  142|  38.6k|            [&] {
  143|  38.6k|                std::vector<CAddress> addresses;
  144|  5.12M|                LIMITED_WHILE (fuzzed_data_provider.ConsumeBool(), 10000) {
  ------------------
  |  |   23|  5.16M|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 5.12M, False: 38.5k]
  |  |  |  Branch (23:49): [True: 5.12M, False: 74]
  |  |  ------------------
  ------------------
  145|  5.12M|                    addresses.push_back(ConsumeAddress(fuzzed_data_provider));
  146|  5.12M|                }
  147|  38.6k|                auto net_addr = ConsumeNetAddr(fuzzed_data_provider);
  148|  38.6k|                auto time_penalty = ConsumeDuration<std::chrono::seconds>(fuzzed_data_provider, /*min=*/0s, /*max=*/100000000s);
  149|  38.6k|                addr_man.Add(addresses, net_addr, time_penalty);
  150|  38.6k|            },
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_3clEv:
  151|   767k|            [&] {
  152|   767k|                auto addr = ConsumeService(fuzzed_data_provider);
  153|   767k|                auto time = ConsumeTime(fuzzed_data_provider);
  154|   767k|                addr_man.Good(addr, time);
  155|   767k|            },
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_4clEv:
  156|  21.0k|            [&] {
  157|  21.0k|                auto addr = ConsumeService(fuzzed_data_provider);
  158|  21.0k|                auto count_failure = fuzzed_data_provider.ConsumeBool();
  159|  21.0k|                auto time = ConsumeTime(fuzzed_data_provider);
  160|  21.0k|                addr_man.Attempt(addr, count_failure, time);
  161|  21.0k|            },
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_5clEv:
  162|  31.7k|            [&] {
  163|  31.7k|                auto addr = ConsumeService(fuzzed_data_provider);
  164|  31.7k|                auto time = ConsumeTime(fuzzed_data_provider);
  165|  31.7k|                addr_man.Connected(addr, time);
  166|  31.7k|            },
addrman.cpp:_ZZ19addrman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_6clEv:
  167|  80.0k|            [&] {
  168|  80.0k|                auto addr = ConsumeService(fuzzed_data_provider);
  169|  80.0k|                auto n_services = ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS);
  170|  80.0k|                addr_man.SetServices(addr, n_services);
  171|  80.0k|            });

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

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

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_:
   38|  1.44M|{
   39|  1.44M|    constexpr size_t call_size{sizeof...(callables)};
   40|  1.44M|    static_assert(call_size >= 1);
   41|  1.44M|    const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
   42|       |
   43|  1.44M|    size_t i{0};
   44|  10.1M|    ((i++ == call_index ? callables() : void()), ...);
  ------------------
  |  Branch (44:7): [True: 44.5k, False: 1.39M]
  |  Branch (44:7): [True: 460k, False: 983k]
  |  Branch (44:7): [True: 38.6k, False: 1.40M]
  |  Branch (44:7): [True: 767k, False: 676k]
  |  Branch (44:7): [True: 21.0k, False: 1.42M]
  |  Branch (44:7): [True: 31.7k, False: 1.41M]
  |  Branch (44:7): [True: 80.0k, False: 1.36M]
  ------------------
   45|  1.44M|    return call_size;
   46|  1.44M|}
_Z29ConsumeRandomLengthByteVectorISt4byteENSt3__16vectorIT_NS1_9allocatorIS3_EEEER18FuzzedDataProviderRKNS1_8optionalImEE:
   64|  7.16k|{
   65|  7.16k|    static_assert(sizeof(B) == 1);
   66|  7.16k|    const std::string s = max_length ?
  ------------------
  |  Branch (66:27): [True: 0, False: 7.16k]
  ------------------
   67|      0|                              fuzzed_data_provider.ConsumeRandomLengthString(*max_length) :
   68|  7.16k|                              fuzzed_data_provider.ConsumeRandomLengthString();
   69|  7.16k|    std::vector<B> ret(s.size());
   70|  7.16k|    std::copy(s.begin(), s.end(), reinterpret_cast<char*>(ret.data()));
   71|  7.16k|    return ret;
   72|  7.16k|}
_Z15ConsumeWeakEnumI12ServiceFlagsLm7EET_R18FuzzedDataProviderRAT0__KS1_:
  148|  5.20M|{
  149|  5.20M|    return fuzzed_data_provider.ConsumeBool() ?
  ------------------
  |  Branch (149:12): [True: 5.16M, False: 37.6k]
  ------------------
  150|  5.16M|               fuzzed_data_provider.PickValueInArray<WeakEnumType>(all_types) :
  151|  5.20M|               WeakEnumType(fuzzed_data_provider.ConsumeIntegral<std::underlying_type_t<WeakEnumType>>());
  152|  5.20M|}
_Z14ConsumeUInt256R18FuzzedDataProvider:
  196|  9.68k|{
  197|  9.68k|    const std::vector<uint8_t> v256 = fuzzed_data_provider.ConsumeBytes<uint8_t>(256 / 8);
  198|  9.68k|    if (v256.size() != 256 / 8) {
  ------------------
  |  Branch (198:9): [True: 1.56k, False: 8.11k]
  ------------------
  199|  1.56k|        return {};
  200|  1.56k|    }
  201|  8.11k|    return uint256{v256};
  202|  9.68k|}
_Z29ConsumeRandomLengthByteVectorIhENSt3__16vectorIT_NS0_9allocatorIS2_EEEER18FuzzedDataProviderRKNS0_8optionalImEE:
   64|  3.04k|{
   65|  3.04k|    static_assert(sizeof(B) == 1);
   66|  3.04k|    const std::string s = max_length ?
  ------------------
  |  Branch (66:27): [True: 0, False: 3.04k]
  ------------------
   67|      0|                              fuzzed_data_provider.ConsumeRandomLengthString(*max_length) :
   68|  3.04k|                              fuzzed_data_provider.ConsumeRandomLengthString();
   69|  3.04k|    std::vector<B> ret(s.size());
   70|  3.04k|    std::copy(s.begin(), s.end(), reinterpret_cast<char*>(ret.data()));
   71|  3.04k|    return ret;
   72|  3.04k|}
_Z15ConsumeDurationINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEEET_R18FuzzedDataProviderNS0_11common_typeIJS6_EE4typeESB_:
  169|   866k|{
  170|   866k|    return Dur{fuzzed_data_provider.ConsumeIntegralInRange(min.count(), max.count())};
  171|   866k|}

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

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

_Z22ConsumeNetGroupManagerR18FuzzedDataProvider:
  237|  7.16k|{
  238|  7.16k|    std::vector<std::byte> asmap{ConsumeRandomLengthByteVector<std::byte>(fuzzed_data_provider)};
  239|  7.16k|    if (!CheckStandardAsmap(asmap)) {
  ------------------
  |  Branch (239:9): [True: 5.00k, False: 2.16k]
  ------------------
  240|  5.00k|        return NetGroupManager::NoAsmap();
  241|  5.00k|    }
  242|  2.16k|    return NetGroupManager::WithLoadedAsmap(std::move(asmap));
  243|  7.16k|}
_ZN20AddrManDeterministicC2ERK15NetGroupManagerR18FuzzedDataProvideri:
   46|  9.68k|        : AddrMan(netgroupman, /*deterministic=*/true, check_ratio)
   47|  9.68k|    {
   48|  9.68k|        WITH_LOCK(m_impl->cs, m_impl->insecure_rand.Reseed(ConsumeUInt256(fuzzed_data_provider)));
  ------------------
  |  |  299|  9.68k|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
  ------------------
   49|  9.68k|    }
_Z14ConsumeServiceR18FuzzedDataProvider:
  251|  6.02M|{
  252|  6.02M|    return {ConsumeNetAddr(fuzzed_data_provider), fuzzed_data_provider.ConsumeIntegral<uint16_t>()};
  253|  6.02M|}

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

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

_ZN17BasicTestingSetupD2Ev:
  252|      2|{
  253|      2|    m_node.ecc_context.reset();
  254|      2|    m_node.kernel.reset();
  255|      2|    if (!EnableFuzzDeterminism()) {
  ------------------
  |  Branch (255:9): [True: 0, False: 2]
  ------------------
  256|      0|        SetMockTime(0s); // Reset mocktime for following tests
  257|      0|    }
  258|      2|    LogInstance().DisconnectTestLogger();
  259|      2|    if (m_has_custom_datadir) {
  ------------------
  |  Branch (259:9): [True: 0, False: 2]
  ------------------
  260|       |        // Only remove the lock file, preserve the data directory.
  261|      0|        UnlockDirectory(m_path_lock, ".lock");
  262|      0|        fs::remove(m_path_lock / ".lock");
  263|      2|    } else {
  264|      2|        fs::remove_all(m_path_root);
  265|      2|    }
  266|       |    // Clear all arguments except for -datadir, which GUI tests currently rely
  267|       |    // on to be set even after the testing setup is destroyed.
  268|      2|    gArgs.ClearArgs();
  269|      2|    gArgs.ForceSetArg("-datadir", fs::PathToString(m_path_root));
  270|      2|}

_ZN13FakeNodeClockC2ENSt3__16chrono10time_pointI9NodeClockNS1_8durationIxNS0_5ratioILl1ELl1EEEEEEE:
   59|  7.16k|    explicit FakeNodeClock(NodeSeconds init_time) { set(init_time); }
_ZN8LimitOneI13FakeNodeClockEC2Ev:
   16|  7.16k|    LimitOne() { Assert(g_T_available) = false; }
  ------------------
  |  |  116|  7.16k|#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
  ------------------
_ZN13FakeNodeClock3setENSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEE:
   72|  7.16k|    void set(std::chrono::seconds t) { set(NodeSeconds{t}); }
_ZN8LimitOneI13FakeNodeClockED2Ev:
   17|  7.16k|    ~LimitOne() { g_T_available = true; }
_ZN13FakeNodeClockD2Ev:
   65|  7.16k|    ~FakeNodeClock() { set(0s); }
_ZN13FakeNodeClock3setENSt3__16chrono10time_pointI9NodeClockNS1_8durationIxNS0_5ratioILl1ELl1EEEEEEE:
   71|  14.3k|    void set(NodeSeconds t) { SetMockTime(m_t = t); }

_ZN10tinyformat6formatIJiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    151|{
 1089|    151|    std::ostringstream oss;
 1090|    151|    format(oss, fmt, args...);
 1091|    151|    return oss.str();
 1092|    151|}
_ZN10tinyformat6formatIJiEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    151|{
 1081|    151|    vformat(out, fmt, makeFormatList(args...));
 1082|    151|}
_ZN10tinyformat14makeFormatListIJiEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    151|{
 1045|    151|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    151|}
_ZN10tinyformat6formatIJEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  5.00k|{
 1089|  5.00k|    std::ostringstream oss;
 1090|  5.00k|    format(oss, fmt, args...);
 1091|  5.00k|    return oss.str();
 1092|  5.00k|}
_ZN10tinyformat6formatIJEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  5.00k|{
 1081|  5.00k|    vformat(out, fmt, makeFormatList(args...));
 1082|  5.00k|}
_ZN10tinyformat14makeFormatListIJEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  5.00k|{
 1045|  5.00k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  5.00k|}
_ZN10tinyformat17FormatStringCheckILj0EEcvPKcEv:
  197|  5.00k|    operator const char*() { return fmt; }
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    676|{
 1089|    676|    std::ostringstream oss;
 1090|    676|    format(oss, fmt, args...);
 1091|    676|    return oss.str();
 1092|    676|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    676|{
 1081|    676|    vformat(out, fmt, makeFormatList(args...));
 1082|    676|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    676|{
 1045|    676|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    676|}
_ZN10tinyformat6formatIJiimEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    676|{
 1089|    676|    std::ostringstream oss;
 1090|    676|    format(oss, fmt, args...);
 1091|    676|    return oss.str();
 1092|    676|}
_ZN10tinyformat6formatIJiimEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    676|{
 1081|    676|    vformat(out, fmt, makeFormatList(args...));
 1082|    676|}
_ZN10tinyformat14makeFormatListIJiimEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    676|{
 1045|    676|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    676|}
_ZN10tinyformat6detail11FormatListNILi3EEC2IJiimEEEDpRKT_:
  990|    676|            : FormatList(&m_formatterStore[0], N),
  991|    676|            m_formatterStore { FormatArg(args)... }
  992|    676|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJhhEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    628|{
 1089|    628|    std::ostringstream oss;
 1090|    628|    format(oss, fmt, args...);
 1091|    628|    return oss.str();
 1092|    628|}
_ZN10tinyformat6formatIJhhEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    628|{
 1081|    628|    vformat(out, fmt, makeFormatList(args...));
 1082|    628|}
_ZN10tinyformat14makeFormatListIJhhEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    628|{
 1045|    628|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    628|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJhhEEEDpRKT_:
  990|    628|            : FormatList(&m_formatterStore[0], N),
  991|    628|            m_formatterStore { FormatArg(args)... }
  992|    628|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJhhA13_chEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    398|{
 1089|    398|    std::ostringstream oss;
 1090|    398|    format(oss, fmt, args...);
 1091|    398|    return oss.str();
 1092|    398|}
_ZN10tinyformat6formatIJhhA13_chEEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    398|{
 1081|    398|    vformat(out, fmt, makeFormatList(args...));
 1082|    398|}
_ZN10tinyformat14makeFormatListIJhhA13_chEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    398|{
 1045|    398|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    398|}
_ZN10tinyformat6detail11FormatListNILi4EEC2IJhhA13_chEEEDpRKT_:
  990|    398|            : FormatList(&m_formatterStore[0], N),
  991|    398|            m_formatterStore { FormatArg(args)... }
  992|    398|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2IhEERKT_:
  534|  2.45k|            : m_value(static_cast<const void*>(&value)),
  535|  2.45k|            m_formatImpl(&formatImpl<T>),
  536|  2.45k|            m_toIntImpl(&toIntImpl<T>)
  537|  2.45k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIhEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  2.45k|        {
  559|  2.45k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  2.45k|        }
_ZN10tinyformat11formatValueERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcS7_ih:
  385|  2.45k|                        const char* fmtEnd, int /**/, charType value) \
  386|  2.45k|{                                                                     \
  387|  2.45k|    switch (*(fmtEnd-1)) {                                            \
  388|  2.45k|        case 'u': case 'd': case 'i': case 'o': case 'X': case 'x':   \
  ------------------
  |  Branch (388:9): [True: 2.45k, False: 0]
  |  Branch (388:19): [True: 0, False: 2.45k]
  |  Branch (388:29): [True: 0, False: 2.45k]
  |  Branch (388:39): [True: 0, False: 2.45k]
  |  Branch (388:49): [True: 0, False: 2.45k]
  |  Branch (388:59): [True: 0, False: 2.45k]
  ------------------
  389|  2.45k|            out << static_cast<int>(value); break;                    \
  390|  2.45k|        default:                                                      \
  ------------------
  |  Branch (390:9): [True: 0, False: 2.45k]
  ------------------
  391|      0|            out << value;                   break;                    \
  392|  2.45k|    }                                                                 \
  393|  2.45k|}
_ZN10tinyformat6formatIJPKcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEES9_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  7.16k|{
 1089|  7.16k|    std::ostringstream oss;
 1090|  7.16k|    format(oss, fmt, args...);
 1091|  7.16k|    return oss.str();
 1092|  7.16k|}
_ZN10tinyformat6formatIJPKcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEvRNS3_13basic_ostreamIcS6_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  7.16k|{
 1081|  7.16k|    vformat(out, fmt, makeFormatList(args...));
 1082|  7.16k|}
_ZN10tinyformat14makeFormatListIJPKcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  7.16k|{
 1045|  7.16k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  7.16k|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJPKcNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEEDpRKT_:
  990|  7.16k|            : FormatList(&m_formatterStore[0], N),
  991|  7.16k|            m_formatterStore { FormatArg(args)... }
  992|  7.16k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat17FormatStringCheckILj2EEcvPKcEv:
  197|  8.66k|    operator const char*() { return fmt; }
_ZN10tinyformat6formatIJmmEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|     94|{
 1089|     94|    std::ostringstream oss;
 1090|     94|    format(oss, fmt, args...);
 1091|     94|    return oss.str();
 1092|     94|}
_ZN10tinyformat6formatIJmmEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|     94|{
 1081|     94|    vformat(out, fmt, makeFormatList(args...));
 1082|     94|}
_ZN10tinyformat14makeFormatListIJmmEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|     94|{
 1045|     94|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|     94|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJmmEEEDpRKT_:
  990|     94|            : FormatList(&m_formatterStore[0], N),
  991|     94|            m_formatterStore { FormatArg(args)... }
  992|     94|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArg10formatImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRNS3_13basic_ostreamIcS6_EEPKcSE_iPKv:
  558|  10.5k|        {
  559|  10.5k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  10.5k|        }
_ZN10tinyformat11formatValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRNS1_13basic_ostreamIcS4_EEPKcSC_iRKT_:
  351|  10.5k|{
  352|  10.5k|#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|  10.5k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  10.5k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  10.5k|#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|  10.5k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  10.5k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  10.5k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded, False: 10.5k]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  10.5k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded, False: 10.5k]
  |  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|  10.5k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 10.5k]
  ------------------
  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|  10.5k|    else
  378|  10.5k|        out << value;
  379|  10.5k|}
_ZN10tinyformat6detail9FormatArgC2IPKcEERKT_:
  534|  7.16k|            : m_value(static_cast<const void*>(&value)),
  535|  7.16k|            m_formatImpl(&formatImpl<T>),
  536|  7.16k|            m_toIntImpl(&toIntImpl<T>)
  537|  7.16k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIPKcEEvRNSt3__113basic_ostreamIcNS5_11char_traitsIcEEEES4_S4_iPKv:
  558|  7.16k|        {
  559|  7.16k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  7.16k|        }
_ZN10tinyformat11formatValueIPKcEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEES2_S2_iRKT_:
  351|  7.16k|{
  352|  7.16k|#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|  7.16k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  7.16k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  7.16k|#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|  7.16k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  7.16k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  7.16k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded, False: 7.16k]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  7.16k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [True: 7.16k, Folded]
  |  Branch (367:37): [True: 0, False: 7.16k]
  ------------------
  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|  7.16k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 7.16k]
  ------------------
  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|  7.16k|    else
  378|  7.16k|        out << value;
  379|  7.16k|}
_ZN10tinyformat6detail9FormatArgC2IdEERKT_:
  534|    676|            : m_value(static_cast<const void*>(&value)),
  535|    676|            m_formatImpl(&formatImpl<T>),
  536|    676|            m_toIntImpl(&toIntImpl<T>)
  537|    676|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIdEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|    676|        {
  559|    676|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|    676|        }
_ZN10tinyformat11formatValueIdEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|    676|{
  352|    676|#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|    676|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|    676|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|    676|#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|    676|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|    676|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|    676|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [True: 676, Folded]
  |  Branch (365:29): [True: 0, False: 676]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|    676|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded, False: 676]
  |  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|    676|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 676]
  ------------------
  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|    676|    else
  378|    676|        out << value;
  379|    676|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_dEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    676|{
 1089|    676|    std::ostringstream oss;
 1090|    676|    format(oss, fmt, args...);
 1091|    676|    return oss.str();
 1092|    676|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_dEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    676|{
 1081|    676|    vformat(out, fmt, makeFormatList(args...));
 1082|    676|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_dEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    676|{
 1045|    676|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    676|}
_ZN10tinyformat6detail11FormatListNILi3EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEESA_dEEEDpRKT_:
  990|    676|            : FormatList(&m_formatterStore[0], N),
  991|    676|            m_formatterStore { FormatArg(args)... }
  992|    676|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail11FormatListNILi1EEC2IJiEEEDpRKT_:
  990|    151|            : FormatList(&m_formatterStore[0], N),
  991|    151|            m_formatterStore { FormatArg(args)... }
  992|    151|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJiiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|     96|{
 1089|     96|    std::ostringstream oss;
 1090|     96|    format(oss, fmt, args...);
 1091|     96|    return oss.str();
 1092|     96|}
_ZN10tinyformat6formatIJiiEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|     96|{
 1081|     96|    vformat(out, fmt, makeFormatList(args...));
 1082|     96|}
_ZN10tinyformat14makeFormatListIJiiEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|     96|{
 1045|     96|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|     96|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJiiEEEDpRKT_:
  990|     96|            : FormatList(&m_formatterStore[0], N),
  991|     96|            m_formatterStore { FormatArg(args)... }
  992|     96|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    676|{
 1089|    676|    std::ostringstream oss;
 1090|    676|    format(oss, fmt, args...);
 1091|    676|    return oss.str();
 1092|    676|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    676|{
 1081|    676|    vformat(out, fmt, makeFormatList(args...));
 1082|    676|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    676|{
 1045|    676|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    676|}
_ZN10tinyformat17FormatStringCheckILj1EEcvPKcEv:
  197|    827|    operator const char*() { return fmt; }
_ZN10tinyformat17FormatStringCheckILj4EEcvPKcEv:
  197|    398|    operator const char*() { return fmt; }
_ZN10tinyformat6detail9FormatArgC2IA13_cEERKT_:
  534|    398|            : m_value(static_cast<const void*>(&value)),
  535|    398|            m_formatImpl(&formatImpl<T>),
  536|    398|            m_toIntImpl(&toIntImpl<T>)
  537|    398|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIA13_cEEvRNSt3__113basic_ostreamIcNS4_11char_traitsIcEEEEPKcSB_iPKv:
  558|    398|        {
  559|    398|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|    398|        }
_ZN10tinyformat11formatValueIA13_cEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_iRKT_:
  351|    398|{
  352|    398|#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|    398|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|    398|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|    398|#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|    398|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|    398|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|    398|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded, False: 398]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|    398|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [True: 398, Folded]
  |  Branch (367:37): [True: 0, False: 398]
  ------------------
  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|    398|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 398]
  ------------------
  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|    398|    else
  378|    398|        out << value;
  379|    398|}
_ZN10tinyformat17FormatStringCheckILj2EEC2EN4util21ConstevalFormatStringILj2EEE:
  196|  7.16k|    FormatStringCheck(util::ConstevalFormatString<num_params> str) : fmt{str.fmt} {}
_ZNK10tinyformat6detail9FormatArg6formatERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_i:
  541|  23.7k|        {
  542|  23.7k|            TINYFORMAT_ASSERT(m_value);
  ------------------
  |  |  153|  23.7k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  |  Branch (542:13): [True: 23.7k, False: 0]
  ------------------
  543|  23.7k|            TINYFORMAT_ASSERT(m_formatImpl);
  ------------------
  |  |  153|  23.7k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  |  Branch (543:13): [True: 23.7k, False: 0]
  ------------------
  544|  23.7k|            m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
  545|  23.7k|        }
_ZN10tinyformat10FormatListC2EPNS_6detail9FormatArgEi:
  966|  16.2k|            : m_args(args), m_N(N) { }
_ZN10tinyformat6detail18parseIntAndAdvanceERPKc:
  578|    676|{
  579|    676|    int i = 0;
  580|  1.35k|    for (;*c >= '0' && *c <= '9'; ++c)
  ------------------
  |  Branch (580:11): [True: 1.35k, False: 0]
  |  Branch (580:24): [True: 676, False: 676]
  ------------------
  581|    676|        i = 10*i + (*c - '0');
  582|    676|    return i;
  583|    676|}
_ZN10tinyformat6detail21parseWidthOrPrecisionERiRPKcbPKNS0_9FormatArgES1_i:
  593|  24.4k|{
  594|  24.4k|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (594:9): [True: 23.7k, False: 676]
  |  Branch (594:22): [True: 676, False: 23.1k]
  ------------------
  595|    676|        n = parseIntAndAdvance(c);
  596|    676|    }
  597|  23.7k|    else if (*c == '*') {
  ------------------
  |  Branch (597:14): [True: 0, False: 23.7k]
  ------------------
  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|  23.7k|    else {
  618|  23.7k|        return false;
  619|  23.7k|    }
  620|    676|    return true;
  621|  24.4k|}
_ZN10tinyformat6detail24printFormatStringLiteralERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKc:
  629|  40.0k|{
  630|  40.0k|    const char* c = fmt;
  631|   665k|    for (;; ++c) {
  632|   665k|        if (*c == '\0') {
  ------------------
  |  Branch (632:13): [True: 16.2k, False: 649k]
  ------------------
  633|  16.2k|            out.write(fmt, c - fmt);
  634|  16.2k|            return c;
  635|  16.2k|        }
  636|   649k|        else if (*c == '%') {
  ------------------
  |  Branch (636:18): [True: 23.7k, False: 625k]
  ------------------
  637|  23.7k|            out.write(fmt, c - fmt);
  638|  23.7k|            if (*(c+1) != '%')
  ------------------
  |  Branch (638:17): [True: 23.7k, False: 0]
  ------------------
  639|  23.7k|                return c;
  640|       |            // for "%%", tack trailing % onto next literal section.
  641|      0|            fmt = ++c;
  642|      0|        }
  643|   665k|    }
  644|  40.0k|}
_ZN10tinyformat6detail21streamStateFromFormatERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERbS7_RiPKcPKNS0_9FormatArgES8_i:
  685|  23.7k|{
  686|  23.7k|    TINYFORMAT_ASSERT(*fmtStart == '%');
  ------------------
  |  |  153|  23.7k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  |  Branch (686:5): [True: 23.7k, False: 0]
  ------------------
  687|       |    // Reset stream state to defaults.
  688|  23.7k|    out.width(0);
  689|  23.7k|    out.precision(6);
  690|  23.7k|    out.fill(' ');
  691|       |    // Reset most flags; ignore irrelevant unitbuf & skipws.
  692|  23.7k|    out.unsetf(std::ios::adjustfield | std::ios::basefield |
  693|  23.7k|               std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
  694|  23.7k|               std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
  695|  23.7k|    bool precisionSet = false;
  696|  23.7k|    bool widthSet = false;
  697|  23.7k|    int widthExtra = 0;
  698|  23.7k|    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|  23.7k|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (702:9): [True: 23.1k, False: 676]
  |  Branch (702:22): [True: 0, False: 23.1k]
  ------------------
  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|  23.7k|    else if (positionalMode) {
  ------------------
  |  Branch (731:14): [True: 0, False: 23.7k]
  ------------------
  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|  23.7k|    if (!widthSet) {
  ------------------
  |  Branch (735:9): [True: 23.7k, False: 0]
  ------------------
  736|       |        // Parse flags
  737|  23.7k|        for (;; ++c) {
  738|  23.7k|            switch (*c) {
  739|      0|                case '#':
  ------------------
  |  Branch (739:17): [True: 0, False: 23.7k]
  ------------------
  740|      0|                    out.setf(std::ios::showpoint | std::ios::showbase);
  741|      0|                    continue;
  742|      0|                case '0':
  ------------------
  |  Branch (742:17): [True: 0, False: 23.7k]
  ------------------
  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: 23.7k]
  ------------------
  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: 23.7k]
  ------------------
  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: 23.7k]
  ------------------
  761|      0|                    out.setf(std::ios::showpos);
  762|      0|                    spacePadPositive = false;
  763|      0|                    widthExtra = 1;
  764|      0|                    continue;
  765|  23.7k|                default:
  ------------------
  |  Branch (765:17): [True: 23.7k, False: 0]
  ------------------
  766|  23.7k|                    break;
  767|  23.7k|            }
  768|  23.7k|            break;
  769|  23.7k|        }
  770|       |        // Parse width
  771|  23.7k|        int width = 0;
  772|  23.7k|        widthSet = parseWidthOrPrecision(width, c, positionalMode,
  773|  23.7k|                                         args, argIndex, numArgs);
  774|  23.7k|        if (widthSet) {
  ------------------
  |  Branch (774:13): [True: 0, False: 23.7k]
  ------------------
  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|  23.7k|    }
  784|       |    // 3) Parse precision
  785|  23.7k|    if (*c == '.') {
  ------------------
  |  Branch (785:9): [True: 676, False: 23.1k]
  ------------------
  786|    676|        ++c;
  787|    676|        int precision = 0;
  788|    676|        parseWidthOrPrecision(precision, c, positionalMode,
  789|    676|                              args, argIndex, numArgs);
  790|       |        // Presence of `.` indicates precision set, unless the inferred value
  791|       |        // was negative in which case the default is used.
  792|    676|        precisionSet = precision >= 0;
  793|    676|        if (precisionSet)
  ------------------
  |  Branch (793:13): [True: 676, False: 0]
  ------------------
  794|    676|            out.precision(precision);
  795|    676|    }
  796|       |    // 4) Ignore any C99 length modifier
  797|  23.7k|    while (*c == 'l' || *c == 'h' || *c == 'L' ||
  ------------------
  |  Branch (797:12): [True: 0, False: 23.7k]
  |  Branch (797:25): [True: 0, False: 23.7k]
  |  Branch (797:38): [True: 0, False: 23.7k]
  ------------------
  798|  23.7k|           *c == 'j' || *c == 'z' || *c == 't') {
  ------------------
  |  Branch (798:12): [True: 0, False: 23.7k]
  |  Branch (798:25): [True: 0, False: 23.7k]
  |  Branch (798:38): [True: 0, False: 23.7k]
  ------------------
  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|  23.7k|    bool intConversion = false;
  805|  23.7k|    switch (*c) {
  806|  4.85k|        case 'u': case 'd': case 'i':
  ------------------
  |  Branch (806:9): [True: 3.31k, False: 20.4k]
  |  Branch (806:19): [True: 192, False: 23.6k]
  |  Branch (806:29): [True: 1.35k, False: 22.4k]
  ------------------
  807|  4.85k|            out.setf(std::ios::dec, std::ios::basefield);
  808|  4.85k|            intConversion = true;
  809|  4.85k|            break;
  810|      0|        case 'o':
  ------------------
  |  Branch (810:9): [True: 0, False: 23.7k]
  ------------------
  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: 23.7k]
  ------------------
  815|      0|            out.setf(std::ios::uppercase);
  816|      0|            [[fallthrough]];
  817|      0|        case 'x': case 'p':
  ------------------
  |  Branch (817:9): [True: 0, False: 23.7k]
  |  Branch (817:19): [True: 0, False: 23.7k]
  ------------------
  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: 23.7k]
  ------------------
  822|      0|            out.setf(std::ios::uppercase);
  823|      0|            [[fallthrough]];
  824|      0|        case 'e':
  ------------------
  |  Branch (824:9): [True: 0, False: 23.7k]
  ------------------
  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: 23.7k]
  ------------------
  829|      0|            out.setf(std::ios::uppercase);
  830|      0|            [[fallthrough]];
  831|    676|        case 'f':
  ------------------
  |  Branch (831:9): [True: 676, False: 23.1k]
  ------------------
  832|    676|            out.setf(std::ios::fixed, std::ios::floatfield);
  833|    676|            break;
  834|      0|        case 'A':
  ------------------
  |  Branch (834:9): [True: 0, False: 23.7k]
  ------------------
  835|      0|            out.setf(std::ios::uppercase);
  836|      0|            [[fallthrough]];
  837|      0|        case 'a':
  ------------------
  |  Branch (837:9): [True: 0, False: 23.7k]
  ------------------
  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: 23.7k]
  ------------------
  847|      0|            out.setf(std::ios::uppercase);
  848|      0|            [[fallthrough]];
  849|      0|        case 'g':
  ------------------
  |  Branch (849:9): [True: 0, False: 23.7k]
  ------------------
  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: 23.7k]
  ------------------
  855|       |            // Handled as special case inside formatValue()
  856|      0|            break;
  857|  18.2k|        case 's':
  ------------------
  |  Branch (857:9): [True: 18.2k, False: 5.53k]
  ------------------
  858|  18.2k|            if (precisionSet)
  ------------------
  |  Branch (858:17): [True: 0, False: 18.2k]
  ------------------
  859|      0|                ntrunc = static_cast<int>(out.precision());
  860|       |            // Make %s print Booleans as "true" and "false"
  861|  18.2k|            out.setf(std::ios::boolalpha);
  862|  18.2k|            break;
  863|      0|        case 'n':
  ------------------
  |  Branch (863:9): [True: 0, False: 23.7k]
  ------------------
  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: 23.7k]
  ------------------
  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: 23.7k]
  ------------------
  872|      0|            break;
  873|  23.7k|    }
  874|  23.7k|    if (intConversion && precisionSet && !widthSet) {
  ------------------
  |  Branch (874:9): [True: 4.85k, False: 18.9k]
  |  Branch (874:26): [True: 0, False: 4.85k]
  |  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|  23.7k|    return c+1;
  884|  23.7k|}
_ZN10tinyformat6detail10formatImplERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcPKNS0_9FormatArgEi:
  891|  16.2k|{
  892|       |    // Saved stream state
  893|  16.2k|    std::streamsize origWidth = out.width();
  894|  16.2k|    std::streamsize origPrecision = out.precision();
  895|  16.2k|    std::ios::fmtflags origFlags = out.flags();
  896|  16.2k|    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|  16.2k|    bool positionalMode = false;
  901|  16.2k|    int argIndex = 0;
  902|  40.0k|    while (true) {
  ------------------
  |  Branch (902:12): [True: 40.0k, Folded]
  ------------------
  903|  40.0k|        fmt = printFormatStringLiteral(out, fmt);
  904|  40.0k|        if (*fmt == '\0') {
  ------------------
  |  Branch (904:13): [True: 16.2k, False: 23.7k]
  ------------------
  905|  16.2k|            if (!positionalMode && argIndex < numArgs) {
  ------------------
  |  Branch (905:17): [True: 16.2k, False: 0]
  |  Branch (905:36): [True: 0, False: 16.2k]
  ------------------
  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|  16.2k|            break;
  909|  16.2k|        }
  910|  23.7k|        bool spacePadPositive = false;
  911|  23.7k|        int ntrunc = -1;
  912|  23.7k|        const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt,
  913|  23.7k|                                                   args, argIndex, numArgs);
  914|       |        // NB: argIndex may be incremented by reading variable width/precision
  915|       |        // in `streamStateFromFormat`, so do the bounds check here.
  916|  23.7k|        if (argIndex >= numArgs) {
  ------------------
  |  Branch (916:13): [True: 0, False: 23.7k]
  ------------------
  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|  23.7k|        const FormatArg& arg = args[argIndex];
  921|       |        // Format the arg into the stream.
  922|  23.7k|        if (!spacePadPositive) {
  ------------------
  |  Branch (922:13): [True: 23.7k, False: 0]
  ------------------
  923|  23.7k|            arg.format(out, fmt, fmtEnd, ntrunc);
  924|  23.7k|        }
  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|  23.7k|        if (!positionalMode)
  ------------------
  |  Branch (941:13): [True: 23.7k, False: 0]
  ------------------
  942|  23.7k|            ++argIndex;
  943|  23.7k|        fmt = fmtEnd;
  944|  23.7k|    }
  945|       |
  946|       |    // Restore stream state
  947|  16.2k|    out.width(origWidth);
  948|  16.2k|    out.precision(origPrecision);
  949|  16.2k|    out.flags(origFlags);
  950|  16.2k|    out.fill(origFill);
  951|  16.2k|}
_ZN10tinyformat7vformatERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcRKNS_10FormatListE:
 1070|  16.2k|{
 1071|  16.2k|    detail::formatImpl(out, fmt, list.m_args, list.m_N);
 1072|  16.2k|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEESA_EEEDpRKT_:
  990|    676|            : FormatList(&m_formatterStore[0], N),
  991|    676|            m_formatterStore { FormatArg(args)... }
  992|    676|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail11FormatListNILi0EEC2Ev:
 1025|  5.00k|    FormatListN() : FormatList(nullptr, 0) {}
_ZN10tinyformat17FormatStringCheckILj0EEC2EN4util21ConstevalFormatStringILj0EEE:
  196|  5.00k|    FormatStringCheck(util::ConstevalFormatString<num_params> str) : fmt{str.fmt} {}
_ZN10tinyformat6detail9FormatArg10formatImplImEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|    864|        {
  559|    864|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|    864|        }
_ZN10tinyformat11formatValueImEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|    864|{
  352|    864|#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|    864|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|    864|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|    864|#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|    864|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|    864|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|    864|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [True: 864, Folded]
  |  Branch (365:29): [True: 0, False: 864]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|    864|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded, False: 864]
  |  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|    864|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 864]
  ------------------
  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|    864|    else
  378|    864|        out << value;
  379|    864|}
_ZN10tinyformat6detail9FormatArg10formatImplIiEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  1.69k|        {
  559|  1.69k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  1.69k|        }
_ZN10tinyformat11formatValueIiEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|  1.69k|{
  352|  1.69k|#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.69k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  1.69k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  1.69k|#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.69k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  1.69k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  1.69k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [True: 1.69k, Folded]
  |  Branch (365:29): [True: 0, False: 1.69k]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  1.69k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded, False: 1.69k]
  |  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.69k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 1.69k]
  ------------------
  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.69k|    else
  378|  1.69k|        out << value;
  379|  1.69k|}
_ZN10tinyformat17FormatStringCheckILj3EEcvPKcEv:
  197|  1.35k|    operator const char*() { return fmt; }
_ZN10tinyformat6detail9FormatArgC2IiEERKT_:
  534|  1.69k|            : m_value(static_cast<const void*>(&value)),
  535|  1.69k|            m_formatImpl(&formatImpl<T>),
  536|  1.69k|            m_toIntImpl(&toIntImpl<T>)
  537|  1.69k|        { }
_ZN10tinyformat6detail9FormatArgC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_:
  534|  10.5k|            : m_value(static_cast<const void*>(&value)),
  535|  10.5k|            m_formatImpl(&formatImpl<T>),
  536|  10.5k|            m_toIntImpl(&toIntImpl<T>)
  537|  10.5k|        { }
_ZN10tinyformat6detail11FormatListNILi1EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEDpRKT_:
  990|    676|            : FormatList(&m_formatterStore[0], N),
  991|    676|            m_formatterStore { FormatArg(args)... }
  992|    676|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2ImEERKT_:
  534|    864|            : m_value(static_cast<const void*>(&value)),
  535|    864|            m_formatImpl(&formatImpl<T>),
  536|    864|            m_toIntImpl(&toIntImpl<T>)
  537|    864|        { }

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

_ZN7uint256C2Eh:
  202|  9.68k|    constexpr explicit uint256(uint8_t v) : base_blob<256>(v) {}
_ZN9base_blobILj256EEC2Eh:
   40|  9.68k|    constexpr explicit base_blob(uint8_t v) : m_data{v} {}
_ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  113|  14.3k|    {
  114|  14.3k|        s << std::span(m_data);
  115|  14.3k|    }
_ZN9base_blobILj256EE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  119|  1.95k|    {
  120|  1.95k|        s.read(MakeWritableByteSpan(m_data));
  121|  1.95k|    }
_ZN9base_blobILj256EE7SetNullEv:
   58|  9.68k|    {
   59|  9.68k|        std::fill(m_data.begin(), m_data.end(), 0);
   60|  9.68k|    }
_ZNK9base_blobILj256EEeqERKS0_:
   62|     39|    constexpr bool operator==(const base_blob&) const = default;
_ZNK9base_blobILj256EE6IsNullEv:
   51|    527|    {
   52|    527|        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
   53|    527|            return val == 0;
   54|    527|        });
   55|    527|    }
_ZZNK9base_blobILj256EE6IsNullEvENKUlhE_clEh:
   52|  1.60k|        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
   53|  1.60k|            return val == 0;
   54|  1.60k|        });
_ZN7uint256C2ENSt3__14spanIKhLm18446744073709551615EEE:
  203|  8.11k|    constexpr explicit uint256(std::span<const unsigned char> vch) : base_blob<256>(vch) {}
_ZN9base_blobILj256EEC2ENSt3__14spanIKhLm18446744073709551615EEE:
   43|  8.11k|    {
   44|  8.11k|        assert(vch.size() == WIDTH);
  ------------------
  |  Branch (44:9): [True: 8.11k, False: 0]
  ------------------
   45|  8.11k|        std::copy(vch.begin(), vch.end(), m_data.begin());
   46|  8.11k|    }
_ZN9base_blobILj256EE4dataEv:
   99|  19.3k|    constexpr unsigned char* data() { return m_data.data(); }
_ZNK9base_blobILj256EE9SerializeI10HashWriterEEvRT_:
  113|  20.1M|    {
  114|  20.1M|        s << std::span(m_data);
  115|  20.1M|    }
_ZN7uint256C2Ev:
  200|  20.1M|    constexpr uint256() = default;
_ZN9base_blobILj256EEC2Ev:
   37|  20.1M|    constexpr base_blob() : m_data() {}
_ZN9base_blobILj256EE5beginEv:
  101|  80.4M|    constexpr unsigned char* begin() { return m_data.data(); }
_ZNK9base_blobILj256EE4dataEv:
   98|  36.2k|    constexpr const unsigned char* data() const { return m_data.data(); }
_ZN9base_blobILj256EE4sizeEv:
  107|  55.5k|    static constexpr unsigned int size() { return WIDTH; }

_ZN8UniValueC2Ev:
   31|  9.68k|    UniValue() { typ = VNULL; }
_ZN8UniValueC2IRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_TnNS1_9enable_ifIXoooooooosr3stdE19is_floating_point_vIT0_Esr3stdE9is_same_vIbSB_Esr3stdE11is_signed_vISB_Esr3stdE13is_unsigned_vISB_Esr3stdE18is_constructible_vIS7_SB_EEbE4typeELb1EEEOT_:
   40|      2|    {
   41|       |        if constexpr (std::is_floating_point_v<T>) {
   42|       |            setFloat(val);
   43|       |        } else if constexpr (std::is_same_v<bool, T>) {
   44|       |            setBool(val);
   45|       |        } else if constexpr (std::is_signed_v<T>) {
   46|       |            setInt(int64_t{val});
   47|       |        } else if constexpr (std::is_unsigned_v<T>) {
   48|       |            setInt(uint64_t{val});
   49|      2|        } else {
   50|      2|            setStr(std::string{std::forward<Ref>(val)});
   51|      2|        }
   52|      2|    }
_ZNK8UniValue6isNullEv:
   81|  9.68k|    bool isNull() const { return (typ == VNULL); }

_ZN8UniValue5clearEv:
   18|      2|{
   19|      2|    typ = VNULL;
   20|      2|    val.clear();
   21|      2|    keys.clear();
   22|      2|    values.clear();
   23|      2|}
_ZN8UniValue6setStrENSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   85|      2|{
   86|      2|    clear();
   87|      2|    typ = VSTR;
   88|      2|    val = std::move(str);
   89|      2|}

_Z9InterpretNSt3__14spanIKSt4byteLm18446744073709551615EEES3_:
  181|  6.65M|{
  182|  6.65M|    size_t pos{0};
  183|  6.65M|    const size_t endpos{asmap.size() * 8};
  184|  6.65M|    uint8_t ip_bit{0};
  185|  6.65M|    const uint8_t ip_bits_end = ip.size() * 8;
  186|  6.65M|    uint32_t default_asn = 0;
  187|  13.3M|    while (pos < endpos) {
  ------------------
  |  Branch (187:12): [True: 13.3M, False: 0]
  ------------------
  188|  13.3M|        Instruction opcode = DecodeType(pos, asmap);
  189|  13.3M|        if (opcode == Instruction::RETURN) {
  ------------------
  |  Branch (189:13): [True: 6.27M, False: 7.03M]
  ------------------
  190|       |            // Found leaf node - return the ASN
  191|  6.27M|            uint32_t asn = DecodeASN(pos, asmap);
  192|  6.27M|            if (asn == INVALID) break; // ASN straddles EOF
  ------------------
  |  Branch (192:17): [True: 0, False: 6.27M]
  ------------------
  193|  6.27M|            return asn;
  194|  7.03M|        } else if (opcode == Instruction::JUMP) {
  ------------------
  |  Branch (194:20): [True: 3.19M, False: 3.84M]
  ------------------
  195|       |            // Binary branch: if IP bit is 1, jump forward; else continue
  196|  3.19M|            uint32_t jump = DecodeJump(pos, asmap);
  197|  3.19M|            if (jump == INVALID) break; // Jump offset straddles EOF
  ------------------
  |  Branch (197:17): [True: 0, False: 3.19M]
  ------------------
  198|  3.19M|            if (ip_bit == ip_bits_end) break; // No input bits left
  ------------------
  |  Branch (198:17): [True: 0, False: 3.19M]
  ------------------
  199|  3.19M|            if (int64_t{jump} >= static_cast<int64_t>(endpos - pos)) break; // Jumping past EOF
  ------------------
  |  Branch (199:17): [True: 0, False: 3.19M]
  ------------------
  200|  3.19M|            if (ConsumeBitBE(ip_bit, ip)) {  // Check next IP bit (big-endian)
  ------------------
  |  Branch (200:17): [True: 1.54M, False: 1.64M]
  ------------------
  201|  1.54M|                pos += jump;  // Bit = 1: skip to right subtree
  202|  1.54M|            }
  203|       |            // Bit = 0: fall through to left subtree
  204|  3.84M|        } else if (opcode == Instruction::MATCH) {
  ------------------
  |  Branch (204:20): [True: 521k, False: 3.32M]
  ------------------
  205|       |            // Compare multiple IP bits against a pattern
  206|       |            // The match value encodes both length and pattern:
  207|       |            // - highest set bit position determines length (bit_width - 1)
  208|       |            // - lower bits contain the pattern to compare
  209|   521k|            uint32_t match = DecodeMatch(pos, asmap);
  210|   521k|            if (match == INVALID) break; // Match bits straddle EOF
  ------------------
  |  Branch (210:17): [True: 0, False: 521k]
  ------------------
  211|   521k|            int matchlen = std::bit_width(match) - 1;  // An n-bit value matches n-1 input bits
  212|   521k|            if ((ip_bits_end - ip_bit) < matchlen) break; // Not enough input bits
  ------------------
  |  Branch (212:17): [True: 0, False: 521k]
  ------------------
  213|  1.01M|            for (int bit = 0; bit < matchlen; bit++) {
  ------------------
  |  Branch (213:31): [True: 872k, False: 146k]
  ------------------
  214|   872k|                if (ConsumeBitBE(ip_bit, ip) != ((match >> (matchlen - 1 - bit)) & 1)) {
  ------------------
  |  Branch (214:21): [True: 375k, False: 497k]
  ------------------
  215|   375k|                    return default_asn;  // Pattern mismatch - use default
  216|   375k|                }
  217|   872k|            }
  218|       |            // Pattern matched - continue execution
  219|  3.32M|        } else if (opcode == Instruction::DEFAULT) {
  ------------------
  |  Branch (219:20): [True: 3.32M, False: 0]
  ------------------
  220|       |            // Update the default ASN for subsequent MATCH failures
  221|  3.32M|            default_asn = DecodeASN(pos, asmap);
  222|  3.32M|            if (default_asn == INVALID) break; // ASN straddles EOF
  ------------------
  |  Branch (222:17): [True: 0, False: 3.32M]
  ------------------
  223|  3.32M|        } else {
  224|      0|            break; // Instruction straddles EOF
  225|      0|        }
  226|  13.3M|    }
  227|       |    // Reached EOF without RETURN, or aborted (see any of the breaks above)
  228|       |    // - should have been caught by SanityCheckAsmap below
  229|  6.65M|    assert(false);
  ------------------
  |  Branch (229:5): [Folded, False: 0]
  ------------------
  230|      0|    return 0; // 0 is not a valid ASN
  231|      0|}
_Z16SanityCheckAsmapNSt3__14spanIKSt4byteLm18446744073709551615EEEi:
  238|  7.16k|{
  239|  7.16k|    size_t pos{0};
  240|  7.16k|    const size_t endpos{asmap.size() * 8};
  241|  7.16k|    std::vector<std::pair<uint32_t, int>> jumps; // All future positions we may jump to (bit offset in asmap -> bits to consume left)
  242|  7.16k|    jumps.reserve(bits);
  243|  7.16k|    Instruction prevopcode = Instruction::JUMP;
  244|  7.16k|    bool had_incomplete_match = false;  // Track <8 bit matches for efficiency check
  245|       |
  246|  17.6k|    while (pos != endpos) {
  ------------------
  |  Branch (246:12): [True: 13.9k, False: 3.63k]
  ------------------
  247|       |        // There was a jump into the middle of the previous instruction
  248|  13.9k|        if (!jumps.empty() && pos >= jumps.back().first) return false;
  ------------------
  |  Branch (248:13): [True: 4.28k, False: 9.71k]
  |  Branch (248:31): [True: 15, False: 4.27k]
  ------------------
  249|       |
  250|  13.9k|        Instruction opcode = DecodeType(pos, asmap);
  251|  13.9k|        if (opcode == Instruction::RETURN) {
  ------------------
  |  Branch (251:13): [True: 6.18k, False: 7.79k]
  ------------------
  252|       |            // There should not be any RETURN immediately after a DEFAULT (could be combined into just RETURN)
  253|  6.18k|            if (prevopcode == Instruction::DEFAULT) return false;
  ------------------
  |  Branch (253:17): [True: 67, False: 6.11k]
  ------------------
  254|  6.11k|            uint32_t asn = DecodeASN(pos, asmap);
  255|  6.11k|            if (asn == INVALID) return false; // ASN straddles EOF
  ------------------
  |  Branch (255:17): [True: 394, False: 5.72k]
  ------------------
  256|  5.72k|            if (jumps.empty()) {
  ------------------
  |  Branch (256:17): [True: 2.53k, False: 3.19k]
  ------------------
  257|       |                // Nothing to execute anymore
  258|  2.53k|                if (endpos - pos > 7) return false; // Excessive padding
  ------------------
  |  Branch (258:21): [True: 279, False: 2.25k]
  ------------------
  259|  13.2k|                while (pos != endpos) {
  ------------------
  |  Branch (259:24): [True: 11.1k, False: 2.16k]
  ------------------
  260|  11.1k|                    if (ConsumeBitLE(pos, asmap)) return false; // Nonzero padding bit
  ------------------
  |  Branch (260:25): [True: 93, False: 11.0k]
  ------------------
  261|  11.1k|                }
  262|  2.16k|                return true; // Sanely reached EOF
  263|  3.19k|            } else {
  264|       |                // Continue by pretending we jumped to the next instruction
  265|  3.19k|                if (pos != jumps.back().first) return false; // Unreachable code
  ------------------
  |  Branch (265:21): [True: 46, False: 3.14k]
  ------------------
  266|  3.14k|                bits = jumps.back().second; // Restore the number of bits we would have had left after this jump
  267|  3.14k|                jumps.pop_back();
  268|  3.14k|                prevopcode = Instruction::JUMP;
  269|  3.14k|            }
  270|  7.79k|        } else if (opcode == Instruction::JUMP) {
  ------------------
  |  Branch (270:20): [True: 3.57k, False: 4.22k]
  ------------------
  271|  3.57k|            uint32_t jump = DecodeJump(pos, asmap);
  272|  3.57k|            if (jump == INVALID) return false; // Jump offset straddles EOF
  ------------------
  |  Branch (272:17): [True: 32, False: 3.54k]
  ------------------
  273|  3.54k|            if (int64_t{jump} > static_cast<int64_t>(endpos - pos)) return false; // Jump out of range
  ------------------
  |  Branch (273:17): [True: 131, False: 3.41k]
  ------------------
  274|  3.41k|            if (bits == 0) return false; // Consuming bits past the end of the input
  ------------------
  |  Branch (274:17): [True: 2, False: 3.40k]
  ------------------
  275|  3.40k|            --bits;
  276|  3.40k|            uint32_t jump_offset = pos + jump;
  277|  3.40k|            if (!jumps.empty() && jump_offset >= jumps.back().first) return false; // Intersecting jumps
  ------------------
  |  Branch (277:17): [True: 849, False: 2.56k]
  |  Branch (277:35): [True: 81, False: 768]
  ------------------
  278|  3.32k|            jumps.emplace_back(jump_offset, bits);  // Queue jump target for validation
  279|  3.32k|            prevopcode = Instruction::JUMP;
  280|  4.22k|        } else if (opcode == Instruction::MATCH) {
  ------------------
  |  Branch (280:20): [True: 2.09k, False: 2.12k]
  ------------------
  281|  2.09k|            uint32_t match = DecodeMatch(pos, asmap);
  282|  2.09k|            if (match == INVALID) return false; // Match bits straddle EOF
  ------------------
  |  Branch (282:17): [True: 40, False: 2.05k]
  ------------------
  283|  2.05k|            int matchlen = std::bit_width(match) - 1;
  284|  2.05k|            if (prevopcode != Instruction::MATCH) had_incomplete_match = false;
  ------------------
  |  Branch (284:17): [True: 1.64k, False: 411]
  ------------------
  285|       |            // Within a sequence of matches only at most one should be incomplete
  286|  2.05k|            if (matchlen < 8 && had_incomplete_match) return false;
  ------------------
  |  Branch (286:17): [True: 1.79k, False: 259]
  |  Branch (286:33): [True: 66, False: 1.72k]
  ------------------
  287|  1.98k|            had_incomplete_match = (matchlen < 8);
  288|  1.98k|            if (bits < matchlen) return false; // Consuming bits past the end of the input
  ------------------
  |  Branch (288:17): [True: 3, False: 1.98k]
  ------------------
  289|  1.98k|            bits -= matchlen;
  290|  1.98k|            prevopcode = Instruction::MATCH;
  291|  2.12k|        } else if (opcode == Instruction::DEFAULT) {
  ------------------
  |  Branch (291:20): [True: 2.09k, False: 31]
  ------------------
  292|       |            // There should not be two successive DEFAULTs (they could be combined into one)
  293|  2.09k|            if (prevopcode == Instruction::DEFAULT) return false;
  ------------------
  |  Branch (293:17): [True: 18, False: 2.08k]
  ------------------
  294|  2.08k|            uint32_t asn = DecodeASN(pos, asmap);
  295|  2.08k|            if (asn == INVALID) return false; // ASN straddles EOF
  ------------------
  |  Branch (295:17): [True: 75, False: 2.00k]
  ------------------
  296|  2.00k|            prevopcode = Instruction::DEFAULT;
  297|  2.00k|        } else {
  298|     31|            return false; // Instruction straddles EOF
  299|     31|        }
  300|  13.9k|    }
  301|  3.63k|    return false; // Reached EOF without RETURN instruction
  302|  7.16k|}
_Z18CheckStandardAsmapNSt3__14spanIKSt4byteLm18446744073709551615EEE:
  309|  7.16k|{
  310|  7.16k|    if (!SanityCheckAsmap(data, 128)) {
  ------------------
  |  Branch (310:9): [True: 5.00k, False: 2.16k]
  ------------------
  311|  5.00k|        LogWarning("Sanity check of asmap data failed\n");
  ------------------
  |  |  126|  5.00k|#define LogWarning(...) detail_LogWithSrcLoc(BCLog::LogFlags::ALL, util::log::Level::Warning, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  119|  5.00k|#define detail_LogWithSrcLoc(category, level, ...) util::log::LogPrintFormatInternal(SourceLocation{__func__}, category, level, __VA_ARGS__)
  |  |  ------------------
  ------------------
  312|  5.00k|        return false;
  313|  5.00k|    }
  314|  2.16k|    return true;
  315|  7.16k|}
_Z12AsmapVersionNSt3__14spanIKSt4byteLm18446744073709551615EEE:
  347|  7.85k|{
  348|  7.85k|    if (data.empty()) return {};
  ------------------
  |  Branch (348:9): [True: 5.64k, False: 2.20k]
  ------------------
  349|       |
  350|  2.20k|    HashWriter asmap_hasher;
  351|  2.20k|    asmap_hasher << data;
  352|  2.20k|    return asmap_hasher.GetHash();
  353|  7.85k|}
asmap.cpp:_ZN12_GLOBAL__N_110DecodeTypeERmNSt3__14spanIKSt4byteLm18446744073709551615EEE:
  142|  13.3M|{
  143|  13.3M|    return Instruction(DecodeBits(bitpos, data, 0, TYPE_BIT_SIZES));
  144|  13.3M|}
asmap.cpp:_ZN12_GLOBAL__N_110DecodeBitsERmNSt3__14spanIKSt4byteLm18446744073709551615EEEhNS2_IKhLm18446744073709551615EEE:
   86|  26.6M|{
   87|  26.6M|    uint32_t val = minval;  // Start with minimum encodable value
   88|  26.6M|    bool bit;
   89|  43.8M|    for (auto bit_sizes_it = bit_sizes.begin(); bit_sizes_it != bit_sizes.end(); ++bit_sizes_it) {
  ------------------
  |  Branch (89:49): [True: 43.8M, False: 0]
  ------------------
   90|       |        // Read continuation bit to determine if we're in this class
   91|  43.8M|        if (bit_sizes_it + 1 != bit_sizes.end()) {  // Unless we're in the last class
  ------------------
  |  Branch (91:13): [True: 39.9M, False: 3.91M]
  ------------------
   92|  39.9M|            if (bitpos >= data.size() * 8) break;
  ------------------
  |  Branch (92:17): [True: 87, False: 39.9M]
  ------------------
   93|  39.9M|            bit = ConsumeBitLE(bitpos, data);
   94|  39.9M|        } else {
   95|  3.91M|            bit = 0;  // Last class has no continuation bit
   96|  3.91M|        }
   97|  43.8M|        if (bit) {
  ------------------
  |  Branch (97:13): [True: 17.2M, False: 26.6M]
  ------------------
   98|       |            // If the value will not fit in this class, subtract its range from val,
   99|       |            // emit a "1" bit and continue with the next class
  100|  17.2M|            val += (1 << *bit_sizes_it);  // Add size of this class
  101|  26.6M|        } else {
  102|       |            // Decode the position within this class in big endian
  103|   197M|            for (int b = 0; b < *bit_sizes_it; b++) {
  ------------------
  |  Branch (103:29): [True: 170M, False: 26.6M]
  ------------------
  104|   170M|                if (bitpos >= data.size() * 8) return INVALID; // Reached EOF in mantissa
  ------------------
  |  Branch (104:21): [True: 485, False: 170M]
  ------------------
  105|   170M|                bit = ConsumeBitLE(bitpos, data);
  106|   170M|                val += bit << (*bit_sizes_it - 1 - b); // Big-endian within the class
  107|   170M|            }
  108|  26.6M|            return val;
  109|  26.6M|        }
  110|  43.8M|    }
  111|     87|    return INVALID; // Reached EOF in exponent
  112|  26.6M|}
asmap.cpp:_ZN12_GLOBAL__N_19DecodeASNERmNSt3__14spanIKSt4byteLm18446744073709551615EEE:
  151|  9.60M|{
  152|  9.60M|    return DecodeBits(bitpos, data, 1, ASN_BIT_SIZES);
  153|  9.60M|}
asmap.cpp:_ZN12_GLOBAL__N_110DecodeJumpERmNSt3__14spanIKSt4byteLm18446744073709551615EEE:
  167|  3.19M|{
  168|  3.19M|    return DecodeBits(bitpos, data, 17, JUMP_BIT_SIZES);
  169|  3.19M|}
asmap.cpp:_ZN12_GLOBAL__N_112ConsumeBitBEERhNSt3__14spanIKSt4byteLm18446744073709551615EEE:
   64|  4.06M|{
   65|  4.06M|    const bool bit = (std::to_integer<uint8_t>(bytes[bitpos / 8]) >> (7 - (bitpos % 8))) & 1;
   66|  4.06M|    ++bitpos;
   67|  4.06M|    return bit;
   68|  4.06M|}
asmap.cpp:_ZN12_GLOBAL__N_111DecodeMatchERmNSt3__14spanIKSt4byteLm18446744073709551615EEE:
  159|   523k|{
  160|   523k|    return DecodeBits(bitpos, data, 2, MATCH_BIT_SIZES);
  161|   523k|}
asmap.cpp:_ZN12_GLOBAL__N_112ConsumeBitLEERmNSt3__14spanIKSt4byteLm18446744073709551615EEE:
   53|   210M|{
   54|   210M|    const bool bit = (std::to_integer<uint8_t>(bytes[bitpos / 8]) >> (bitpos % 8)) & 1;
   55|   210M|    ++bitpos;
   56|   210M|    return bit;
   57|   210M|}

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

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

_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_RKNS0_15source_locationENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE:
   90|  7.16k|{
   91|  7.16k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 7.16k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  7.16k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 7.16k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  7.16k|    }
   96|  7.16k|    return std::forward<T>(val);
   97|  7.16k|}
_Z22inline_assertion_checkILb1ERNSt3__16atomicIbEEEOT0_S5_RKNS0_15source_locationENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE:
   90|  7.16k|{
   91|  7.16k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 7.16k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  7.16k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 7.16k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  7.16k|    }
   96|  7.16k|    return std::forward<T>(val);
   97|  7.16k|}
_Z21EnableFuzzDeterminismv:
   39|  7.17k|{
   40|  7.17k|    if constexpr (G_FUZZING_BUILD) {
   41|  7.17k|        return true;
   42|       |    } else if constexpr (!G_ABORT_ON_FAILED_ASSUME) {
   43|       |        // Running fuzz tests is always disabled if Assume() doesn't abort
   44|       |        // (ie, non-fuzz non-debug builds), as otherwise tests which
   45|       |        // should fail due to a failing Assume may still pass. As such,
   46|       |        // we also statically disable fuzz determinism in that case.
   47|       |        return false;
   48|       |    } else {
   49|       |        return g_enable_dynamic_fuzz_determinism;
   50|       |    }
   51|  7.17k|}
_Z22inline_assertion_checkILb1ERbEOT0_S2_RKNSt3__115source_locationENS3_17basic_string_viewIcNS3_11char_traitsIcEEEE:
   90|  7.16k|{
   91|  7.16k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 7.16k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  7.16k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 7.16k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  7.16k|    }
   96|  7.16k|    return std::forward<T>(val);
   97|  7.16k|}
_Z22inline_assertion_checkILb1EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   90|  28.6k|{
   91|  28.6k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 28.6k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  28.6k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 28.6k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  28.6k|    }
   96|  28.6k|    return std::forward<T>(val);
   97|  28.6k|}
_Z22inline_assertion_checkILb0EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   90|   753M|{
   91|   753M|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [Folded, False: 0]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|   753M|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 753M]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|   753M|    }
   96|   753M|    return std::forward<T>(val);
   97|   753M|}

setup_common.cpp:_ZN2fsL12PathToStringERKNS_4pathE:
  163|      2|{
  164|       |    // Implementation note: On Windows, the std::filesystem::path(string)
  165|       |    // constructor and std::filesystem::path::string() method are not safe to
  166|       |    // use here, because these methods encode the path using C++'s narrow
  167|       |    // multibyte encoding, which on Windows corresponds to the current "code
  168|       |    // page", which is unpredictable and typically not able to represent all
  169|       |    // valid paths. So fs::path::utf8string() and
  170|       |    // fs::u8path() functions are used instead on Windows. On
  171|       |    // POSIX, u8string/utf8string/u8path functions are not safe to use because paths are
  172|       |    // not always valid UTF-8, so plain string methods which do not transform
  173|       |    // the path there are used.
  174|       |#ifdef WIN32
  175|       |    return path.utf8string();
  176|       |#else
  177|      2|    static_assert(std::is_same_v<path::string_type, std::string>, "PathToString not implemented on this platform");
  178|      2|    return path.std::filesystem::path::string();
  179|      2|#endif
  180|      2|}

_ZN4util3log22LogPrintFormatInternalIJPKcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEvO14SourceLocationN5BCLog8LogFlagsENS0_5LevelENS_21ConstevalFormatStringIXsZT_EEEDpRKT_:
  101|  7.16k|{
  102|  7.16k|    return LogPrintFormatInternal_(std::move(source_loc), flag, level, /*should_ratelimit=*/true, fmt, args...);
  103|  7.16k|}
_ZN4util3log23LogPrintFormatInternal_IJPKcNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEvO14SourceLocationN5BCLog8LogFlagsENS0_5LevelEbNS_21ConstevalFormatStringIXsZT_EEEDpRKT_:
   84|  7.16k|{
   85|  7.16k|    std::string log_msg;
   86|  7.16k|    try {
   87|  7.16k|        log_msg = tfm::format(fmt, args...);
   88|  7.16k|    } catch (tinyformat::format_error& fmterr) {
   89|      0|        log_msg = "Error \"" + std::string{fmterr.what()} + "\" while formatting log message: " + fmt.fmt;
   90|      0|    }
   91|  7.16k|    util::log::Log(util::log::Entry{
   92|  7.16k|        .category = flag,
   93|  7.16k|        .level = level,
   94|  7.16k|        .should_ratelimit = should_ratelimit,
   95|  7.16k|        .source_loc = std::move(source_loc),
   96|  7.16k|        .message = std::move(log_msg)});
   97|  7.16k|}
_ZN14SourceLocationC2EPKcNSt3__115source_locationE:
   31|  12.1k|        : m_func{func}, m_loc{loc} {}
_ZN4util3log22LogPrintFormatInternalIJEEEvO14SourceLocationN5BCLog8LogFlagsENS0_5LevelENS_21ConstevalFormatStringIXsZT_EEEDpRKT_:
  101|  5.00k|{
  102|  5.00k|    return LogPrintFormatInternal_(std::move(source_loc), flag, level, /*should_ratelimit=*/true, fmt, args...);
  103|  5.00k|}
_ZN4util3log23LogPrintFormatInternal_IJEEEvO14SourceLocationN5BCLog8LogFlagsENS0_5LevelEbNS_21ConstevalFormatStringIXsZT_EEEDpRKT_:
   84|  5.00k|{
   85|  5.00k|    std::string log_msg;
   86|  5.00k|    try {
   87|  5.00k|        log_msg = tfm::format(fmt, args...);
   88|  5.00k|    } catch (tinyformat::format_error& fmterr) {
   89|      0|        log_msg = "Error \"" + std::string{fmterr.what()} + "\" while formatting log message: " + fmt.fmt;
   90|      0|    }
   91|  5.00k|    util::log::Log(util::log::Entry{
   92|  5.00k|        .category = flag,
   93|  5.00k|        .level = level,
   94|  5.00k|        .should_ratelimit = should_ratelimit,
   95|  5.00k|        .source_loc = std::move(source_loc),
   96|  5.00k|        .message = std::move(log_msg)});
   97|  5.00k|}

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

_ZN8StdMutex12CheckNotHeldERS_:
   37|  12.1k|    static inline StdMutex& CheckNotHeld(StdMutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; }
_ZN8StdMutex5GuardC2ERS_:
   33|  12.1k|        explicit Guard(StdMutex& cs) EXCLUSIVE_LOCK_FUNCTION(cs) : std::lock_guard<StdMutex>(cs) {}

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

_ZN4util9HasPrefixINSt3__14spanIKhLm18446744073709551615EEELm12EEEbRKT_RKNS1_5arrayIhXT0_EEE:
  263|   121k|{
  264|   121k|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (264:12): [True: 121k, False: 0]
  ------------------
  265|   121k|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (265:12): [True: 136, False: 121k]
  ------------------
  266|   121k|}
_ZN4util9HasPrefixINSt3__14spanIKhLm18446744073709551615EEELm6EEEbRKT_RKNS1_5arrayIhXT0_EEE:
  263|   242k|{
  264|   242k|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (264:12): [True: 242k, False: 0]
  ------------------
  265|   242k|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (265:12): [True: 151, False: 242k]
  ------------------
  266|   242k|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm2EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  263|  23.4M|{
  264|  23.4M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (264:12): [True: 23.4M, False: 0]
  ------------------
  265|  23.4M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (265:12): [True: 1.86k, False: 23.4M]
  ------------------
  266|  23.4M|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm3EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  263|  98.4M|{
  264|  98.4M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (264:12): [True: 98.4M, False: 0]
  ------------------
  265|  98.4M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (265:12): [True: 10.9k, False: 98.3M]
  ------------------
  266|  98.4M|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm4EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  263|  66.4M|{
  264|  66.4M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (264:12): [True: 66.4M, False: 0]
  ------------------
  265|  66.4M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (265:12): [True: 4.40k, False: 66.4M]
  ------------------
  266|  66.4M|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm8EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  263|  44.3M|{
  264|  44.3M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (264:12): [True: 44.3M, False: 0]
  ------------------
  265|  44.3M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (265:12): [True: 4.97k, False: 44.3M]
  ------------------
  266|  44.3M|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm6EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  263|  9.80M|{
  264|  9.80M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (264:12): [True: 9.80M, False: 0]
  ------------------
  265|  9.80M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (265:12): [True: 2.18k, False: 9.80M]
  ------------------
  266|  9.80M|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm12EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  263|  45.1M|{
  264|  45.1M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (264:12): [True: 45.1M, False: 0]
  ------------------
  265|  45.1M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (265:12): [True: 4.43k, False: 45.1M]
  ------------------
  266|  45.1M|}

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

_ZN4util21ThreadGetInternalNameEv:
   56|  12.1k|std::string util::ThreadGetInternalName() { return g_thread_name; }

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

_ZN9NodeClock3nowEv:
   39|  3.83M|{
   40|  3.83M|    const auto mocktime{g_mock_time.load(std::memory_order_relaxed)};
   41|  3.83M|    if (!mocktime.count()) {
  ------------------
  |  Branch (41:9): [True: 0, False: 3.83M]
  ------------------
   42|      0|        g_used_system_time = true;
   43|      0|    }
   44|  3.83M|    const auto ret{
   45|  3.83M|        mocktime.count() ?
  ------------------
  |  Branch (45:9): [True: 3.83M, False: 0]
  ------------------
   46|  3.83M|            mocktime :
   47|  3.83M|            std::chrono::system_clock::now().time_since_epoch()};
   48|  3.83M|    assert(ret > 0s);
  ------------------
  |  Branch (48:5): [True: 3.83M, False: 0]
  ------------------
   49|  3.83M|    return time_point{ret};
   50|  3.83M|};
_Z11SetMockTimeNSt3__16chrono10time_pointI9NodeClockNS0_8durationIxNS_5ratioILl1ELl1EEEEEEE:
   52|  14.3k|void SetMockTime(std::chrono::time_point<NodeClock, std::chrono::seconds> mock) { SetMockTime(mock.time_since_epoch()); }
_Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   54|  21.5k|{
   55|  21.5k|    Assert(mock_time_in >= 0s);
  ------------------
  |  |  116|  21.5k|#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
  ------------------
   56|  21.5k|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   57|  21.5k|}
_Z11GetMockTimev:
   60|  12.1k|{
   61|  12.1k|    return g_mock_time.load(std::memory_order_relaxed);
   62|  12.1k|}
_ZN19MockableSteadyClock13ClearMockTimeEv:
   84|  7.16k|{
   85|  7.16k|    g_mock_steady_time.store(0ms, std::memory_order_relaxed);
   86|  7.16k|}
_Z20ParseISO8601DateTimeNSt3__117basic_string_viewIcNS_11char_traitsIcEEEE:
  108|      2|{
  109|      2|    constexpr auto FMT_SIZE{std::string_view{"2000-01-01T01:01:01Z"}.size()};
  110|      2|    if (str.size() != FMT_SIZE || str[4] != '-' || str[7] != '-' || str[10] != 'T' || str[13] != ':' || str[16] != ':' || str[19] != 'Z') {
  ------------------
  |  Branch (110:9): [True: 0, False: 2]
  |  Branch (110:35): [True: 0, False: 2]
  |  Branch (110:52): [True: 0, False: 2]
  |  Branch (110:69): [True: 0, False: 2]
  |  Branch (110:87): [True: 0, False: 2]
  |  Branch (110:105): [True: 0, False: 2]
  |  Branch (110:123): [True: 0, False: 2]
  ------------------
  111|      0|        return {};
  112|      0|    }
  113|      2|    const auto year{ToIntegral<uint16_t>(str.substr(0, 4))};
  114|      2|    const auto month{ToIntegral<uint8_t>(str.substr(5, 2))};
  115|      2|    const auto day{ToIntegral<uint8_t>(str.substr(8, 2))};
  116|      2|    const auto hour{ToIntegral<uint8_t>(str.substr(11, 2))};
  117|      2|    const auto min{ToIntegral<uint8_t>(str.substr(14, 2))};
  118|      2|    const auto sec{ToIntegral<uint8_t>(str.substr(17, 2))};
  119|      2|    if (!year || !month || !day || !hour || !min || !sec) {
  ------------------
  |  Branch (119:9): [True: 0, False: 2]
  |  Branch (119:18): [True: 0, False: 2]
  |  Branch (119:28): [True: 0, False: 2]
  |  Branch (119:36): [True: 0, False: 2]
  |  Branch (119:45): [True: 0, False: 2]
  |  Branch (119:53): [True: 0, False: 2]
  ------------------
  120|      0|        return {};
  121|      0|    }
  122|      2|    const std::chrono::year_month_day ymd{std::chrono::year{*year}, std::chrono::month{*month}, std::chrono::day{*day}};
  123|      2|    if (!ymd.ok()) {
  ------------------
  |  Branch (123:9): [True: 0, False: 2]
  ------------------
  124|      0|        return {};
  125|      0|    }
  126|      2|    const auto time{std::chrono::hours{*hour} + std::chrono::minutes{*min} + std::chrono::seconds{*sec}};
  127|      2|    const auto tp{std::chrono::sys_days{ymd} + time};
  128|      2|    return int64_t{TicksSinceEpoch<std::chrono::seconds>(tp)};
  129|      2|}

_Z5TicksINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEES5_EDaT0_:
   83|  41.8k|{
   84|  41.8k|    return std::chrono::duration_cast<Dur1>(d).count();
   85|  41.8k|}
_Z15TicksSinceEpochINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEENS1_10time_pointI9NodeClockS5_EEEDaT0_:
   94|  41.8k|{
   95|  41.8k|    return Ticks<Duration>(t.time_since_epoch());
   96|  41.8k|}
_Z15TicksSinceEpochINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEENS1_10time_pointINS1_12system_clockES5_EEEDaT0_:
   94|      2|{
   95|      2|    return Ticks<Duration>(t.time_since_epoch());
   96|      2|}
_Z5TicksINSt3__16chrono8durationIdNS0_5ratioILl1ELl1000EEEEENS2_IxNS3_ILl1ELl1000000000EEEEEEDaT0_:
   83|    676|{
   84|    676|    return std::chrono::duration_cast<Dur1>(d).count();
   85|    676|}
_Z3NowINSt3__16chrono10time_pointI9NodeClockNS1_8durationIxNS0_5ratioILl1ELl1EEEEEEEET_v:
  128|  2.80M|{
  129|  2.80M|    return std::chrono::time_point_cast<typename T::duration>(T::clock::now());
  130|  2.80M|}

_ZN12TokenPipeEndD2Ev:
   37|      4|{
   38|      4|    Close();
   39|      4|}
_ZN12TokenPipeEnd5CloseEv:
   80|      4|{
   81|      4|    if (m_fd != -1) close(m_fd);
  ------------------
  |  Branch (81:9): [True: 4, False: 0]
  ------------------
   82|      4|    m_fd = -1;
   83|      4|}

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