_ZNK8AddrInfo14GetTriedBucketERK7uint256RK15NetGroupManager:
   49|  44.2k|{
   50|  44.2k|    uint64_t hash1 = (HashWriter{} << nKey << GetKey()).GetCheapHash();
   51|  44.2k|    uint64_t hash2 = (HashWriter{} << nKey << netgroupman.GetGroup(*this) << (hash1 % ADDRMAN_TRIED_BUCKETS_PER_GROUP)).GetCheapHash();
   52|  44.2k|    return hash2 % ADDRMAN_TRIED_BUCKET_COUNT;
   53|  44.2k|}
_ZNK8AddrInfo12GetNewBucketERK7uint256RK8CNetAddrRK15NetGroupManager:
   56|  35.2k|{
   57|  35.2k|    std::vector<unsigned char> vchSourceGroupKey = netgroupman.GetGroup(src);
   58|  35.2k|    uint64_t hash1 = (HashWriter{} << nKey << netgroupman.GetGroup(*this) << vchSourceGroupKey).GetCheapHash();
   59|  35.2k|    uint64_t hash2 = (HashWriter{} << nKey << vchSourceGroupKey << (hash1 % ADDRMAN_NEW_BUCKETS_PER_SOURCE_GROUP)).GetCheapHash();
   60|  35.2k|    return hash2 % ADDRMAN_NEW_BUCKET_COUNT;
   61|  35.2k|}
_ZNK8AddrInfo17GetBucketPositionERK7uint256bi:
   64|   115k|{
   65|   115k|    uint64_t hash1 = (HashWriter{} << nKey << (fNew ? uint8_t{'N'} : uint8_t{'K'}) << bucket << GetKey()).GetCheapHash();
  ------------------
  |  Branch (65:48): [True: 71.5k, False: 44.2k]
  ------------------
   66|   115k|    return hash1 % ADDRMAN_BUCKET_SIZE;
   67|   115k|}
_ZNK8AddrInfo10IsTerribleENSt3__16chrono10time_pointI9NodeClockNS1_8durationIxNS0_5ratioILl1ELl1EEEEEEE:
   70|   853k|{
   71|   853k|    if (now - m_last_try <= 1min) { // never remove things tried in the last minute
  ------------------
  |  Branch (71:9): [True: 0, False: 853k]
  ------------------
   72|      0|        return false;
   73|      0|    }
   74|       |
   75|   853k|    if (nTime > now + 10min) { // came in a flying DeLorean
  ------------------
  |  Branch (75:9): [True: 270k, False: 583k]
  ------------------
   76|   270k|        return true;
   77|   270k|    }
   78|       |
   79|   583k|    if (now - nTime > ADDRMAN_HORIZON) { // not seen in recent history
  ------------------
  |  Branch (79:9): [True: 560k, False: 22.6k]
  ------------------
   80|   560k|        return true;
   81|   560k|    }
   82|       |
   83|  22.6k|    if (TicksSinceEpoch<std::chrono::seconds>(m_last_success) == 0 && nAttempts >= ADDRMAN_RETRIES) { // tried N times and never a success
  ------------------
  |  Branch (83:9): [True: 412, False: 22.2k]
  |  Branch (83:71): [True: 202, False: 210]
  ------------------
   84|    202|        return true;
   85|    202|    }
   86|       |
   87|  22.4k|    if (now - m_last_success > ADDRMAN_MIN_FAIL && nAttempts >= ADDRMAN_MAX_FAILURES) { // N successive failures in the last week
  ------------------
  |  Branch (87:9): [True: 4.73k, False: 17.7k]
  |  Branch (87:9): [True: 1.93k, False: 20.5k]
  |  Branch (87:52): [True: 1.93k, False: 2.79k]
  ------------------
   88|  1.93k|        return true;
   89|  1.93k|    }
   90|       |
   91|  20.5k|    return false;
   92|  22.4k|}
_ZN11AddrManImplC2ERK15NetGroupManagerbi:
  110|  9.84k|    : insecure_rand{deterministic}
  111|  9.84k|    , nKey{deterministic ? uint256{1} : insecure_rand.rand256()}
  ------------------
  |  Branch (111:12): [True: 9.84k, False: 0]
  ------------------
  112|  9.84k|    , m_consistency_check_ratio{consistency_check_ratio}
  113|  9.84k|    , m_netgroupman{netgroupman}
  114|  9.84k|{
  115|  10.0M|    for (auto& bucket : vvNew) {
  ------------------
  |  Branch (115:23): [True: 10.0M, False: 9.84k]
  ------------------
  116|   645M|        for (auto& entry : bucket) {
  ------------------
  |  Branch (116:26): [True: 645M, False: 10.0M]
  ------------------
  117|   645M|            entry = -1;
  118|   645M|        }
  119|  10.0M|    }
  120|  2.52M|    for (auto& bucket : vvTried) {
  ------------------
  |  Branch (120:23): [True: 2.52M, False: 9.84k]
  ------------------
  121|   161M|        for (auto& entry : bucket) {
  ------------------
  |  Branch (121:26): [True: 161M, False: 2.52M]
  ------------------
  122|   161M|            entry = -1;
  123|   161M|        }
  124|  2.52M|    }
  125|  9.84k|}
_ZN11AddrManImplD2Ev:
  128|  9.84k|{
  129|  9.84k|    nKey.SetNull();
  130|  9.84k|}
_ZNK11AddrManImpl10SwapRandomEjj:
  433|   944k|{
  434|   944k|    AssertLockHeld(cs);
  ------------------
  |  |  142|   944k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  435|       |
  436|   944k|    if (nRndPos1 == nRndPos2)
  ------------------
  |  Branch (436:9): [True: 235k, False: 708k]
  ------------------
  437|   235k|        return;
  438|       |
  439|   708k|    assert(nRndPos1 < vRandom.size() && nRndPos2 < vRandom.size());
  440|       |
  441|   708k|    nid_type nId1 = vRandom[nRndPos1];
  442|   708k|    nid_type nId2 = vRandom[nRndPos2];
  443|       |
  444|   708k|    const auto it_1{mapInfo.find(nId1)};
  445|   708k|    const auto it_2{mapInfo.find(nId2)};
  446|   708k|    assert(it_1 != mapInfo.end());
  447|   708k|    assert(it_2 != mapInfo.end());
  448|       |
  449|   708k|    it_1->second.nRandomPos = nRndPos2;
  450|   708k|    it_2->second.nRandomPos = nRndPos1;
  451|       |
  452|   708k|    vRandom[nRndPos1] = nId2;
  453|   708k|    vRandom[nRndPos2] = nId1;
  454|   708k|}
_ZN11AddrManImpl6DeleteEl:
  457|  85.7k|{
  458|  85.7k|    AssertLockHeld(cs);
  ------------------
  |  |  142|  85.7k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  459|       |
  460|  85.7k|    assert(mapInfo.count(nId) != 0);
  461|  85.7k|    AddrInfo& info = mapInfo[nId];
  462|  85.7k|    assert(!info.fInTried);
  463|  85.7k|    assert(info.nRefCount == 0);
  464|       |
  465|  85.7k|    SwapRandom(info.nRandomPos, vRandom.size() - 1);
  466|  85.7k|    m_network_counts[info.GetNetwork()].n_new--;
  467|  85.7k|    vRandom.pop_back();
  468|  85.7k|    mapAddr.erase(info);
  469|  85.7k|    mapInfo.erase(nId);
  470|  85.7k|    nNew--;
  471|  85.7k|}
_ZNK11AddrManImpl8GetAddr_EmmNSt3__18optionalI7NetworkEEb:
  813|  79.8k|{
  814|  79.8k|    AssertLockHeld(cs);
  ------------------
  |  |  142|  79.8k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  815|  79.8k|    Assume(max_pct <= 100);
  ------------------
  |  |   97|  79.8k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  816|       |
  817|  79.8k|    size_t nNodes = vRandom.size();
  818|  79.8k|    if (max_pct != 0) {
  ------------------
  |  Branch (818:9): [True: 64.2k, False: 15.5k]
  ------------------
  819|  64.2k|        max_pct = std::min(max_pct, size_t{100});
  820|  64.2k|        nNodes = max_pct * nNodes / 100;
  821|  64.2k|    }
  822|  79.8k|    if (max_addresses != 0) {
  ------------------
  |  Branch (822:9): [True: 65.1k, False: 14.6k]
  ------------------
  823|  65.1k|        nNodes = std::min(nNodes, max_addresses);
  824|  65.1k|    }
  825|       |
  826|       |    // gather a list of random nodes, skipping those of low quality
  827|  79.8k|    const auto now{Now<NodeSeconds>()};
  828|  79.8k|    std::vector<CAddress> addresses;
  829|  79.8k|    addresses.reserve(nNodes);
  830|   938k|    for (unsigned int n = 0; n < vRandom.size(); n++) {
  ------------------
  |  Branch (830:30): [True: 862k, False: 75.5k]
  ------------------
  831|   862k|        if (addresses.size() >= nNodes)
  ------------------
  |  Branch (831:13): [True: 4.30k, False: 858k]
  ------------------
  832|  4.30k|            break;
  833|       |
  834|   858k|        int nRndPos = insecure_rand.randrange(vRandom.size() - n) + n;
  835|   858k|        SwapRandom(n, nRndPos);
  836|   858k|        const auto it{mapInfo.find(vRandom[n])};
  837|   858k|        assert(it != mapInfo.end());
  838|       |
  839|   858k|        const AddrInfo& ai{it->second};
  840|       |
  841|       |        // Filter by network (optional)
  842|   858k|        if (network != std::nullopt && ai.GetNetClass() != network) continue;
  ------------------
  |  Branch (842:13): [True: 7.09k, False: 851k]
  |  Branch (842:13): [True: 4.73k, False: 853k]
  |  Branch (842:40): [True: 4.73k, False: 2.36k]
  ------------------
  843|       |
  844|       |        // Filter for quality
  845|   853k|        if (ai.IsTerrible(now) && filtered) continue;
  ------------------
  |  Branch (845:13): [True: 833k, False: 20.5k]
  |  Branch (845:35): [True: 829k, False: 3.39k]
  ------------------
  846|       |
  847|  23.9k|        addresses.push_back(ai);
  848|  23.9k|    }
  849|  79.8k|    LogDebug(BCLog::ADDRMAN, "GetAddr returned %d random addresses\n", addresses.size());
  ------------------
  |  |  280|  79.8k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  79.8k|    do {                                                  \
  |  |  |  |  274|  79.8k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 79.8k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  79.8k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  850|  79.8k|    return addresses;
  851|  79.8k|}
_ZNK11AddrManImpl5CheckEv:
 1049|   159k|{
 1050|   159k|    AssertLockHeld(cs);
  ------------------
  |  |  142|   159k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
 1051|       |
 1052|       |    // Run consistency checks 1 in m_consistency_check_ratio times if enabled
 1053|   159k|    if (m_consistency_check_ratio == 0) return;
  ------------------
  |  Branch (1053:9): [True: 159k, False: 0]
  ------------------
 1054|      0|    if (insecure_rand.randrange(m_consistency_check_ratio) >= 1) return;
  ------------------
  |  Branch (1054:9): [True: 0, False: 0]
  ------------------
 1055|       |
 1056|      0|    const int err{CheckAddrman()};
 1057|      0|    if (err) {
  ------------------
  |  Branch (1057:9): [True: 0, False: 0]
  ------------------
 1058|      0|        LogPrintf("ADDRMAN CONSISTENCY CHECK FAILED!!! err=%i\n", err);
  ------------------
  |  |  266|      0|#define LogPrintf(...) LogInfo(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |  261|      0|#define LogInfo(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1059|      0|        assert(false);
 1060|      0|    }
 1061|      0|}
_ZNK11AddrManImpl12CheckAddrmanEv:
 1064|  1.47k|{
 1065|  1.47k|    AssertLockHeld(cs);
  ------------------
  |  |  142|  1.47k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
 1066|       |
 1067|  1.47k|    LOG_TIME_MILLIS_WITH_CATEGORY_MSG_ONCE(
  ------------------
  |  |  106|  1.47k|    BCLog::Timer<std::chrono::milliseconds> UNIQUE_NAME(logging_timer)(__func__, end_msg, log_category, /* msg_on_completion=*/false)
  |  |  ------------------
  |  |  |  |   11|  1.47k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  1.47k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  1.47k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1068|  1.47k|        strprintf("new %i, tried %i, total %u", nNew, nTried, vRandom.size()), BCLog::ADDRMAN);
 1069|       |
 1070|  1.47k|    std::unordered_set<nid_type> setTried;
 1071|  1.47k|    std::unordered_map<nid_type, int> mapNew;
 1072|  1.47k|    std::unordered_map<Network, NewTriedCount> local_counts;
 1073|       |
 1074|  1.47k|    if (vRandom.size() != (size_t)(nTried + nNew))
  ------------------
  |  Branch (1074:9): [True: 0, False: 1.47k]
  ------------------
 1075|      0|        return -7;
 1076|       |
 1077|  4.06k|    for (const auto& entry : mapInfo) {
  ------------------
  |  Branch (1077:28): [True: 4.06k, False: 1.22k]
  ------------------
 1078|  4.06k|        nid_type n = entry.first;
 1079|  4.06k|        const AddrInfo& info = entry.second;
 1080|  4.06k|        if (info.fInTried) {
  ------------------
  |  Branch (1080:13): [True: 2.94k, False: 1.11k]
  ------------------
 1081|  2.94k|            if (!TicksSinceEpoch<std::chrono::seconds>(info.m_last_success)) {
  ------------------
  |  Branch (1081:17): [True: 69, False: 2.87k]
  ------------------
 1082|     69|                return -1;
 1083|     69|            }
 1084|  2.87k|            if (info.nRefCount)
  ------------------
  |  Branch (1084:17): [True: 0, False: 2.87k]
  ------------------
 1085|      0|                return -2;
 1086|  2.87k|            setTried.insert(n);
 1087|  2.87k|            local_counts[info.GetNetwork()].n_tried++;
 1088|  2.87k|        } else {
 1089|  1.11k|            if (info.nRefCount < 0 || info.nRefCount > ADDRMAN_NEW_BUCKETS_PER_ADDRESS)
  ------------------
  |  Branch (1089:17): [True: 0, False: 1.11k]
  |  Branch (1089:39): [True: 0, False: 1.11k]
  ------------------
 1090|      0|                return -3;
 1091|  1.11k|            if (!info.nRefCount)
  ------------------
  |  Branch (1091:17): [True: 0, False: 1.11k]
  ------------------
 1092|      0|                return -4;
 1093|  1.11k|            mapNew[n] = info.nRefCount;
 1094|  1.11k|            local_counts[info.GetNetwork()].n_new++;
 1095|  1.11k|        }
 1096|  3.99k|        const auto it{mapAddr.find(info)};
 1097|  3.99k|        if (it == mapAddr.end() || it->second != n) {
  ------------------
  |  Branch (1097:13): [True: 16, False: 3.97k]
  |  Branch (1097:13): [True: 19, False: 3.97k]
  |  Branch (1097:36): [True: 3, False: 3.97k]
  ------------------
 1098|     19|            return -5;
 1099|     19|        }
 1100|  3.97k|        if (info.nRandomPos < 0 || (size_t)info.nRandomPos >= vRandom.size() || vRandom[info.nRandomPos] != n)
  ------------------
  |  Branch (1100:13): [True: 0, False: 3.97k]
  |  Branch (1100:36): [True: 0, False: 3.97k]
  |  Branch (1100:81): [True: 0, False: 3.97k]
  ------------------
 1101|      0|            return -14;
 1102|  3.97k|        if (info.m_last_try < NodeSeconds{0s}) {
  ------------------
  |  Branch (1102:13): [True: 0, False: 3.97k]
  ------------------
 1103|      0|            return -6;
 1104|      0|        }
 1105|  3.97k|        if (info.m_last_success < NodeSeconds{0s}) {
  ------------------
  |  Branch (1105:13): [True: 165, False: 3.80k]
  ------------------
 1106|    165|            return -8;
 1107|    165|        }
 1108|  3.97k|    }
 1109|       |
 1110|  1.22k|    if (setTried.size() != (size_t)nTried)
  ------------------
  |  Branch (1110:9): [True: 0, False: 1.22k]
  ------------------
 1111|      0|        return -9;
 1112|  1.22k|    if (mapNew.size() != (size_t)nNew)
  ------------------
  |  Branch (1112:9): [True: 0, False: 1.22k]
  ------------------
 1113|      0|        return -10;
 1114|       |
 1115|   314k|    for (int n = 0; n < ADDRMAN_TRIED_BUCKET_COUNT; n++) {
  ------------------
  |  Branch (1115:21): [True: 313k, False: 1.22k]
  ------------------
 1116|  20.3M|        for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
  ------------------
  |  Branch (1116:25): [True: 20.0M, False: 313k]
  ------------------
 1117|  20.0M|            if (vvTried[n][i] != -1) {
  ------------------
  |  Branch (1117:17): [True: 2.57k, False: 20.0M]
  ------------------
 1118|  2.57k|                if (!setTried.count(vvTried[n][i]))
  ------------------
  |  Branch (1118:21): [True: 0, False: 2.57k]
  ------------------
 1119|      0|                    return -11;
 1120|  2.57k|                const auto it{mapInfo.find(vvTried[n][i])};
 1121|  2.57k|                if (it == mapInfo.end() || it->second.GetTriedBucket(nKey, m_netgroupman) != n) {
  ------------------
  |  Branch (1121:21): [True: 0, False: 2.57k]
  |  Branch (1121:21): [True: 0, False: 2.57k]
  |  Branch (1121:44): [True: 0, False: 2.57k]
  ------------------
 1122|      0|                    return -17;
 1123|      0|                }
 1124|  2.57k|                if (it->second.GetBucketPosition(nKey, false, n) != i) {
  ------------------
  |  Branch (1124:21): [True: 0, False: 2.57k]
  ------------------
 1125|      0|                    return -18;
 1126|      0|                }
 1127|  2.57k|                setTried.erase(vvTried[n][i]);
 1128|  2.57k|            }
 1129|  20.0M|        }
 1130|   313k|    }
 1131|       |
 1132|  1.25M|    for (int n = 0; n < ADDRMAN_NEW_BUCKET_COUNT; n++) {
  ------------------
  |  Branch (1132:21): [True: 1.25M, False: 1.22k]
  ------------------
 1133|  81.4M|        for (int i = 0; i < ADDRMAN_BUCKET_SIZE; i++) {
  ------------------
  |  Branch (1133:25): [True: 80.1M, False: 1.25M]
  ------------------
 1134|  80.1M|            if (vvNew[n][i] != -1) {
  ------------------
  |  Branch (1134:17): [True: 1.03k, False: 80.1M]
  ------------------
 1135|  1.03k|                if (!mapNew.count(vvNew[n][i]))
  ------------------
  |  Branch (1135:21): [True: 0, False: 1.03k]
  ------------------
 1136|      0|                    return -12;
 1137|  1.03k|                const auto it{mapInfo.find(vvNew[n][i])};
 1138|  1.03k|                if (it == mapInfo.end() || it->second.GetBucketPosition(nKey, true, n) != i) {
  ------------------
  |  Branch (1138:21): [True: 0, False: 1.03k]
  |  Branch (1138:21): [True: 0, False: 1.03k]
  |  Branch (1138:44): [True: 0, False: 1.03k]
  ------------------
 1139|      0|                    return -19;
 1140|      0|                }
 1141|  1.03k|                if (--mapNew[vvNew[n][i]] == 0)
  ------------------
  |  Branch (1141:21): [True: 976, False: 56]
  ------------------
 1142|    976|                    mapNew.erase(vvNew[n][i]);
 1143|  1.03k|            }
 1144|  80.1M|        }
 1145|  1.25M|    }
 1146|       |
 1147|  1.22k|    if (setTried.size())
  ------------------
  |  Branch (1147:9): [True: 0, False: 1.22k]
  ------------------
 1148|      0|        return -13;
 1149|  1.22k|    if (mapNew.size())
  ------------------
  |  Branch (1149:9): [True: 0, False: 1.22k]
  ------------------
 1150|      0|        return -15;
 1151|  1.22k|    if (nKey.IsNull())
  ------------------
  |  Branch (1151:9): [True: 1, False: 1.22k]
  ------------------
 1152|      1|        return -16;
 1153|       |
 1154|       |    // It's possible that m_network_counts may have all-zero entries that local_counts
 1155|       |    // doesn't have if addrs from a network were being added and then removed again in the past.
 1156|  1.22k|    if (m_network_counts.size() < local_counts.size()) {
  ------------------
  |  Branch (1156:9): [True: 0, False: 1.22k]
  ------------------
 1157|      0|        return -20;
 1158|      0|    }
 1159|  1.69k|    for (const auto& [net, count] : m_network_counts) {
  ------------------
  |  Branch (1159:35): [True: 1.69k, False: 1.22k]
  ------------------
 1160|  1.69k|        if (local_counts[net].n_new != count.n_new || local_counts[net].n_tried != count.n_tried) {
  ------------------
  |  Branch (1160:13): [True: 0, False: 1.69k]
  |  Branch (1160:55): [True: 0, False: 1.69k]
  ------------------
 1161|      0|            return -21;
 1162|      0|        }
 1163|  1.69k|    }
 1164|       |
 1165|  1.22k|    return 0;
 1166|  1.22k|}
_ZNK11AddrManImpl7GetAddrEmmNSt3__18optionalI7NetworkEEb:
 1230|  79.8k|{
 1231|  79.8k|    LOCK(cs);
  ------------------
  |  |  257|  79.8k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  79.8k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  79.8k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  79.8k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1232|  79.8k|    Check();
 1233|  79.8k|    auto addresses = GetAddr_(max_addresses, max_pct, network, filtered);
 1234|  79.8k|    Check();
 1235|  79.8k|    return addresses;
 1236|  79.8k|}
_ZN7AddrManC2ERK15NetGroupManagerbi:
 1273|  9.84k|    : m_impl(std::make_unique<AddrManImpl>(netgroupman, deterministic, consistency_check_ratio)) {}
_ZN7AddrManD2Ev:
 1275|  9.84k|AddrMan::~AddrMan() = default;
_ZN7AddrMan11UnserializeI10DataStreamEEvRT_:
 1285|  3.77k|{
 1286|  3.77k|    m_impl->Unserialize<Stream>(s_);
 1287|  3.77k|}
_ZNK7AddrMan7GetAddrEmmNSt3__18optionalI7NetworkEEb:
 1333|  79.8k|{
 1334|  79.8k|    return m_impl->GetAddr(max_addresses, max_pct, network, filtered);
 1335|  79.8k|}
_ZN11AddrManImpl11UnserializeI10DataStreamEEvRT_:
  232|  3.77k|{
  233|  3.77k|    LOCK(cs);
  ------------------
  |  |  257|  3.77k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  3.77k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  3.77k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  3.77k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  234|       |
  235|  3.77k|    assert(vRandom.empty());
  236|       |
  237|  3.77k|    Format format;
  238|  3.77k|    s_ >> Using<CustomUintFormatter<1>>(format);
  239|       |
  240|  3.77k|    const auto ser_params = (format >= Format::V3_BIP155 ? CAddress::V2_DISK : CAddress::V1_DISK);
  ------------------
  |  Branch (240:30): [True: 2.12k, False: 1.64k]
  ------------------
  241|  3.77k|    ParamsStream s{s_, ser_params};
  242|       |
  243|  3.77k|    uint8_t compat;
  244|  3.77k|    s >> compat;
  245|  3.77k|    if (compat < INCOMPATIBILITY_BASE) {
  ------------------
  |  Branch (245:9): [True: 162, False: 3.60k]
  ------------------
  246|    162|        throw std::ios_base::failure(strprintf(
  ------------------
  |  | 1172|    162|#define strprintf tfm::format
  ------------------
  247|    162|            "Corrupted addrman database: The compat value (%u) "
  248|    162|            "is lower than the expected minimum value %u.",
  249|    162|            compat, INCOMPATIBILITY_BASE));
  250|    162|    }
  251|  3.60k|    const uint8_t lowest_compatible = compat - INCOMPATIBILITY_BASE;
  252|  3.60k|    if (lowest_compatible > FILE_FORMAT) {
  ------------------
  |  Branch (252:9): [True: 379, False: 3.22k]
  ------------------
  253|    379|        throw InvalidAddrManVersionError(strprintf(
  ------------------
  |  | 1172|    379|#define strprintf tfm::format
  ------------------
  254|    379|            "Unsupported format of addrman database: %u. It is compatible with formats >=%u, "
  255|    379|            "but the maximum supported by this version of %s is %u.",
  256|    379|            uint8_t{format}, lowest_compatible, CLIENT_NAME, uint8_t{FILE_FORMAT}));
  ------------------
  |  |  127|    379|#define CLIENT_NAME "Bitcoin Core"
  ------------------
  257|    379|    }
  258|       |
  259|  3.22k|    s >> nKey;
  260|  3.22k|    s >> nNew;
  261|  3.22k|    s >> nTried;
  262|  3.22k|    int nUBuckets = 0;
  263|  3.22k|    s >> nUBuckets;
  264|  3.22k|    if (format >= Format::V1_DETERMINISTIC) {
  ------------------
  |  Branch (264:9): [True: 1.56k, False: 1.66k]
  ------------------
  265|  1.56k|        nUBuckets ^= (1 << 30);
  266|  1.56k|    }
  267|       |
  268|  3.22k|    if (nNew > ADDRMAN_NEW_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE || nNew < 0) {
  ------------------
  |  Branch (268:9): [True: 289, False: 2.94k]
  |  Branch (268:66): [True: 46, False: 2.89k]
  ------------------
  269|     52|        throw std::ios_base::failure(
  270|     52|                strprintf("Corrupt AddrMan serialization: nNew=%d, should be in [0, %d]",
  ------------------
  |  | 1172|     52|#define strprintf tfm::format
  ------------------
  271|     52|                    nNew,
  272|     52|                    ADDRMAN_NEW_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE));
  273|     52|    }
  274|       |
  275|  3.17k|    if (nTried > ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE || nTried < 0) {
  ------------------
  |  Branch (275:9): [True: 294, False: 2.88k]
  |  Branch (275:70): [True: 52, False: 2.83k]
  ------------------
  276|     63|        throw std::ios_base::failure(
  277|     63|                strprintf("Corrupt AddrMan serialization: nTried=%d, should be in [0, %d]",
  ------------------
  |  | 1172|     63|#define strprintf tfm::format
  ------------------
  278|     63|                    nTried,
  279|     63|                    ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE));
  280|     63|    }
  281|       |
  282|       |    // Deserialize entries from the new table.
  283|   221k|    for (int n = 0; n < nNew; n++) {
  ------------------
  |  Branch (283:21): [True: 218k, False: 3.11k]
  ------------------
  284|   218k|        AddrInfo& info = mapInfo[n];
  285|   218k|        s >> info;
  286|   218k|        mapAddr[info] = n;
  287|   218k|        info.nRandomPos = vRandom.size();
  288|   218k|        vRandom.push_back(n);
  289|   218k|        m_network_counts[info.GetNetwork()].n_new++;
  290|   218k|    }
  291|  3.11k|    nIdCount = nNew;
  292|       |
  293|       |    // Deserialize entries from the tried table.
  294|  3.11k|    int nLost = 0;
  295|  45.1k|    for (int n = 0; n < nTried; n++) {
  ------------------
  |  Branch (295:21): [True: 42.0k, False: 3.11k]
  ------------------
  296|  42.0k|        AddrInfo info;
  297|  42.0k|        s >> info;
  298|  42.0k|        int nKBucket = info.GetTriedBucket(nKey, m_netgroupman);
  299|  42.0k|        int nKBucketPos = info.GetBucketPosition(nKey, false, nKBucket);
  300|  42.0k|        if (info.IsValid()
  ------------------
  |  Branch (300:13): [True: 20.9k, False: 21.1k]
  ------------------
  301|  42.0k|                && vvTried[nKBucket][nKBucketPos] == -1) {
  ------------------
  |  Branch (301:20): [True: 5.19k, False: 15.7k]
  ------------------
  302|  5.19k|            info.nRandomPos = vRandom.size();
  303|  5.19k|            info.fInTried = true;
  304|  5.19k|            vRandom.push_back(nIdCount);
  305|  5.19k|            mapInfo[nIdCount] = info;
  306|  5.19k|            mapAddr[info] = nIdCount;
  307|  5.19k|            vvTried[nKBucket][nKBucketPos] = nIdCount;
  308|  5.19k|            nIdCount++;
  309|  5.19k|            m_network_counts[info.GetNetwork()].n_tried++;
  310|  36.8k|        } else {
  311|  36.8k|            nLost++;
  312|  36.8k|        }
  313|  42.0k|    }
  314|  3.11k|    nTried -= nLost;
  315|       |
  316|       |    // Store positions in the new table buckets to apply later (if possible).
  317|       |    // An entry may appear in up to ADDRMAN_NEW_BUCKETS_PER_ADDRESS buckets,
  318|       |    // so we store all bucket-entry_index pairs to iterate through later.
  319|  3.11k|    std::vector<std::pair<int, int>> bucket_entries;
  320|       |
  321|  64.3k|    for (int bucket = 0; bucket < nUBuckets; ++bucket) {
  ------------------
  |  Branch (321:26): [True: 61.2k, False: 3.11k]
  ------------------
  322|  61.2k|        int num_entries{0};
  323|  61.2k|        s >> num_entries;
  324|   488k|        for (int n = 0; n < num_entries; ++n) {
  ------------------
  |  Branch (324:25): [True: 427k, False: 61.2k]
  ------------------
  325|   427k|            int entry_index{0};
  326|   427k|            s >> entry_index;
  327|   427k|            if (entry_index >= 0 && entry_index < nNew) {
  ------------------
  |  Branch (327:17): [True: 412k, False: 14.5k]
  |  Branch (327:37): [True: 335k, False: 77.4k]
  ------------------
  328|   335k|                bucket_entries.emplace_back(bucket, entry_index);
  329|   335k|            }
  330|   427k|        }
  331|  61.2k|    }
  332|       |
  333|       |    // If the bucket count and asmap checksum haven't changed, then attempt
  334|       |    // to restore the entries to the buckets/positions they were in before
  335|       |    // serialization.
  336|  3.11k|    uint256 supplied_asmap_checksum{m_netgroupman.GetAsmapChecksum()};
  337|  3.11k|    uint256 serialized_asmap_checksum;
  338|  3.11k|    if (format >= Format::V2_ASMAP) {
  ------------------
  |  Branch (338:9): [True: 347, False: 2.76k]
  ------------------
  339|    347|        s >> serialized_asmap_checksum;
  340|    347|    }
  341|  3.11k|    const bool restore_bucketing{nUBuckets == ADDRMAN_NEW_BUCKET_COUNT &&
  ------------------
  |  Branch (341:34): [True: 25, False: 3.08k]
  ------------------
  342|  3.11k|        serialized_asmap_checksum == supplied_asmap_checksum};
  ------------------
  |  Branch (342:9): [True: 22, False: 3]
  ------------------
  343|       |
  344|  3.11k|    if (!restore_bucketing) {
  ------------------
  |  Branch (344:9): [True: 1.45k, False: 1.66k]
  ------------------
  345|  1.45k|        LogDebug(BCLog::ADDRMAN, "Bucketing method was updated, re-bucketing addrman entries from disk\n");
  ------------------
  |  |  280|  1.45k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  1.45k|    do {                                                  \
  |  |  |  |  274|  1.45k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 1.45k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  1.45k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  346|  1.45k|    }
  347|       |
  348|  36.0k|    for (auto bucket_entry : bucket_entries) {
  ------------------
  |  Branch (348:28): [True: 36.0k, False: 3.11k]
  ------------------
  349|  36.0k|        int bucket{bucket_entry.first};
  350|  36.0k|        const int entry_index{bucket_entry.second};
  351|  36.0k|        AddrInfo& info = mapInfo[entry_index];
  352|       |
  353|       |        // Don't store the entry in the new bucket if it's not a valid address for our addrman
  354|  36.0k|        if (!info.IsValid()) continue;
  ------------------
  |  Branch (354:13): [True: 466, False: 35.6k]
  ------------------
  355|       |
  356|       |        // The entry shouldn't appear in more than
  357|       |        // ADDRMAN_NEW_BUCKETS_PER_ADDRESS. If it has already, just skip
  358|       |        // this bucket_entry.
  359|  35.6k|        if (info.nRefCount >= ADDRMAN_NEW_BUCKETS_PER_ADDRESS) continue;
  ------------------
  |  Branch (359:13): [True: 272, False: 35.3k]
  ------------------
  360|       |
  361|  35.3k|        int bucket_position = info.GetBucketPosition(nKey, true, bucket);
  362|  35.3k|        if (restore_bucketing && vvNew[bucket][bucket_position] == -1) {
  ------------------
  |  Branch (362:13): [True: 550, False: 34.7k]
  |  Branch (362:34): [True: 119, False: 431]
  ------------------
  363|       |            // Bucketing has not changed, using existing bucket positions for the new table
  364|    119|            vvNew[bucket][bucket_position] = entry_index;
  365|    119|            ++info.nRefCount;
  366|  35.2k|        } else {
  367|       |            // In case the new table data cannot be used (bucket count wrong or new asmap),
  368|       |            // try to give them a reference based on their primary source address.
  369|  35.2k|            bucket = info.GetNewBucket(nKey, m_netgroupman);
  370|  35.2k|            bucket_position = info.GetBucketPosition(nKey, true, bucket);
  371|  35.2k|            if (vvNew[bucket][bucket_position] == -1) {
  ------------------
  |  Branch (371:17): [True: 1.11k, False: 34.0k]
  ------------------
  372|  1.11k|                vvNew[bucket][bucket_position] = entry_index;
  373|  1.11k|                ++info.nRefCount;
  374|  1.11k|            }
  375|  35.2k|        }
  376|  35.3k|    }
  377|       |
  378|       |    // Prune new entries with refcount 0 (as a result of collisions or invalid address).
  379|  3.11k|    int nLostUnk = 0;
  380|  93.6k|    for (auto it = mapInfo.cbegin(); it != mapInfo.cend(); ) {
  ------------------
  |  Branch (380:38): [True: 90.5k, False: 3.11k]
  ------------------
  381|  90.5k|        if (it->second.fInTried == false && it->second.nRefCount == 0) {
  ------------------
  |  Branch (381:13): [True: 86.9k, False: 3.59k]
  |  Branch (381:45): [True: 85.7k, False: 1.12k]
  ------------------
  382|  85.7k|            const auto itCopy = it++;
  383|  85.7k|            Delete(itCopy->first);
  384|  85.7k|            ++nLostUnk;
  385|  85.7k|        } else {
  386|  4.72k|            ++it;
  387|  4.72k|        }
  388|  90.5k|    }
  389|  3.11k|    if (nLost + nLostUnk > 0) {
  ------------------
  |  Branch (389:9): [True: 743, False: 2.37k]
  ------------------
  390|    743|        LogDebug(BCLog::ADDRMAN, "addrman lost %i new and %i tried addresses due to collisions or invalid addresses\n", nLostUnk, nLost);
  ------------------
  |  |  280|    743|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|    743|    do {                                                  \
  |  |  |  |  274|    743|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 743]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|    743|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  391|    743|    }
  392|       |
  393|  3.11k|    const int check_code{CheckAddrman()};
  394|  3.11k|    if (check_code != 0) {
  ------------------
  |  Branch (394:9): [True: 254, False: 2.86k]
  ------------------
  395|    254|        throw std::ios_base::failure(strprintf(
  ------------------
  |  | 1172|    254|#define strprintf tfm::format
  ------------------
  396|    254|            "Corrupt data. Consistency check failed with code %s",
  397|    254|            check_code));
  398|    254|    }
  399|  3.11k|}

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

_ZN8AddrInfoC2Ev:
   81|   265k|    AddrInfo() : CAddress(), source()
   82|   265k|    {
   83|   265k|    }
_ZNK8AddrInfo12GetNewBucketERK7uint256RK15NetGroupManager:
   93|  35.2k|    {
   94|  35.2k|        return GetNewBucket(nKey, source, netgroupman);
   95|  35.2k|    }
_ZN8AddrInfo16SerializationOpsI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEES_17ActionUnserializeEEvRT0_RT_T1_:
   73|   260k|    {
   74|   260k|        READWRITE(AsBase<CAddress>(obj), obj.source, Using<ChronoFormatter<int64_t>>(obj.m_last_success), obj.nAttempts);
  ------------------
  |  |  156|   260k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
   75|   260k|    }

_ZN6BanManD2Ev:
   25|      2|{
   26|      2|    DumpBanlist();
   27|      2|}
_ZN6BanMan11DumpBanlistEv:
   49|      2|{
   50|      2|    static Mutex dump_mutex;
   51|      2|    LOCK(dump_mutex);
  ------------------
  |  |  257|      2|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   52|       |
   53|      2|    banmap_t banmap;
   54|      2|    {
   55|      2|        LOCK(m_banned_mutex);
  ------------------
  |  |  257|      2|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   56|      2|        SweepBanned();
   57|      2|        if (!m_is_dirty) return;
  ------------------
  |  Branch (57:13): [True: 2, False: 0]
  ------------------
   58|      0|        banmap = m_banned;
   59|      0|        m_is_dirty = false;
   60|      0|    }
   61|       |
   62|      0|    const auto start{SteadyClock::now()};
   63|      0|    if (!m_ban_db.Write(banmap)) {
  ------------------
  |  Branch (63:9): [True: 0, False: 0]
  ------------------
   64|      0|        LOCK(m_banned_mutex);
  ------------------
  |  |  257|      0|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      0|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      0|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      0|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   65|      0|        m_is_dirty = true;
   66|      0|    }
   67|       |
   68|      0|    LogDebug(BCLog::NET, "Flushed %d banned node addresses/subnets to disk  %dms\n", banmap.size(),
  ------------------
  |  |  280|      0|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|      0|    do {                                                  \
  |  |  |  |  274|      0|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   69|      0|             Ticks<std::chrono::milliseconds>(SteadyClock::now() - start));
   70|      0|}
_ZN6BanMan11SweepBannedEv:
  183|      2|{
  184|      2|    AssertLockHeld(m_banned_mutex);
  ------------------
  |  |  142|      2|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  185|       |
  186|      2|    int64_t now = GetTime();
  187|      2|    bool notify_ui = false;
  188|      2|    banmap_t::iterator it = m_banned.begin();
  189|      2|    while (it != m_banned.end()) {
  ------------------
  |  Branch (189:12): [True: 0, False: 2]
  ------------------
  190|      0|        CSubNet sub_net = (*it).first;
  191|      0|        CBanEntry ban_entry = (*it).second;
  192|      0|        if (!sub_net.IsValid() || now > ban_entry.nBanUntil) {
  ------------------
  |  Branch (192:13): [True: 0, False: 0]
  |  Branch (192:35): [True: 0, False: 0]
  ------------------
  193|      0|            m_banned.erase(it++);
  194|      0|            m_is_dirty = true;
  195|      0|            notify_ui = true;
  196|      0|            LogDebug(BCLog::NET, "Removed banned node address/subnet: %s\n", sub_net.ToString());
  ------------------
  |  |  280|      0|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|      0|    do {                                                  \
  |  |  |  |  274|      0|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  197|      0|        } else {
  198|      0|            ++it;
  199|      0|        }
  200|      0|    }
  201|       |
  202|       |    // update UI
  203|      2|    if (notify_ui && m_client_interface) {
  ------------------
  |  Branch (203:9): [True: 0, False: 2]
  |  Branch (203:22): [True: 0, False: 0]
  ------------------
  204|      0|        m_client_interface->BannedListChanged();
  205|      0|    }
  206|      2|}

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

_ZN11CCheckQueueI12CScriptCheckNSt3__14pairI13ScriptError_tNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEE4LoopEb:
   73|      0|    {
   74|      0|        std::condition_variable& cond = fMaster ? m_master_cv : m_worker_cv;
  ------------------
  |  Branch (74:41): [True: 0, False: 0]
  ------------------
   75|      0|        std::vector<T> vChecks;
   76|      0|        vChecks.reserve(nBatchSize);
   77|      0|        unsigned int nNow = 0;
   78|      0|        std::optional<R> local_result;
   79|      0|        bool do_work;
   80|      0|        do {
   81|      0|            {
   82|      0|                WAIT_LOCK(m_mutex, lock);
  ------------------
  |  |  262|      0|#define WAIT_LOCK(cs, name) UniqueLock name(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  ------------------
   83|       |                // first do the clean-up of the previous loop run (allowing us to do it in the same critsect)
   84|      0|                if (nNow) {
  ------------------
  |  Branch (84:21): [True: 0, False: 0]
  ------------------
   85|      0|                    if (local_result.has_value() && !m_result.has_value()) {
  ------------------
  |  Branch (85:25): [True: 0, False: 0]
  |  Branch (85:53): [True: 0, False: 0]
  ------------------
   86|      0|                        std::swap(local_result, m_result);
   87|      0|                    }
   88|      0|                    nTodo -= nNow;
   89|      0|                    if (nTodo == 0 && !fMaster) {
  ------------------
  |  Branch (89:25): [True: 0, False: 0]
  |  Branch (89:39): [True: 0, False: 0]
  ------------------
   90|       |                        // We processed the last element; inform the master it can exit and return the result
   91|      0|                        m_master_cv.notify_one();
   92|      0|                    }
   93|      0|                } else {
   94|       |                    // first iteration
   95|      0|                    nTotal++;
   96|      0|                }
   97|       |                // logically, the do loop starts here
   98|      4|                while (queue.empty() && !m_request_stop) {
  ------------------
  |  Branch (98:24): [True: 4, False: 18.4E]
  |  Branch (98:41): [True: 0, False: 4]
  ------------------
   99|      0|                    if (fMaster && nTodo == 0) {
  ------------------
  |  Branch (99:25): [True: 0, False: 0]
  |  Branch (99:36): [True: 0, False: 0]
  ------------------
  100|      0|                        nTotal--;
  101|      0|                        std::optional<R> to_return = std::move(m_result);
  102|       |                        // reset the status for new work later
  103|      0|                        m_result = std::nullopt;
  104|       |                        // return the current status
  105|      0|                        return to_return;
  106|      0|                    }
  107|      0|                    nIdle++;
  108|      0|                    cond.wait(lock); // wait
  109|      0|                    nIdle--;
  110|      0|                }
  111|      4|                if (m_request_stop) {
  ------------------
  |  Branch (111:21): [True: 4, False: 18.4E]
  ------------------
  112|       |                    // return value does not matter, because m_request_stop is only set in the destructor.
  113|      4|                    return std::nullopt;
  114|      4|                }
  115|       |
  116|       |                // Decide how many work units to process now.
  117|       |                // * Do not try to do everything at once, but aim for increasingly smaller batches so
  118|       |                //   all workers finish approximately simultaneously.
  119|       |                // * Try to account for idle jobs which will instantly start helping.
  120|       |                // * Don't do batches smaller than 1 (duh), or larger than nBatchSize.
  121|  18.4E|                nNow = std::max(1U, std::min(nBatchSize, (unsigned int)queue.size() / (nTotal + nIdle + 1)));
  122|  18.4E|                auto start_it = queue.end() - nNow;
  123|  18.4E|                vChecks.assign(std::make_move_iterator(start_it), std::make_move_iterator(queue.end()));
  124|  18.4E|                queue.erase(start_it, queue.end());
  125|       |                // Check whether we need to do work at all
  126|  18.4E|                do_work = !m_result.has_value();
  127|  18.4E|            }
  128|       |            // execute work
  129|  18.4E|            if (do_work) {
  ------------------
  |  Branch (129:17): [True: 0, False: 18.4E]
  ------------------
  130|      0|                for (T& check : vChecks) {
  ------------------
  |  Branch (130:31): [True: 0, False: 0]
  ------------------
  131|      0|                    local_result = check();
  132|      0|                    if (local_result.has_value()) break;
  ------------------
  |  Branch (132:25): [True: 0, False: 0]
  ------------------
  133|      0|                }
  134|      0|            }
  135|  18.4E|            vChecks.clear();
  136|  18.4E|        } while (true);
  ------------------
  |  Branch (136:18): [Folded - Ignored]
  ------------------
  137|      0|    }
_ZN11CCheckQueueI12CScriptCheckNSt3__14pairI13ScriptError_tNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEED2Ev:
  192|      2|    {
  193|      2|        WITH_LOCK(m_mutex, m_request_stop = true);
  ------------------
  |  |  301|      2|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
  ------------------
  194|      2|        m_worker_cv.notify_all();
  195|      4|        for (std::thread& t : m_worker_threads) {
  ------------------
  |  Branch (195:29): [True: 4, False: 2]
  ------------------
  196|      4|            t.join();
  197|      4|        }
  198|      2|    }

_ZN16CCoinsCacheEntryD2Ev:
  173|      2|    {
  174|      2|        SetClean();
  175|      2|    }
_ZN16CCoinsCacheEntry8SetCleanEv:
  181|      2|    {
  182|      2|        if (!m_flags) return;
  ------------------
  |  Branch (182:13): [True: 0, False: 2]
  ------------------
  183|      2|        m_next->second.m_prev = m_prev;
  184|      2|        m_prev->second.m_next = m_next;
  185|      2|        m_flags = 0;
  186|      2|        m_prev = m_next = nullptr;
  187|      2|    }
_ZN10CCoinsViewD2Ev:
  335|      6|    virtual ~CCoinsView() = default;

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

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

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

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

_Z17internal_bswap_16t:
   45|  13.4k|{
   46|  13.4k|#ifdef bitcoin_builtin_bswap16
   47|  13.4k|    return bitcoin_builtin_bswap16(x);
  ------------------
  |  |   21|  13.4k|#      define bitcoin_builtin_bswap16(x) __builtin_bswap16(x)
  ------------------
   48|       |#else
   49|       |    return (x >> 8) | (x << 8);
   50|       |#endif
   51|  13.4k|}
_Z17internal_bswap_32j:
   54|  5.14M|{
   55|  5.14M|#ifdef bitcoin_builtin_bswap32
   56|  5.14M|    return bitcoin_builtin_bswap32(x);
  ------------------
  |  |   24|  5.14M|#      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|  5.14M|}
_Z17internal_bswap_64m:
   64|  1.40M|{
   65|  1.40M|#ifdef bitcoin_builtin_bswap64
   66|  1.40M|    return bitcoin_builtin_bswap64(x);
  ------------------
  |  |   27|  1.40M|#      define bitcoin_builtin_bswap64(x) __builtin_bswap64(x)
  ------------------
   67|       |#else
   68|       |     return (((x & 0xff00000000000000ull) >> 56)
   69|       |          | ((x & 0x00ff000000000000ull) >> 40)
   70|       |          | ((x & 0x0000ff0000000000ull) >> 24)
   71|       |          | ((x & 0x000000ff00000000ull) >> 8)
   72|       |          | ((x & 0x00000000ff000000ull) << 8)
   73|       |          | ((x & 0x0000000000ff0000ull) << 24)
   74|       |          | ((x & 0x000000000000ff00ull) << 40)
   75|       |          | ((x & 0x00000000000000ffull) << 56));
   76|       |#endif
   77|  1.40M|}

_Z16htole16_internalt:
   19|     59|{
   20|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(host_16bits);
   21|     59|        else return host_16bits;
   22|     59|}
_Z16be16toh_internalt:
   24|  13.4k|{
   25|  13.4k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_16(big_endian_16bits);
   26|       |        else return big_endian_16bits;
   27|  13.4k|}
_Z16le16toh_internalt:
   29|     94|{
   30|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits);
   31|     94|        else return little_endian_16bits;
   32|     94|}
_Z16htobe32_internalj:
   34|  5.08M|{
   35|  5.08M|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(host_32bits);
   36|       |        else return host_32bits;
   37|  5.08M|}
_Z16htole32_internalj:
   39|   771k|{
   40|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits);
   41|   771k|        else return host_32bits;
   42|   771k|}
_Z16be32toh_internalj:
   44|  62.9k|{
   45|  62.9k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(big_endian_32bits);
   46|       |        else return big_endian_32bits;
   47|  62.9k|}
_Z16le32toh_internalj:
   49|  1.82M|{
   50|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits);
   51|  1.82M|        else return little_endian_32bits;
   52|  1.82M|}
_Z16htobe64_internalm:
   54|   819k|{
   55|   819k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(host_64bits);
   56|       |        else return host_64bits;
   57|   819k|}
_Z16htole64_internalm:
   59|  94.8k|{
   60|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(host_64bits);
   61|  94.8k|        else return host_64bits;
   62|  94.8k|}
_Z16be64toh_internalm:
   64|   586k|{
   65|   586k|    if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(big_endian_64bits);
   66|       |        else return big_endian_64bits;
   67|   586k|}
_Z16le64toh_internalm:
   69|   895k|{
   70|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits);
   71|   895k|        else return little_endian_64bits;
   72|   895k|}

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

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

_Z8ReadLE64ITk8ByteTypehEmPKT_:
   36|   301k|{
   37|   301k|    uint64_t x;
   38|   301k|    memcpy(&x, ptr, 8);
   39|   301k|    return le64toh_internal(x);
   40|   301k|}
_Z8ReadLE64ITk8ByteTypeSt4byteEmPKT_:
   36|  77.3k|{
   37|  77.3k|    uint64_t x;
   38|  77.3k|    memcpy(&x, ptr, 8);
   39|  77.3k|    return le64toh_internal(x);
   40|  77.3k|}
_Z9WriteLE32ITk8ByteTypeSt4byteEvPT_j:
   51|   614k|{
   52|   614k|    uint32_t v = htole32_internal(x);
   53|   614k|    memcpy(ptr, &v, 4);
   54|   614k|}
_Z9WriteLE64ITk8ByteTypehEvPT_m:
   58|  15.4k|{
   59|  15.4k|    uint64_t v = htole64_internal(x);
   60|  15.4k|    memcpy(ptr, &v, 8);
   61|  15.4k|}
_Z8ReadBE16ITk8ByteTypehEtPKT_:
   65|  13.4k|{
   66|  13.4k|    uint16_t x;
   67|  13.4k|    memcpy(&x, ptr, 2);
   68|  13.4k|    return be16toh_internal(x);
   69|  13.4k|}
_Z9WriteBE32ITk8ByteTypehEvPT_j:
   96|  5.08M|{
   97|  5.08M|    uint32_t v = htobe32_internal(x);
   98|  5.08M|    memcpy(ptr, &v, 4);
   99|  5.08M|}
_Z8ReadBE32ITk8ByteTypehEjPKT_:
   73|  62.9k|{
   74|  62.9k|    uint32_t x;
   75|  62.9k|    memcpy(&x, ptr, 4);
   76|  62.9k|    return be32toh_internal(x);
   77|  62.9k|}
_Z9WriteBE64ITk8ByteTypehEvPT_m:
  103|   819k|{
  104|   819k|    uint64_t v = htobe64_internal(x);
  105|   819k|    memcpy(ptr, &v, 8);
  106|   819k|}
_Z8ReadBE64ITk8ByteTypehEmPKT_:
   81|   327k|{
   82|   327k|    uint64_t x;
   83|   327k|    memcpy(&x, ptr, 8);
   84|   327k|    return be64toh_internal(x);
   85|   327k|}
_Z8ReadLE32ITk8ByteTypeSt4byteEjPKT_:
   28|   542k|{
   29|   542k|    uint32_t x;
   30|   542k|    memcpy(&x, ptr, 4);
   31|   542k|    return le32toh_internal(x);
   32|   542k|}

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

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

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

_Z7KeccakFRA25_m:
   19|  3.85k|{
   20|  3.85k|    static constexpr uint64_t RNDC[24] = {
   21|  3.85k|        0x0000000000000001, 0x0000000000008082, 0x800000000000808a, 0x8000000080008000,
   22|  3.85k|        0x000000000000808b, 0x0000000080000001, 0x8000000080008081, 0x8000000000008009,
   23|  3.85k|        0x000000000000008a, 0x0000000000000088, 0x0000000080008009, 0x000000008000000a,
   24|  3.85k|        0x000000008000808b, 0x800000000000008b, 0x8000000000008089, 0x8000000000008003,
   25|  3.85k|        0x8000000000008002, 0x8000000000000080, 0x000000000000800a, 0x800000008000000a,
   26|  3.85k|        0x8000000080008081, 0x8000000000008080, 0x0000000080000001, 0x8000000080008008
   27|  3.85k|    };
   28|  3.85k|    static constexpr int ROUNDS = 24;
   29|       |
   30|  96.4k|    for (int round = 0; round < ROUNDS; ++round) {
  ------------------
  |  Branch (30:25): [True: 92.5k, False: 3.85k]
  ------------------
   31|  92.5k|        uint64_t bc0, bc1, bc2, bc3, bc4, t;
   32|       |
   33|       |        // Theta
   34|  92.5k|        bc0 = st[0] ^ st[5] ^ st[10] ^ st[15] ^ st[20];
   35|  92.5k|        bc1 = st[1] ^ st[6] ^ st[11] ^ st[16] ^ st[21];
   36|  92.5k|        bc2 = st[2] ^ st[7] ^ st[12] ^ st[17] ^ st[22];
   37|  92.5k|        bc3 = st[3] ^ st[8] ^ st[13] ^ st[18] ^ st[23];
   38|  92.5k|        bc4 = st[4] ^ st[9] ^ st[14] ^ st[19] ^ st[24];
   39|  92.5k|        t = bc4 ^ std::rotl(bc1, 1); st[0] ^= t; st[5] ^= t; st[10] ^= t; st[15] ^= t; st[20] ^= t;
   40|  92.5k|        t = bc0 ^ std::rotl(bc2, 1); st[1] ^= t; st[6] ^= t; st[11] ^= t; st[16] ^= t; st[21] ^= t;
   41|  92.5k|        t = bc1 ^ std::rotl(bc3, 1); st[2] ^= t; st[7] ^= t; st[12] ^= t; st[17] ^= t; st[22] ^= t;
   42|  92.5k|        t = bc2 ^ std::rotl(bc4, 1); st[3] ^= t; st[8] ^= t; st[13] ^= t; st[18] ^= t; st[23] ^= t;
   43|  92.5k|        t = bc3 ^ std::rotl(bc0, 1); st[4] ^= t; st[9] ^= t; st[14] ^= t; st[19] ^= t; st[24] ^= t;
   44|       |
   45|       |        // Rho Pi
   46|  92.5k|        t = st[1];
   47|  92.5k|        bc0 = st[10]; st[10] = std::rotl(t, 1); t = bc0;
   48|  92.5k|        bc0 = st[7]; st[7] = std::rotl(t, 3); t = bc0;
   49|  92.5k|        bc0 = st[11]; st[11] = std::rotl(t, 6); t = bc0;
   50|  92.5k|        bc0 = st[17]; st[17] = std::rotl(t, 10); t = bc0;
   51|  92.5k|        bc0 = st[18]; st[18] = std::rotl(t, 15); t = bc0;
   52|  92.5k|        bc0 = st[3]; st[3] = std::rotl(t, 21); t = bc0;
   53|  92.5k|        bc0 = st[5]; st[5] = std::rotl(t, 28); t = bc0;
   54|  92.5k|        bc0 = st[16]; st[16] = std::rotl(t, 36); t = bc0;
   55|  92.5k|        bc0 = st[8]; st[8] = std::rotl(t, 45); t = bc0;
   56|  92.5k|        bc0 = st[21]; st[21] = std::rotl(t, 55); t = bc0;
   57|  92.5k|        bc0 = st[24]; st[24] = std::rotl(t, 2); t = bc0;
   58|  92.5k|        bc0 = st[4]; st[4] = std::rotl(t, 14); t = bc0;
   59|  92.5k|        bc0 = st[15]; st[15] = std::rotl(t, 27); t = bc0;
   60|  92.5k|        bc0 = st[23]; st[23] = std::rotl(t, 41); t = bc0;
   61|  92.5k|        bc0 = st[19]; st[19] = std::rotl(t, 56); t = bc0;
   62|  92.5k|        bc0 = st[13]; st[13] = std::rotl(t, 8); t = bc0;
   63|  92.5k|        bc0 = st[12]; st[12] = std::rotl(t, 25); t = bc0;
   64|  92.5k|        bc0 = st[2]; st[2] = std::rotl(t, 43); t = bc0;
   65|  92.5k|        bc0 = st[20]; st[20] = std::rotl(t, 62); t = bc0;
   66|  92.5k|        bc0 = st[14]; st[14] = std::rotl(t, 18); t = bc0;
   67|  92.5k|        bc0 = st[22]; st[22] = std::rotl(t, 39); t = bc0;
   68|  92.5k|        bc0 = st[9]; st[9] = std::rotl(t, 61); t = bc0;
   69|  92.5k|        bc0 = st[6]; st[6] = std::rotl(t, 20); t = bc0;
   70|  92.5k|        st[1] = std::rotl(t, 44);
   71|       |
   72|       |        // Chi Iota
   73|  92.5k|        bc0 = st[0]; bc1 = st[1]; bc2 = st[2]; bc3 = st[3]; bc4 = st[4];
   74|  92.5k|        st[0] = bc0 ^ (~bc1 & bc2) ^ RNDC[round];
   75|  92.5k|        st[1] = bc1 ^ (~bc2 & bc3);
   76|  92.5k|        st[2] = bc2 ^ (~bc3 & bc4);
   77|  92.5k|        st[3] = bc3 ^ (~bc4 & bc0);
   78|  92.5k|        st[4] = bc4 ^ (~bc0 & bc1);
   79|  92.5k|        bc0 = st[5]; bc1 = st[6]; bc2 = st[7]; bc3 = st[8]; bc4 = st[9];
   80|  92.5k|        st[5] = bc0 ^ (~bc1 & bc2);
   81|  92.5k|        st[6] = bc1 ^ (~bc2 & bc3);
   82|  92.5k|        st[7] = bc2 ^ (~bc3 & bc4);
   83|  92.5k|        st[8] = bc3 ^ (~bc4 & bc0);
   84|  92.5k|        st[9] = bc4 ^ (~bc0 & bc1);
   85|  92.5k|        bc0 = st[10]; bc1 = st[11]; bc2 = st[12]; bc3 = st[13]; bc4 = st[14];
   86|  92.5k|        st[10] = bc0 ^ (~bc1 & bc2);
   87|  92.5k|        st[11] = bc1 ^ (~bc2 & bc3);
   88|  92.5k|        st[12] = bc2 ^ (~bc3 & bc4);
   89|  92.5k|        st[13] = bc3 ^ (~bc4 & bc0);
   90|  92.5k|        st[14] = bc4 ^ (~bc0 & bc1);
   91|  92.5k|        bc0 = st[15]; bc1 = st[16]; bc2 = st[17]; bc3 = st[18]; bc4 = st[19];
   92|  92.5k|        st[15] = bc0 ^ (~bc1 & bc2);
   93|  92.5k|        st[16] = bc1 ^ (~bc2 & bc3);
   94|  92.5k|        st[17] = bc2 ^ (~bc3 & bc4);
   95|  92.5k|        st[18] = bc3 ^ (~bc4 & bc0);
   96|  92.5k|        st[19] = bc4 ^ (~bc0 & bc1);
   97|  92.5k|        bc0 = st[20]; bc1 = st[21]; bc2 = st[22]; bc3 = st[23]; bc4 = st[24];
   98|  92.5k|        st[20] = bc0 ^ (~bc1 & bc2);
   99|  92.5k|        st[21] = bc1 ^ (~bc2 & bc3);
  100|  92.5k|        st[22] = bc2 ^ (~bc3 & bc4);
  101|  92.5k|        st[23] = bc3 ^ (~bc4 & bc0);
  102|  92.5k|        st[24] = bc4 ^ (~bc0 & bc1);
  103|  92.5k|    }
  104|  3.85k|}
_ZN8SHA3_2565WriteE4SpanIKhE:
  107|  11.5k|{
  108|  11.5k|    if (m_bufsize && data.size() >= sizeof(m_buffer) - m_bufsize) {
  ------------------
  |  Branch (108:9): [True: 7.71k, False: 3.85k]
  |  Branch (108:22): [True: 7.71k, False: 0]
  ------------------
  109|       |        // Fill the buffer and process it.
  110|  7.71k|        std::copy(data.begin(), data.begin() + (sizeof(m_buffer) - m_bufsize), m_buffer + m_bufsize);
  111|  7.71k|        data = data.subspan(sizeof(m_buffer) - m_bufsize);
  112|  7.71k|        m_state[m_pos++] ^= ReadLE64(m_buffer);
  113|  7.71k|        m_bufsize = 0;
  114|  7.71k|        if (m_pos == RATE_BUFFERS) {
  ------------------
  |  Branch (114:13): [True: 0, False: 7.71k]
  ------------------
  115|      0|            KeccakF(m_state);
  116|      0|            m_pos = 0;
  117|      0|        }
  118|  7.71k|    }
  119|  26.9k|    while (data.size() >= sizeof(m_buffer)) {
  ------------------
  |  Branch (119:12): [True: 15.4k, False: 11.5k]
  ------------------
  120|       |        // Process chunks directly from the buffer.
  121|  15.4k|        m_state[m_pos++] ^= ReadLE64(data.data());
  122|  15.4k|        data = data.subspan(8);
  123|  15.4k|        if (m_pos == RATE_BUFFERS) {
  ------------------
  |  Branch (123:13): [True: 0, False: 15.4k]
  ------------------
  124|      0|            KeccakF(m_state);
  125|      0|            m_pos = 0;
  126|      0|        }
  127|  15.4k|    }
  128|  11.5k|    if (data.size()) {
  ------------------
  |  Branch (128:9): [True: 7.71k, False: 3.85k]
  ------------------
  129|       |        // Keep the remainder in the buffer.
  130|  7.71k|        std::copy(data.begin(), data.end(), m_buffer + m_bufsize);
  131|  7.71k|        m_bufsize += data.size();
  132|  7.71k|    }
  133|  11.5k|    return *this;
  134|  11.5k|}
_ZN8SHA3_2568FinalizeE4SpanIhE:
  137|  3.85k|{
  138|  3.85k|    assert(output.size() == OUTPUT_SIZE);
  139|  3.85k|    std::fill(m_buffer + m_bufsize, m_buffer + sizeof(m_buffer), 0);
  140|  3.85k|    m_buffer[m_bufsize] ^= 0x06;
  141|  3.85k|    m_state[m_pos] ^= ReadLE64(m_buffer);
  142|  3.85k|    m_state[RATE_BUFFERS - 1] ^= 0x8000000000000000;
  143|  3.85k|    KeccakF(m_state);
  144|  19.2k|    for (unsigned i = 0; i < 4; ++i) {
  ------------------
  |  Branch (144:26): [True: 15.4k, False: 3.85k]
  ------------------
  145|  15.4k|        WriteLE64(output.data() + 8 * i, m_state[i]);
  146|  15.4k|    }
  147|  3.85k|    return *this;
  148|  3.85k|}

_ZN8SHA3_256C2Ev:
   35|  3.85k|    SHA3_256() = default;

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

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

_ZN10CDBWrapperD2Ev:
  279|      4|{
  280|      4|    delete DBContext().pdb;
  281|      4|    DBContext().pdb = nullptr;
  282|      4|    delete DBContext().options.filter_policy;
  283|      4|    DBContext().options.filter_policy = nullptr;
  284|      4|    delete DBContext().options.info_log;
  285|      4|    DBContext().options.info_log = nullptr;
  286|      4|    delete DBContext().options.block_cache;
  287|      4|    DBContext().options.block_cache = nullptr;
  288|      4|    delete DBContext().penv;
  289|      4|    DBContext().options.env = nullptr;
  290|      4|}

_ZNK10CDBWrapper9DBContextEv:
  212|     40|    auto& DBContext() const LIFETIMEBOUND { return *Assert(m_db_context); }
  ------------------
  |  |   85|     40|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------

_ZN8CHash2568FinalizeE4SpanIhE:
   30|  41.0k|    void Finalize(Span<unsigned char> output) {
   31|  41.0k|        assert(output.size() == OUTPUT_SIZE);
   32|  41.0k|        unsigned char buf[CSHA256::OUTPUT_SIZE];
   33|  41.0k|        sha.Finalize(buf);
   34|  41.0k|        sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
   35|  41.0k|    }
_ZN8CHash2565WriteE4SpanIKhE:
   37|  41.0k|    CHash256& Write(Span<const unsigned char> input) {
   38|  41.0k|        sha.Write(input.data(), input.size());
   39|  41.0k|        return *this;
   40|  41.0k|    }
_ZN8CHash2565ResetEv:
   42|  25.1k|    CHash256& Reset() {
   43|  25.1k|        sha.Reset();
   44|  25.1k|        return *this;
   45|  25.1k|    }
_ZN10HashWriter5writeE4SpanIKSt4byteE:
  107|  1.25M|    {
  108|  1.25M|        ctx.Write(UCharCast(src.data()), src.size());
  109|  1.25M|    }
_ZN10HashWriter7GetHashEv:
  115|   275k|    uint256 GetHash() {
  116|   275k|        uint256 result;
  117|   275k|        ctx.Finalize(result.begin());
  118|   275k|        ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin());
  119|   275k|        return result;
  120|   275k|    }
_ZN10HashWriter12GetCheapHashEv:
  135|   274k|    inline uint64_t GetCheapHash() {
  136|   274k|        uint256 result = GetHash();
  137|   274k|        return ReadLE64(result.begin());
  138|   274k|    }
_Z4HashINSt3__16vectorIhNS0_9allocatorIhEEEEE7uint256RKT_:
   76|  41.0k|{
   77|  41.0k|    uint256 result;
   78|  41.0k|    CHash256().Write(MakeUCharSpan(in1)).Finalize(result);
   79|  41.0k|    return result;
   80|  41.0k|}
_ZN10HashWriterlsINSt3__16vectorIhNS1_9allocatorIhEEEEEERS_RKT_:
  142|   309k|    {
  143|   309k|        ::Serialize(*this, obj);
  144|   309k|        return *this;
  145|   309k|    }
_ZN10HashWriterlsI7uint256EERS_RKT_:
  142|   274k|    {
  143|   274k|        ::Serialize(*this, obj);
  144|   274k|        return *this;
  145|   274k|    }
_ZN10HashWriterlsI4SpanIKhEEERS_RKT_:
  142|   274k|    {
  143|   274k|        ::Serialize(*this, obj);
  144|   274k|        return *this;
  145|   274k|    }
_ZN10HashWriterlsImEERS_RKT_:
  142|  79.4k|    {
  143|  79.4k|        ::Serialize(*this, obj);
  144|  79.4k|        return *this;
  145|  79.4k|    }
_ZN10HashWriterlsIhEERS_RKT_:
  142|   115k|    {
  143|   115k|        ::Serialize(*this, obj);
  144|   115k|        return *this;
  145|   115k|    }
_ZN10HashWriterlsIiEERS_RKT_:
  142|   115k|    {
  143|   115k|        ::Serialize(*this, obj);
  144|   115k|        return *this;
  145|   115k|    }
_ZN10HashWriterlsINSt3__16vectorIbNS1_9allocatorIbEEEEEERS_RKT_:
  142|    440|    {
  143|    440|        ::Serialize(*this, obj);
  144|    440|        return *this;
  145|    440|    }

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

_ZNK12CChainParams12MessageStartEv:
   94|  25.1k|    const MessageStartChars& MessageStart() const { return pchMessageStart; }
_ZNK12CChainParams14GetDefaultPortEv:
   95|   226k|    uint16_t GetDefaultPort() const { return nDefaultPort; }

_ZN6kernel13NotificationsD2Ev:
   38|      2|    virtual ~Notifications() = default;

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

_ZN7leveldb6DBImplD2Ev:
  153|      4|DBImpl::~DBImpl() {
  154|       |  // Wait for background work to finish.
  155|      4|  mutex_.Lock();
  156|      4|  shutting_down_.store(true, std::memory_order_release);
  157|      4|  while (background_compaction_scheduled_) {
  ------------------
  |  Branch (157:10): [True: 0, False: 4]
  ------------------
  158|      0|    background_work_finished_signal_.Wait();
  159|      0|  }
  160|      4|  mutex_.Unlock();
  161|       |
  162|      4|  if (db_lock_ != nullptr) {
  ------------------
  |  Branch (162:7): [True: 4, False: 0]
  ------------------
  163|      4|    env_->UnlockFile(db_lock_);
  164|      4|  }
  165|       |
  166|      4|  delete versions_;
  167|      4|  if (mem_ != nullptr) mem_->Unref();
  ------------------
  |  Branch (167:7): [True: 4, False: 0]
  ------------------
  168|      4|  if (imm_ != nullptr) imm_->Unref();
  ------------------
  |  Branch (168:7): [True: 0, False: 4]
  ------------------
  169|      4|  delete tmp_batch_;
  170|      4|  delete log_;
  171|      4|  delete logfile_;
  172|      4|  delete table_cache_;
  173|       |
  174|      4|  if (owns_info_log_) {
  ------------------
  |  Branch (174:7): [True: 0, False: 4]
  ------------------
  175|      0|    delete options_.info_log;
  176|      0|  }
  177|      4|  if (owns_cache_) {
  ------------------
  |  Branch (177:7): [True: 0, False: 4]
  ------------------
  178|      0|    delete options_.block_cache;
  179|      0|  }
  180|      4|}
_ZN7leveldb2DBD2Ev:
 1477|      4|DB::~DB() = default;
_ZN7leveldb8SnapshotD2Ev:
 1522|      4|Snapshot::~Snapshot() = default;

_ZN7leveldb3log6WriterD2Ev:
   32|      8|Writer::~Writer() = default;

_ZN7leveldb8MemTableD2Ev:
   24|      4|MemTable::~MemTable() { assert(refs_ == 0); }

_ZN7leveldb8MemTable5UnrefEv:
   33|      4|  void Unref() {
   34|      4|    --refs_;
   35|      4|    assert(refs_ >= 0);
   36|      4|    if (refs_ <= 0) {
  ------------------
  |  Branch (36:9): [True: 4, False: 0]
  ------------------
   37|      4|      delete this;
   38|      4|    }
   39|      4|  }

_ZN7leveldb10TableCacheD2Ev:
   39|      4|TableCache::~TableCache() { delete cache_; }

_ZN7leveldb7VersionD2Ev:
   68|      8|Version::~Version() {
   69|      8|  assert(refs_ == 0);
   70|       |
   71|       |  // Remove from linked list
   72|      8|  prev_->next_ = next_;
   73|      8|  next_->prev_ = prev_;
   74|       |
   75|       |  // Drop references to files
   76|     64|  for (int level = 0; level < config::kNumLevels; level++) {
  ------------------
  |  Branch (76:23): [True: 56, False: 8]
  ------------------
   77|     56|    for (size_t i = 0; i < files_[level].size(); i++) {
  ------------------
  |  Branch (77:24): [True: 0, False: 56]
  ------------------
   78|      0|      FileMetaData* f = files_[level][i];
   79|      0|      assert(f->refs > 0);
   80|      0|      f->refs--;
   81|      0|      if (f->refs <= 0) {
  ------------------
  |  Branch (81:11): [True: 0, False: 0]
  ------------------
   82|      0|        delete f;
   83|      0|      }
   84|      0|    }
   85|     56|  }
   86|      8|}
_ZN7leveldb7Version5UnrefEv:
  456|      4|void Version::Unref() {
  457|      4|  assert(this != &vset_->dummy_versions_);
  458|      4|  assert(refs_ >= 1);
  459|      4|  --refs_;
  460|      4|  if (refs_ == 0) {
  ------------------
  |  Branch (460:7): [True: 4, False: 0]
  ------------------
  461|      4|    delete this;
  462|      4|  }
  463|      4|}
_ZN7leveldb10VersionSetD2Ev:
  754|      4|VersionSet::~VersionSet() {
  755|      4|  current_->Unref();
  756|      4|  assert(dummy_versions_.next_ == &dummy_versions_);  // List must be empty
  757|      4|  delete descriptor_log_;
  758|      4|  delete descriptor_file_;
  759|      4|}

_ZN7leveldb10WriteBatchD2Ev:
   31|      4|WriteBatch::~WriteBatch() = default;

memenv.cc:_ZN7leveldb12_GLOBAL__N_111InMemoryEnvD2Ev:
  229|      4|  ~InMemoryEnv() override {
  230|     12|    for (const auto& kvp : file_map_) {
  ------------------
  |  Branch (230:26): [True: 12, False: 4]
  ------------------
  231|     12|      kvp.second->Unref();
  232|     12|    }
  233|      4|  }
memenv.cc:_ZN7leveldb12_GLOBAL__N_19FileState5UnrefEv:
   41|     20|  void Unref() {
   42|     20|    bool do_delete = false;
   43|       |
   44|     20|    {
   45|     20|      MutexLock lock(&refs_mutex_);
   46|     20|      --refs_;
   47|     20|      assert(refs_ >= 0);
   48|     20|      if (refs_ <= 0) {
  ------------------
  |  Branch (48:11): [True: 12, False: 8]
  ------------------
   49|     12|        do_delete = true;
   50|     12|      }
   51|     20|    }
   52|       |
   53|     20|    if (do_delete) {
  ------------------
  |  Branch (53:9): [True: 12, False: 8]
  ------------------
   54|     12|      delete this;
   55|     12|    }
   56|     20|  }
memenv.cc:_ZN7leveldb12_GLOBAL__N_19FileStateD2Ev:
  143|     12|  ~FileState() { Truncate(); }
memenv.cc:_ZN7leveldb12_GLOBAL__N_19FileState8TruncateEv:
   63|     12|  void Truncate() {
   64|     12|    MutexLock lock(&blocks_mutex_);
   65|     12|    for (char*& block : blocks_) {
  ------------------
  |  Branch (65:23): [True: 10, False: 12]
  ------------------
   66|     10|      delete[] block;
   67|     10|    }
   68|     12|    blocks_.clear();
   69|     12|    size_ = 0;
   70|     12|  }
memenv.cc:_ZN7leveldb12_GLOBAL__N_116WritableFileImplD2Ev:
  207|      8|  ~WritableFileImpl() override { file_->Unref(); }
memenv.cc:_ZN7leveldb12_GLOBAL__N_111InMemoryEnv10UnlockFileEPNS_8FileLockE:
  367|      4|  Status UnlockFile(FileLock* lock) override {
  368|      4|    delete lock;
  369|      4|    return Status::OK();
  370|      4|  }

_ZN7leveldb6StatusD2Ev:
   28|      8|  ~Status() { delete[] state_; }
_ZN7leveldb6StatusC2Ev:
   27|      4|  Status() noexcept : state_(nullptr) {}
_ZN7leveldb6Status2OKEv:
   37|      4|  static Status OK() { return Status(); }

_ZN7leveldb4port7CondVarD2Ev:
   68|      4|  ~CondVar() = default;
_ZN7leveldb4port5Mutex4LockEv:
   55|     36|  void Lock() EXCLUSIVE_LOCK_FUNCTION() { mu_.lock(); }
_ZN7leveldb4port5Mutex6UnlockEv:
   56|     36|  void Unlock() UNLOCK_FUNCTION() { mu_.unlock(); }

_ZN7leveldb5ArenaD2Ev:
   14|      4|Arena::~Arena() {
   15|      8|  for (size_t i = 0; i < blocks_.size(); i++) {
  ------------------
  |  Branch (15:22): [True: 4, False: 4]
  ------------------
   16|      4|    delete[] blocks_[i];
   17|      4|  }
   18|      4|}

_ZN7leveldb5CacheD2Ev:
   17|      8|Cache::~Cache() {}
cache.cc:_ZN7leveldb12_GLOBAL__N_18LRUCacheD2Ev:
  205|    128|LRUCache::~LRUCache() {
  206|    128|  assert(in_use_.next == &in_use_);  // Error if caller has an unreleased handle
  207|    128|  for (LRUHandle* e = lru_.next; e != &lru_;) {
  ------------------
  |  Branch (207:34): [True: 0, False: 128]
  ------------------
  208|      0|    LRUHandle* next = e->next;
  209|      0|    assert(e->in_cache);
  210|      0|    e->in_cache = false;
  211|      0|    assert(e->refs == 1);  // Invariant of lru_ list.
  212|      0|    Unref(e);
  213|      0|    e = next;
  214|      0|  }
  215|    128|}
cache.cc:_ZN7leveldb12_GLOBAL__N_111HandleTableD2Ev:
   72|    128|  ~HandleTable() { delete[] list_; }
cache.cc:_ZN7leveldb12_GLOBAL__N_115ShardedLRUCacheD2Ev:
  357|      8|  ~ShardedLRUCache() override {}

_ZN7leveldb10ComparatorD2Ev:
   18|     16|Comparator::~Comparator() = default;

_ZN7leveldb3EnvD2Ev:
    9|      4|Env::~Env() = default;
_ZN7leveldb12WritableFileD2Ev:
   19|      8|WritableFile::~WritableFile() = default;
_ZN7leveldb6LoggerD2Ev:
   21|      4|Logger::~Logger() = default;
_ZN7leveldb8FileLockD2Ev:
   23|      4|FileLock::~FileLock() = default;

_ZN7leveldb12FilterPolicyD2Ev:
    9|      8|FilterPolicy::~FilterPolicy() {}

_ZN7leveldb9MutexLockC2EPNS_4port5MutexE:
   25|     32|  explicit MutexLock(port::Mutex* mu) EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
   26|     32|    this->mu_->Lock();
   27|     32|  }
_ZN7leveldb9MutexLockD2Ev:
   28|     32|  ~MutexLock() UNLOCK_FUNCTION() { this->mu_->Unlock(); }

_Z11LogInstancev:
   25|   268k|{
   26|       |/**
   27|       | * NOTE: the logger instances is leaked on exit. This is ugly, but will be
   28|       | * cleaned up by the OS/libc. Defining a logger as a global object doesn't work
   29|       | * since the order of destruction of static/global objects is undefined.
   30|       | * Consider if the logger gets destroyed, and then some later destructor calls
   31|       | * LogPrintf, maybe indirectly, and you get a core dump at shutdown trying to
   32|       | * access the logger. When the shutdown sequence is fully audited and tested,
   33|       | * explicit destruction of these objects can be implemented by changing this
   34|       | * from a raw pointer to a std::unique_ptr.
   35|       | * Since the ~Logger() destructor is never called, the Logger class and all
   36|       | * its subclasses must have implicitly-defined destructors.
   37|       | *
   38|       | * This method of initialization was originally introduced in
   39|       | * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c.
   40|       | */
   41|   268k|    static BCLog::Logger* g_logger{new BCLog::Logger()};
   42|   268k|    return *g_logger;
   43|   268k|}
_ZN5BCLog6Logger20DisconnectTestLoggerEv:
   97|      2|{
   98|      2|    StdLockGuard scoped_lock(m_cs);
   99|      2|    m_buffering = true;
  100|      2|    if (m_fileout != nullptr) fclose(m_fileout);
  ------------------
  |  Branch (100:9): [True: 0, False: 2]
  ------------------
  101|      2|    m_fileout = nullptr;
  102|      2|    m_print_callbacks.clear();
  103|      2|    m_max_buffer_memusage = DEFAULT_MAX_LOG_BUFFER;
  104|      2|    m_cur_buffer_memusage = 0;
  105|      2|    m_buffer_lines_discarded = 0;
  106|      2|    m_msgs_before_open.clear();
  107|      2|}
_ZNK5BCLog6Logger15WillLogCategoryENS_8LogFlagsE:
  148|   242k|{
  149|   242k|    return (m_categories.load(std::memory_order_relaxed) & category) != 0;
  150|   242k|}
_ZNK5BCLog6Logger20WillLogCategoryLevelENS_8LogFlagsENS_5LevelE:
  153|   242k|{
  154|       |    // Log messages at Info, Warning and Error level unconditionally, so that
  155|       |    // important troubleshooting information doesn't get lost.
  156|   242k|    if (level >= BCLog::Level::Info) return true;
  ------------------
  |  Branch (156:9): [True: 0, False: 242k]
  ------------------
  157|       |
  158|   242k|    if (!WillLogCategory(category)) return false;
  ------------------
  |  Branch (158:9): [True: 242k, False: 0]
  ------------------
  159|       |
  160|      0|    StdLockGuard scoped_lock(m_cs);
  161|      0|    const auto it{m_category_log_levels.find(category)};
  162|      0|    return level >= (it == m_category_log_levels.end() ? LogLevel() : it->second);
  ------------------
  |  Branch (162:22): [True: 0, False: 0]
  ------------------
  163|   242k|}

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

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

net.cpp:_ZN8memusageL11MallocUsageEm:
   53|   242k|{
   54|       |    // Measured on libc6 2.19 on Linux.
   55|   242k|    if (alloc == 0) {
  ------------------
  |  Branch (55:9): [True: 95.6k, False: 146k]
  ------------------
   56|  95.6k|        return 0;
   57|   146k|    } else if (sizeof(void*) == 8) {
  ------------------
  |  Branch (57:16): [Folded - Ignored]
  ------------------
   58|   146k|        return ((alloc + 31) >> 4) << 4;
   59|   146k|    } else if (sizeof(void*) == 4) {
  ------------------
  |  Branch (59:16): [Folded - Ignored]
  ------------------
   60|      0|        return ((alloc + 15) >> 3) << 3;
   61|      0|    } else {
   62|      0|        assert(0);
   63|      0|    }
   64|   242k|}
net.cpp:_ZN8memusageL12DynamicUsageERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   95|   242k|{
   96|   242k|    const char* s_ptr = reinterpret_cast<const char*>(&s);
   97|       |    // Don't count the dynamic memory used for string, if it resides in the
   98|       |    // "small string" optimization area (which stores data inside the object itself, up to some
   99|       |    // size; 15 bytes in modern libstdc++).
  100|   242k|    if (!std::less{}(s.data(), s_ptr) && !std::greater{}(s.data() + s.size(), s_ptr + sizeof(s))) {
  ------------------
  |  Branch (100:9): [True: 242k, False: 0]
  |  Branch (100:9): [True: 242k, False: 0]
  |  Branch (100:42): [True: 242k, False: 0]
  ------------------
  101|   242k|        return 0;
  102|   242k|    }
  103|      0|    return MallocUsage(s.capacity());
  104|   242k|}
net.cpp:_ZN8memusageL12DynamicUsageIhNSt3__19allocatorIhEEEEmRKNS1_6vectorIT_T0_EE:
   90|   242k|{
   91|   242k|    return MallocUsage(v.capacity() * sizeof(T));
   92|   242k|}

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

_ZNK17CSerializedNetMsg14GetMemoryUsageEv:
  129|   242k|{
  130|   242k|    return sizeof(*this) + memusage::DynamicUsage(m_type) + memusage::DynamicUsage(data);
  131|   242k|}
_ZN8CConnman8FindNodeERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  347|  10.8k|{
  348|  10.8k|    LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  10.8k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  10.8k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  10.8k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  10.8k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  349|  94.0k|    for (CNode* pnode : m_nodes) {
  ------------------
  |  Branch (349:23): [True: 94.0k, False: 10.1k]
  ------------------
  350|  94.0k|        if (pnode->m_addr_name == addrName) {
  ------------------
  |  Branch (350:13): [True: 767, False: 93.3k]
  ------------------
  351|    767|            return pnode;
  352|    767|        }
  353|  94.0k|    }
  354|  10.1k|    return nullptr;
  355|  10.8k|}
_ZN8CConnman18CheckIncomingNonceEm:
  374|  1.48k|{
  375|  1.48k|    LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  1.48k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  1.48k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  1.48k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  1.48k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  376|  3.37k|    for (const CNode* pnode : m_nodes) {
  ------------------
  |  Branch (376:29): [True: 3.37k, False: 1.12k]
  ------------------
  377|  3.37k|        if (!pnode->fSuccessfullyConnected && !pnode->IsInboundConn() && pnode->GetLocalNonce() == nonce)
  ------------------
  |  Branch (377:13): [True: 3.37k, False: 0]
  |  Branch (377:47): [True: 3.11k, False: 268]
  |  Branch (377:74): [True: 365, False: 2.74k]
  ------------------
  378|    365|            return false;
  379|  3.37k|    }
  380|  1.12k|    return true;
  381|  1.48k|}
_ZN5CNode21CloseSocketDisconnectEv:
  561|    223|{
  562|    223|    fDisconnect = true;
  563|    223|    LOCK(m_sock_mutex);
  ------------------
  |  |  257|    223|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|    223|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|    223|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|    223|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  564|    223|    if (m_sock) {
  ------------------
  |  Branch (564:9): [True: 223, False: 0]
  ------------------
  565|    223|        LogDebug(BCLog::NET, "Resetting socket for peer=%d%s", GetId(), LogIP(fLogIPs));
  ------------------
  |  |  280|    223|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|    223|    do {                                                  \
  |  |  |  |  274|    223|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 223]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|    223|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  566|    223|        m_sock.reset();
  567|       |
  568|    223|        TRACEPOINT(net, closed_connection,
  569|    223|            GetId(),
  570|    223|            m_addr_name.c_str(),
  571|    223|            ConnectionTypeAsString().c_str(),
  572|    223|            ConnectedThroughNetwork(),
  573|    223|            Ticks<std::chrono::seconds>(m_connected));
  574|    223|    }
  575|    223|    m_i2p_sam_session.reset();
  576|    223|}
_ZNK5CNode12GetAddrLocalEv:
  594|  17.8k|{
  595|  17.8k|    AssertLockNotHeld(m_addr_local_mutex);
  ------------------
  |  |  147|  17.8k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
  596|  17.8k|    LOCK(m_addr_local_mutex);
  ------------------
  |  |  257|  17.8k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  17.8k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  17.8k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  17.8k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  597|  17.8k|    return m_addr_local;
  598|  17.8k|}
_ZNK5CNode23ConnectedThroughNetworkEv:
  609|  23.3k|{
  610|  23.3k|    return m_inbound_onion ? NET_ONION : addr.GetNetClass();
  ------------------
  |  Branch (610:12): [True: 2.14k, False: 21.1k]
  ------------------
  611|  23.3k|}
_ZN5CNode9CopyStatsER10CNodeStats:
  621|  17.8k|{
  622|  17.8k|    stats.nodeid = this->GetId();
  623|  17.8k|    X(addr);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  624|  17.8k|    X(addrBind);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  625|  17.8k|    stats.m_network = ConnectedThroughNetwork();
  626|  17.8k|    X(m_last_send);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  627|  17.8k|    X(m_last_recv);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  628|  17.8k|    X(m_last_tx_time);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  629|  17.8k|    X(m_last_block_time);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  630|  17.8k|    X(m_connected);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  631|  17.8k|    X(m_addr_name);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  632|  17.8k|    X(nVersion);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  633|  17.8k|    {
  634|  17.8k|        LOCK(m_subver_mutex);
  ------------------
  |  |  257|  17.8k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  17.8k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  17.8k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  17.8k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  635|  17.8k|        X(cleanSubVer);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  636|  17.8k|    }
  637|  17.8k|    stats.fInbound = IsInboundConn();
  638|  17.8k|    X(m_bip152_highbandwidth_to);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  639|  17.8k|    X(m_bip152_highbandwidth_from);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  640|  17.8k|    {
  641|  17.8k|        LOCK(cs_vSend);
  ------------------
  |  |  257|  17.8k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  17.8k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  17.8k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  17.8k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  642|  17.8k|        X(mapSendBytesPerMsgType);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  643|  17.8k|        X(nSendBytes);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  644|  17.8k|    }
  645|  17.8k|    {
  646|  17.8k|        LOCK(cs_vRecv);
  ------------------
  |  |  257|  17.8k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  17.8k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  17.8k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  17.8k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  647|  17.8k|        X(mapRecvBytesPerMsgType);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  648|  17.8k|        X(nRecvBytes);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  649|  17.8k|        Transport::Info info = m_transport->GetInfo();
  650|  17.8k|        stats.m_transport_type = info.transport_type;
  651|  17.8k|        if (info.session_id) stats.m_session_id = HexStr(*info.session_id);
  ------------------
  |  Branch (651:13): [True: 0, False: 17.8k]
  ------------------
  652|  17.8k|    }
  653|  17.8k|    X(m_permission_flags);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  654|       |
  655|  17.8k|    X(m_last_ping_time);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  656|  17.8k|    X(m_min_ping_time);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  657|       |
  658|       |    // Leave string empty if addrLocal invalid (not filled in yet)
  659|  17.8k|    CService addrLocalUnlocked = GetAddrLocal();
  660|  17.8k|    stats.addrLocal = addrLocalUnlocked.IsValid() ? addrLocalUnlocked.ToStringAddrPort() : "";
  ------------------
  |  Branch (660:23): [True: 0, False: 17.8k]
  ------------------
  661|       |
  662|  17.8k|    X(m_conn_type);
  ------------------
  |  |  619|  17.8k|#define X(name) stats.name = name
  ------------------
  663|  17.8k|}
_ZN11V1TransportC2El:
  723|  25.1k|    : m_magic_bytes{Params().MessageStart()}, m_node_id{node_id}
  724|  25.1k|{
  725|  25.1k|    LOCK(m_recv_mutex);
  ------------------
  |  |  257|  25.1k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  25.1k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  25.1k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  25.1k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  726|  25.1k|    Reset();
  727|  25.1k|}
_ZNK11V1Transport7GetInfoEv:
  730|  17.8k|{
  731|  17.8k|    return {.transport_type = TransportProtocolType::V1, .session_id = {}};
  732|  17.8k|}
_ZN11V1Transport16SetMessageToSendER17CSerializedNetMsg:
  842|  41.0k|{
  843|  41.0k|    AssertLockNotHeld(m_send_mutex);
  ------------------
  |  |  147|  41.0k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
  844|       |    // Determine whether a new message can be set.
  845|  41.0k|    LOCK(m_send_mutex);
  ------------------
  |  |  257|  41.0k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  41.0k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  41.0k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  41.0k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  846|  41.0k|    if (m_sending_header || m_bytes_sent < m_message_to_send.data.size()) return false;
  ------------------
  |  Branch (846:9): [True: 0, False: 41.0k]
  |  Branch (846:29): [True: 0, False: 41.0k]
  ------------------
  847|       |
  848|       |    // create dbl-sha256 checksum
  849|  41.0k|    uint256 hash = Hash(msg.data);
  850|       |
  851|       |    // create header
  852|  41.0k|    CMessageHeader hdr(m_magic_bytes, msg.m_type.c_str(), msg.data.size());
  853|  41.0k|    memcpy(hdr.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE);
  854|       |
  855|       |    // serialize header
  856|  41.0k|    m_header_to_send.clear();
  857|  41.0k|    VectorWriter{m_header_to_send, 0, hdr};
  858|       |
  859|       |    // update state
  860|  41.0k|    m_message_to_send = std::move(msg);
  861|  41.0k|    m_sending_header = true;
  862|  41.0k|    m_bytes_sent = 0;
  863|  41.0k|    return true;
  864|  41.0k|}
_ZNK11V1Transport14GetBytesToSendEb:
  867|   201k|{
  868|   201k|    AssertLockNotHeld(m_send_mutex);
  ------------------
  |  |  147|   201k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
  869|   201k|    LOCK(m_send_mutex);
  ------------------
  |  |  257|   201k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|   201k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|   201k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|   201k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  870|   201k|    if (m_sending_header) {
  ------------------
  |  Branch (870:9): [True: 45.2k, False: 156k]
  ------------------
  871|  45.2k|        return {Span{m_header_to_send}.subspan(m_bytes_sent),
  872|       |                // We have more to send after the header if the message has payload, or if there
  873|       |                // is a next message after that.
  874|  45.2k|                have_next_message || !m_message_to_send.data.empty(),
  ------------------
  |  Branch (874:17): [True: 4.15k, False: 41.0k]
  |  Branch (874:38): [True: 40.2k, False: 815]
  ------------------
  875|  45.2k|                m_message_to_send.m_type
  876|  45.2k|               };
  877|   156k|    } else {
  878|   156k|        return {Span{m_message_to_send.data}.subspan(m_bytes_sent),
  879|       |                // We only have more to send after this message's payload if there is another
  880|       |                // message.
  881|   156k|                have_next_message,
  882|   156k|                m_message_to_send.m_type
  883|   156k|               };
  884|   156k|    }
  885|   201k|}
_ZN11V1Transport13MarkBytesSentEm:
  888|  80.8k|{
  889|  80.8k|    AssertLockNotHeld(m_send_mutex);
  ------------------
  |  |  147|  80.8k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
  890|  80.8k|    LOCK(m_send_mutex);
  ------------------
  |  |  257|  80.8k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  80.8k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  80.8k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  80.8k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  891|  80.8k|    m_bytes_sent += bytes_sent;
  892|  80.8k|    if (m_sending_header && m_bytes_sent == m_header_to_send.size()) {
  ------------------
  |  Branch (892:9): [True: 40.8k, False: 39.9k]
  |  Branch (892:29): [True: 40.8k, False: 64]
  ------------------
  893|       |        // We're done sending a message's header. Switch to sending its data bytes.
  894|  40.8k|        m_sending_header = false;
  895|  40.8k|        m_bytes_sent = 0;
  896|  40.8k|    } else if (!m_sending_header && m_bytes_sent == m_message_to_send.data.size()) {
  ------------------
  |  Branch (896:16): [True: 39.9k, False: 64]
  |  Branch (896:37): [True: 39.8k, False: 108]
  ------------------
  897|       |        // We're done sending a message's data. Wipe the data vector to reduce memory consumption.
  898|  39.8k|        ClearShrink(m_message_to_send.data);
  899|  39.8k|        m_bytes_sent = 0;
  900|  39.8k|    }
  901|  80.8k|}
_ZNK11V1Transport18GetSendMemoryUsageEv:
  904|   121k|{
  905|   121k|    AssertLockNotHeld(m_send_mutex);
  ------------------
  |  |  147|   121k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
  906|   121k|    LOCK(m_send_mutex);
  ------------------
  |  |  257|   121k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|   121k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|   121k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|   121k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  907|       |    // Don't count sending-side fields besides m_message_to_send, as they're all small and bounded.
  908|   121k|    return m_message_to_send.GetMemoryUsage();
  909|   121k|}
_ZNK8CConnman14SocketSendDataER5CNode:
 1600|  41.0k|{
 1601|  41.0k|    auto it = node.vSendMsg.begin();
 1602|  41.0k|    size_t nSentSize = 0;
 1603|  41.0k|    bool data_left{false}; //!< second return value (whether unsent data remains)
 1604|  41.0k|    std::optional<bool> expected_more;
 1605|       |
 1606|   121k|    while (true) {
  ------------------
  |  Branch (1606:12): [Folded - Ignored]
  ------------------
 1607|   121k|        if (it != node.vSendMsg.end()) {
  ------------------
  |  Branch (1607:13): [True: 41.0k, False: 80.7k]
  ------------------
 1608|       |            // If possible, move one message from the send queue to the transport. This fails when
 1609|       |            // there is an existing message still being sent, or (for v2 transports) when the
 1610|       |            // handshake has not yet completed.
 1611|  41.0k|            size_t memusage = it->GetMemoryUsage();
 1612|  41.0k|            if (node.m_transport->SetMessageToSend(*it)) {
  ------------------
  |  Branch (1612:17): [True: 41.0k, False: 0]
  ------------------
 1613|       |                // Update memory usage of send buffer (as *it will be deleted).
 1614|  41.0k|                node.m_send_memusage -= memusage;
 1615|  41.0k|                ++it;
 1616|  41.0k|            }
 1617|  41.0k|        }
 1618|   121k|        const auto& [data, more, msg_type] = node.m_transport->GetBytesToSend(it != node.vSendMsg.end());
 1619|       |        // We rely on the 'more' value returned by GetBytesToSend to correctly predict whether more
 1620|       |        // bytes are still to be sent, to correctly set the MSG_MORE flag. As a sanity check,
 1621|       |        // verify that the previously returned 'more' was correct.
 1622|   121k|        if (expected_more.has_value()) Assume(!data.empty() == *expected_more);
  ------------------
  |  |   97|  80.7k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  |  Branch (1622:13): [True: 80.7k, False: 41.0k]
  ------------------
 1623|   121k|        expected_more = more;
 1624|   121k|        data_left = !data.empty(); // will be overwritten on next loop if all of data gets sent
 1625|   121k|        int nBytes = 0;
 1626|   121k|        if (!data.empty()) {
  ------------------
  |  Branch (1626:13): [True: 81.1k, False: 40.6k]
  ------------------
 1627|  81.1k|            LOCK(node.m_sock_mutex);
  ------------------
  |  |  257|  81.1k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  81.1k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  81.1k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  81.1k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1628|       |            // There is no socket in case we've already disconnected, or in test cases without
 1629|       |            // real connections. In these cases, we bail out immediately and just leave things
 1630|       |            // in the send queue and transport.
 1631|  81.1k|            if (!node.m_sock) {
  ------------------
  |  Branch (1631:17): [True: 0, False: 81.1k]
  ------------------
 1632|      0|                break;
 1633|      0|            }
 1634|  81.1k|            int flags = MSG_NOSIGNAL | MSG_DONTWAIT;
 1635|  81.1k|#ifdef MSG_MORE
 1636|  81.1k|            if (more) {
  ------------------
  |  Branch (1636:17): [True: 40.2k, False: 40.8k]
  ------------------
 1637|  40.2k|                flags |= MSG_MORE;
 1638|  40.2k|            }
 1639|  81.1k|#endif
 1640|  81.1k|            nBytes = node.m_sock->Send(reinterpret_cast<const char*>(data.data()), data.size(), flags);
 1641|  81.1k|        }
 1642|   121k|        if (nBytes > 0) {
  ------------------
  |  Branch (1642:13): [True: 80.8k, False: 40.9k]
  ------------------
 1643|  80.8k|            node.m_last_send = GetTime<std::chrono::seconds>();
 1644|  80.8k|            node.nSendBytes += nBytes;
 1645|       |            // Notify transport that bytes have been processed.
 1646|  80.8k|            node.m_transport->MarkBytesSent(nBytes);
 1647|       |            // Update statistics per message type.
 1648|  80.8k|            if (!msg_type.empty()) { // don't report v2 handshake bytes for now
  ------------------
  |  Branch (1648:17): [True: 72.8k, False: 8.02k]
  ------------------
 1649|  72.8k|                node.AccountForSentBytes(msg_type, nBytes);
 1650|  72.8k|            }
 1651|  80.8k|            nSentSize += nBytes;
 1652|  80.8k|            if ((size_t)nBytes != data.size()) {
  ------------------
  |  Branch (1652:17): [True: 172, False: 80.7k]
  ------------------
 1653|       |                // could not send full message; stop sending more
 1654|    172|                break;
 1655|    172|            }
 1656|  80.8k|        } else {
 1657|  40.9k|            if (nBytes < 0) {
  ------------------
  |  Branch (1657:17): [True: 236, False: 40.6k]
  ------------------
 1658|       |                // error
 1659|    236|                int nErr = WSAGetLastError();
  ------------------
  |  |   48|    236|#define WSAGetLastError()   errno
  ------------------
 1660|    236|                if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
  ------------------
  |  |   50|    472|#define WSAEWOULDBLOCK      EWOULDBLOCK
  ------------------
                              if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
  ------------------
  |  |   52|    465|#define WSAEMSGSIZE         EMSGSIZE
  ------------------
                              if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
  ------------------
  |  |   53|    463|#define WSAEINTR            EINTR
  ------------------
                              if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
  ------------------
  |  |   54|    223|#define WSAEINPROGRESS      EINPROGRESS
  ------------------
  |  Branch (1660:21): [True: 229, False: 7]
  |  Branch (1660:47): [True: 227, False: 2]
  |  Branch (1660:70): [True: 223, False: 4]
  |  Branch (1660:90): [True: 223, False: 0]
  ------------------
 1661|    223|                    LogDebug(BCLog::NET, "socket send error, %s: %s\n", node.DisconnectMsg(fLogIPs), NetworkErrorString(nErr));
  ------------------
  |  |  280|    223|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|    223|    do {                                                  \
  |  |  |  |  274|    223|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 223]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|    223|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1662|    223|                    node.CloseSocketDisconnect();
 1663|    223|                }
 1664|    236|            }
 1665|  40.9k|            break;
 1666|  40.9k|        }
 1667|   121k|    }
 1668|       |
 1669|  41.0k|    node.fPauseSend = node.m_send_memusage + node.m_transport->GetSendMemoryUsage() > nSendBufferMaxSize;
 1670|       |
 1671|  41.0k|    if (it == node.vSendMsg.end()) {
  ------------------
  |  Branch (1671:9): [True: 41.0k, False: 0]
  ------------------
 1672|  41.0k|        assert(node.m_send_memusage == 0);
 1673|  41.0k|    }
 1674|  41.0k|    node.vSendMsg.erase(node.vSendMsg.begin(), it);
 1675|  41.0k|    return {nSentSize, data_left};
 1676|  41.0k|}
_ZNK8CConnman21GetTryNewOutboundPeerEv:
 2416|  7.29k|{
 2417|  7.29k|    return m_try_another_outbound_peer;
 2418|  7.29k|}
_ZN8CConnman21SetTryNewOutboundPeerEb:
 2421|  49.4k|{
 2422|  49.4k|    m_try_another_outbound_peer = flag;
 2423|  49.4k|    LogDebug(BCLog::NET, "setting try another outbound peer=%s\n", flag ? "true" : "false");
  ------------------
  |  |  280|  49.4k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  49.4k|    do {                                                  \
  |  |  |  |  274|  49.4k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 49.4k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (255:116): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  49.4k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2424|  49.4k|}
_ZNK8CConnman25GetExtraFullOutboundCountEv:
 2452|  7.29k|{
 2453|  7.29k|    int full_outbound_peers = 0;
 2454|  7.29k|    {
 2455|  7.29k|        LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  7.29k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.29k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.29k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.29k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2456|  17.8k|        for (const CNode* pnode : m_nodes) {
  ------------------
  |  Branch (2456:33): [True: 17.8k, False: 7.29k]
  ------------------
 2457|  17.8k|            if (pnode->fSuccessfullyConnected && !pnode->fDisconnect && pnode->IsFullOutboundConn()) {
  ------------------
  |  Branch (2457:17): [True: 0, False: 17.8k]
  |  Branch (2457:50): [True: 0, False: 0]
  |  Branch (2457:73): [True: 0, False: 0]
  ------------------
 2458|      0|                ++full_outbound_peers;
 2459|      0|            }
 2460|  17.8k|        }
 2461|  7.29k|    }
 2462|  7.29k|    return std::max(full_outbound_peers - m_max_outbound_full_relay, 0);
 2463|  7.29k|}
_ZNK8CConnman16GetAddedNodeInfoEb:
 2896|  7.29k|{
 2897|  7.29k|    std::vector<AddedNodeInfo> ret;
 2898|       |
 2899|  7.29k|    std::list<AddedNodeParams> lAddresses(0);
 2900|  7.29k|    {
 2901|  7.29k|        LOCK(m_added_nodes_mutex);
  ------------------
  |  |  257|  7.29k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.29k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.29k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.29k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2902|  7.29k|        ret.reserve(m_added_node_params.size());
 2903|  7.29k|        std::copy(m_added_node_params.cbegin(), m_added_node_params.cend(), std::back_inserter(lAddresses));
 2904|  7.29k|    }
 2905|       |
 2906|       |
 2907|       |    // Build a map of all already connected addresses (by IP:port and by name) to inbound/outbound and resolved CService
 2908|  7.29k|    std::map<CService, bool> mapConnected;
 2909|  7.29k|    std::map<std::string, std::pair<bool, CService>> mapConnectedByName;
 2910|  7.29k|    {
 2911|  7.29k|        LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  7.29k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.29k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.29k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.29k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2912|  17.8k|        for (const CNode* pnode : m_nodes) {
  ------------------
  |  Branch (2912:33): [True: 17.8k, False: 7.29k]
  ------------------
 2913|  17.8k|            if (pnode->addr.IsValid()) {
  ------------------
  |  Branch (2913:17): [True: 15.6k, False: 2.18k]
  ------------------
 2914|  15.6k|                mapConnected[pnode->addr] = pnode->IsInboundConn();
 2915|  15.6k|            }
 2916|  17.8k|            std::string addrName{pnode->m_addr_name};
 2917|  17.8k|            if (!addrName.empty()) {
  ------------------
  |  Branch (2917:17): [True: 17.8k, False: 0]
  ------------------
 2918|  17.8k|                mapConnectedByName[std::move(addrName)] = std::make_pair(pnode->IsInboundConn(), static_cast<const CService&>(pnode->addr));
 2919|  17.8k|            }
 2920|  17.8k|        }
 2921|  7.29k|    }
 2922|       |
 2923|  11.6k|    for (const auto& addr : lAddresses) {
  ------------------
  |  Branch (2923:27): [True: 11.6k, False: 7.29k]
  ------------------
 2924|  11.6k|        CService service{MaybeFlipIPv6toCJDNS(LookupNumeric(addr.m_added_node, GetDefaultPort(addr.m_added_node)))};
 2925|  11.6k|        AddedNodeInfo addedNode{addr, CService(), false, false};
 2926|  11.6k|        if (service.IsValid()) {
  ------------------
  |  Branch (2926:13): [True: 959, False: 10.7k]
  ------------------
 2927|       |            // strAddNode is an IP:port
 2928|    959|            auto it = mapConnected.find(service);
 2929|    959|            if (it != mapConnected.end()) {
  ------------------
  |  Branch (2929:17): [True: 24, False: 935]
  ------------------
 2930|     24|                if (!include_connected) {
  ------------------
  |  Branch (2930:21): [True: 10, False: 14]
  ------------------
 2931|     10|                    continue;
 2932|     10|                }
 2933|     14|                addedNode.resolvedAddress = service;
 2934|     14|                addedNode.fConnected = true;
 2935|     14|                addedNode.fInbound = it->second;
 2936|     14|            }
 2937|  10.7k|        } else {
 2938|       |            // strAddNode is a name
 2939|  10.7k|            auto it = mapConnectedByName.find(addr.m_added_node);
 2940|  10.7k|            if (it != mapConnectedByName.end()) {
  ------------------
  |  Branch (2940:17): [True: 417, False: 10.2k]
  ------------------
 2941|    417|                if (!include_connected) {
  ------------------
  |  Branch (2941:21): [True: 152, False: 265]
  ------------------
 2942|    152|                    continue;
 2943|    152|                }
 2944|    265|                addedNode.resolvedAddress = it->second.second;
 2945|    265|                addedNode.fConnected = true;
 2946|    265|                addedNode.fInbound = it->second.first;
 2947|    265|            }
 2948|  10.7k|        }
 2949|  11.5k|        ret.emplace_back(std::move(addedNode));
 2950|  11.5k|    }
 2951|       |
 2952|  7.29k|    return ret;
 2953|  7.29k|}
_ZN8CConnman16SetNetworkActiveEb:
 3195|  11.6k|{
 3196|  11.6k|    LogPrintf("%s: %s\n", __func__, active);
  ------------------
  |  |  266|  11.6k|#define LogPrintf(...) LogInfo(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |  261|  11.6k|#define LogInfo(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|  11.6k|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3197|       |
 3198|  11.6k|    if (fNetworkActive == active) {
  ------------------
  |  Branch (3198:9): [True: 4.48k, False: 7.20k]
  ------------------
 3199|  4.48k|        return;
 3200|  4.48k|    }
 3201|       |
 3202|  7.20k|    fNetworkActive = active;
 3203|       |
 3204|  7.20k|    if (m_client_interface) {
  ------------------
  |  Branch (3204:9): [True: 0, False: 7.20k]
  ------------------
 3205|      0|        m_client_interface->NotifyNetworkActiveChanged(fNetworkActive);
 3206|      0|    }
 3207|  7.20k|}
_ZN8CConnmanC2EmmR7AddrManRK15NetGroupManagerRK12CChainParamsb:
 3211|  7.29k|    : addrman(addrman_in)
 3212|  7.29k|    , m_netgroupman{netgroupman}
 3213|  7.29k|    , nSeed0(nSeed0In)
 3214|  7.29k|    , nSeed1(nSeed1In)
 3215|  7.29k|    , m_params(params)
 3216|  7.29k|{
 3217|  7.29k|    SetTryNewOutboundPeer(false);
 3218|       |
 3219|  7.29k|    Options connOptions;
 3220|  7.29k|    Init(connOptions);
 3221|  7.29k|    SetNetworkActive(network_active);
 3222|  7.29k|}
_ZNK8CConnman14GetDefaultPortE7Network:
 3230|  3.17k|{
 3231|  3.17k|    return net == NET_I2P ? I2P_SAM31_PORT : m_params.GetDefaultPort();
  ------------------
  |  Branch (3231:12): [True: 2.07k, False: 1.09k]
  ------------------
 3232|  3.17k|}
_ZNK8CConnman14GetDefaultPortERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
 3235|   228k|{
 3236|   228k|    CNetAddr a;
 3237|   228k|    return a.SetSpecial(addr) ? GetDefaultPort(a.GetNetwork()) : m_params.GetDefaultPort();
  ------------------
  |  Branch (3237:12): [True: 3.17k, False: 225k]
  ------------------
 3238|   228k|}
_ZN8CConnman9InterruptEv:
 3416|  7.29k|{
 3417|  7.29k|    {
 3418|  7.29k|        LOCK(mutexMsgProc);
  ------------------
  |  |  257|  7.29k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.29k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.29k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.29k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3419|  7.29k|        flagInterruptMsgProc = true;
 3420|  7.29k|    }
 3421|  7.29k|    condMsgProc.notify_all();
 3422|       |
 3423|  7.29k|    interruptNet();
 3424|  7.29k|    g_socks5_interrupt();
 3425|       |
 3426|  7.29k|    if (semOutbound) {
  ------------------
  |  Branch (3426:9): [True: 0, False: 7.29k]
  ------------------
 3427|      0|        for (int i=0; i<m_max_automatic_outbound; i++) {
  ------------------
  |  Branch (3427:23): [True: 0, False: 0]
  ------------------
 3428|      0|            semOutbound->post();
 3429|      0|        }
 3430|      0|    }
 3431|       |
 3432|  7.29k|    if (semAddnode) {
  ------------------
  |  Branch (3432:9): [True: 0, False: 7.29k]
  ------------------
 3433|      0|        for (int i=0; i<m_max_addnode; i++) {
  ------------------
  |  Branch (3433:23): [True: 0, False: 0]
  ------------------
 3434|      0|            semAddnode->post();
 3435|      0|        }
 3436|      0|    }
 3437|  7.29k|}
_ZN8CConnman11StopThreadsEv:
 3440|  7.29k|{
 3441|  7.29k|    if (threadI2PAcceptIncoming.joinable()) {
  ------------------
  |  Branch (3441:9): [True: 0, False: 7.29k]
  ------------------
 3442|      0|        threadI2PAcceptIncoming.join();
 3443|      0|    }
 3444|  7.29k|    if (threadMessageHandler.joinable())
  ------------------
  |  Branch (3444:9): [True: 0, False: 7.29k]
  ------------------
 3445|      0|        threadMessageHandler.join();
 3446|  7.29k|    if (threadOpenConnections.joinable())
  ------------------
  |  Branch (3446:9): [True: 0, False: 7.29k]
  ------------------
 3447|      0|        threadOpenConnections.join();
 3448|  7.29k|    if (threadOpenAddedConnections.joinable())
  ------------------
  |  Branch (3448:9): [True: 0, False: 7.29k]
  ------------------
 3449|      0|        threadOpenAddedConnections.join();
 3450|  7.29k|    if (threadDNSAddressSeed.joinable())
  ------------------
  |  Branch (3450:9): [True: 0, False: 7.29k]
  ------------------
 3451|      0|        threadDNSAddressSeed.join();
 3452|  7.29k|    if (threadSocketHandler.joinable())
  ------------------
  |  Branch (3452:9): [True: 0, False: 7.29k]
  ------------------
 3453|      0|        threadSocketHandler.join();
 3454|  7.29k|}
_ZN8CConnman9StopNodesEv:
 3457|  7.29k|{
 3458|  7.29k|    if (fAddressesInitialized) {
  ------------------
  |  Branch (3458:9): [True: 0, False: 7.29k]
  ------------------
 3459|      0|        DumpAddresses();
 3460|      0|        fAddressesInitialized = false;
 3461|       |
 3462|      0|        if (m_use_addrman_outgoing) {
  ------------------
  |  Branch (3462:13): [True: 0, False: 0]
  ------------------
 3463|       |            // Anchor connections are only dumped during clean shutdown.
 3464|      0|            std::vector<CAddress> anchors_to_dump = GetCurrentBlockRelayOnlyConns();
 3465|      0|            if (anchors_to_dump.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
  ------------------
  |  Branch (3465:17): [True: 0, False: 0]
  ------------------
 3466|      0|                anchors_to_dump.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
 3467|      0|            }
 3468|      0|            DumpAnchors(gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME, anchors_to_dump);
 3469|      0|        }
 3470|      0|    }
 3471|       |
 3472|       |    // Delete peer connections.
 3473|  7.29k|    std::vector<CNode*> nodes;
 3474|  7.29k|    WITH_LOCK(m_nodes_mutex, nodes.swap(m_nodes));
  ------------------
  |  |  301|  7.29k|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
  ------------------
 3475|  7.29k|    for (CNode* pnode : nodes) {
  ------------------
  |  Branch (3475:23): [True: 0, False: 7.29k]
  ------------------
 3476|      0|        LogDebug(BCLog::NET, "Stopping node, %s", pnode->DisconnectMsg(fLogIPs));
  ------------------
  |  |  280|      0|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|      0|    do {                                                  \
  |  |  |  |  274|      0|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3477|      0|        pnode->CloseSocketDisconnect();
 3478|      0|        DeleteNode(pnode);
 3479|      0|    }
 3480|       |
 3481|  7.29k|    for (CNode* pnode : m_nodes_disconnected) {
  ------------------
  |  Branch (3481:23): [True: 0, False: 7.29k]
  ------------------
 3482|      0|        DeleteNode(pnode);
 3483|      0|    }
 3484|  7.29k|    m_nodes_disconnected.clear();
 3485|  7.29k|    vhListenSocket.clear();
 3486|  7.29k|    semOutbound.reset();
 3487|  7.29k|    semAddnode.reset();
 3488|  7.29k|}
_ZN8CConnmanD2Ev:
 3498|  7.29k|{
 3499|  7.29k|    Interrupt();
 3500|  7.29k|    Stop();
 3501|  7.29k|}
_ZNK8CConnman12GetAddressesEmmNSt3__18optionalI7NetworkEEb:
 3504|  79.8k|{
 3505|  79.8k|    std::vector<CAddress> addresses = addrman.GetAddr(max_addresses, max_pct, network, filtered);
 3506|  79.8k|    if (m_banman) {
  ------------------
  |  Branch (3506:9): [True: 0, False: 79.8k]
  ------------------
 3507|      0|        addresses.erase(std::remove_if(addresses.begin(), addresses.end(),
 3508|      0|                        [this](const CAddress& addr){return m_banman->IsDiscouraged(addr) || m_banman->IsBanned(addr);}),
 3509|      0|                        addresses.end());
 3510|      0|    }
 3511|  79.8k|    return addresses;
 3512|  79.8k|}
_ZN8CConnman12GetAddressesER5CNodemm:
 3515|  5.46k|{
 3516|  5.46k|    auto local_socket_bytes = requestor.addrBind.GetAddrBytes();
 3517|  5.46k|    uint64_t cache_id = GetDeterministicRandomizer(RANDOMIZER_ID_ADDRCACHE)
 3518|  5.46k|        .Write(requestor.ConnectedThroughNetwork())
 3519|  5.46k|        .Write(local_socket_bytes)
 3520|       |        // For outbound connections, the port of the bound address is randomly
 3521|       |        // assigned by the OS and would therefore not be useful for seeding.
 3522|  5.46k|        .Write(requestor.IsInboundConn() ? requestor.addrBind.GetPort() : 0)
  ------------------
  |  Branch (3522:16): [True: 1.24k, False: 4.22k]
  ------------------
 3523|  5.46k|        .Finalize();
 3524|  5.46k|    const auto current_time = GetTime<std::chrono::microseconds>();
 3525|  5.46k|    auto r = m_addr_response_caches.emplace(cache_id, CachedAddrResponse{});
 3526|  5.46k|    CachedAddrResponse& cache_entry = r.first->second;
 3527|  5.46k|    if (cache_entry.m_cache_entry_expiration < current_time) { // If emplace() added new one it has expiration 0.
  ------------------
  |  Branch (3527:9): [True: 755, False: 4.70k]
  ------------------
 3528|    755|        cache_entry.m_addrs_response_cache = GetAddresses(max_addresses, max_pct, /*network=*/std::nullopt);
 3529|       |        // Choosing a proper cache lifetime is a trade-off between the privacy leak minimization
 3530|       |        // and the usefulness of ADDR responses to honest users.
 3531|       |        //
 3532|       |        // Longer cache lifetime makes it more difficult for an attacker to scrape
 3533|       |        // enough AddrMan data to maliciously infer something useful.
 3534|       |        // By the time an attacker scraped enough AddrMan records, most of
 3535|       |        // the records should be old enough to not leak topology info by
 3536|       |        // e.g. analyzing real-time changes in timestamps.
 3537|       |        //
 3538|       |        // It takes only several hundred requests to scrape everything from an AddrMan containing 100,000 nodes,
 3539|       |        // so ~24 hours of cache lifetime indeed makes the data less inferable by the time
 3540|       |        // most of it could be scraped (considering that timestamps are updated via
 3541|       |        // ADDR self-announcements and when nodes communicate).
 3542|       |        // We also should be robust to those attacks which may not require scraping *full* victim's AddrMan
 3543|       |        // (because even several timestamps of the same handful of nodes may leak privacy).
 3544|       |        //
 3545|       |        // On the other hand, longer cache lifetime makes ADDR responses
 3546|       |        // outdated and less useful for an honest requestor, e.g. if most nodes
 3547|       |        // in the ADDR response are no longer active.
 3548|       |        //
 3549|       |        // However, the churn in the network is known to be rather low. Since we consider
 3550|       |        // nodes to be "terrible" (see IsTerrible()) if the timestamps are older than 30 days,
 3551|       |        // max. 24 hours of "penalty" due to cache shouldn't make any meaningful difference
 3552|       |        // in terms of the freshness of the response.
 3553|    755|        cache_entry.m_cache_entry_expiration = current_time +
 3554|    755|            21h + FastRandomContext().randrange<std::chrono::microseconds>(6h);
 3555|    755|    }
 3556|  5.46k|    return cache_entry.m_addrs_response_cache;
 3557|  5.46k|}
_ZN8CConnman7AddNodeERK15AddedNodeParams:
 3560|  78.9k|{
 3561|  78.9k|    const CService resolved(LookupNumeric(add.m_added_node, GetDefaultPort(add.m_added_node)));
 3562|  78.9k|    const bool resolved_is_valid{resolved.IsValid()};
 3563|       |
 3564|  78.9k|    LOCK(m_added_nodes_mutex);
  ------------------
  |  |  257|  78.9k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  78.9k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  78.9k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  78.9k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3565|  3.74M|    for (const auto& it : m_added_node_params) {
  ------------------
  |  Branch (3565:25): [True: 3.74M, False: 27.7k]
  ------------------
 3566|  3.74M|        if (add.m_added_node == it.m_added_node || (resolved_is_valid && resolved == LookupNumeric(it.m_added_node, GetDefaultPort(it.m_added_node)))) return false;
  ------------------
  |  Branch (3566:13): [True: 50.6k, False: 3.69M]
  |  Branch (3566:13): [True: 51.1k, False: 3.68M]
  |  Branch (3566:53): [True: 137k, False: 3.55M]
  |  Branch (3566:74): [True: 554, False: 137k]
  ------------------
 3567|  3.74M|    }
 3568|       |
 3569|  27.7k|    m_added_node_params.push_back(add);
 3570|  27.7k|    return true;
 3571|  78.9k|}
_ZN8CConnman15RemoveAddedNodeERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
 3574|  70.6k|{
 3575|  70.6k|    LOCK(m_added_nodes_mutex);
  ------------------
  |  |  257|  70.6k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  70.6k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  70.6k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  70.6k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3576|   994k|    for (auto it = m_added_node_params.begin(); it != m_added_node_params.end(); ++it) {
  ------------------
  |  Branch (3576:49): [True: 940k, False: 54.5k]
  ------------------
 3577|   940k|        if (strNode == it->m_added_node) {
  ------------------
  |  Branch (3577:13): [True: 16.1k, False: 924k]
  ------------------
 3578|  16.1k|            m_added_node_params.erase(it);
 3579|  16.1k|            return true;
 3580|  16.1k|        }
 3581|   940k|    }
 3582|  54.5k|    return false;
 3583|  70.6k|}
_ZNK8CConnman12GetNodeCountE19ConnectionDirection:
 3597|  2.08k|{
 3598|  2.08k|    LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  2.08k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  2.08k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  2.08k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  2.08k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3599|  2.08k|    if (flags == ConnectionDirection::Both) // Shortcut if we want total
  ------------------
  |  Branch (3599:9): [True: 589, False: 1.50k]
  ------------------
 3600|    589|        return m_nodes.size();
 3601|       |
 3602|  1.50k|    int nNum = 0;
 3603|  13.4k|    for (const auto& pnode : m_nodes) {
  ------------------
  |  Branch (3603:28): [True: 13.4k, False: 1.50k]
  ------------------
 3604|  13.4k|        if (flags & (pnode->IsInboundConn() ? ConnectionDirection::In : ConnectionDirection::Out)) {
  ------------------
  |  Branch (3604:13): [True: 787, False: 12.6k]
  |  Branch (3604:22): [True: 732, False: 12.7k]
  ------------------
 3605|    787|            nNum++;
 3606|    787|        }
 3607|  13.4k|    }
 3608|       |
 3609|  1.50k|    return nNum;
 3610|  2.08k|}
_ZNK8CConnman11GetMappedASERK8CNetAddr:
 3620|  17.8k|{
 3621|  17.8k|    return m_netgroupman.GetMappedAS(addr);
 3622|  17.8k|}
_ZNK8CConnman12GetNodeStatsERNSt3__16vectorI10CNodeStatsNS0_9allocatorIS2_EEEE:
 3625|  7.29k|{
 3626|  7.29k|    vstats.clear();
 3627|  7.29k|    LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  7.29k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.29k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.29k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.29k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3628|  7.29k|    vstats.reserve(m_nodes.size());
 3629|  17.8k|    for (CNode* pnode : m_nodes) {
  ------------------
  |  Branch (3629:23): [True: 17.8k, False: 7.29k]
  ------------------
 3630|  17.8k|        vstats.emplace_back();
 3631|  17.8k|        pnode->CopyStats(vstats.back());
 3632|  17.8k|        vstats.back().m_mapped_as = GetMappedAS(pnode->addr);
 3633|  17.8k|    }
 3634|  7.29k|}
_ZN8CConnman14DisconnectNodeERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
 3637|  10.8k|{
 3638|  10.8k|    LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  10.8k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  10.8k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  10.8k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  10.8k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3639|  10.8k|    if (CNode* pnode = FindNode(strNode)) {
  ------------------
  |  Branch (3639:16): [True: 767, False: 10.1k]
  ------------------
 3640|    767|        LogDebug(BCLog::NET, "disconnect by address%s match, %s", (fLogIPs ? strprintf("=%s", strNode) : ""), pnode->DisconnectMsg(fLogIPs));
  ------------------
  |  |  280|    767|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|    767|    do {                                                  \
  |  |  |  |  274|    767|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 767]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (255:116): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|    767|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3641|    767|        pnode->fDisconnect = true;
 3642|    767|        return true;
 3643|    767|    }
 3644|  10.1k|    return false;
 3645|  10.8k|}
_ZN8CConnman14DisconnectNodeERK7CSubNet:
 3648|  21.6k|{
 3649|  21.6k|    bool disconnected = false;
 3650|  21.6k|    LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  21.6k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  21.6k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  21.6k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  21.6k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3651|   250k|    for (CNode* pnode : m_nodes) {
  ------------------
  |  Branch (3651:23): [True: 250k, False: 21.6k]
  ------------------
 3652|   250k|        if (subnet.Match(pnode->addr)) {
  ------------------
  |  Branch (3652:13): [True: 731, False: 250k]
  ------------------
 3653|    731|            LogDebug(BCLog::NET, "disconnect by subnet%s match, %s", (fLogIPs ? strprintf("=%s", subnet.ToString()) : ""), pnode->DisconnectMsg(fLogIPs));
  ------------------
  |  |  280|    731|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|    731|    do {                                                  \
  |  |  |  |  274|    731|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 731]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (255:116): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|    731|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3654|    731|            pnode->fDisconnect = true;
 3655|    731|            disconnected = true;
 3656|    731|        }
 3657|   250k|    }
 3658|  21.6k|    return disconnected;
 3659|  21.6k|}
_ZN8CConnman14DisconnectNodeERK8CNetAddr:
 3662|  17.7k|{
 3663|  17.7k|    return DisconnectNode(CSubNet(addr));
 3664|  17.7k|}
_ZN8CConnman14DisconnectNodeEl:
 3667|  17.1k|{
 3668|  17.1k|    LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  17.1k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  17.1k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  17.1k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  17.1k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3669|   290k|    for(CNode* pnode : m_nodes) {
  ------------------
  |  Branch (3669:22): [True: 290k, False: 16.0k]
  ------------------
 3670|   290k|        if (id == pnode->GetId()) {
  ------------------
  |  Branch (3670:13): [True: 1.06k, False: 289k]
  ------------------
 3671|  1.06k|            LogDebug(BCLog::NET, "disconnect by id, %s", pnode->DisconnectMsg(fLogIPs));
  ------------------
  |  |  280|  1.06k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  1.06k|    do {                                                  \
  |  |  |  |  274|  1.06k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 1.06k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  1.06k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3672|  1.06k|            pnode->fDisconnect = true;
 3673|  1.06k|            return true;
 3674|  1.06k|        }
 3675|   290k|    }
 3676|  16.0k|    return false;
 3677|  17.1k|}
_ZN8CConnman15RecordBytesSentEm:
 3685|  40.8k|{
 3686|  40.8k|    AssertLockNotHeld(m_total_bytes_sent_mutex);
  ------------------
  |  |  147|  40.8k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
 3687|  40.8k|    LOCK(m_total_bytes_sent_mutex);
  ------------------
  |  |  257|  40.8k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  40.8k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  40.8k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  40.8k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3688|       |
 3689|  40.8k|    nTotalBytesSent += bytes;
 3690|       |
 3691|  40.8k|    const auto now = GetTime<std::chrono::seconds>();
 3692|  40.8k|    if (nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME < now)
  ------------------
  |  Branch (3692:9): [True: 599, False: 40.2k]
  ------------------
 3693|    599|    {
 3694|       |        // timeframe expired, reset cycle
 3695|    599|        nMaxOutboundCycleStartTime = now;
 3696|    599|        nMaxOutboundTotalBytesSentInCycle = 0;
 3697|    599|    }
 3698|       |
 3699|  40.8k|    nMaxOutboundTotalBytesSentInCycle += bytes;
 3700|  40.8k|}
_ZNK8CConnman20GetMaxOutboundTargetEv:
 3703|  7.29k|{
 3704|  7.29k|    AssertLockNotHeld(m_total_bytes_sent_mutex);
  ------------------
  |  |  147|  7.29k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
 3705|  7.29k|    LOCK(m_total_bytes_sent_mutex);
  ------------------
  |  |  257|  7.29k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.29k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.29k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.29k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3706|  7.29k|    return nMaxOutboundLimit;
 3707|  7.29k|}
_ZNK8CConnman23GetMaxOutboundTimeframeEv:
 3710|  7.29k|{
 3711|  7.29k|    return MAX_UPLOAD_TIMEFRAME;
 3712|  7.29k|}
_ZNK8CConnman29GetMaxOutboundTimeLeftInCycleEv:
 3715|  7.29k|{
 3716|  7.29k|    AssertLockNotHeld(m_total_bytes_sent_mutex);
  ------------------
  |  |  147|  7.29k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
 3717|  7.29k|    LOCK(m_total_bytes_sent_mutex);
  ------------------
  |  |  257|  7.29k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.29k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.29k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.29k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3718|  7.29k|    return GetMaxOutboundTimeLeftInCycle_();
 3719|  7.29k|}
_ZNK8CConnman30GetMaxOutboundTimeLeftInCycle_Ev:
 3722|  41.1k|{
 3723|  41.1k|    AssertLockHeld(m_total_bytes_sent_mutex);
  ------------------
  |  |  142|  41.1k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
 3724|       |
 3725|  41.1k|    if (nMaxOutboundLimit == 0)
  ------------------
  |  Branch (3725:9): [True: 3.50k, False: 37.6k]
  ------------------
 3726|  3.50k|        return 0s;
 3727|       |
 3728|  37.6k|    if (nMaxOutboundCycleStartTime.count() == 0)
  ------------------
  |  Branch (3728:9): [True: 26.0k, False: 11.6k]
  ------------------
 3729|  26.0k|        return MAX_UPLOAD_TIMEFRAME;
 3730|       |
 3731|  11.6k|    const std::chrono::seconds cycleEndTime = nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME;
 3732|  11.6k|    const auto now = GetTime<std::chrono::seconds>();
 3733|  11.6k|    return (cycleEndTime < now) ? 0s : cycleEndTime - now;
  ------------------
  |  Branch (3733:12): [True: 0, False: 11.6k]
  ------------------
 3734|  37.6k|}
_ZNK8CConnman21OutboundTargetReachedEb:
 3737|  35.7k|{
 3738|  35.7k|    AssertLockNotHeld(m_total_bytes_sent_mutex);
  ------------------
  |  |  147|  35.7k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
 3739|  35.7k|    LOCK(m_total_bytes_sent_mutex);
  ------------------
  |  |  257|  35.7k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  35.7k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  35.7k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  35.7k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3740|  35.7k|    if (nMaxOutboundLimit == 0)
  ------------------
  |  Branch (3740:9): [True: 685, False: 35.1k]
  ------------------
 3741|    685|        return false;
 3742|       |
 3743|  35.1k|    if (historicalBlockServingLimit)
  ------------------
  |  Branch (3743:9): [True: 33.8k, False: 1.24k]
  ------------------
 3744|  33.8k|    {
 3745|       |        // keep a large enough buffer to at least relay each block once
 3746|  33.8k|        const std::chrono::seconds timeLeftInCycle = GetMaxOutboundTimeLeftInCycle_();
 3747|  33.8k|        const uint64_t buffer = timeLeftInCycle / std::chrono::minutes{10} * MAX_BLOCK_SERIALIZED_SIZE;
 3748|  33.8k|        if (buffer >= nMaxOutboundLimit || nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit - buffer)
  ------------------
  |  Branch (3748:13): [True: 565, False: 33.2k]
  |  Branch (3748:44): [True: 258, False: 33.0k]
  ------------------
 3749|    823|            return true;
 3750|  33.8k|    }
 3751|  1.24k|    else if (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit)
  ------------------
  |  Branch (3751:14): [True: 90, False: 1.15k]
  ------------------
 3752|     90|        return true;
 3753|       |
 3754|  34.1k|    return false;
 3755|  35.1k|}
_ZNK8CConnman26GetOutboundTargetBytesLeftEv:
 3758|  7.29k|{
 3759|  7.29k|    AssertLockNotHeld(m_total_bytes_sent_mutex);
  ------------------
  |  |  147|  7.29k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
 3760|  7.29k|    LOCK(m_total_bytes_sent_mutex);
  ------------------
  |  |  257|  7.29k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.29k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.29k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.29k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3761|  7.29k|    if (nMaxOutboundLimit == 0)
  ------------------
  |  Branch (3761:9): [True: 3.50k, False: 3.78k]
  ------------------
 3762|  3.50k|        return 0;
 3763|       |
 3764|  3.78k|    return (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit) ? 0 : nMaxOutboundLimit - nMaxOutboundTotalBytesSentInCycle;
  ------------------
  |  Branch (3764:12): [True: 21, False: 3.76k]
  ------------------
 3765|  7.29k|}
_ZNK8CConnman17GetTotalBytesRecvEv:
 3768|  7.29k|{
 3769|  7.29k|    return nTotalBytesRecv;
 3770|  7.29k|}
_ZNK8CConnman17GetTotalBytesSentEv:
 3773|  7.29k|{
 3774|  7.29k|    AssertLockNotHeld(m_total_bytes_sent_mutex);
  ------------------
  |  |  147|  7.29k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
 3775|  7.29k|    LOCK(m_total_bytes_sent_mutex);
  ------------------
  |  |  257|  7.29k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.29k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.29k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.29k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3776|  7.29k|    return nTotalBytesSent;
 3777|  7.29k|}
_ZNK8CConnman16GetLocalServicesEv:
 3780|  21.8k|{
 3781|  21.8k|    return m_local_services;
 3782|  21.8k|}
_ZN5CNodeC2ElNSt3__110shared_ptrI4SockEERK8CAddressmmRK8CServiceRKNS0_12basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE14ConnectionTypebO12CNodeOptions:
 3803|  25.1k|    : m_transport{MakeTransport(idIn, node_opts.use_v2transport, conn_type_in == ConnectionType::INBOUND)},
 3804|  25.1k|      m_permission_flags{node_opts.permission_flags},
 3805|  25.1k|      m_sock{sock},
 3806|  25.1k|      m_connected{GetTime<std::chrono::seconds>()},
 3807|  25.1k|      addr{addrIn},
 3808|  25.1k|      addrBind{addrBindIn},
 3809|  25.1k|      m_addr_name{addrNameIn.empty() ? addr.ToStringAddrPort() : addrNameIn},
  ------------------
  |  Branch (3809:19): [True: 10.5k, False: 14.6k]
  ------------------
 3810|  25.1k|      m_dest(addrNameIn),
 3811|  25.1k|      m_inbound_onion{inbound_onion},
 3812|  25.1k|      m_prefer_evict{node_opts.prefer_evict},
 3813|  25.1k|      nKeyedNetGroup{nKeyedNetGroupIn},
 3814|  25.1k|      m_conn_type{conn_type_in},
 3815|  25.1k|      id{idIn},
 3816|  25.1k|      nLocalHostNonce{nLocalHostNonceIn},
 3817|  25.1k|      m_recv_flood_size{node_opts.recv_flood_size},
 3818|  25.1k|      m_i2p_sam_session{std::move(node_opts.i2p_sam_session)}
 3819|  25.1k|{
 3820|  25.1k|    if (inbound_onion) assert(conn_type_in == ConnectionType::INBOUND);
  ------------------
  |  Branch (3820:9): [True: 1.46k, False: 23.7k]
  ------------------
 3821|       |
 3822|   881k|    for (const auto& msg : ALL_NET_MESSAGE_TYPES) {
  ------------------
  |  Branch (3822:26): [True: 881k, False: 25.1k]
  ------------------
 3823|   881k|        mapRecvBytesPerMsgType[msg] = 0;
 3824|   881k|    }
 3825|  25.1k|    mapRecvBytesPerMsgType[NET_MESSAGE_TYPE_OTHER] = 0;
 3826|       |
 3827|  25.1k|    if (fLogIPs) {
  ------------------
  |  Branch (3827:9): [True: 0, False: 25.1k]
  ------------------
 3828|      0|        LogDebug(BCLog::NET, "Added connection to %s peer=%d\n", m_addr_name, id);
  ------------------
  |  |  280|      0|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|      0|    do {                                                  \
  |  |  |  |  274|      0|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3829|  25.1k|    } else {
 3830|  25.1k|        LogDebug(BCLog::NET, "Added connection peer=%d\n", id);
  ------------------
  |  |  280|  25.1k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  25.1k|    do {                                                  \
  |  |  |  |  274|  25.1k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 25.1k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  25.1k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3831|  25.1k|    }
 3832|  25.1k|}
_ZN8CConnman18NodeFullyConnectedEPK5CNode:
 3866|   437k|{
 3867|   437k|    return pnode && pnode->fSuccessfullyConnected && !pnode->fDisconnect;
  ------------------
  |  Branch (3867:12): [True: 437k, False: 0]
  |  Branch (3867:21): [True: 0, False: 437k]
  |  Branch (3867:54): [True: 0, False: 0]
  ------------------
 3868|   437k|}
_ZN8CConnman11PushMessageEP5CNodeO17CSerializedNetMsg:
 3871|  79.9k|{
 3872|  79.9k|    AssertLockNotHeld(m_total_bytes_sent_mutex);
  ------------------
  |  |  147|  79.9k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
 3873|  79.9k|    size_t nMessageSize = msg.data.size();
 3874|  79.9k|    LogDebug(BCLog::NET, "sending %s (%d bytes) peer=%d\n", msg.m_type, nMessageSize, pnode->GetId());
  ------------------
  |  |  280|  79.9k|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  273|  79.9k|    do {                                                  \
  |  |  |  |  274|  79.9k|        if (LogAcceptCategory((category), (level))) {     \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (274:13): [True: 0, False: 79.9k]
  |  |  |  |  ------------------
  |  |  |  |  275|      0|            LogPrintLevel_(category, level, __VA_ARGS__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  276|      0|        }                                                 \
  |  |  |  |  277|  79.9k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (277:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3875|  79.9k|    if (gArgs.GetBoolArg("-capturemessages", false)) {
  ------------------
  |  Branch (3875:9): [True: 0, False: 79.9k]
  ------------------
 3876|      0|        CaptureMessage(pnode->addr, msg.m_type, msg.data, /*is_incoming=*/false);
 3877|      0|    }
 3878|       |
 3879|  79.9k|    TRACEPOINT(net, outbound_message,
 3880|  79.9k|        pnode->GetId(),
 3881|  79.9k|        pnode->m_addr_name.c_str(),
 3882|  79.9k|        pnode->ConnectionTypeAsString().c_str(),
 3883|  79.9k|        msg.m_type.c_str(),
 3884|  79.9k|        msg.data.size(),
 3885|  79.9k|        msg.data.data()
 3886|  79.9k|    );
 3887|       |
 3888|  79.9k|    size_t nBytesSent = 0;
 3889|  79.9k|    {
 3890|  79.9k|        LOCK(pnode->cs_vSend);
  ------------------
  |  |  257|  79.9k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  79.9k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  79.9k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  79.9k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3891|       |        // Check if the transport still has unsent bytes, and indicate to it that we're about to
 3892|       |        // give it a message to send.
 3893|  79.9k|        const auto& [to_send, more, _msg_type] =
 3894|  79.9k|            pnode->m_transport->GetBytesToSend(/*have_next_message=*/true);
 3895|  79.9k|        const bool queue_was_empty{to_send.empty() && pnode->vSendMsg.empty()};
  ------------------
  |  Branch (3895:36): [True: 41.0k, False: 38.9k]
  |  Branch (3895:55): [True: 41.0k, False: 0]
  ------------------
 3896|       |
 3897|       |        // Update memory usage of send buffer.
 3898|  79.9k|        pnode->m_send_memusage += msg.GetMemoryUsage();
 3899|  79.9k|        if (pnode->m_send_memusage + pnode->m_transport->GetSendMemoryUsage() > nSendBufferMaxSize) pnode->fPauseSend = true;
  ------------------
  |  Branch (3899:13): [True: 79.9k, False: 0]
  ------------------
 3900|       |        // Move message to vSendMsg queue.
 3901|  79.9k|        pnode->vSendMsg.push_back(std::move(msg));
 3902|       |
 3903|       |        // If there was nothing to send before, and there is now (predicted by the "more" value
 3904|       |        // returned by the GetBytesToSend call above), attempt "optimistic write":
 3905|       |        // because the poll/select loop may pause for SELECT_TIMEOUT_MILLISECONDS before actually
 3906|       |        // doing a send, try sending from the calling thread if the queue was empty before.
 3907|       |        // With a V1Transport, more will always be true here, because adding a message always
 3908|       |        // results in sendable bytes there, but with V2Transport this is not the case (it may
 3909|       |        // still be in the handshake).
 3910|  79.9k|        if (queue_was_empty && more) {
  ------------------
  |  Branch (3910:13): [True: 41.0k, False: 38.9k]
  |  Branch (3910:32): [True: 41.0k, False: 0]
  ------------------
 3911|  41.0k|            std::tie(nBytesSent, std::ignore) = SocketSendData(*pnode);
 3912|  41.0k|        }
 3913|  79.9k|    }
 3914|  79.9k|    if (nBytesSent) RecordBytesSent(nBytesSent);
  ------------------
  |  Branch (3914:9): [True: 40.8k, False: 39.0k]
  ------------------
 3915|  79.9k|}
_ZN8CConnman7ForNodeElNSt3__18functionIFbP5CNodeEEE:
 3918|  2.23k|{
 3919|  2.23k|    CNode* found = nullptr;
 3920|  2.23k|    LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  2.23k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  2.23k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  2.23k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  2.23k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3921|  12.8k|    for (auto&& pnode : m_nodes) {
  ------------------
  |  Branch (3921:23): [True: 12.8k, False: 2.16k]
  ------------------
 3922|  12.8k|        if(pnode->GetId() == id) {
  ------------------
  |  Branch (3922:12): [True: 76, False: 12.7k]
  ------------------
 3923|     76|            found = pnode;
 3924|     76|            break;
 3925|     76|        }
 3926|  12.8k|    }
 3927|  2.23k|    return found != nullptr && NodeFullyConnected(found) && func(found);
  ------------------
  |  Branch (3927:12): [True: 76, False: 2.16k]
  |  Branch (3927:32): [True: 0, False: 76]
  |  Branch (3927:61): [True: 0, False: 0]
  ------------------
 3928|  2.23k|}
_ZNK8CConnman26GetDeterministicRandomizerEm:
 3931|  7.62k|{
 3932|  7.62k|    return CSipHasher(nSeed0, nSeed1).Write(id);
 3933|  7.62k|}
_ZN8CConnman16ASMapHealthCheckEv:
 3970|  7.29k|{
 3971|  7.29k|    const std::vector<CAddress> v4_addrs{GetAddresses(/*max_addresses=*/ 0, /*max_pct=*/ 0, Network::NET_IPV4, /*filtered=*/ false)};
 3972|  7.29k|    const std::vector<CAddress> v6_addrs{GetAddresses(/*max_addresses=*/ 0, /*max_pct=*/ 0, Network::NET_IPV6, /*filtered=*/ false)};
 3973|  7.29k|    std::vector<CNetAddr> clearnet_addrs;
 3974|  7.29k|    clearnet_addrs.reserve(v4_addrs.size() + v6_addrs.size());
 3975|  7.29k|    std::transform(v4_addrs.begin(), v4_addrs.end(), std::back_inserter(clearnet_addrs),
 3976|  7.29k|        [](const CAddress& addr) { return static_cast<CNetAddr>(addr); });
 3977|  7.29k|    std::transform(v6_addrs.begin(), v6_addrs.end(), std::back_inserter(clearnet_addrs),
 3978|  7.29k|        [](const CAddress& addr) { return static_cast<CNetAddr>(addr); });
 3979|  7.29k|    m_netgroupman.ASMapHealthCheck(clearnet_addrs);
 3980|  7.29k|}
net.cpp:_ZL13MakeTransportlbb:
 3785|  25.1k|{
 3786|  25.1k|    if (use_v2transport) {
  ------------------
  |  Branch (3786:9): [True: 0, False: 25.1k]
  ------------------
 3787|      0|        return std::make_unique<V2Transport>(id, /*initiating=*/!inbound);
 3788|  25.1k|    } else {
 3789|  25.1k|        return std::make_unique<V1Transport>(id);
 3790|  25.1k|    }
 3791|  25.1k|}
net.cpp:_ZZN8CConnman16ASMapHealthCheckEvENK3$_0clERK8CAddress:
 3976|    137|        [](const CAddress& addr) { return static_cast<CNetAddr>(addr); });
net.cpp:_ZZN8CConnman16ASMapHealthCheckEvENK3$_1clERK8CAddress:
 3978|  2.22k|        [](const CAddress& addr) { return static_cast<CNetAddr>(addr); });

_ZN11V1Transport5ResetEv:
  386|  25.1k|    void Reset() EXCLUSIVE_LOCKS_REQUIRED(m_recv_mutex) {
  387|  25.1k|        AssertLockHeld(m_recv_mutex);
  ------------------
  |  |  142|  25.1k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
  ------------------
  388|  25.1k|        vRecv.clear();
  389|  25.1k|        hdrbuf.clear();
  390|  25.1k|        hdrbuf.resize(24);
  391|  25.1k|        in_data = false;
  392|  25.1k|        nHdrPos = 0;
  393|  25.1k|        nDataPos = 0;
  394|  25.1k|        data_hash.SetNull();
  395|  25.1k|        hasher.Reset();
  396|  25.1k|    }
_ZN5CNode19AccountForSentBytesERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEm:
  756|  72.8k|    {
  757|  72.8k|        mapSendBytesPerMsgType[msg_type] += sent_bytes;
  758|  72.8k|    }
_ZNK5CNode26IsManualOrFullOutboundConnEv:
  784|  17.8k|    {
  785|  17.8k|        switch (m_conn_type) {
  ------------------
  |  Branch (785:17): [True: 0, False: 17.8k]
  ------------------
  786|  2.09k|        case ConnectionType::INBOUND:
  ------------------
  |  Branch (786:9): [True: 2.09k, False: 15.7k]
  ------------------
  787|  8.12k|        case ConnectionType::FEELER:
  ------------------
  |  Branch (787:9): [True: 6.02k, False: 11.8k]
  ------------------
  788|  8.30k|        case ConnectionType::BLOCK_RELAY:
  ------------------
  |  Branch (788:9): [True: 187, False: 17.6k]
  ------------------
  789|  11.4k|        case ConnectionType::ADDR_FETCH:
  ------------------
  |  Branch (789:9): [True: 3.19k, False: 14.6k]
  ------------------
  790|  11.4k|                return false;
  791|  6.01k|        case ConnectionType::OUTBOUND_FULL_RELAY:
  ------------------
  |  Branch (791:9): [True: 6.01k, False: 11.8k]
  ------------------
  792|  6.38k|        case ConnectionType::MANUAL:
  ------------------
  |  Branch (792:9): [True: 373, False: 17.5k]
  ------------------
  793|  6.38k|                return true;
  794|  17.8k|        } // no default case, so the compiler can warn about missing cases
  795|       |
  796|      0|        assert(false);
  797|      0|    }
_ZNK5CNode13IsInboundConnEv:
  811|  73.7k|    bool IsInboundConn() const {
  812|  73.7k|        return m_conn_type == ConnectionType::INBOUND;
  813|  73.7k|    }
_ZNK5CNode5GetIdEv:
  894|   321k|    NodeId GetId() const {
  895|   321k|        return id;
  896|   321k|    }
_ZNK5CNode13GetLocalNonceEv:
  898|  3.11k|    uint64_t GetLocalNonce() const {
  899|  3.11k|        return nLocalHostNonce;
  900|  3.11k|    }
_ZN8CConnman4InitERKNS_7OptionsE:
 1084|  14.5k|    {
 1085|  14.5k|        AssertLockNotHeld(m_total_bytes_sent_mutex);
  ------------------
  |  |  147|  14.5k|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
 1086|       |
 1087|  14.5k|        m_local_services = connOptions.m_local_services;
 1088|  14.5k|        m_max_automatic_connections = connOptions.m_max_automatic_connections;
 1089|  14.5k|        m_max_outbound_full_relay = std::min(MAX_OUTBOUND_FULL_RELAY_CONNECTIONS, m_max_automatic_connections);
 1090|  14.5k|        m_max_outbound_block_relay = std::min(MAX_BLOCK_RELAY_ONLY_CONNECTIONS, m_max_automatic_connections - m_max_outbound_full_relay);
 1091|  14.5k|        m_max_automatic_outbound = m_max_outbound_full_relay + m_max_outbound_block_relay + m_max_feeler;
 1092|  14.5k|        m_max_inbound = std::max(0, m_max_automatic_connections - m_max_automatic_outbound);
 1093|  14.5k|        m_use_addrman_outgoing = connOptions.m_use_addrman_outgoing;
 1094|  14.5k|        m_client_interface = connOptions.uiInterface;
 1095|  14.5k|        m_banman = connOptions.m_banman;
 1096|  14.5k|        m_msgproc = connOptions.m_msgproc;
 1097|  14.5k|        nSendBufferMaxSize = connOptions.nSendBufferMaxSize;
 1098|  14.5k|        nReceiveFloodSize = connOptions.nReceiveFloodSize;
 1099|  14.5k|        m_peer_connect_timeout = std::chrono::seconds{connOptions.m_peer_connect_timeout};
 1100|  14.5k|        {
 1101|  14.5k|            LOCK(m_total_bytes_sent_mutex);
  ------------------
  |  |  257|  14.5k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  14.5k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  14.5k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  14.5k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1102|  14.5k|            nMaxOutboundLimit = connOptions.nMaxOutboundLimit;
 1103|  14.5k|        }
 1104|  14.5k|        vWhitelistedRangeIncoming = connOptions.vWhitelistedRangeIncoming;
 1105|  14.5k|        vWhitelistedRangeOutgoing = connOptions.vWhitelistedRangeOutgoing;
 1106|  14.5k|        {
 1107|  14.5k|            LOCK(m_added_nodes_mutex);
  ------------------
  |  |  257|  14.5k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  14.5k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  14.5k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  14.5k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1108|       |            // Attempt v2 connection if we support v2 - we'll reconnect with v1 if our
 1109|       |            // peer doesn't support it or immediately disconnects us for another reason.
 1110|  14.5k|            const bool use_v2transport(GetLocalServices() & NODE_P2P_V2);
 1111|  14.5k|            for (const std::string& added_node : connOptions.m_added_nodes) {
  ------------------
  |  Branch (1111:48): [True: 0, False: 14.5k]
  ------------------
 1112|      0|                m_added_node_params.push_back({added_node, use_v2transport});
 1113|      0|            }
 1114|  14.5k|        }
 1115|  14.5k|        m_onion_binds = connOptions.onion_binds;
 1116|  14.5k|        whitelist_forcerelay = connOptions.whitelist_forcerelay;
 1117|  14.5k|        whitelist_relay = connOptions.whitelist_relay;
 1118|  14.5k|    }
_ZN8CConnman4StopEv:
 1130|  7.29k|    {
 1131|  7.29k|        StopThreads();
 1132|  7.29k|        StopNodes();
 1133|  7.29k|    };
_ZNK8CConnman16GetNetworkActiveEv:
 1136|  7.29k|    bool GetNetworkActive() const { return fNetworkActive; };
_ZNK8CConnman21GetUseAddrmanOutgoingEv:
 1137|  7.29k|    bool GetUseAddrmanOutgoing() const { return m_use_addrman_outgoing; };
_ZN8CConnman11ForEachNodeERKNSt3__18functionIFvP5CNodeEEE:
 1152|  39.4k|    {
 1153|  39.4k|        LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  39.4k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  39.4k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  39.4k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  39.4k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1154|   437k|        for (auto&& node : m_nodes) {
  ------------------
  |  Branch (1154:26): [True: 437k, False: 39.4k]
  ------------------
 1155|   437k|            if (NodeFullyConnected(node))
  ------------------
  |  Branch (1155:17): [True: 0, False: 437k]
  ------------------
 1156|      0|                func(node);
 1157|   437k|        }
 1158|  39.4k|    };
_ZN17CSerializedNetMsgC2Ev:
  115|   105k|    CSerializedNetMsg() = default;
_ZN9TransportD2Ev:
  256|  25.1k|    virtual ~Transport() = default;
_ZN17CSerializedNetMsgC2EOS_:
  116|  79.9k|    CSerializedNetMsg(CSerializedNetMsg&&) = default;
_ZN17CSerializedNetMsgaSEOS_:
  117|  41.0k|    CSerializedNetMsg& operator=(CSerializedNetMsg&&) = default;

_ZN11PeerManagerD2Ev:
   86|      2|    virtual ~PeerManager() = default;

_ZN8CNetAddr23SetNetFromBIP155NetworkEhm:
   49|   307k|{
   50|   307k|    switch (possible_bip155_net) {
  ------------------
  |  Branch (50:13): [True: 211k, False: 96.7k]
  ------------------
   51|  39.7k|    case BIP155Network::IPV4:
  ------------------
  |  Branch (51:5): [True: 39.7k, False: 268k]
  ------------------
   52|  39.7k|        if (address_size == ADDR_IPV4_SIZE) {
  ------------------
  |  Branch (52:13): [True: 39.7k, False: 10]
  ------------------
   53|  39.7k|            m_net = NET_IPV4;
   54|  39.7k|            return true;
   55|  39.7k|        }
   56|     10|        throw std::ios_base::failure(
   57|     10|            strprintf("BIP155 IPv4 address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|     10|#define strprintf tfm::format
  ------------------
   58|     10|                      ADDR_IPV4_SIZE));
   59|  33.8k|    case BIP155Network::IPV6:
  ------------------
  |  Branch (59:5): [True: 33.8k, False: 274k]
  ------------------
   60|  33.8k|        if (address_size == ADDR_IPV6_SIZE) {
  ------------------
  |  Branch (60:13): [True: 33.7k, False: 11]
  ------------------
   61|  33.7k|            m_net = NET_IPV6;
   62|  33.7k|            return true;
   63|  33.7k|        }
   64|     11|        throw std::ios_base::failure(
   65|     11|            strprintf("BIP155 IPv6 address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|     11|#define strprintf tfm::format
  ------------------
   66|     11|                      ADDR_IPV6_SIZE));
   67|  4.01k|    case BIP155Network::TORV3:
  ------------------
  |  Branch (67:5): [True: 4.01k, False: 303k]
  ------------------
   68|  4.01k|        if (address_size == ADDR_TORV3_SIZE) {
  ------------------
  |  Branch (68:13): [True: 4.01k, False: 5]
  ------------------
   69|  4.01k|            m_net = NET_ONION;
   70|  4.01k|            return true;
   71|  4.01k|        }
   72|      5|        throw std::ios_base::failure(
   73|      5|            strprintf("BIP155 TORv3 address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|      5|#define strprintf tfm::format
  ------------------
   74|      5|                      ADDR_TORV3_SIZE));
   75|  12.6k|    case BIP155Network::I2P:
  ------------------
  |  Branch (75:5): [True: 12.6k, False: 295k]
  ------------------
   76|  12.6k|        if (address_size == ADDR_I2P_SIZE) {
  ------------------
  |  Branch (76:13): [True: 12.6k, False: 10]
  ------------------
   77|  12.6k|            m_net = NET_I2P;
   78|  12.6k|            return true;
   79|  12.6k|        }
   80|     10|        throw std::ios_base::failure(
   81|     10|            strprintf("BIP155 I2P address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|     10|#define strprintf tfm::format
  ------------------
   82|     10|                      ADDR_I2P_SIZE));
   83|  6.56k|    case BIP155Network::CJDNS:
  ------------------
  |  Branch (83:5): [True: 6.56k, False: 301k]
  ------------------
   84|  6.56k|        if (address_size == ADDR_CJDNS_SIZE) {
  ------------------
  |  Branch (84:13): [True: 6.55k, False: 6]
  ------------------
   85|  6.55k|            m_net = NET_CJDNS;
   86|  6.55k|            return true;
   87|  6.55k|        }
   88|      6|        throw std::ios_base::failure(
   89|      6|            strprintf("BIP155 CJDNS address with length %u (should be %u)", address_size,
  ------------------
  |  | 1172|      6|#define strprintf tfm::format
  ------------------
   90|      6|                      ADDR_CJDNS_SIZE));
   91|   307k|    }
   92|       |
   93|       |    // Don't throw on addresses with unknown network ids (maybe from the future).
   94|       |    // Instead silently drop them and have the unserialization code consume
   95|       |    // subsequent ones which may be known to us.
   96|   211k|    return false;
   97|   307k|}
_ZN8CNetAddrC2Ev:
  104|  1.41M|CNetAddr::CNetAddr() = default;
_ZN8CNetAddr13SetLegacyIPv6E4SpanIKhE:
  138|   314k|{
  139|   314k|    assert(ipv6.size() == ADDR_IPV6_SIZE);
  140|       |
  141|   314k|    size_t skip{0};
  142|       |
  143|   314k|    if (HasPrefix(ipv6, IPV4_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (143:9): [True: 3.46k, False: 311k]
  ------------------
  144|       |        // IPv4-in-IPv6
  145|  3.46k|        m_net = NET_IPV4;
  146|  3.46k|        skip = sizeof(IPV4_IN_IPV6_PREFIX);
  147|   311k|    } else if (HasPrefix(ipv6, TORV2_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (147:16): [True: 14, False: 311k]
  ------------------
  148|       |        // TORv2-in-IPv6 (unsupported). Unserialize as !IsValid(), thus ignoring them.
  149|       |        // Mimic a default-constructed CNetAddr object which is !IsValid() and thus
  150|       |        // will not be gossiped, but continue reading next addresses from the stream.
  151|     14|        m_net = NET_IPV6;
  152|     14|        m_addr.assign(ADDR_IPV6_SIZE, 0x0);
  153|     14|        return;
  154|   311k|    } else if (HasPrefix(ipv6, INTERNAL_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (154:16): [True: 160, False: 310k]
  ------------------
  155|       |        // Internal-in-IPv6
  156|    160|        m_net = NET_INTERNAL;
  157|    160|        skip = sizeof(INTERNAL_IN_IPV6_PREFIX);
  158|   310k|    } else {
  159|       |        // IPv6
  160|   310k|        m_net = NET_IPV6;
  161|   310k|    }
  162|       |
  163|   314k|    m_addr.assign(ipv6.begin() + skip, ipv6.end());
  164|   314k|}
_ZN8CNetAddr11SetInternalERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  173|  3.45k|{
  174|  3.45k|    if (name.empty()) {
  ------------------
  |  Branch (174:9): [True: 15, False: 3.44k]
  ------------------
  175|     15|        return false;
  176|     15|    }
  177|  3.44k|    m_net = NET_INTERNAL;
  178|  3.44k|    unsigned char hash[32] = {};
  179|  3.44k|    CSHA256().Write((const unsigned char*)name.data(), name.size()).Finalize(hash);
  180|  3.44k|    m_addr.assign(hash, hash + ADDR_INTERNAL_SIZE);
  181|  3.44k|    return true;
  182|  3.45k|}
_ZN8CNetAddr10SetSpecialERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  212|   403k|{
  213|   403k|    if (!ContainsNoNUL(addr)) {
  ------------------
  |  Branch (213:9): [True: 35.4k, False: 367k]
  ------------------
  214|  35.4k|        return false;
  215|  35.4k|    }
  216|       |
  217|   367k|    if (SetTor(addr)) {
  ------------------
  |  Branch (217:9): [True: 2.58k, False: 365k]
  ------------------
  218|  2.58k|        return true;
  219|  2.58k|    }
  220|       |
  221|   365k|    if (SetI2P(addr)) {
  ------------------
  |  Branch (221:9): [True: 5.31k, False: 359k]
  ------------------
  222|  5.31k|        return true;
  223|  5.31k|    }
  224|       |
  225|   359k|    return false;
  226|   365k|}
_ZN8CNetAddr6SetTorERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  229|   367k|{
  230|   367k|    static const char* suffix{".onion"};
  231|   367k|    static constexpr size_t suffix_len{6};
  232|       |
  233|   367k|    if (addr.size() <= suffix_len || addr.substr(addr.size() - suffix_len) != suffix) {
  ------------------
  |  Branch (233:9): [True: 96.1k, False: 271k]
  |  Branch (233:9): [True: 361k, False: 6.10k]
  |  Branch (233:38): [True: 265k, False: 6.10k]
  ------------------
  234|   361k|        return false;
  235|   361k|    }
  236|       |
  237|  6.10k|    auto input = DecodeBase32(std::string_view{addr}.substr(0, addr.size() - suffix_len));
  238|       |
  239|  6.10k|    if (!input) {
  ------------------
  |  Branch (239:9): [True: 2.10k, False: 4.00k]
  ------------------
  240|  2.10k|        return false;
  241|  2.10k|    }
  242|       |
  243|  4.00k|    if (input->size() == torv3::TOTAL_LEN) {
  ------------------
  |  Branch (243:9): [True: 3.60k, False: 397]
  ------------------
  244|  3.60k|        Span<const uint8_t> input_pubkey{input->data(), ADDR_TORV3_SIZE};
  245|  3.60k|        Span<const uint8_t> input_checksum{input->data() + ADDR_TORV3_SIZE, torv3::CHECKSUM_LEN};
  246|  3.60k|        Span<const uint8_t> input_version{input->data() + ADDR_TORV3_SIZE + torv3::CHECKSUM_LEN, sizeof(torv3::VERSION)};
  247|       |
  248|  3.60k|        if (!std::ranges::equal(input_version, torv3::VERSION)) {
  ------------------
  |  Branch (248:13): [True: 371, False: 3.23k]
  ------------------
  249|    371|            return false;
  250|    371|        }
  251|       |
  252|  3.23k|        uint8_t calculated_checksum[torv3::CHECKSUM_LEN];
  253|  3.23k|        torv3::Checksum(input_pubkey, calculated_checksum);
  254|       |
  255|  3.23k|        if (!std::ranges::equal(input_checksum, calculated_checksum)) {
  ------------------
  |  Branch (255:13): [True: 647, False: 2.58k]
  ------------------
  256|    647|            return false;
  257|    647|        }
  258|       |
  259|  2.58k|        m_net = NET_ONION;
  260|  2.58k|        m_addr.assign(input_pubkey.begin(), input_pubkey.end());
  261|  2.58k|        return true;
  262|  3.23k|    }
  263|       |
  264|    397|    return false;
  265|  4.00k|}
_ZN8CNetAddr6SetI2PERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
  268|   365k|{
  269|       |    // I2P addresses that we support consist of 52 base32 characters + ".b32.i2p".
  270|   365k|    static constexpr size_t b32_len{52};
  271|   365k|    static const char* suffix{".b32.i2p"};
  272|   365k|    static constexpr size_t suffix_len{8};
  273|       |
  274|   365k|    if (addr.size() != b32_len + suffix_len || ToLower(addr.substr(b32_len)) != suffix) {
  ------------------
  |  Branch (274:9): [True: 355k, False: 9.66k]
  |  Branch (274:9): [True: 357k, False: 7.76k]
  |  Branch (274:48): [True: 1.89k, False: 7.76k]
  ------------------
  275|   357k|        return false;
  276|   357k|    }
  277|       |
  278|       |    // Remove the ".b32.i2p" suffix and pad to a multiple of 8 chars, so DecodeBase32()
  279|       |    // can decode it.
  280|  7.76k|    const std::string b32_padded = addr.substr(0, b32_len) + "====";
  281|       |
  282|  7.76k|    auto address_bytes = DecodeBase32(b32_padded);
  283|       |
  284|  7.76k|    if (!address_bytes || address_bytes->size() != ADDR_I2P_SIZE) {
  ------------------
  |  Branch (284:9): [True: 2.23k, False: 5.52k]
  |  Branch (284:27): [True: 206, False: 5.31k]
  ------------------
  285|  2.44k|        return false;
  286|  2.44k|    }
  287|       |
  288|  5.31k|    m_net = NET_I2P;
  289|  5.31k|    m_addr.assign(address_bytes->begin(), address_bytes->end());
  290|       |
  291|  5.31k|    return true;
  292|  7.76k|}
_ZN8CNetAddrC2ERK7in_addr:
  295|  15.8k|{
  296|  15.8k|    m_net = NET_IPV4;
  297|  15.8k|    const uint8_t* ptr = reinterpret_cast<const uint8_t*>(&ipv4Addr);
  298|  15.8k|    m_addr.assign(ptr, ptr + ADDR_IPV4_SIZE);
  299|  15.8k|}
_ZN8CNetAddrC2ERK8in6_addrj:
  302|  11.0k|{
  303|  11.0k|    SetLegacyIPv6({reinterpret_cast<const uint8_t*>(&ipv6Addr), sizeof(ipv6Addr)});
  304|  11.0k|    m_scope_id = scope;
  305|  11.0k|}
_ZNK8CNetAddr9IsRFC1918Ev:
  316|   639k|{
  317|   639k|    return IsIPv4() && (
  ------------------
  |  Branch (317:12): [True: 36.0k, False: 603k]
  ------------------
  318|  36.0k|        m_addr[0] == 10 ||
  ------------------
  |  Branch (318:9): [True: 308, False: 35.7k]
  ------------------
  319|  36.0k|        (m_addr[0] == 192 && m_addr[1] == 168) ||
  ------------------
  |  Branch (319:10): [True: 689, False: 35.0k]
  |  Branch (319:30): [True: 72, False: 617]
  ------------------
  320|  36.0k|        (m_addr[0] == 172 && m_addr[1] >= 16 && m_addr[1] <= 31));
  ------------------
  |  Branch (320:10): [True: 1.04k, False: 34.6k]
  |  Branch (320:30): [True: 259, False: 786]
  |  Branch (320:49): [True: 175, False: 84]
  ------------------
  321|   639k|}
_ZNK8CNetAddr9IsRFC2544Ev:
  324|   638k|{
  325|   638k|    return IsIPv4() && m_addr[0] == 198 && (m_addr[1] == 18 || m_addr[1] == 19);
  ------------------
  |  Branch (325:12): [True: 35.4k, False: 603k]
  |  Branch (325:24): [True: 1.35k, False: 34.1k]
  |  Branch (325:45): [True: 347, False: 1.00k]
  |  Branch (325:64): [True: 154, False: 851]
  ------------------
  326|   638k|}
_ZNK8CNetAddr9IsRFC3927Ev:
  329|   638k|{
  330|   638k|    return IsIPv4() && HasPrefix(m_addr, std::array<uint8_t, 2>{169, 254});
  ------------------
  |  Branch (330:12): [True: 34.9k, False: 603k]
  |  Branch (330:24): [True: 462, False: 34.5k]
  ------------------
  331|   638k|}
_ZNK8CNetAddr9IsRFC6598Ev:
  334|   636k|{
  335|   636k|    return IsIPv4() && m_addr[0] == 100 && m_addr[1] >= 64 && m_addr[1] <= 127;
  ------------------
  |  Branch (335:12): [True: 34.5k, False: 602k]
  |  Branch (335:24): [True: 1.12k, False: 33.4k]
  |  Branch (335:44): [True: 688, False: 432]
  |  Branch (335:63): [True: 220, False: 468]
  ------------------
  336|   636k|}
_ZNK8CNetAddr9IsRFC5737Ev:
  339|   636k|{
  340|   636k|    return IsIPv4() && (HasPrefix(m_addr, std::array<uint8_t, 3>{192, 0, 2}) ||
  ------------------
  |  Branch (340:12): [True: 34.3k, False: 602k]
  |  Branch (340:25): [True: 305, False: 34.0k]
  ------------------
  341|  34.3k|                        HasPrefix(m_addr, std::array<uint8_t, 3>{198, 51, 100}) ||
  ------------------
  |  Branch (341:25): [True: 284, False: 33.7k]
  ------------------
  342|  34.3k|                        HasPrefix(m_addr, std::array<uint8_t, 3>{203, 0, 113}));
  ------------------
  |  Branch (342:25): [True: 60, False: 33.6k]
  ------------------
  343|   636k|}
_ZNK8CNetAddr9IsRFC3849Ev:
  346|   935k|{
  347|   935k|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 4>{0x20, 0x01, 0x0D, 0xB8});
  ------------------
  |  Branch (347:12): [True: 696k, False: 239k]
  |  Branch (347:24): [True: 206, False: 695k]
  ------------------
  348|   935k|}
_ZNK8CNetAddr9IsRFC3964Ev:
  351|   284k|{
  352|   284k|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 2>{0x20, 0x02});
  ------------------
  |  Branch (352:12): [True: 264k, False: 20.5k]
  |  Branch (352:24): [True: 1.58k, False: 262k]
  ------------------
  353|   284k|}
_ZNK8CNetAddr9IsRFC6052Ev:
  356|   289k|{
  357|   289k|    return IsIPv6() &&
  ------------------
  |  Branch (357:12): [True: 268k, False: 20.5k]
  ------------------
  358|   289k|           HasPrefix(m_addr, std::array<uint8_t, 12>{0x00, 0x64, 0xFF, 0x9B, 0x00, 0x00,
  ------------------
  |  Branch (358:12): [True: 3.35k, False: 265k]
  ------------------
  359|   268k|                                                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00});
  360|   289k|}
_ZNK8CNetAddr9IsRFC4380Ev:
  363|   283k|{
  364|   283k|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 4>{0x20, 0x01, 0x00, 0x00});
  ------------------
  |  Branch (364:12): [True: 262k, False: 20.5k]
  |  Branch (364:24): [True: 4.41k, False: 258k]
  ------------------
  365|   283k|}
_ZNK8CNetAddr9IsRFC4862Ev:
  368|   637k|{
  369|   637k|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 8>{0xFE, 0x80, 0x00, 0x00,
  ------------------
  |  Branch (369:12): [True: 552k, False: 84.8k]
  |  Branch (369:24): [True: 837, False: 551k]
  ------------------
  370|   552k|                                                                0x00, 0x00, 0x00, 0x00});
  371|   637k|}
_ZNK8CNetAddr9IsRFC4193Ev:
  374|   635k|{
  375|   635k|    return IsIPv6() && (m_addr[0] & 0xFE) == 0xFC;
  ------------------
  |  Branch (375:12): [True: 551k, False: 83.9k]
  |  Branch (375:24): [True: 1.83k, False: 550k]
  ------------------
  376|   635k|}
_ZNK8CNetAddr9IsRFC6145Ev:
  379|   291k|{
  380|   291k|    return IsIPv6() &&
  ------------------
  |  Branch (380:12): [True: 271k, False: 20.5k]
  ------------------
  381|   291k|           HasPrefix(m_addr, std::array<uint8_t, 12>{0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  ------------------
  |  Branch (381:12): [True: 4.65k, False: 266k]
  ------------------
  382|   271k|                                                     0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00});
  383|   291k|}
_ZNK8CNetAddr9IsRFC4843Ev:
  386|   634k|{
  387|   634k|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 3>{0x20, 0x01, 0x00}) &&
  ------------------
  |  Branch (387:12): [True: 550k, False: 83.9k]
  |  Branch (387:24): [True: 7.42k, False: 542k]
  ------------------
  388|   634k|           (m_addr[3] & 0xF0) == 0x10;
  ------------------
  |  Branch (388:12): [True: 1.31k, False: 6.10k]
  ------------------
  389|   634k|}
_ZNK8CNetAddr9IsRFC7343Ev:
  392|   632k|{
  393|   632k|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 3>{0x20, 0x01, 0x00}) &&
  ------------------
  |  Branch (393:12): [True: 548k, False: 83.9k]
  |  Branch (393:24): [True: 6.10k, False: 542k]
  ------------------
  394|   632k|           (m_addr[3] & 0xF0) == 0x20;
  ------------------
  |  Branch (394:12): [True: 277, False: 5.83k]
  ------------------
  395|   632k|}
_ZNK8CNetAddr7IsHeNetEv:
  398|  72.3k|{
  399|  72.3k|    return IsIPv6() && HasPrefix(m_addr, std::array<uint8_t, 4>{0x20, 0x01, 0x04, 0x70});
  ------------------
  |  Branch (399:12): [True: 72.3k, False: 0]
  |  Branch (399:24): [True: 254, False: 72.1k]
  ------------------
  400|  72.3k|}
_ZNK8CNetAddr7IsLocalEv:
  403|   735k|{
  404|       |    // IPv4 loopback (127.0.0.0/8 or 0.0.0.0/8)
  405|   735k|    if (IsIPv4() && (m_addr[0] == 127 || m_addr[0] == 0)) {
  ------------------
  |  Branch (405:9): [True: 36.4k, False: 698k]
  |  Branch (405:22): [True: 247, False: 36.1k]
  |  Branch (405:42): [True: 2.72k, False: 33.4k]
  ------------------
  406|  2.97k|        return true;
  407|  2.97k|    }
  408|       |
  409|       |    // IPv6 loopback (::1/128)
  410|   732k|    static const unsigned char pchLocal[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
  411|   732k|    if (IsIPv6() && memcmp(m_addr.data(), pchLocal, sizeof(pchLocal)) == 0) {
  ------------------
  |  Branch (411:9): [True: 645k, False: 86.6k]
  |  Branch (411:21): [True: 1.58k, False: 643k]
  ------------------
  412|  1.58k|        return true;
  413|  1.58k|    }
  414|       |
  415|   730k|    return false;
  416|   732k|}
_ZNK8CNetAddr7IsValidEv:
  429|  1.40M|{
  430|       |    // unspecified IPv6 address (::/128)
  431|  1.40M|    unsigned char ipNone6[16] = {};
  432|  1.40M|    if (IsIPv6() && memcmp(m_addr.data(), ipNone6, sizeof(ipNone6)) == 0) {
  ------------------
  |  Branch (432:9): [True: 1.16M, False: 239k]
  |  Branch (432:21): [True: 470k, False: 696k]
  ------------------
  433|   470k|        return false;
  434|   470k|    }
  435|       |
  436|   935k|    if (IsCJDNS() && !HasCJDNSPrefix()) {
  ------------------
  |  Branch (436:9): [True: 13.6k, False: 921k]
  |  Branch (436:22): [True: 409, False: 13.2k]
  ------------------
  437|    409|        return false;
  438|    409|    }
  439|       |
  440|       |    // documentation IPv6 address
  441|   935k|    if (IsRFC3849())
  ------------------
  |  Branch (441:9): [True: 206, False: 934k]
  ------------------
  442|    206|        return false;
  443|       |
  444|   934k|    if (IsInternal())
  ------------------
  |  Branch (444:9): [True: 36.2k, False: 898k]
  ------------------
  445|  36.2k|        return false;
  446|       |
  447|   898k|    if (IsIPv4()) {
  ------------------
  |  Branch (447:9): [True: 56.5k, False: 842k]
  ------------------
  448|  56.5k|        const uint32_t addr = ReadBE32(m_addr.data());
  449|  56.5k|        if (addr == INADDR_ANY || addr == INADDR_NONE) {
  ------------------
  |  Branch (449:13): [True: 1.51k, False: 55.0k]
  |  Branch (449:35): [True: 2.26k, False: 52.7k]
  ------------------
  450|  3.78k|            return false;
  451|  3.78k|        }
  452|  56.5k|    }
  453|       |
  454|   894k|    return true;
  455|   898k|}
_ZNK8CNetAddr10IsRoutableEv:
  467|   989k|{
  468|   989k|    return IsValid() && !(IsRFC1918() || IsRFC2544() || IsRFC3927() || IsRFC4862() || IsRFC6598() || IsRFC5737() || IsRFC4193() || IsRFC4843() || IsRFC7343() || IsLocal() || IsInternal());
  ------------------
  |  Branch (468:12): [True: 639k, False: 350k]
  |  Branch (468:27): [True: 555, False: 638k]
  |  Branch (468:42): [True: 501, False: 638k]
  |  Branch (468:57): [True: 462, False: 637k]
  |  Branch (468:72): [True: 837, False: 636k]
  |  Branch (468:87): [True: 220, False: 636k]
  |  Branch (468:102): [True: 649, False: 635k]
  |  Branch (468:117): [True: 1.83k, False: 634k]
  |  Branch (468:132): [True: 1.31k, False: 632k]
  |  Branch (468:147): [True: 277, False: 632k]
  |  Branch (468:162): [True: 3.22k, False: 629k]
  |  Branch (468:175): [True: 0, False: 629k]
  ------------------
  469|   989k|}
_ZNK8CNetAddr10IsInternalEv:
  477|  2.28M|{
  478|  2.28M|   return m_net == NET_INTERNAL;
  479|  2.28M|}
_ZNK8CNetAddr18IsAddrV1CompatibleEv:
  482|   278k|{
  483|   278k|    switch (m_net) {
  ------------------
  |  Branch (483:13): [True: 0, False: 278k]
  ------------------
  484|  6.47k|    case NET_IPV4:
  ------------------
  |  Branch (484:5): [True: 6.47k, False: 271k]
  ------------------
  485|   268k|    case NET_IPV6:
  ------------------
  |  Branch (485:5): [True: 262k, False: 16.1k]
  ------------------
  486|   269k|    case NET_INTERNAL:
  ------------------
  |  Branch (486:5): [True: 497, False: 277k]
  ------------------
  487|   269k|        return true;
  488|  1.25k|    case NET_ONION:
  ------------------
  |  Branch (488:5): [True: 1.25k, False: 277k]
  ------------------
  489|  8.51k|    case NET_I2P:
  ------------------
  |  Branch (489:5): [True: 7.25k, False: 271k]
  ------------------
  490|  9.15k|    case NET_CJDNS:
  ------------------
  |  Branch (490:5): [True: 636, False: 277k]
  ------------------
  491|  9.15k|        return false;
  492|      0|    case NET_UNROUTABLE: // m_net is never and should not be set to NET_UNROUTABLE
  ------------------
  |  Branch (492:5): [True: 0, False: 278k]
  ------------------
  493|      0|    case NET_MAX:        // m_net is never and should not be set to NET_MAX
  ------------------
  |  Branch (493:5): [True: 0, False: 278k]
  ------------------
  494|      0|        assert(false);
  495|   278k|    } // no default case, so the compiler can warn about missing cases
  496|       |
  497|      0|    assert(false);
  498|      0|}
_ZNK8CNetAddr10GetNetworkEv:
  501|   321k|{
  502|   321k|    if (IsInternal())
  ------------------
  |  Branch (502:9): [True: 496, False: 321k]
  ------------------
  503|    496|        return NET_INTERNAL;
  504|       |
  505|   321k|    if (!IsRoutable())
  ------------------
  |  Branch (505:9): [True: 284k, False: 36.6k]
  ------------------
  506|   284k|        return NET_UNROUTABLE;
  507|       |
  508|  36.6k|    return m_net;
  509|   321k|}
_Z13OnionToString4SpanIKhE:
  574|    623|{
  575|    623|    uint8_t checksum[torv3::CHECKSUM_LEN];
  576|    623|    torv3::Checksum(addr, checksum);
  577|       |    // TORv3 onion_address = base32(PUBKEY | CHECKSUM | VERSION) + ".onion"
  578|    623|    prevector<torv3::TOTAL_LEN, uint8_t> address{addr.begin(), addr.end()};
  579|    623|    address.insert(address.end(), checksum, checksum + torv3::CHECKSUM_LEN);
  580|    623|    address.insert(address.end(), torv3::VERSION, torv3::VERSION + sizeof(torv3::VERSION));
  581|    623|    return EncodeBase32(address) + ".onion";
  582|    623|}
_ZNK8CNetAddr12ToStringAddrEv:
  585|  10.5k|{
  586|  10.5k|    switch (m_net) {
  ------------------
  |  Branch (586:13): [True: 0, False: 10.5k]
  ------------------
  587|  7.20k|    case NET_IPV4:
  ------------------
  |  Branch (587:5): [True: 7.20k, False: 3.35k]
  ------------------
  588|  7.20k|        return IPv4ToString(m_addr);
  589|  1.49k|    case NET_IPV6:
  ------------------
  |  Branch (589:5): [True: 1.49k, False: 9.05k]
  ------------------
  590|  1.49k|        return IPv6ToString(m_addr, m_scope_id);
  591|    623|    case NET_ONION:
  ------------------
  |  Branch (591:5): [True: 623, False: 9.92k]
  ------------------
  592|    623|        return OnionToString(m_addr);
  593|    631|    case NET_I2P:
  ------------------
  |  Branch (593:5): [True: 631, False: 9.92k]
  ------------------
  594|    631|        return EncodeBase32(m_addr, false /* don't pad with = */) + ".b32.i2p";
  595|    183|    case NET_CJDNS:
  ------------------
  |  Branch (595:5): [True: 183, False: 10.3k]
  ------------------
  596|    183|        return IPv6ToString(m_addr, 0);
  597|    420|    case NET_INTERNAL:
  ------------------
  |  Branch (597:5): [True: 420, False: 10.1k]
  ------------------
  598|    420|        return EncodeBase32(m_addr) + ".internal";
  599|      0|    case NET_UNROUTABLE: // m_net is never and should not be set to NET_UNROUTABLE
  ------------------
  |  Branch (599:5): [True: 0, False: 10.5k]
  ------------------
  600|      0|    case NET_MAX:        // m_net is never and should not be set to NET_MAX
  ------------------
  |  Branch (600:5): [True: 0, False: 10.5k]
  ------------------
  601|      0|        assert(false);
  602|  10.5k|    } // no default case, so the compiler can warn about missing cases
  603|       |
  604|      0|    assert(false);
  605|      0|}
_ZeqRK8CNetAddrS1_:
  608|   396k|{
  609|   396k|    return a.m_net == b.m_net && a.m_addr == b.m_addr;
  ------------------
  |  Branch (609:12): [True: 293k, False: 103k]
  |  Branch (609:34): [True: 234k, False: 58.4k]
  ------------------
  610|   396k|}
_ZltRK8CNetAddrS1_:
  613|  74.1k|{
  614|  74.1k|    return std::tie(a.m_net, a.m_addr) < std::tie(b.m_net, b.m_addr);
  615|  74.1k|}
_ZNK8CNetAddr13HasLinkedIPv4Ev:
  657|   304k|{
  658|   304k|    return IsRoutable() && (IsIPv4() || IsRFC6145() || IsRFC6052() || IsRFC3964() || IsRFC4380());
  ------------------
  |  Branch (658:12): [True: 304k, False: 0]
  |  Branch (658:29): [True: 15.8k, False: 288k]
  |  Branch (658:41): [True: 3.36k, False: 285k]
  |  Branch (658:56): [True: 2.31k, False: 283k]
  |  Branch (658:71): [True: 1.19k, False: 281k]
  |  Branch (658:86): [True: 3.02k, False: 278k]
  ------------------
  659|   304k|}
_ZNK8CNetAddr13GetLinkedIPv4Ev:
  662|  6.35k|{
  663|  6.35k|    if (IsIPv4()) {
  ------------------
  |  Branch (663:9): [True: 2.24k, False: 4.11k]
  ------------------
  664|  2.24k|        return ReadBE32(m_addr.data());
  665|  4.11k|    } else if (IsRFC6052() || IsRFC6145()) {
  ------------------
  |  Branch (665:16): [True: 1.04k, False: 3.07k]
  |  Branch (665:31): [True: 1.29k, False: 1.78k]
  ------------------
  666|       |        // mapped IPv4, SIIT translated IPv4: the IPv4 address is the last 4 bytes of the address
  667|  2.33k|        return ReadBE32(Span{m_addr}.last(ADDR_IPV4_SIZE).data());
  668|  2.33k|    } else if (IsRFC3964()) {
  ------------------
  |  Branch (668:16): [True: 394, False: 1.38k]
  ------------------
  669|       |        // 6to4 tunneled IPv4: the IPv4 address is in bytes 2-6
  670|    394|        return ReadBE32(Span{m_addr}.subspan(2, ADDR_IPV4_SIZE).data());
  671|  1.38k|    } else if (IsRFC4380()) {
  ------------------
  |  Branch (671:16): [True: 1.38k, False: 0]
  ------------------
  672|       |        // Teredo tunneled IPv4: the IPv4 address is in the last 4 bytes of the address, but bitflipped
  673|  1.38k|        return ~ReadBE32(Span{m_addr}.last(ADDR_IPV4_SIZE).data());
  674|  1.38k|    }
  675|      0|    assert(false);
  676|      0|}
_ZNK8CNetAddr11GetNetClassEv:
  679|   265k|{
  680|       |    // Make sure that if we return NET_IPV6, then IsIPv6() is true. The callers expect that.
  681|       |
  682|       |    // Check for "internal" first because such addresses are also !IsRoutable()
  683|       |    // and we don't want to return NET_UNROUTABLE in that case.
  684|   265k|    if (IsInternal()) {
  ------------------
  |  Branch (684:9): [True: 3.20k, False: 262k]
  ------------------
  685|  3.20k|        return NET_INTERNAL;
  686|  3.20k|    }
  687|   262k|    if (!IsRoutable()) {
  ------------------
  |  Branch (687:9): [True: 52.5k, False: 210k]
  ------------------
  688|  52.5k|        return NET_UNROUTABLE;
  689|  52.5k|    }
  690|   210k|    if (HasLinkedIPv4()) {
  ------------------
  |  Branch (690:9): [True: 19.4k, False: 190k]
  ------------------
  691|  19.4k|        return NET_IPV4;
  692|  19.4k|    }
  693|   190k|    return m_net;
  694|   210k|}
_ZNK8CNetAddr12GetAddrBytesEv:
  697|   278k|{
  698|   278k|    if (IsAddrV1Compatible()) {
  ------------------
  |  Branch (698:9): [True: 269k, False: 9.15k]
  ------------------
  699|   269k|        uint8_t serialized[V1_SERIALIZATION_SIZE];
  700|   269k|        SerializeV1Array(serialized);
  701|   269k|        return {std::begin(serialized), std::end(serialized)};
  702|   269k|    }
  703|  9.15k|    return std::vector<unsigned char>(m_addr.begin(), m_addr.end());
  704|   278k|}
_ZN8CServiceC2Ev:
  784|   578k|CService::CService() : port(0)
  785|   578k|{
  786|   578k|}
_ZN8CServiceC2ERK8CNetAddrt:
  788|  82.0k|CService::CService(const CNetAddr& cip, uint16_t portIn) : CNetAddr(cip), port(portIn)
  789|  82.0k|{
  790|  82.0k|}
_ZNK8CService7GetPortEv:
  840|  1.24k|{
  841|  1.24k|    return port;
  842|  1.24k|}
_ZeqRK8CServiceS1_:
  845|   355k|{
  846|   355k|    return static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) && a.port == b.port;
  ------------------
  |  Branch (846:12): [True: 218k, False: 137k]
  |  Branch (846:68): [True: 218k, False: 225]
  ------------------
  847|   355k|}
_ZltRK8CServiceS1_:
  850|  74.1k|{
  851|  74.1k|    return static_cast<CNetAddr>(a) < static_cast<CNetAddr>(b) || (static_cast<CNetAddr>(a) == static_cast<CNetAddr>(b) && a.port < b.port);
  ------------------
  |  Branch (851:12): [True: 37.8k, False: 36.3k]
  |  Branch (851:68): [True: 15.5k, False: 20.8k]
  |  Branch (851:124): [True: 2.69k, False: 12.8k]
  ------------------
  852|  74.1k|}
_ZNK8CService6GetKeyEv:
  900|   160k|{
  901|   160k|    auto key = GetAddrBytes();
  902|   160k|    key.push_back(port / 0x100); // most significant byte of our port
  903|   160k|    key.push_back(port & 0x0FF); // least significant byte of our port
  904|   160k|    return key;
  905|   160k|}
_ZNK8CService16ToStringAddrPortEv:
  908|  10.5k|{
  909|  10.5k|    const auto port_str = strprintf("%u", port);
  ------------------
  |  | 1172|  10.5k|#define strprintf tfm::format
  ------------------
  910|       |
  911|  10.5k|    if (IsIPv4() || IsTor() || IsI2P() || IsInternal()) {
  ------------------
  |  Branch (911:9): [True: 7.20k, False: 3.35k]
  |  Branch (911:21): [True: 623, False: 2.72k]
  |  Branch (911:32): [True: 631, False: 2.09k]
  |  Branch (911:43): [True: 420, False: 1.67k]
  ------------------
  912|  8.87k|        return ToStringAddr() + ":" + port_str;
  913|  8.87k|    } else {
  914|  1.67k|        return "[" + ToStringAddr() + "]:" + port_str;
  915|  1.67k|    }
  916|  10.5k|}
_ZN7CSubNetC2Ev:
  919|  68.4k|    valid(false)
  920|  68.4k|{
  921|  68.4k|    memset(netmask, 0, sizeof(netmask));
  922|  68.4k|}
_ZN7CSubNetC2ERK8CNetAddrh:
  924|  43.3k|CSubNet::CSubNet(const CNetAddr& addr, uint8_t mask) : CSubNet()
  925|  43.3k|{
  926|  43.3k|    valid = (addr.IsIPv4() && mask <= ADDR_IPV4_SIZE * 8) ||
  ------------------
  |  Branch (926:14): [True: 17.0k, False: 26.2k]
  |  Branch (926:31): [True: 6.59k, False: 10.5k]
  ------------------
  927|  43.3k|            (addr.IsIPv6() && mask <= ADDR_IPV6_SIZE * 8);
  ------------------
  |  Branch (927:14): [True: 19.1k, False: 17.6k]
  |  Branch (927:31): [True: 18.9k, False: 171]
  ------------------
  928|  43.3k|    if (!valid) {
  ------------------
  |  Branch (928:9): [True: 17.7k, False: 25.5k]
  ------------------
  929|  17.7k|        return;
  930|  17.7k|    }
  931|       |
  932|  25.5k|    assert(mask <= sizeof(netmask) * 8);
  933|       |
  934|  25.5k|    network = addr;
  935|       |
  936|  25.5k|    uint8_t n = mask;
  937|   355k|    for (size_t i = 0; i < network.m_addr.size(); ++i) {
  ------------------
  |  Branch (937:24): [True: 329k, False: 25.5k]
  ------------------
  938|   329k|        const uint8_t bits = n < 8 ? n : 8;
  ------------------
  |  Branch (938:30): [True: 311k, False: 18.6k]
  ------------------
  939|   329k|        netmask[i] = (uint8_t)((uint8_t)0xFF << (8 - bits)); // Set first bits.
  940|   329k|        network.m_addr[i] &= netmask[i]; // Normalize network according to netmask.
  941|   329k|        n -= bits;
  942|   329k|    }
  943|  25.5k|}
_ZN7CSubNetC2ERK8CNetAddr:
  996|  17.7k|CSubNet::CSubNet(const CNetAddr& addr) : CSubNet()
  997|  17.7k|{
  998|  17.7k|    switch (addr.m_net) {
  ------------------
  |  Branch (998:13): [True: 0, False: 17.7k]
  ------------------
  999|  2.19k|    case NET_IPV4:
  ------------------
  |  Branch (999:5): [True: 2.19k, False: 15.5k]
  ------------------
 1000|  14.6k|    case NET_IPV6:
  ------------------
  |  Branch (1000:5): [True: 12.4k, False: 5.33k]
  ------------------
 1001|  14.6k|        valid = true;
 1002|  14.6k|        assert(addr.m_addr.size() <= sizeof(netmask));
 1003|  14.6k|        memset(netmask, 0xFF, addr.m_addr.size());
 1004|  14.6k|        break;
 1005|  1.31k|    case NET_ONION:
  ------------------
  |  Branch (1005:5): [True: 1.31k, False: 16.4k]
  ------------------
 1006|  1.97k|    case NET_I2P:
  ------------------
  |  Branch (1006:5): [True: 661, False: 17.1k]
  ------------------
 1007|  2.48k|    case NET_CJDNS:
  ------------------
  |  Branch (1007:5): [True: 511, False: 17.2k]
  ------------------
 1008|  2.48k|        valid = true;
 1009|  2.48k|        break;
 1010|    657|    case NET_INTERNAL:
  ------------------
  |  Branch (1010:5): [True: 657, False: 17.1k]
  ------------------
 1011|    657|    case NET_UNROUTABLE:
  ------------------
  |  Branch (1011:5): [True: 0, False: 17.7k]
  ------------------
 1012|    657|    case NET_MAX:
  ------------------
  |  Branch (1012:5): [True: 0, False: 17.7k]
  ------------------
 1013|    657|        return;
 1014|  17.7k|    }
 1015|       |
 1016|  17.1k|    network = addr;
 1017|  17.1k|}
_ZNK7CSubNet5MatchERK8CNetAddr:
 1024|   250k|{
 1025|   250k|    if (!valid || !addr.IsValid() || network.m_net != addr.m_net)
  ------------------
  |  Branch (1025:9): [True: 38.6k, False: 212k]
  |  Branch (1025:19): [True: 37.8k, False: 174k]
  |  Branch (1025:38): [True: 104k, False: 70.2k]
  ------------------
 1026|   180k|        return false;
 1027|       |
 1028|  70.2k|    switch (network.m_net) {
  ------------------
  |  Branch (1028:13): [True: 0, False: 70.2k]
  ------------------
 1029|    690|    case NET_IPV4:
  ------------------
  |  Branch (1029:5): [True: 690, False: 69.5k]
  ------------------
 1030|  66.2k|    case NET_IPV6:
  ------------------
  |  Branch (1030:5): [True: 65.5k, False: 4.67k]
  ------------------
 1031|  66.2k|        break;
 1032|    245|    case NET_ONION:
  ------------------
  |  Branch (1032:5): [True: 245, False: 69.9k]
  ------------------
 1033|  3.55k|    case NET_I2P:
  ------------------
  |  Branch (1033:5): [True: 3.30k, False: 66.9k]
  ------------------
 1034|  3.98k|    case NET_CJDNS:
  ------------------
  |  Branch (1034:5): [True: 428, False: 69.7k]
  ------------------
 1035|  3.98k|    case NET_INTERNAL:
  ------------------
  |  Branch (1035:5): [True: 0, False: 70.2k]
  ------------------
 1036|  3.98k|        return addr == network;
 1037|      0|    case NET_UNROUTABLE:
  ------------------
  |  Branch (1037:5): [True: 0, False: 70.2k]
  ------------------
 1038|      0|    case NET_MAX:
  ------------------
  |  Branch (1038:5): [True: 0, False: 70.2k]
  ------------------
 1039|      0|        return false;
 1040|  70.2k|    }
 1041|       |
 1042|  66.2k|    assert(network.m_addr.size() == addr.m_addr.size());
 1043|  89.6k|    for (size_t x = 0; x < addr.m_addr.size(); ++x) {
  ------------------
  |  Branch (1043:24): [True: 89.2k, False: 428]
  ------------------
 1044|  89.2k|        if ((addr.m_addr[x] & netmask[x]) != network.m_addr[x]) {
  ------------------
  |  Branch (1044:13): [True: 65.8k, False: 23.4k]
  ------------------
 1045|  65.8k|            return false;
 1046|  65.8k|        }
 1047|  89.2k|    }
 1048|    428|    return true;
 1049|  66.2k|}
netaddress.cpp:_ZN5torv3L8ChecksumE4SpanIKhERA2_h:
  191|  3.85k|{
  192|       |    // TORv3 CHECKSUM = H(".onion checksum" | PUBKEY | VERSION)[:2]
  193|  3.85k|    static const unsigned char prefix[] = ".onion checksum";
  194|  3.85k|    static constexpr size_t prefix_len = 15;
  195|       |
  196|  3.85k|    SHA3_256 hasher;
  197|       |
  198|  3.85k|    hasher.Write(Span{prefix}.first(prefix_len));
  199|  3.85k|    hasher.Write(addr_pubkey);
  200|  3.85k|    hasher.Write(VERSION);
  201|       |
  202|  3.85k|    uint8_t checksum_full[SHA3_256::OUTPUT_SIZE];
  203|       |
  204|  3.85k|    hasher.Finalize(checksum_full);
  205|       |
  206|  3.85k|    memcpy(checksum, checksum_full, sizeof(checksum));
  207|  3.85k|}
netaddress.cpp:_ZL12IPv4ToString4SpanIKhE:
  512|  7.20k|{
  513|  7.20k|    return strprintf("%u.%u.%u.%u", a[0], a[1], a[2], a[3]);
  ------------------
  |  | 1172|  7.20k|#define strprintf tfm::format
  ------------------
  514|  7.20k|}
netaddress.cpp:_ZL12IPv6ToString4SpanIKhEj:
  519|  1.67k|{
  520|  1.67k|    assert(a.size() == ADDR_IPV6_SIZE);
  521|  1.67k|    const std::array groups{
  522|  1.67k|        ReadBE16(&a[0]),
  523|  1.67k|        ReadBE16(&a[2]),
  524|  1.67k|        ReadBE16(&a[4]),
  525|  1.67k|        ReadBE16(&a[6]),
  526|  1.67k|        ReadBE16(&a[8]),
  527|  1.67k|        ReadBE16(&a[10]),
  528|  1.67k|        ReadBE16(&a[12]),
  529|  1.67k|        ReadBE16(&a[14]),
  530|  1.67k|    };
  531|       |
  532|       |    // The zero compression implementation is inspired by Rust's std::net::Ipv6Addr, see
  533|       |    // https://github.com/rust-lang/rust/blob/cc4103089f40a163f6d143f06359cba7043da29b/library/std/src/net/ip.rs#L1635-L1683
  534|  1.67k|    struct ZeroSpan {
  535|  1.67k|        size_t start_index{0};
  536|  1.67k|        size_t len{0};
  537|  1.67k|    };
  538|       |
  539|       |    // Find longest sequence of consecutive all-zero fields. Use first zero sequence if two or more
  540|       |    // zero sequences of equal length are found.
  541|  1.67k|    ZeroSpan longest, current;
  542|  15.0k|    for (size_t i{0}; i < groups.size(); ++i) {
  ------------------
  |  Branch (542:23): [True: 13.4k, False: 1.67k]
  ------------------
  543|  13.4k|        if (groups[i] != 0) {
  ------------------
  |  Branch (543:13): [True: 10.6k, False: 2.72k]
  ------------------
  544|  10.6k|            current = {i + 1, 0};
  545|  10.6k|            continue;
  546|  10.6k|        }
  547|  2.72k|        current.len += 1;
  548|  2.72k|        if (current.len > longest.len) {
  ------------------
  |  Branch (548:13): [True: 2.50k, False: 221]
  ------------------
  549|  2.50k|            longest = current;
  550|  2.50k|        }
  551|  2.72k|    }
  552|       |
  553|  1.67k|    std::string r;
  554|  1.67k|    r.reserve(39);
  555|  15.0k|    for (size_t i{0}; i < groups.size(); ++i) {
  ------------------
  |  Branch (555:23): [True: 13.4k, False: 1.67k]
  ------------------
  556|       |        // Replace the longest sequence of consecutive all-zero fields with two colons ("::").
  557|  13.4k|        if (longest.len >= 2 && i >= longest.start_index && i < longest.start_index + longest.len) {
  ------------------
  |  Branch (557:13): [True: 4.10k, False: 9.30k]
  |  Branch (557:33): [True: 3.15k, False: 945]
  |  Branch (557:61): [True: 2.34k, False: 811]
  ------------------
  558|  2.34k|            if (i == longest.start_index) {
  ------------------
  |  Branch (558:17): [True: 513, False: 1.83k]
  ------------------
  559|    513|                r += "::";
  560|    513|            }
  561|  2.34k|            continue;
  562|  2.34k|        }
  563|  11.0k|        r += strprintf("%s%x", ((!r.empty() && r.back() != ':') ? ":" : ""), groups[i]);
  ------------------
  |  | 1172|  11.0k|#define strprintf tfm::format
  ------------------
  |  Branch (563:34): [True: 9.59k, False: 1.46k]
  |  Branch (563:48): [True: 9.35k, False: 243]
  ------------------
  564|  11.0k|    }
  565|       |
  566|  1.67k|    if (scope_id != 0) {
  ------------------
  |  Branch (566:9): [True: 0, False: 1.67k]
  ------------------
  567|      0|        r += strprintf("%%%u", scope_id);
  ------------------
  |  | 1172|      0|#define strprintf tfm::format
  ------------------
  568|      0|    }
  569|       |
  570|  1.67k|    return r;
  571|  1.67k|}

_ZNK8CNetAddr6IsIPv4Ev:
  157|  5.18M|    [[nodiscard]] bool IsIPv4() const { return m_net == NET_IPV4; } // IPv4 mapped address (::FFFF:0:0/96, 0.0.0.0/0)
_ZNK8CNetAddr6IsIPv6Ev:
  158|  6.89M|    [[nodiscard]] bool IsIPv6() const { return m_net == NET_IPV6; } // IPv6 address (not mapped IPv4, not Tor)
_ZNK8CNetAddr5IsTorEv:
  174|  78.2k|    [[nodiscard]] bool IsTor() const { return m_net == NET_ONION; }
_ZNK8CNetAddr5IsI2PEv:
  175|  77.3k|    [[nodiscard]] bool IsI2P() const { return m_net == NET_I2P; }
_ZNK8CNetAddr7IsCJDNSEv:
  176|  1.00M|    [[nodiscard]] bool IsCJDNS() const { return m_net == NET_CJDNS; }
_ZNK8CNetAddr14HasCJDNSPrefixEv:
  177|  24.7k|    [[nodiscard]] bool HasCJDNSPrefix() const { return m_addr[0] == CJDNS_PREFIX; }
_ZNK8CNetAddr16SerializeV1ArrayERA16_h:
  325|   269k|    {
  326|   269k|        size_t prefix_size;
  327|       |
  328|   269k|        switch (m_net) {
  ------------------
  |  Branch (328:17): [True: 0, False: 269k]
  ------------------
  329|   262k|        case NET_IPV6:
  ------------------
  |  Branch (329:9): [True: 262k, False: 6.97k]
  ------------------
  330|   262k|            assert(m_addr.size() == sizeof(arr));
  331|   262k|            memcpy(arr, m_addr.data(), m_addr.size());
  332|   262k|            return;
  333|  6.47k|        case NET_IPV4:
  ------------------
  |  Branch (333:9): [True: 6.47k, False: 262k]
  ------------------
  334|  6.47k|            prefix_size = sizeof(IPV4_IN_IPV6_PREFIX);
  335|  6.47k|            assert(prefix_size + m_addr.size() == sizeof(arr));
  336|  6.47k|            memcpy(arr, IPV4_IN_IPV6_PREFIX.data(), prefix_size);
  337|  6.47k|            memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
  338|  6.47k|            return;
  339|    497|        case NET_INTERNAL:
  ------------------
  |  Branch (339:9): [True: 497, False: 268k]
  ------------------
  340|    497|            prefix_size = sizeof(INTERNAL_IN_IPV6_PREFIX);
  341|    497|            assert(prefix_size + m_addr.size() == sizeof(arr));
  342|    497|            memcpy(arr, INTERNAL_IN_IPV6_PREFIX.data(), prefix_size);
  343|    497|            memcpy(arr + prefix_size, m_addr.data(), m_addr.size());
  344|    497|            return;
  345|      0|        case NET_ONION:
  ------------------
  |  Branch (345:9): [True: 0, False: 269k]
  ------------------
  346|      0|        case NET_I2P:
  ------------------
  |  Branch (346:9): [True: 0, False: 269k]
  ------------------
  347|      0|        case NET_CJDNS:
  ------------------
  |  Branch (347:9): [True: 0, False: 269k]
  ------------------
  348|      0|            break;
  349|      0|        case NET_UNROUTABLE:
  ------------------
  |  Branch (349:9): [True: 0, False: 269k]
  ------------------
  350|      0|        case NET_MAX:
  ------------------
  |  Branch (350:9): [True: 0, False: 269k]
  ------------------
  351|      0|            assert(false);
  352|   269k|        } // no default case, so the compiler can warn about missing cases
  353|       |
  354|       |        // Serialize ONION, I2P and CJDNS as all-zeros.
  355|      0|        memset(arr, 0x0, V1_SERIALIZATION_SIZE);
  356|      0|    }
_ZN8CNetAddr18UnserializeV1ArrayERA16_h:
  400|   303k|    {
  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|   303k|        SetLegacyIPv6(arr);
  404|   303k|    }
_ZN12CServiceHashC2Ev:
  577|  9.84k|        : m_salt_k0{FastRandomContext().rand64()},
  578|  9.84k|          m_salt_k1{FastRandomContext().rand64()}
  579|  9.84k|    {
  580|  9.84k|    }
_ZNK12CServiceHashclERK8CService:
  585|   312k|    {
  586|   312k|        CSipHasher hasher(m_salt_k0, m_salt_k1);
  587|   312k|        hasher.Write(a.m_net);
  588|   312k|        hasher.Write(a.port);
  589|   312k|        hasher.Write(a.m_addr);
  590|   312k|        return static_cast<size_t>(hasher.Finalize());
  591|   312k|    }
_ZN8CService16SerializationOpsI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEES_17ActionUnserializeEEvRT0_RT_T1_:
  565|   259k|    {
  566|   259k|        READWRITE(AsBase<CNetAddr>(obj), Using<BigEndianFormatter<2>>(obj.port));
  ------------------
  |  |  156|   259k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
  ------------------
  567|   259k|    }
_ZN8CNetAddr11UnserializeI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  252|   259k|    {
  253|   259k|        if (s.template GetParams<SerParams>().enc == Encoding::V2) {
  ------------------
  |  Branch (253:13): [True: 5.96k, False: 253k]
  ------------------
  254|  5.96k|            UnserializeV2Stream(s);
  255|   253k|        } else {
  256|   253k|            UnserializeV1Stream(s);
  257|   253k|        }
  258|   259k|    }
_ZN8CNetAddr19UnserializeV2StreamI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  424|  5.96k|    {
  425|  5.96k|        uint8_t bip155_net;
  426|  5.96k|        s >> bip155_net;
  427|       |
  428|  5.96k|        size_t address_size;
  429|  5.96k|        s >> COMPACTSIZE(address_size);
  ------------------
  |  |  501|  5.96k|#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
  ------------------
  430|       |
  431|  5.96k|        if (address_size > MAX_ADDRV2_SIZE) {
  ------------------
  |  Branch (431:13): [True: 28, False: 5.93k]
  ------------------
  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|  5.93k|        m_scope_id = 0;
  437|       |
  438|  5.93k|        if (SetNetFromBIP155Network(bip155_net, address_size)) {
  ------------------
  |  Branch (438:13): [True: 3.69k, False: 2.24k]
  ------------------
  439|  3.69k|            m_addr.resize(address_size);
  440|  3.69k|            s >> Span{m_addr};
  441|       |
  442|  3.69k|            if (m_net != NET_IPV6) {
  ------------------
  |  Branch (442:17): [True: 3.19k, False: 494]
  ------------------
  443|  3.19k|                return;
  444|  3.19k|            }
  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|    494|            if (util::HasPrefix(m_addr, INTERNAL_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (451:17): [True: 204, False: 290]
  ------------------
  452|    204|                m_net = NET_INTERNAL;
  453|    204|                memmove(m_addr.data(), m_addr.data() + INTERNAL_IN_IPV6_PREFIX.size(),
  454|    204|                        ADDR_INTERNAL_SIZE);
  455|    204|                m_addr.resize(ADDR_INTERNAL_SIZE);
  456|    204|                return;
  457|    204|            }
  458|       |
  459|    290|            if (!util::HasPrefix(m_addr, IPV4_IN_IPV6_PREFIX) &&
  ------------------
  |  Branch (459:17): [True: 245, False: 45]
  ------------------
  460|    290|                !util::HasPrefix(m_addr, TORV2_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (460:17): [True: 227, False: 18]
  ------------------
  461|    227|                return;
  462|    227|            }
  463|       |
  464|       |            // IPv4 and TORv2 are not supposed to be embedded in IPv6 (like in V1
  465|       |            // encoding). Unserialize as !IsValid(), thus ignoring them.
  466|  2.24k|        } else {
  467|       |            // If we receive an unknown BIP155 network id (from the future?) then
  468|       |            // ignore the address - unserialize as !IsValid().
  469|  2.24k|            s.ignore(address_size);
  470|  2.24k|        }
  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|  2.30k|        m_net = NET_IPV6;
  475|  2.30k|        m_addr.assign(ADDR_IPV6_SIZE, 0x0);
  476|  2.30k|    }
_ZN8CNetAddr19UnserializeV1StreamI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEENS_9SerParamsEEEEvRT_:
  411|   253k|    {
  412|   253k|        uint8_t serialized[V1_SERIALIZATION_SIZE];
  413|       |
  414|   253k|        s >> serialized;
  415|       |
  416|   253k|        UnserializeV1Array(serialized);
  417|   253k|    }
_ZN8CNetAddr11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  252|   352k|    {
  253|   352k|        if (s.template GetParams<SerParams>().enc == Encoding::V2) {
  ------------------
  |  Branch (253:13): [True: 302k, False: 49.8k]
  ------------------
  254|   302k|            UnserializeV2Stream(s);
  255|   302k|        } else {
  256|  49.8k|            UnserializeV1Stream(s);
  257|  49.8k|        }
  258|   352k|    }
_ZN8CNetAddr19UnserializeV2StreamI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  424|   302k|    {
  425|   302k|        uint8_t bip155_net;
  426|   302k|        s >> bip155_net;
  427|       |
  428|   302k|        size_t address_size;
  429|   302k|        s >> COMPACTSIZE(address_size);
  ------------------
  |  |  501|   302k|#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
  ------------------
  430|       |
  431|   302k|        if (address_size > MAX_ADDRV2_SIZE) {
  ------------------
  |  Branch (431:13): [True: 37, False: 302k]
  ------------------
  432|     37|            throw std::ios_base::failure(strprintf(
  ------------------
  |  | 1172|     37|#define strprintf tfm::format
  ------------------
  433|     37|                "Address too long: %u > %u", address_size, MAX_ADDRV2_SIZE));
  434|     37|        }
  435|       |
  436|   302k|        m_scope_id = 0;
  437|       |
  438|   302k|        if (SetNetFromBIP155Network(bip155_net, address_size)) {
  ------------------
  |  Branch (438:13): [True: 93.0k, False: 209k]
  ------------------
  439|  93.0k|            m_addr.resize(address_size);
  440|  93.0k|            s >> Span{m_addr};
  441|       |
  442|  93.0k|            if (m_net != NET_IPV6) {
  ------------------
  |  Branch (442:17): [True: 59.7k, False: 33.3k]
  ------------------
  443|  59.7k|                return;
  444|  59.7k|            }
  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|  33.3k|            if (util::HasPrefix(m_addr, INTERNAL_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (451:17): [True: 21, False: 33.2k]
  ------------------
  452|     21|                m_net = NET_INTERNAL;
  453|     21|                memmove(m_addr.data(), m_addr.data() + INTERNAL_IN_IPV6_PREFIX.size(),
  454|     21|                        ADDR_INTERNAL_SIZE);
  455|     21|                m_addr.resize(ADDR_INTERNAL_SIZE);
  456|     21|                return;
  457|     21|            }
  458|       |
  459|  33.2k|            if (!util::HasPrefix(m_addr, IPV4_IN_IPV6_PREFIX) &&
  ------------------
  |  Branch (459:17): [True: 33.1k, False: 102]
  ------------------
  460|  33.2k|                !util::HasPrefix(m_addr, TORV2_IN_IPV6_PREFIX)) {
  ------------------
  |  Branch (460:17): [True: 32.7k, False: 402]
  ------------------
  461|  32.7k|                return;
  462|  32.7k|            }
  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|   209k|        } else {
  467|       |            // If we receive an unknown BIP155 network id (from the future?) then
  468|       |            // ignore the address - unserialize as !IsValid().
  469|   209k|            s.ignore(address_size);
  470|   209k|        }
  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|   209k|        m_net = NET_IPV6;
  475|   209k|        m_addr.assign(ADDR_IPV6_SIZE, 0x0);
  476|   209k|    }
_ZN8CNetAddr19UnserializeV1StreamI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  411|  49.8k|    {
  412|  49.8k|        uint8_t serialized[V1_SERIALIZATION_SIZE];
  413|       |
  414|  49.8k|        s >> serialized;
  415|       |
  416|  49.8k|        UnserializeV1Array(serialized);
  417|  49.8k|    }

_Z18WrappedGetAddrInfoRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEb:
   46|   169k|{
   47|   169k|    addrinfo ai_hint{};
   48|       |    // We want a TCP port, which is a streaming socket type
   49|   169k|    ai_hint.ai_socktype = SOCK_STREAM;
   50|   169k|    ai_hint.ai_protocol = IPPROTO_TCP;
   51|       |    // We don't care which address family (IPv4 or IPv6) is returned
   52|   169k|    ai_hint.ai_family = AF_UNSPEC;
   53|       |
   54|       |    // If we allow lookups of hostnames, use the AI_ADDRCONFIG flag to only
   55|       |    // return addresses whose family we have an address configured for.
   56|       |    //
   57|       |    // If we don't allow lookups, then use the AI_NUMERICHOST flag for
   58|       |    // getaddrinfo to only decode numerical network addresses and suppress
   59|       |    // hostname lookups.
   60|   169k|    ai_hint.ai_flags = allow_lookup ? AI_ADDRCONFIG : AI_NUMERICHOST;
  ------------------
  |  Branch (60:24): [True: 0, False: 169k]
  ------------------
   61|       |
   62|   169k|    addrinfo* ai_res{nullptr};
   63|   169k|    const int n_err{getaddrinfo(name.c_str(), nullptr, &ai_hint, &ai_res)};
   64|   169k|    if (n_err != 0) {
  ------------------
  |  Branch (64:9): [True: 142k, False: 26.9k]
  ------------------
   65|   142k|        if ((ai_hint.ai_flags & AI_ADDRCONFIG) == AI_ADDRCONFIG) {
  ------------------
  |  Branch (65:13): [True: 0, False: 142k]
  ------------------
   66|       |            // AI_ADDRCONFIG on some systems may exclude loopback-only addresses
   67|       |            // If first lookup failed we perform a second lookup without AI_ADDRCONFIG
   68|      0|            ai_hint.ai_flags = (ai_hint.ai_flags & ~AI_ADDRCONFIG);
   69|      0|            const int n_err_retry{getaddrinfo(name.c_str(), nullptr, &ai_hint, &ai_res)};
   70|      0|            if (n_err_retry != 0) {
  ------------------
  |  Branch (70:17): [True: 0, False: 0]
  ------------------
   71|      0|                return {};
   72|      0|            }
   73|   142k|        } else {
   74|   142k|            return {};
   75|   142k|        }
   76|   142k|    }
   77|       |
   78|       |    // Traverse the linked list starting with ai_trav.
   79|  26.9k|    addrinfo* ai_trav{ai_res};
   80|  26.9k|    std::vector<CNetAddr> resolved_addresses;
   81|  53.8k|    while (ai_trav != nullptr) {
  ------------------
  |  Branch (81:12): [True: 26.9k, False: 26.9k]
  ------------------
   82|  26.9k|        if (ai_trav->ai_family == AF_INET) {
  ------------------
  |  Branch (82:13): [True: 15.8k, False: 11.0k]
  ------------------
   83|  15.8k|            assert(ai_trav->ai_addrlen >= sizeof(sockaddr_in));
   84|  15.8k|            resolved_addresses.emplace_back(reinterpret_cast<sockaddr_in*>(ai_trav->ai_addr)->sin_addr);
   85|  15.8k|        }
   86|  26.9k|        if (ai_trav->ai_family == AF_INET6) {
  ------------------
  |  Branch (86:13): [True: 11.0k, False: 15.8k]
  ------------------
   87|  11.0k|            assert(ai_trav->ai_addrlen >= sizeof(sockaddr_in6));
   88|  11.0k|            const sockaddr_in6* s6{reinterpret_cast<sockaddr_in6*>(ai_trav->ai_addr)};
   89|  11.0k|            resolved_addresses.emplace_back(s6->sin6_addr, s6->sin6_scope_id);
   90|  11.0k|        }
   91|  26.9k|        ai_trav = ai_trav->ai_next;
   92|  26.9k|    }
   93|  26.9k|    freeaddrinfo(ai_res);
   94|       |
   95|  26.9k|    return resolved_addresses;
   96|  26.9k|}
_Z6LookupRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEtbjNS_8functionIFNS_6vectorI8CNetAddrNS3_ISA_EEEES7_bEEE:
  196|   193k|{
  197|   193k|    if (name.empty() || !ContainsNoNUL(name)) {
  ------------------
  |  Branch (197:9): [True: 18.5k, False: 174k]
  |  Branch (197:25): [True: 0, False: 174k]
  ------------------
  198|  18.5k|        return {};
  199|  18.5k|    }
  200|   174k|    uint16_t port{portDefault};
  201|   174k|    std::string hostname;
  202|   174k|    SplitHostPort(name, port, hostname);
  203|       |
  204|   174k|    const std::vector<CNetAddr> addresses{LookupIntern(hostname, nMaxSolutions, fAllowLookup, dns_lookup_function)};
  205|   174k|    if (addresses.empty()) return {};
  ------------------
  |  Branch (205:9): [True: 142k, False: 31.6k]
  ------------------
  206|  31.6k|    std::vector<CService> services;
  207|  31.6k|    services.reserve(addresses.size());
  208|  31.6k|    for (const auto& addr : addresses)
  ------------------
  |  Branch (208:27): [True: 31.6k, False: 31.6k]
  ------------------
  209|  31.6k|        services.emplace_back(addr, port);
  210|  31.6k|    return services;
  211|   174k|}
_Z6LookupRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEtbNS_8functionIFNS_6vectorI8CNetAddrNS3_ISA_EEEES7_bEEE:
  214|   193k|{
  215|   193k|    const std::vector<CService> services{Lookup(name, portDefault, fAllowLookup, 1, dns_lookup_function)};
  216|       |
  217|   193k|    return services.empty() ? std::nullopt : std::make_optional(services.front());
  ------------------
  |  Branch (217:12): [True: 161k, False: 31.6k]
  ------------------
  218|   193k|}
_Z13LookupNumericRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEtNS_8functionIFNS_6vectorI8CNetAddrNS3_ISA_EEEES7_bEEE:
  221|   228k|{
  222|   228k|    if (!ContainsNoNUL(name)) {
  ------------------
  |  Branch (222:9): [True: 35.4k, False: 193k]
  ------------------
  223|  35.4k|        return {};
  224|  35.4k|    }
  225|       |    // "1.2:345" will fail to resolve the ip, but will still set the port.
  226|       |    // If the ip fails to resolve, re-init the result.
  227|   193k|    return Lookup(name, portDefault, /*fAllowLookup=*/false, dns_lookup_function).value_or(CService{});
  228|   228k|}
_Z20MaybeFlipIPv6toCJDNSRK8CService:
  883|  11.6k|{
  884|  11.6k|    CService ret{service};
  885|  11.6k|    if (ret.IsIPv6() && ret.HasCJDNSPrefix() && g_reachable_nets.Contains(NET_CJDNS)) {
  ------------------
  |  Branch (885:9): [True: 11.0k, False: 591]
  |  Branch (885:25): [True: 25, False: 11.0k]
  |  Branch (885:49): [True: 25, False: 0]
  ------------------
  886|     25|        ret.m_net = NET_CJDNS;
  887|     25|    }
  888|  11.6k|    return ret;
  889|  11.6k|}
netbase.cpp:_ZL12LookupInternRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEjbNS_8functionIFNS_6vectorI8CNetAddrNS3_ISA_EEEES7_bEEE:
  149|   174k|{
  150|   174k|    if (!ContainsNoNUL(name)) return {};
  ------------------
  |  Branch (150:9): [True: 0, False: 174k]
  ------------------
  151|   174k|    {
  152|   174k|        CNetAddr addr;
  153|       |        // From our perspective, onion addresses are not hostnames but rather
  154|       |        // direct encodings of CNetAddr much like IPv4 dotted-decimal notation
  155|       |        // or IPv6 colon-separated hextet notation. Since we can't use
  156|       |        // getaddrinfo to decode them and it wouldn't make sense to resolve
  157|       |        // them, we return a network address representing it instead. See
  158|       |        // CNetAddr::SetSpecial(const std::string&) for more details.
  159|   174k|        if (addr.SetSpecial(name)) return {addr};
  ------------------
  |  Branch (159:13): [True: 4.73k, False: 169k]
  ------------------
  160|   174k|    }
  161|       |
  162|   169k|    std::vector<CNetAddr> addresses;
  163|       |
  164|   169k|    for (const CNetAddr& resolved : dns_lookup_function(name, fAllowLookup)) {
  ------------------
  |  Branch (164:35): [True: 26.9k, False: 169k]
  ------------------
  165|  26.9k|        if (nMaxSolutions > 0 && addresses.size() >= nMaxSolutions) {
  ------------------
  |  Branch (165:13): [True: 26.9k, False: 0]
  |  Branch (165:34): [True: 0, False: 26.9k]
  ------------------
  166|      0|            break;
  167|      0|        }
  168|       |        /* Never allow resolving to an internal address. Consider any such result invalid */
  169|  26.9k|        if (!resolved.IsInternal()) {
  ------------------
  |  Branch (169:13): [True: 26.9k, False: 0]
  ------------------
  170|  26.9k|            addresses.push_back(resolved);
  171|  26.9k|        }
  172|  26.9k|    }
  173|       |
  174|   169k|    return addresses;
  175|   174k|}

_ZNK13ReachableNets8ContainsE7Network:
  125|     25|    {
  126|     25|        AssertLockNotHeld(m_mutex);
  ------------------
  |  |  147|     25|#define AssertLockNotHeld(cs) AssertLockNotHeldInline(#cs, __FILE__, __LINE__, &cs)
  ------------------
  127|     25|        LOCK(m_mutex);
  ------------------
  |  |  257|     25|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|     25|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|     25|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|     25|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  128|     25|        return m_reachable.count(net) > 0;
  129|     25|    }
net.cpp:_Zan19ConnectionDirectionS_:
   44|  13.4k|static inline bool operator&(ConnectionDirection a, ConnectionDirection b) {
   45|  13.4k|    using underlying = typename std::underlying_type<ConnectionDirection>::type;
   46|  13.4k|    return (underlying(a) & underlying(b));
   47|  13.4k|}

_ZNK15NetGroupManager16GetAsmapChecksumEv:
   12|  1.50k|{
   13|  1.50k|    if (!m_asmap.size()) return {};
  ------------------
  |  Branch (13:9): [True: 1.06k, False: 440]
  ------------------
   14|       |
   15|    440|    return (HashWriter{} << m_asmap).GetHash();
   16|  1.50k|}
_ZNK15NetGroupManager8GetGroupERK8CNetAddr:
   19|   114k|{
   20|   114k|    std::vector<unsigned char> vchRet;
   21|       |    // If non-empty asmap is supplied and the address is IPv4/IPv6,
   22|       |    // return ASN to be used for bucketing.
   23|   114k|    uint32_t asn = GetMappedAS(address);
   24|   114k|    if (asn != 0) { // Either asmap was empty, or address has non-asmappable net class (e.g. TOR).
  ------------------
  |  Branch (24:9): [True: 11.9k, False: 102k]
  ------------------
   25|  11.9k|        vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in the same bucket
   26|  59.9k|        for (int i = 0; i < 4; i++) {
  ------------------
  |  Branch (26:25): [True: 47.9k, False: 11.9k]
  ------------------
   27|  47.9k|            vchRet.push_back((asn >> (8 * i)) & 0xFF);
   28|  47.9k|        }
   29|  11.9k|        return vchRet;
   30|  11.9k|    }
   31|       |
   32|   102k|    vchRet.push_back(address.GetNetClass());
   33|   102k|    int nStartByte{0};
   34|   102k|    int nBits{0};
   35|       |
   36|   102k|    if (address.IsLocal()) {
  ------------------
  |  Branch (36:9): [True: 1.33k, False: 101k]
  ------------------
   37|       |        // all local addresses belong to the same group
   38|   101k|    } else if (address.IsInternal()) {
  ------------------
  |  Branch (38:16): [True: 321, False: 101k]
  ------------------
   39|       |        // All internal-usage addresses get their own group.
   40|       |        // Skip over the INTERNAL_IN_IPV6_PREFIX returned by CAddress::GetAddrBytes().
   41|    321|        nStartByte = INTERNAL_IN_IPV6_PREFIX.size();
   42|    321|        nBits = ADDR_INTERNAL_SIZE * 8;
   43|   101k|    } else if (!address.IsRoutable()) {
  ------------------
  |  Branch (43:16): [True: 23.0k, False: 77.9k]
  ------------------
   44|       |        // all other unroutable addresses belong to the same group
   45|  77.9k|    } else if (address.HasLinkedIPv4()) {
  ------------------
  |  Branch (45:16): [True: 3.04k, False: 74.8k]
  ------------------
   46|       |        // IPv4 addresses (and mapped IPv4 addresses) use /16 groups
   47|  3.04k|        uint32_t ipv4 = address.GetLinkedIPv4();
   48|  3.04k|        vchRet.push_back((ipv4 >> 24) & 0xFF);
   49|  3.04k|        vchRet.push_back((ipv4 >> 16) & 0xFF);
   50|  3.04k|        return vchRet;
   51|  74.8k|    } else if (address.IsTor() || address.IsI2P()) {
  ------------------
  |  Branch (51:16): [True: 274, False: 74.5k]
  |  Branch (51:35): [True: 2.13k, False: 72.4k]
  ------------------
   52|  2.41k|        nBits = 4;
   53|  72.4k|    } else if (address.IsCJDNS()) {
  ------------------
  |  Branch (53:16): [True: 62, False: 72.3k]
  ------------------
   54|       |        // Treat in the same way as Tor and I2P because the address in all of
   55|       |        // them is "random" bytes (derived from a public key). However in CJDNS
   56|       |        // the first byte is a constant (see CJDNS_PREFIX), so the random bytes
   57|       |        // come after it. Thus skip the constant 8 bits at the start.
   58|     62|        nBits = 12;
   59|  72.3k|    } else if (address.IsHeNet()) {
  ------------------
  |  Branch (59:16): [True: 254, False: 72.1k]
  ------------------
   60|       |        // for he.net, use /36 groups
   61|    254|        nBits = 36;
   62|  72.1k|    } else {
   63|       |        // for the rest of the IPv6 network, use /32 groups
   64|  72.1k|        nBits = 32;
   65|  72.1k|    }
   66|       |
   67|       |    // Push our address onto vchRet.
   68|  99.6k|    auto addr_bytes = address.GetAddrBytes();
   69|  99.6k|    const size_t num_bytes = nBits / 8;
   70|  99.6k|    vchRet.insert(vchRet.end(), addr_bytes.begin() + nStartByte, addr_bytes.begin() + nStartByte + num_bytes);
   71|  99.6k|    nBits %= 8;
   72|       |    // ...for the last byte, push nBits and for the rest of the byte push 1's
   73|  99.6k|    if (nBits > 0) {
  ------------------
  |  Branch (73:9): [True: 2.72k, False: 96.8k]
  ------------------
   74|  2.72k|        assert(num_bytes < addr_bytes.size());
   75|  2.72k|        vchRet.push_back(addr_bytes[num_bytes + nStartByte] | ((1 << (8 - nBits)) - 1));
   76|  2.72k|    }
   77|       |
   78|  99.6k|    return vchRet;
   79|  99.6k|}
_ZNK15NetGroupManager11GetMappedASERK8CNetAddr:
   82|   134k|{
   83|   134k|    uint32_t net_class = address.GetNetClass();
   84|   134k|    if (m_asmap.size() == 0 || (net_class != NET_IPV4 && net_class != NET_IPV6)) {
  ------------------
  |  Branch (84:9): [True: 115k, False: 19.3k]
  |  Branch (84:33): [True: 16.0k, False: 3.31k]
  |  Branch (84:58): [True: 2.79k, False: 13.2k]
  ------------------
   85|   118k|        return 0; // Indicates not found, safe because AS0 is reserved per RFC7607.
   86|   118k|    }
   87|  16.5k|    std::vector<bool> ip_bits(128);
   88|  16.5k|    if (address.HasLinkedIPv4()) {
  ------------------
  |  Branch (88:9): [True: 3.31k, False: 13.2k]
  ------------------
   89|       |        // For lookup, treat as if it was just an IPv4 address (IPV4_IN_IPV6_PREFIX + IPv4 bits)
   90|  43.0k|        for (int8_t byte_i = 0; byte_i < 12; ++byte_i) {
  ------------------
  |  Branch (90:33): [True: 39.7k, False: 3.31k]
  ------------------
   91|   357k|            for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
  ------------------
  |  Branch (91:37): [True: 318k, False: 39.7k]
  ------------------
   92|   318k|                ip_bits[byte_i * 8 + bit_i] = (IPV4_IN_IPV6_PREFIX[byte_i] >> (7 - bit_i)) & 1;
   93|   318k|            }
   94|  39.7k|        }
   95|  3.31k|        uint32_t ipv4 = address.GetLinkedIPv4();
   96|   109k|        for (int i = 0; i < 32; ++i) {
  ------------------
  |  Branch (96:25): [True: 106k, False: 3.31k]
  ------------------
   97|   106k|            ip_bits[96 + i] = (ipv4 >> (31 - i)) & 1;
   98|   106k|        }
   99|  13.2k|    } else {
  100|       |        // Use all 128 bits of the IPv6 address otherwise
  101|  13.2k|        assert(address.IsIPv6());
  102|  13.2k|        auto addr_bytes = address.GetAddrBytes();
  103|   225k|        for (int8_t byte_i = 0; byte_i < 16; ++byte_i) {
  ------------------
  |  Branch (103:33): [True: 211k, False: 13.2k]
  ------------------
  104|   211k|            uint8_t cur_byte = addr_bytes[byte_i];
  105|  1.90M|            for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
  ------------------
  |  Branch (105:37): [True: 1.69M, False: 211k]
  ------------------
  106|  1.69M|                ip_bits[byte_i * 8 + bit_i] = (cur_byte >> (7 - bit_i)) & 1;
  107|  1.69M|            }
  108|   211k|        }
  109|  13.2k|    }
  110|  16.5k|    uint32_t mapped_as = Interpret(m_asmap, ip_bits);
  111|  16.5k|    return mapped_as;
  112|  16.5k|}
_ZNK15NetGroupManager16ASMapHealthCheckERKNSt3__16vectorI8CNetAddrNS0_9allocatorIS2_EEEE:
  114|  7.29k|void NetGroupManager::ASMapHealthCheck(const std::vector<CNetAddr>& clearnet_addrs) const {
  115|  7.29k|    std::set<uint32_t> clearnet_asns{};
  116|  7.29k|    int unmapped_count{0};
  117|       |
  118|  7.29k|    for (const auto& addr : clearnet_addrs) {
  ------------------
  |  Branch (118:27): [True: 2.36k, False: 7.29k]
  ------------------
  119|  2.36k|        uint32_t asn = GetMappedAS(addr);
  120|  2.36k|        if (asn == 0) {
  ------------------
  |  Branch (120:13): [True: 1.80k, False: 559]
  ------------------
  121|  1.80k|            ++unmapped_count;
  122|  1.80k|            continue;
  123|  1.80k|        }
  124|    559|        clearnet_asns.insert(asn);
  125|    559|    }
  126|       |
  127|  7.29k|    LogPrintf("ASMap Health Check: %i clearnet peers are mapped to %i ASNs with %i peers being unmapped\n", clearnet_addrs.size(), clearnet_asns.size(), unmapped_count);
  ------------------
  |  |  266|  7.29k|#define LogPrintf(...) LogInfo(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |  261|  7.29k|#define LogInfo(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|  7.29k|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  128|  7.29k|}

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

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

_ZN4node17TxDownloadManagerD2Ev:
   20|      2|TxDownloadManager::~TxDownloadManager() = default;

_ZNK9prevectorILj28EhjiE9is_directEv:
  173|      2|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj16EhjiEaSEOS0_:
  284|  63.7k|    prevector& operator=(prevector<N, T, Size, Diff>&& other) noexcept {
  285|  63.7k|        if (!is_direct()) {
  ------------------
  |  Branch (285:13): [True: 2.03k, False: 61.7k]
  ------------------
  286|  2.03k|            free(_union.indirect_contents.indirect);
  287|  2.03k|        }
  288|  63.7k|        _union = std::move(other._union);
  289|  63.7k|        _size = other._size;
  290|  63.7k|        other._size = 0;
  291|  63.7k|        return *this;
  292|  63.7k|    }
_ZNK9prevectorILj16EhjiE9is_directEv:
  173|  35.0M|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj16EhjiED2Ev:
  474|  2.93M|    ~prevector() {
  475|  2.93M|        if (!is_direct()) {
  ------------------
  |  Branch (475:13): [True: 234k, False: 2.70M]
  ------------------
  476|   234k|            free(_union.indirect_contents.indirect);
  477|   234k|            _union.indirect_contents.indirect = nullptr;
  478|   234k|        }
  479|  2.93M|    }
_ZN9prevectorILj16EhjiEC2ERKS0_:
  263|  1.28M|    prevector(const prevector<N, T, Size, Diff>& other) {
  264|  1.28M|        size_type n = other.size();
  265|  1.28M|        change_capacity(n);
  266|  1.28M|        _size += n;
  267|  1.28M|        fill(item_ptr(0), other.begin(),  other.end());
  268|  1.28M|    }
_ZNK9prevectorILj16EhjiE4sizeEv:
  294|  11.6M|    size_type size() const {
  295|  11.6M|        return is_direct() ? _size : _size - N - 1;
  ------------------
  |  Branch (295:16): [True: 11.0M, False: 635k]
  ------------------
  296|  11.6M|    }
_ZN9prevectorILj16EhjiE15change_capacityEj:
  175|  2.76M|    void change_capacity(size_type new_capacity) {
  176|  2.76M|        if (new_capacity <= N) {
  ------------------
  |  Branch (176:13): [True: 2.52M, False: 236k]
  ------------------
  177|  2.52M|            if (!is_direct()) {
  ------------------
  |  Branch (177:17): [True: 0, False: 2.52M]
  ------------------
  178|      0|                T* indirect = indirect_ptr(0);
  179|      0|                T* src = indirect;
  180|      0|                T* dst = direct_ptr(0);
  181|      0|                memcpy(dst, src, size() * sizeof(T));
  182|      0|                free(indirect);
  183|      0|                _size -= N + 1;
  184|      0|            }
  185|  2.52M|        } else {
  186|   236k|            if (!is_direct()) {
  ------------------
  |  Branch (186:17): [True: 0, False: 236k]
  ------------------
  187|       |                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
  188|       |                    success. These should instead use an allocator or new/delete so that handlers
  189|       |                    are called as necessary, but performance would be slightly degraded by doing so. */
  190|      0|                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
  191|      0|                assert(_union.indirect_contents.indirect);
  192|      0|                _union.indirect_contents.capacity = new_capacity;
  193|   236k|            } else {
  194|   236k|                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
  195|   236k|                assert(new_indirect);
  196|   236k|                T* src = direct_ptr(0);
  197|   236k|                T* dst = reinterpret_cast<T*>(new_indirect);
  198|   236k|                memcpy(dst, src, size() * sizeof(T));
  199|   236k|                _union.indirect_contents.indirect = new_indirect;
  200|   236k|                _union.indirect_contents.capacity = new_capacity;
  201|   236k|                _size += N + 1;
  202|   236k|            }
  203|   236k|        }
  204|  2.76M|    }
_ZN9prevectorILj16EhjiE12indirect_ptrEi:
  171|   252k|    T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.indirect_contents.indirect) + pos; }
_ZN9prevectorILj16EhjiE10direct_ptrEi:
  169|  5.84M|    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
_ZN9prevectorILj16EhjiE4fillITkNSt3__114input_iteratorENS0_14const_iteratorEEEvPhT_S5_:
  214|  1.37M|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|  23.2M|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 21.8M, False: 1.37M]
  ------------------
  216|  21.8M|            new(static_cast<void*>(dst)) T(*first);
  217|  21.8M|            ++dst;
  218|  21.8M|            ++first;
  219|  21.8M|        }
  220|  1.37M|    }
_ZNK9prevectorILj16EhjiE14const_iteratorneES1_:
  125|  28.2M|        bool operator!=(const_iterator x) const { return ptr != x.ptr; }
_ZNK9prevectorILj16EhjiE14const_iteratordeEv:
  111|  32.6M|        const T& operator*() const { return *ptr; }
_ZN9prevectorILj16EhjiE14const_iteratorppEv:
  114|  31.0M|        const_iterator& operator++() { ptr++; return *this; }
_ZN9prevectorILj16EhjiE8item_ptrEi:
  206|  5.86M|    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (206:47): [True: 5.60M, False: 252k]
  ------------------
_ZNK9prevectorILj16EhjiE5beginEv:
  303|  5.88M|    const_iterator begin() const { return const_iterator(item_ptr(0)); }
_ZNK9prevectorILj16EhjiE8item_ptrEi:
  207|  11.1M|    const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (207:59): [True: 10.5M, False: 582k]
  ------------------
_ZNK9prevectorILj16EhjiE10direct_ptrEi:
  170|  10.5M|    const T* direct_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.direct) + pos; }
_ZNK9prevectorILj16EhjiE12indirect_ptrEi:
  172|   582k|    const T* indirect_ptr(difference_type pos) const { return reinterpret_cast<const T*>(_union.indirect_contents.indirect) + pos; }
_ZN9prevectorILj16EhjiE14const_iteratorC2EPKh:
  109|  7.65M|        const_iterator(const T* ptr_) : ptr(ptr_) {}
_ZNK9prevectorILj16EhjiE3endEv:
  305|  1.77M|    const_iterator end() const { return const_iterator(item_ptr(size())); }
_ZN9prevectorILj16EhjiEaSERKS0_:
  276|  89.1k|    prevector& operator=(const prevector<N, T, Size, Diff>& other) {
  277|  89.1k|        if (&other == this) {
  ------------------
  |  Branch (277:13): [True: 0, False: 89.1k]
  ------------------
  278|      0|            return *this;
  279|      0|        }
  280|  89.1k|        assign(other.begin(), other.end());
  281|  89.1k|        return *this;
  282|  89.1k|    }
_ZN9prevectorILj16EhjiE6assignITkNSt3__114input_iteratorENS0_14const_iteratorEEEvT_S4_:
  233|  89.1k|    void assign(InputIterator first, InputIterator last) {
  234|  89.1k|        size_type n = last - first;
  235|  89.1k|        clear();
  236|  89.1k|        if (capacity() < n) {
  ------------------
  |  Branch (236:13): [True: 12.7k, False: 76.3k]
  ------------------
  237|  12.7k|            change_capacity(n);
  238|  12.7k|        }
  239|  89.1k|        _size += n;
  240|  89.1k|        fill(item_ptr(0), first, last);
  241|  89.1k|    }
_ZmiN9prevectorILj16EhjiE14const_iteratorES1_:
  118|  98.2k|        difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); }
_ZN9prevectorILj16EhjiE5clearEv:
  355|   642k|    void clear() {
  356|   642k|        resize(0);
  357|   642k|    }
_ZN9prevectorILj16EhjiE6resizeEj:
  328|   739k|    void resize(size_type new_size) {
  329|   739k|        size_type cur_size = size();
  330|   739k|        if (cur_size == new_size) {
  ------------------
  |  Branch (330:13): [True: 40.3k, False: 699k]
  ------------------
  331|  40.3k|            return;
  332|  40.3k|        }
  333|   699k|        if (cur_size > new_size) {
  ------------------
  |  Branch (333:13): [True: 682k, False: 16.6k]
  ------------------
  334|   682k|            erase(item_ptr(new_size), end());
  335|   682k|            return;
  336|   682k|        }
  337|  16.6k|        if (new_size > capacity()) {
  ------------------
  |  Branch (337:13): [True: 16.6k, False: 0]
  ------------------
  338|  16.6k|            change_capacity(new_size);
  339|  16.6k|        }
  340|  16.6k|        ptrdiff_t increase = new_size - cur_size;
  341|  16.6k|        fill(item_ptr(cur_size), increase);
  342|  16.6k|        _size += increase;
  343|  16.6k|    }
_ZN9prevectorILj16EhjiE5eraseENS0_8iteratorES1_:
  420|   682k|    iterator erase(iterator first, iterator last) {
  421|       |        // Erase is not allowed to the change the object's capacity. That means
  422|       |        // that when starting with an indirectly allocated prevector with
  423|       |        // size and capacity > N, the result may be a still indirectly allocated
  424|       |        // prevector with size <= N and capacity > N. A shrink_to_fit() call is
  425|       |        // necessary to switch to the (more efficient) directly allocated
  426|       |        // representation (with capacity N and size <= N).
  427|   682k|        iterator p = first;
  428|   682k|        char* endp = (char*)&(*end());
  429|   682k|        _size -= last - p;
  430|   682k|        memmove(&(*first), &(*last), endp - ((char*)(&(*last))));
  431|   682k|        return first;
  432|   682k|    }
_ZNK9prevectorILj16EhjiE8iteratordeEv:
   59|  4.09M|        T& operator*() const { return *ptr; }
_ZmiN9prevectorILj16EhjiE8iteratorES1_:
   66|   682k|        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
_ZN9prevectorILj16EhjiE8iteratorC2EPh:
   58|  2.04M|        iterator(T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj16EhjiE3endEv:
  304|  1.36M|    iterator end() { return iterator(item_ptr(size())); }
_ZN9prevectorILj16EhjiE4fillEPhlRKh:
  209|  1.67M|    void fill(T* dst, ptrdiff_t count, const T& value = T{}) {
  210|  1.67M|        std::fill_n(dst, count, value);
  211|  1.67M|    }
_ZNK9prevectorILj16EhjiE8capacityEv:
  312|   659k|    size_t capacity() const {
  313|   659k|        if (is_direct()) {
  ------------------
  |  Branch (313:13): [True: 659k, False: 0]
  ------------------
  314|   659k|            return N;
  315|   659k|        } else {
  316|      0|            return _union.indirect_contents.capacity;
  317|      0|        }
  318|   659k|    }
_ZN9prevectorILj16EhjiEC2EOS0_:
  271|   207k|        : _union(std::move(other._union)), _size(other._size)
  272|   207k|    {
  273|   207k|        other._size = 0;
  274|   207k|    }
_ZNK9prevectorILj16EhjiEixEj:
  324|  1.02M|    const T& operator[](size_type pos) const {
  325|  1.02M|        return *item_ptr(pos);
  326|  1.02M|    }
_ZNK9prevectorILj16EhjiE4dataEv:
  537|  2.46M|    const value_type* data() const {
  538|  2.46M|        return item_ptr(0);
  539|  2.46M|    }
_ZN9prevectorILj16EhjiE4dataEv:
  533|  97.1k|    value_type* data() {
  534|  97.1k|        return item_ptr(0);
  535|  97.1k|    }
_ZN9prevectorILj28EhjiED2Ev:
  474|      2|    ~prevector() {
  475|      2|        if (!is_direct()) {
  ------------------
  |  Branch (475:13): [True: 0, False: 2]
  ------------------
  476|      0|            free(_union.indirect_contents.indirect);
  477|      0|            _union.indirect_contents.indirect = nullptr;
  478|      0|        }
  479|      2|    }
_ZNK9prevectorILj16EhjiE14const_iteratorptEv:
  112|  3.74M|        const T* operator->() const { return ptr; }
_ZN9prevectorILj16EhjiE6assignEjRKh:
  223|   211k|    void assign(size_type n, const T& val) {
  224|   211k|        clear();
  225|   211k|        if (capacity() < n) {
  ------------------
  |  Branch (225:13): [True: 0, False: 211k]
  ------------------
  226|      0|            change_capacity(n);
  227|      0|        }
  228|   211k|        _size += n;
  229|   211k|        fill(item_ptr(0), n, val);
  230|   211k|    }
_ZN9prevectorILj35EhjiE4dataEv:
  533|    623|    value_type* data() {
  534|    623|        return item_ptr(0);
  535|    623|    }
_ZN9prevectorILj35EhjiE8item_ptrEi:
  206|  4.98k|    T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); }
  ------------------
  |  Branch (206:47): [True: 4.98k, False: 0]
  ------------------
_ZNK9prevectorILj35EhjiE9is_directEv:
  173|  11.8k|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj35EhjiE10direct_ptrEi:
  169|  4.98k|    T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union.direct) + pos; }
_ZNK9prevectorILj35EhjiE4sizeEv:
  294|  4.36k|    size_type size() const {
  295|  4.36k|        return is_direct() ? _size : _size - N - 1;
  ------------------
  |  Branch (295:16): [True: 4.36k, False: 0]
  ------------------
  296|  4.36k|    }
_ZNK9prevectorILj16EhjiEltERKS0_:
  502|  96.3k|    bool operator<(const prevector<N, T, Size, Diff>& other) const {
  503|  96.3k|        if (size() < other.size()) {
  ------------------
  |  Branch (503:13): [True: 0, False: 96.3k]
  ------------------
  504|      0|            return true;
  505|      0|        }
  506|  96.3k|        if (size() > other.size()) {
  ------------------
  |  Branch (506:13): [True: 0, False: 96.3k]
  ------------------
  507|      0|            return false;
  508|      0|        }
  509|  96.3k|        const_iterator b1 = begin();
  510|  96.3k|        const_iterator b2 = other.begin();
  511|  96.3k|        const_iterator e1 = end();
  512|   668k|        while (b1 != e1) {
  ------------------
  |  Branch (512:16): [True: 637k, False: 31.0k]
  ------------------
  513|   637k|            if ((*b1) < (*b2)) {
  ------------------
  |  Branch (513:17): [True: 48.3k, False: 589k]
  ------------------
  514|  48.3k|                return true;
  515|  48.3k|            }
  516|   589k|            if ((*b2) < (*b1)) {
  ------------------
  |  Branch (516:17): [True: 16.9k, False: 572k]
  ------------------
  517|  16.9k|                return false;
  518|  16.9k|            }
  519|   572k|            ++b1;
  520|   572k|            ++b2;
  521|   572k|        }
  522|  31.0k|        return false;
  523|  96.3k|    }
_ZN9prevectorILj16EhjiEC2EjRKh:
  249|  1.44M|    explicit prevector(size_type n, const T& val) {
  250|  1.44M|        change_capacity(n);
  251|  1.44M|        _size += n;
  252|  1.44M|        fill(item_ptr(0), n, val);
  253|  1.44M|    }
_ZN9prevectorILj16EhjiE6assignITkNSt3__114input_iteratorEPKhEEvT_S5_:
  233|   333k|    void assign(InputIterator first, InputIterator last) {
  234|   333k|        size_type n = last - first;
  235|   333k|        clear();
  236|   333k|        if (capacity() < n) {
  ------------------
  |  Branch (236:13): [True: 2.58k, False: 330k]
  ------------------
  237|  2.58k|            change_capacity(n);
  238|  2.58k|        }
  239|   333k|        _size += n;
  240|   333k|        fill(item_ptr(0), first, last);
  241|   333k|    }
_ZN9prevectorILj16EhjiE4fillITkNSt3__114input_iteratorEPKhEEvPhT_S6_:
  214|   333k|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|  5.47M|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 5.13M, False: 333k]
  ------------------
  216|  5.13M|            new(static_cast<void*>(dst)) T(*first);
  217|  5.13M|            ++dst;
  218|  5.13M|            ++first;
  219|  5.13M|        }
  220|   333k|    }
_ZN9prevectorILj16EhjiE6assignITkNSt3__114input_iteratorEPhEEvT_S4_:
  233|  3.44k|    void assign(InputIterator first, InputIterator last) {
  234|  3.44k|        size_type n = last - first;
  235|  3.44k|        clear();
  236|  3.44k|        if (capacity() < n) {
  ------------------
  |  Branch (236:13): [True: 0, False: 3.44k]
  ------------------
  237|      0|            change_capacity(n);
  238|      0|        }
  239|  3.44k|        _size += n;
  240|  3.44k|        fill(item_ptr(0), first, last);
  241|  3.44k|    }
_ZN9prevectorILj16EhjiE4fillITkNSt3__114input_iteratorEPhEEvS3_T_S4_:
  214|  3.44k|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|  37.8k|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 34.4k, False: 3.44k]
  ------------------
  216|  34.4k|            new(static_cast<void*>(dst)) T(*first);
  217|  34.4k|            ++dst;
  218|  34.4k|            ++first;
  219|  34.4k|        }
  220|  3.44k|    }
_ZN9prevectorILj16EhjiE6assignITkNSt3__114input_iteratorENS2_11__wrap_iterIPhEEEEvT_S6_:
  233|  5.31k|    void assign(InputIterator first, InputIterator last) {
  234|  5.31k|        size_type n = last - first;
  235|  5.31k|        clear();
  236|  5.31k|        if (capacity() < n) {
  ------------------
  |  Branch (236:13): [True: 5.31k, False: 0]
  ------------------
  237|  5.31k|            change_capacity(n);
  238|  5.31k|        }
  239|  5.31k|        _size += n;
  240|  5.31k|        fill(item_ptr(0), first, last);
  241|  5.31k|    }
_ZN9prevectorILj16EhjiE4fillITkNSt3__114input_iteratorENS2_11__wrap_iterIPhEEEEvS4_T_S6_:
  214|  5.31k|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|   175k|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 170k, False: 5.31k]
  ------------------
  216|   170k|            new(static_cast<void*>(dst)) T(*first);
  217|   170k|            ++dst;
  218|   170k|            ++first;
  219|   170k|        }
  220|  5.31k|    }
_ZN9prevectorILj35EhjiEC2ITkNSt3__114input_iteratorEPKhEET_S5_:
  256|    623|    prevector(InputIterator first, InputIterator last) {
  257|    623|        size_type n = last - first;
  258|    623|        change_capacity(n);
  259|    623|        _size += n;
  260|    623|        fill(item_ptr(0), first, last);
  261|    623|    }
_ZN9prevectorILj35EhjiE15change_capacityEj:
  175|    623|    void change_capacity(size_type new_capacity) {
  176|    623|        if (new_capacity <= N) {
  ------------------
  |  Branch (176:13): [True: 623, False: 0]
  ------------------
  177|    623|            if (!is_direct()) {
  ------------------
  |  Branch (177:17): [True: 0, False: 623]
  ------------------
  178|      0|                T* indirect = indirect_ptr(0);
  179|      0|                T* src = indirect;
  180|      0|                T* dst = direct_ptr(0);
  181|      0|                memcpy(dst, src, size() * sizeof(T));
  182|      0|                free(indirect);
  183|      0|                _size -= N + 1;
  184|      0|            }
  185|    623|        } else {
  186|      0|            if (!is_direct()) {
  ------------------
  |  Branch (186:17): [True: 0, False: 0]
  ------------------
  187|       |                /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert
  188|       |                    success. These should instead use an allocator or new/delete so that handlers
  189|       |                    are called as necessary, but performance would be slightly degraded by doing so. */
  190|      0|                _union.indirect_contents.indirect = static_cast<char*>(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity));
  191|      0|                assert(_union.indirect_contents.indirect);
  192|      0|                _union.indirect_contents.capacity = new_capacity;
  193|      0|            } else {
  194|      0|                char* new_indirect = static_cast<char*>(malloc(((size_t)sizeof(T)) * new_capacity));
  195|      0|                assert(new_indirect);
  196|      0|                T* src = direct_ptr(0);
  197|      0|                T* dst = reinterpret_cast<T*>(new_indirect);
  198|      0|                memcpy(dst, src, size() * sizeof(T));
  199|      0|                _union.indirect_contents.indirect = new_indirect;
  200|      0|                _union.indirect_contents.capacity = new_capacity;
  201|      0|                _size += N + 1;
  202|      0|            }
  203|      0|        }
  204|    623|    }
_ZN9prevectorILj35EhjiE4fillITkNSt3__114input_iteratorEPKhEEvPhT_S6_:
  214|  1.24k|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|  21.8k|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 20.5k, False: 1.24k]
  ------------------
  216|  20.5k|            new(static_cast<void*>(dst)) T(*first);
  217|  20.5k|            ++dst;
  218|  20.5k|            ++first;
  219|  20.5k|        }
  220|  1.24k|    }
_ZN9prevectorILj35EhjiED2Ev:
  474|    623|    ~prevector() {
  475|    623|        if (!is_direct()) {
  ------------------
  |  Branch (475:13): [True: 0, False: 623]
  ------------------
  476|      0|            free(_union.indirect_contents.indirect);
  477|      0|            _union.indirect_contents.indirect = nullptr;
  478|      0|        }
  479|    623|    }
_ZN9prevectorILj35EhjiE3endEv:
  304|  1.24k|    iterator end() { return iterator(item_ptr(size())); }
_ZN9prevectorILj35EhjiE8iteratorC2EPh:
   58|  2.49k|        iterator(T* ptr_) : ptr(ptr_) {}
_ZN9prevectorILj35EhjiE6insertITkNSt3__114input_iteratorEPhEEvNS0_8iteratorET_S5_:
  387|    623|    void insert(iterator pos, InputIterator first, InputIterator last) {
  388|    623|        size_type p = pos - begin();
  389|    623|        difference_type count = last - first;
  390|    623|        size_type new_size = size() + count;
  391|    623|        if (capacity() < new_size) {
  ------------------
  |  Branch (391:13): [True: 0, False: 623]
  ------------------
  392|      0|            change_capacity(new_size + (new_size >> 1));
  393|      0|        }
  394|    623|        T* ptr = item_ptr(p);
  395|    623|        T* dst = ptr + count;
  396|    623|        memmove(dst, ptr, (size() - p) * sizeof(T));
  397|    623|        _size += count;
  398|    623|        fill(ptr, first, last);
  399|    623|    }
_ZmiN9prevectorILj35EhjiE8iteratorES1_:
   66|  1.24k|        difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); }
_ZNK9prevectorILj35EhjiE8iteratordeEv:
   59|  2.49k|        T& operator*() const { return *ptr; }
_ZN9prevectorILj35EhjiE5beginEv:
  302|  1.24k|    iterator begin() { return iterator(item_ptr(0)); }
_ZNK9prevectorILj35EhjiE8capacityEv:
  312|  1.24k|    size_t capacity() const {
  313|  1.24k|        if (is_direct()) {
  ------------------
  |  Branch (313:13): [True: 1.24k, False: 0]
  ------------------
  314|  1.24k|            return N;
  315|  1.24k|        } else {
  316|      0|            return _union.indirect_contents.capacity;
  317|      0|        }
  318|  1.24k|    }
_ZN9prevectorILj35EhjiE4fillITkNSt3__114input_iteratorEPhEEvS3_T_S4_:
  214|    623|    void fill(T* dst, InputIterator first, InputIterator last) {
  215|  1.86k|        while (first != last) {
  ------------------
  |  Branch (215:16): [True: 1.24k, False: 623]
  ------------------
  216|  1.24k|            new(static_cast<void*>(dst)) T(*first);
  217|  1.24k|            ++dst;
  218|  1.24k|            ++first;
  219|  1.24k|        }
  220|    623|    }
_ZN9prevectorILj35EhjiE6insertITkNSt3__114input_iteratorEPKhEEvNS0_8iteratorET_S6_:
  387|    623|    void insert(iterator pos, InputIterator first, InputIterator last) {
  388|    623|        size_type p = pos - begin();
  389|    623|        difference_type count = last - first;
  390|    623|        size_type new_size = size() + count;
  391|    623|        if (capacity() < new_size) {
  ------------------
  |  Branch (391:13): [True: 0, False: 623]
  ------------------
  392|      0|            change_capacity(new_size + (new_size >> 1));
  393|      0|        }
  394|    623|        T* ptr = item_ptr(p);
  395|    623|        T* dst = ptr + count;
  396|    623|        memmove(dst, ptr, (size() - p) * sizeof(T));
  397|    623|        _size += count;
  398|    623|        fill(ptr, first, last);
  399|    623|    }
_ZNK9prevectorILj16EhjiEeqERKS0_:
  481|   293k|    bool operator==(const prevector<N, T, Size, Diff>& other) const {
  482|   293k|        if (other.size() != size()) {
  ------------------
  |  Branch (482:13): [True: 0, False: 293k]
  ------------------
  483|      0|            return false;
  484|      0|        }
  485|   293k|        const_iterator b1 = begin();
  486|   293k|        const_iterator b2 = other.begin();
  487|   293k|        const_iterator e1 = end();
  488|  4.32M|        while (b1 != e1) {
  ------------------
  |  Branch (488:16): [True: 4.09M, False: 234k]
  ------------------
  489|  4.09M|            if ((*b1) != (*b2)) {
  ------------------
  |  Branch (489:17): [True: 58.4k, False: 4.03M]
  ------------------
  490|  58.4k|                return false;
  491|  58.4k|            }
  492|  4.03M|            ++b1;
  493|  4.03M|            ++b2;
  494|  4.03M|        }
  495|   234k|        return true;
  496|   293k|    }
_ZN9prevectorILj16EhjiEixEj:
  320|   329k|    T& operator[](size_type pos) {
  321|   329k|        return *item_ptr(pos);
  322|   329k|    }

_ZN14CMessageHeaderC2ERKNSt3__15arrayIhLm4EEEPKcj:
   11|  41.0k|    : pchMessageStart{pchMessageStartIn}
   12|  41.0k|{
   13|       |    // Copy the message type name
   14|  41.0k|    size_t i = 0;
   15|   232k|    for (; i < MESSAGE_TYPE_SIZE && msg_type[i] != 0; ++i) m_msg_type[i] = msg_type[i];
  ------------------
  |  Branch (15:12): [True: 226k, False: 6.36k]
  |  Branch (15:37): [True: 191k, False: 34.7k]
  ------------------
   16|  41.0k|    assert(msg_type[i] == 0); // Assert that the message type name passed in is not longer than MESSAGE_TYPE_SIZE
   17|       |
   18|  41.0k|    nMessageSize = nMessageSizeIn;
   19|  41.0k|}

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

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

_ZN11RandomMixinI17FastRandomContextE4ImplEv:
  185|  1.15M|    RandomNumberGenerator auto& Impl() noexcept { return static_cast<T&>(*this); }
_ZN11RandomMixinI17FastRandomContextE8randbitsEi:
  205|  1.09M|    {
  206|  1.09M|        Assume(bits <= 64);
  ------------------
  |  |   97|  1.09M|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  207|       |        // Requests for the full 64 bits are passed through.
  208|  1.09M|        if (bits == 64) return Impl().rand64();
  ------------------
  |  Branch (208:13): [True: 0, False: 1.09M]
  ------------------
  209|  1.09M|        uint64_t ret;
  210|  1.09M|        if (bits <= bitbuf_size) {
  ------------------
  |  Branch (210:13): [True: 1.04M, False: 57.7k]
  ------------------
  211|       |            // If there is enough entropy left in bitbuf, return its bottom bits bits.
  212|  1.04M|            ret = bitbuf;
  213|  1.04M|            bitbuf >>= bits;
  214|  1.04M|            bitbuf_size -= bits;
  215|  1.04M|        } 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|  57.7k|            uint64_t gen = Impl().rand64();
  220|  57.7k|            ret = (gen << bitbuf_size) | bitbuf;
  221|  57.7k|            bitbuf = gen >> (bits - bitbuf_size);
  222|  57.7k|            bitbuf_size = 64 + bitbuf_size - bits;
  223|  57.7k|        }
  224|       |        // Return the bottom bits bits of ret.
  225|  1.09M|        return ret & ((uint64_t{1} << bits) - 1);
  226|  1.09M|    }
_ZN17FastRandomContext6rand64Ev:
  396|  77.3k|    {
  397|  77.3k|        if (requires_seed) RandomSeed();
  ------------------
  |  Branch (397:13): [True: 20.4k, False: 56.9k]
  ------------------
  398|  77.3k|        std::array<std::byte, 8> buf;
  399|  77.3k|        rng.Keystream(buf);
  400|  77.3k|        return ReadLE64(buf.data());
  401|  77.3k|    }
_Z11GetRandHashv:
  455|  20.4k|{
  456|  20.4k|    uint256 hash;
  457|  20.4k|    GetRandBytes(hash);
  458|  20.4k|    return hash;
  459|  20.4k|}
_ZN11RandomMixinI17FastRandomContextE9randrangeITkNSt3__18integralEmEET_S4_:
  255|   858k|    {
  256|   858k|        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max());
  257|   858k|        Assume(range > 0);
  ------------------
  |  |   97|   858k|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  258|   858k|        uint64_t maxval = range - 1U;
  259|   858k|        int bits = std::bit_width(maxval);
  260|  1.09M|        while (true) {
  ------------------
  |  Branch (260:16): [Folded - Ignored]
  ------------------
  261|  1.09M|            uint64_t ret = Impl().randbits(bits);
  262|  1.09M|            if (ret <= maxval) return ret;
  ------------------
  |  Branch (262:17): [True: 858k, False: 238k]
  ------------------
  263|  1.09M|        }
  264|   858k|    }
_ZN11RandomMixinI17FastRandomContextEC2Ev:
  195|  30.2k|    constexpr RandomMixin() noexcept = default;
_ZN11RandomMixinI17FastRandomContextE10FlushCacheEv:
  189|  9.84k|    {
  190|  9.84k|        bitbuf = 0;
  191|  9.84k|        bitbuf_size = 0;
  192|  9.84k|    }
_ZN11RandomMixinI17FastRandomContextE9randrangeITkNSt3__18integralExEET_S4_:
  255|    755|    {
  256|    755|        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max());
  257|    755|        Assume(range > 0);
  ------------------
  |  |   97|    755|#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  258|    755|        uint64_t maxval = range - 1U;
  259|    755|        int bits = std::bit_width(maxval);
  260|  2.50k|        while (true) {
  ------------------
  |  Branch (260:16): [Folded - Ignored]
  ------------------
  261|  2.50k|            uint64_t ret = Impl().randbits(bits);
  262|  2.50k|            if (ret <= maxval) return ret;
  ------------------
  |  Branch (262:17): [True: 755, False: 1.74k]
  ------------------
  263|  2.50k|        }
  264|    755|    }
_ZN11RandomMixinI17FastRandomContextE9randrangeITk17StdChronoDurationNSt3__16chrono8durationIxNS3_5ratioILl1ELl1000000EEEEEEET_NS3_11common_typeIJS9_EE4typeE:
  342|    755|    {
  343|    755|        return Dur{Impl().randrange(range.count())};
  344|    755|    }

_ZN10CSchedulerD2Ev:
   17|      2|{
   18|      2|    assert(nThreadsServicingQueue == 0);
   19|      2|    if (stopWhenEmpty) assert(taskQueue.empty());
  ------------------
  |  Branch (19:9): [True: 0, False: 2]
  ------------------
   20|      2|}
_ZN10CScheduler12serviceQueueEv:
   24|      0|{
   25|      0|    WAIT_LOCK(newTaskMutex, lock);
  ------------------
  |  |  262|      0|#define WAIT_LOCK(cs, name) UniqueLock name(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  ------------------
   26|      0|    ++nThreadsServicingQueue;
   27|       |
   28|       |    // newTaskMutex is locked throughout this loop EXCEPT
   29|       |    // when the thread is waiting or when the user's function
   30|       |    // is called.
   31|      2|    while (!shouldStop()) {
  ------------------
  |  Branch (31:12): [True: 0, False: 2]
  ------------------
   32|      0|        try {
   33|      0|            while (!shouldStop() && taskQueue.empty()) {
  ------------------
  |  Branch (33:20): [True: 0, False: 0]
  |  Branch (33:37): [True: 0, False: 0]
  ------------------
   34|       |                // Wait until there is something to do.
   35|      0|                newTaskScheduled.wait(lock);
   36|      0|            }
   37|       |
   38|       |            // Wait until either there is a new task, or until
   39|       |            // the time of the first item on the queue:
   40|       |
   41|      0|            while (!shouldStop() && !taskQueue.empty()) {
  ------------------
  |  Branch (41:20): [True: 0, False: 0]
  |  Branch (41:37): [True: 0, False: 0]
  ------------------
   42|      0|                std::chrono::steady_clock::time_point timeToWaitFor = taskQueue.begin()->first;
   43|      0|                if (newTaskScheduled.wait_until(lock, timeToWaitFor) == std::cv_status::timeout) {
  ------------------
  |  Branch (43:21): [True: 0, False: 0]
  ------------------
   44|      0|                    break; // Exit loop after timeout, it means we reached the time of the event
   45|      0|                }
   46|      0|            }
   47|       |
   48|       |            // If there are multiple threads, the queue can empty while we're waiting (another
   49|       |            // thread may service the task we were waiting on).
   50|      0|            if (shouldStop() || taskQueue.empty())
  ------------------
  |  Branch (50:17): [True: 0, False: 0]
  |  Branch (50:33): [True: 0, False: 0]
  ------------------
   51|      2|                continue;
   52|       |
   53|  18.4E|            Function f = taskQueue.begin()->second;
   54|  18.4E|            taskQueue.erase(taskQueue.begin());
   55|       |
   56|  18.4E|            {
   57|       |                // Unlock before calling f, so it can reschedule itself or another task
   58|       |                // without deadlocking:
   59|  18.4E|                REVERSE_LOCK(lock);
  ------------------
  |  |  243|  18.4E|#define REVERSE_LOCK(g) typename std::decay<decltype(g)>::type::reverse_lock UNIQUE_NAME(revlock)(g, #g, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  18.4E|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  18.4E|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  18.4E|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   60|  18.4E|                f();
   61|  18.4E|            }
   62|  18.4E|        } catch (...) {
   63|      0|            --nThreadsServicingQueue;
   64|      0|            throw;
   65|      0|        }
   66|      0|    }
   67|      2|    --nThreadsServicingQueue;
   68|      2|    newTaskScheduled.notify_one();
   69|      2|}
_ZNK10CScheduler24AreThreadsServicingQueueEv:
  126|      2|{
  127|      2|    LOCK(newTaskMutex);
  ------------------
  |  |  257|      2|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  128|      2|    return nThreadsServicingQueue;
  129|      2|}
_ZN16SerialTaskRunner12ProcessQueueEv:
  146|      2|{
  147|      2|    std::function<void()> callback;
  148|      2|    {
  149|      2|        LOCK(m_callbacks_mutex);
  ------------------
  |  |  257|      2|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  150|      2|        if (m_are_callbacks_running) return;
  ------------------
  |  Branch (150:13): [True: 0, False: 2]
  ------------------
  151|      2|        if (m_callbacks_pending.empty()) return;
  ------------------
  |  Branch (151:13): [True: 2, False: 0]
  ------------------
  152|      0|        m_are_callbacks_running = true;
  153|       |
  154|      0|        callback = std::move(m_callbacks_pending.front());
  155|      0|        m_callbacks_pending.pop_front();
  156|      0|    }
  157|       |
  158|       |    // RAII the setting of fCallbacksRunning and calling MaybeScheduleProcessQueue
  159|       |    // to ensure both happen safely even if callback() throws.
  160|      0|    struct RAIICallbacksRunning {
  161|      0|        SerialTaskRunner* instance;
  162|      0|        explicit RAIICallbacksRunning(SerialTaskRunner* _instance) : instance(_instance) {}
  163|      0|        ~RAIICallbacksRunning()
  164|      0|        {
  165|      0|            {
  166|      0|                LOCK(instance->m_callbacks_mutex);
  167|      0|                instance->m_are_callbacks_running = false;
  168|      0|            }
  169|      0|            instance->MaybeScheduleProcessQueue();
  170|      0|        }
  171|      0|    } raiicallbacksrunning(this);
  172|       |
  173|      0|    callback();
  174|      0|}
_ZN16SerialTaskRunner5flushEv:
  186|      2|{
  187|      2|    assert(!m_scheduler.AreThreadsServicingQueue());
  188|      2|    bool should_continue = true;
  189|      4|    while (should_continue) {
  ------------------
  |  Branch (189:12): [True: 2, False: 2]
  ------------------
  190|      2|        ProcessQueue();
  191|      2|        LOCK(m_callbacks_mutex);
  ------------------
  |  |  257|      2|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  192|      2|        should_continue = !m_callbacks_pending.empty();
  193|      2|    }
  194|      2|}

_ZN10CScheduler4stopEv:
   80|      2|    {
   81|      2|        WITH_LOCK(newTaskMutex, stopRequested = true);
  ------------------
  |  |  301|      2|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
  ------------------
   82|      2|        newTaskScheduled.notify_all();
   83|      2|        if (m_service_thread.joinable()) m_service_thread.join();
  ------------------
  |  Branch (83:13): [True: 2, False: 0]
  ------------------
   84|      2|    }
_ZNK10CScheduler10shouldStopEv:
  111|      8|    bool shouldStop() const EXCLUSIVE_LOCKS_REQUIRED(newTaskMutex) { return stopRequested || (stopWhenEmpty && taskQueue.empty()); }
  ------------------
  |  Branch (111:77): [True: 8, False: 0]
  |  Branch (111:95): [True: 0, False: 0]
  |  Branch (111:112): [True: 0, False: 0]
  ------------------

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

secp256k1.c:secp256k1_fe_clear:
   21|      2|SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) {
   22|      2|    secp256k1_memclear(a, sizeof(secp256k1_fe));
   23|      2|}

secp256k1.c:secp256k1_ge_clear:
  305|      2|static void secp256k1_ge_clear(secp256k1_ge *r) {
  306|      2|    secp256k1_memclear(r, sizeof(secp256k1_ge));
  307|      2|}

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

secp256k1_context_preallocated_destroy:
  176|      2|void secp256k1_context_preallocated_destroy(secp256k1_context* ctx) {
  177|      2|    ARG_CHECK_VOID(ctx == NULL || secp256k1_context_is_proper(ctx));
  ------------------
  |  |   52|      2|#define ARG_CHECK_VOID(cond) do { \
  |  |   53|      2|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|      4|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 2]
  |  |  |  |  |  Branch (136:39): [True: 0, False: 2]
  |  |  |  |  |  Branch (136:39): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   55|      0|        return; \
  |  |   56|      0|    } \
  |  |   57|      2|} while(0)
  |  |  ------------------
  |  |  |  Branch (57:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  178|       |
  179|       |    /* Defined as noop */
  180|      2|    if (ctx == NULL) {
  ------------------
  |  Branch (180:9): [True: 0, False: 2]
  ------------------
  181|      0|        return;
  182|      0|    }
  183|       |
  184|      2|    secp256k1_ecmult_gen_context_clear(&ctx->ecmult_gen_ctx);
  185|      2|}
secp256k1_context_destroy:
  187|      2|void secp256k1_context_destroy(secp256k1_context* ctx) {
  188|      2|    ARG_CHECK_VOID(ctx == NULL || secp256k1_context_is_proper(ctx));
  ------------------
  |  |   52|      2|#define ARG_CHECK_VOID(cond) do { \
  |  |   53|      2|    if (EXPECT(!(cond), 0)) { \
  |  |  ------------------
  |  |  |  |  136|      4|#define EXPECT(x,c) __builtin_expect((x),(c))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:21): [True: 0, False: 2]
  |  |  |  |  |  Branch (136:39): [True: 0, False: 2]
  |  |  |  |  |  Branch (136:39): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   54|      0|        secp256k1_callback_call(&ctx->illegal_callback, #cond); \
  |  |   55|      0|        return; \
  |  |   56|      0|    } \
  |  |   57|      2|} while(0)
  |  |  ------------------
  |  |  |  Branch (57:9): [Folded - Ignored]
  |  |  ------------------
  ------------------
  189|       |
  190|       |    /* Defined as noop */
  191|      2|    if (ctx == NULL) {
  ------------------
  |  Branch (191:9): [True: 0, False: 2]
  ------------------
  192|      0|        return;
  193|      0|    }
  194|       |
  195|      2|    secp256k1_context_preallocated_destroy(ctx);
  196|      2|    free(ctx);
  197|      2|}
secp256k1.c:secp256k1_context_is_proper:
   82|      4|static int secp256k1_context_is_proper(const secp256k1_context* ctx) {
   83|      4|    return secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx);
   84|      4|}

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

_Z11UnserializeI10DataStreamR20AddrManDeterministicQ14UnserializableIT0_T_EEvRS4_OS3_:
  762|  3.77k|{
  763|  3.77k|    a.Unserialize(is);
  764|  3.77k|}
_Z9SerializeI10DataStreamEvRT_h:
  258|  92.7k|template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
_Z14ser_writedata8I10DataStreamEvRT_h:
   55|   185k|{
   56|   185k|    s.write(AsBytes(Span{&obj, 1}));
   57|   185k|}
_Z9SerializeI10DataStreamhNSt3__19allocatorIhEEEvRT_RKNS1_6vectorIT0_T1_EE:
  846|  92.7k|{
  847|  92.7k|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|  92.7k|        WriteCompactSize(os, v.size());
  849|  92.7k|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (849:13): [True: 92.7k, False: 0]
  ------------------
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|       |    } else {
  859|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|       |    }
  861|  92.7k|}
_Z16WriteCompactSizeI10DataStreamEvRT_m:
  309|  92.7k|{
  310|  92.7k|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 92.7k, False: 0]
  ------------------
  311|  92.7k|    {
  312|  92.7k|        ser_writedata8(os, nSize);
  313|  92.7k|    }
  314|      0|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 0, False: 0]
  ------------------
  315|      0|    {
  316|      0|        ser_writedata8(os, 253);
  317|      0|        ser_writedata16(os, nSize);
  318|      0|    }
  319|      0|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 0, False: 0]
  ------------------
  320|      0|    {
  321|      0|        ser_writedata8(os, 254);
  322|      0|        ser_writedata32(os, nSize);
  323|      0|    }
  324|      0|    else
  325|      0|    {
  326|      0|        ser_writedata8(os, 255);
  327|      0|        ser_writedata64(os, nSize);
  328|      0|    }
  329|  92.7k|    return;
  330|  92.7k|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEC2ES1_RKS3_:
 1127|  96.3k|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER8AddrInfoQ14UnserializableIT0_T_EEvRS9_OS8_:
  762|   260k|{
  763|   260k|    a.Unserialize(is);
  764|   260k|}
_ZN8AddrInfo11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  228|   260k|    {                                                                                               \
  229|   260k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   260k|        Unser(s, *this);                                                                            \
  231|   260k|    }
_ZN8AddrInfo5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_RS_:
  180|   260k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJRS4_R8CNetAddr7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNSE_8durationIxNSD_5ratioILl1ELl1EEEEEEEERiEEEvRT_DpOT0_:
 1033|   260k|    {
 1034|   260k|        ::UnserializeMany(s, args...);
 1035|   260k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJRS3_R8CNetAddrR7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNSD_8durationIxNSC_5ratioILl1ELl1EEEEEEEERiEEvRT_DpOT0_:
 1001|   260k|{
 1002|   260k|    (::Unserialize(s, args), ...);
 1003|   260k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERS3_Q14UnserializableIT0_T_EEvRS8_OS7_:
  762|   260k|{
  763|   260k|    a.Unserialize(is);
  764|   260k|}
_ZN8CAddress11UnserializeI12ParamsStreamIR10DataStreamNS_9SerParamsEEEEvRT_:
  228|   260k|    {                                                                                               \
  229|   260k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   260k|        Unser(s, *this);                                                                            \
  231|   260k|    }
_ZN8CAddress5UnserI12ParamsStreamIR10DataStreamNS_9SerParamsEEEEvRT_RS_:
  180|   260k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZNK12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE9GetParamsIS3_EERKDav:
 1144|   260k|    {
 1145|   260k|        if constexpr (std::is_convertible_v<Params, P>) {
 1146|   260k|            return m_params;
 1147|       |        } else {
 1148|       |            return m_substream.template GetParams<P>();
 1149|       |        }
 1150|   260k|    }
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJRjEEEvRT_DpOT0_:
 1033|   260k|    {
 1034|   260k|        ::UnserializeMany(s, args...);
 1035|   260k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJRjEEvRT_DpOT0_:
 1001|   260k|{
 1002|   260k|    (::Unserialize(s, args), ...);
 1003|   260k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_Rj:
  277|   520k|template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); }
_Z14ser_readdata32I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEjRT_:
  102|  1.27M|{
  103|  1.27M|    uint32_t obj;
  104|  1.27M|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|  1.27M|    return le32toh_internal(obj);
  106|  1.27M|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE4readE4SpanISt4byteE:
 1136|  2.55M|    void read(Span<std::byte> dst) { GetStream().read(dst); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE9GetStreamEv:
 1154|  3.29M|    {
 1155|       |        if constexpr (ContainsStream<SubStream>) {
 1156|       |            return m_substream.GetStream();
 1157|  3.29M|        } else {
 1158|  3.29M|            return m_substream;
 1159|  3.29M|        }
 1160|  3.29M|    }
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNSB_8durationIxNSA_5ratioILl1ELl1EEEEEEEEEEEvRT_DpOT0_:
 1033|   259k|    {
 1034|   259k|        ::UnserializeMany(s, args...);
 1035|   259k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJR7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEEEvRT_DpOT0_:
 1001|   259k|{
 1002|   259k|    (::Unserialize(s, args), ...);
 1003|   259k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEQ14UnserializableIT0_T_EEvRSM_OSL_:
  762|   259k|{
  763|   259k|    a.Unserialize(is);
  764|   259k|}
_ZN7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  483|   259k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15ChronoFormatterIjLb1EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEENSt3__16chrono10time_pointI9NodeClockNS9_8durationIxNS8_5ratioILl1ELl1EEEEEEEEEvRT_RT0_:
  591|   259k|    {
  592|   259k|        U u;
  593|   259k|        s >> u;
  594|       |        // Lossy deserialization does not make sense, so force Wnarrowing
  595|   259k|        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
  596|   259k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRjEERS4_OT_:
 1134|   259k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
deserialize.cpp:_ZL5UsingI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE7WrapperIT_RT0_EOSE_:
  497|   259k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI15ChronoFormatterIjLb1EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEEC2ESB_:
  481|   259k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN17ActionUnserialize8SerWriteI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERS4_ZNS4_16SerializationOpsIS6_S4_S_EEvRT0_RT_T1_EUlRS6_RKS4_E_EEvSC_OS9_OSD_:
 1045|  5.98k|    {
 1046|  5.98k|    }
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI20CompactSizeFormatterILb0EERmEEEEvRT_DpOT0_:
 1033|  5.98k|    {
 1034|  5.98k|        ::UnserializeMany(s, args...);
 1035|  5.98k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJR7WrapperI20CompactSizeFormatterILb0EERmEEEvRT_DpOT0_:
 1001|  5.98k|{
 1002|  5.98k|    (::Unserialize(s, args), ...);
 1003|  5.98k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI20CompactSizeFormatterILb0EERmEQ14UnserializableIT0_T_EEvRSD_OSC_:
  762|  5.98k|{
  763|  5.98k|    a.Unserialize(is);
  764|  5.98k|}
_ZN7WrapperI20CompactSizeFormatterILb0EERmE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  483|  5.98k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN20CompactSizeFormatterILb0EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEmEEvRT_RT0_:
  569|  5.98k|    {
  570|  5.98k|        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
  571|  5.98k|        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (571:13): [True: 21, False: 5.96k]
  |  Branch (571:50): [True: 0, False: 5.96k]
  ------------------
  572|      0|            throw std::ios_base::failure("CompactSize exceeds limit of type");
  573|      0|        }
  574|  5.98k|        v = n;
  575|  5.98k|    }
_Z15ReadCompactSizeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEmRT_b:
  340|   308k|{
  341|   308k|    uint8_t chSize = ser_readdata8(is);
  342|   308k|    uint64_t nSizeRet = 0;
  343|   308k|    if (chSize < 253)
  ------------------
  |  Branch (343:9): [True: 306k, False: 1.82k]
  ------------------
  344|   306k|    {
  345|   306k|        nSizeRet = chSize;
  346|   306k|    }
  347|  1.82k|    else if (chSize == 253)
  ------------------
  |  Branch (347:14): [True: 63, False: 1.76k]
  ------------------
  348|     63|    {
  349|     63|        nSizeRet = ser_readdata16(is);
  350|     63|        if (nSizeRet < 253)
  ------------------
  |  Branch (350:13): [True: 7, False: 56]
  ------------------
  351|      7|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|     63|    }
  353|  1.76k|    else if (chSize == 254)
  ------------------
  |  Branch (353:14): [True: 1.51k, False: 246]
  ------------------
  354|  1.51k|    {
  355|  1.51k|        nSizeRet = ser_readdata32(is);
  356|  1.51k|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (356:13): [True: 14, False: 1.50k]
  ------------------
  357|     14|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|  1.51k|    }
  359|    246|    else
  360|    246|    {
  361|    246|        nSizeRet = ser_readdata64(is);
  362|    246|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (362:13): [True: 27, False: 219]
  ------------------
  363|     27|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  364|    246|    }
  365|   308k|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (365:9): [True: 302k, False: 5.97k]
  |  Branch (365:24): [True: 78, False: 302k]
  ------------------
  366|     78|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  367|     78|    }
  368|   308k|    return nSizeRet;
  369|   308k|}
_Z13ser_readdata8I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEhRT_:
   84|   614k|{
   85|   614k|    uint8_t obj;
   86|   614k|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|   614k|    return obj;
   88|   614k|}
_Z14ser_readdata16I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEtRT_:
   90|     63|{
   91|     63|    uint16_t obj;
   92|     63|    s.read(AsWritableBytes(Span{&obj, 1}));
   93|     63|    return le16toh_internal(obj);
   94|     63|}
_Z14ser_readdata64I12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEmRT_:
  114|   259k|{
  115|   259k|    uint64_t obj;
  116|   259k|    s.read(AsWritableBytes(Span{&obj, 1}));
  117|   259k|    return le64toh_internal(obj);
  118|   259k|}
deserialize.cpp:_ZL5UsingI20CompactSizeFormatterILb0EERmE7WrapperIT_RT0_EOS5_:
  497|  5.98k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI20CompactSizeFormatterILb0EERmEC2ES2_:
  481|  5.98k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN17ActionUnserialize7SerReadI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEERS4_ZNS4_16SerializationOpsIS6_S4_S_EEvRT0_RT_T1_EUlRS6_S7_E_EEvSC_OS9_OSD_:
 1039|  5.96k|    {
 1040|  5.96k|        fn(s, std::forward<Type>(obj));
 1041|  5.96k|    }
_ZZN8CAddress16SerializationOpsI12ParamsStreamIR10DataStreamNS_9SerParamsEES_17ActionUnserializeEEvRT0_RT_T1_ENKUlRS5_RS_E_clESC_SD_:
  157|  5.96k|#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, typename std::remove_const<Type>::type& obj) { code; })
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsEEEEvRT_DpOT0_:
 1033|   253k|    {
 1034|   253k|        ::UnserializeMany(s, args...);
 1035|   253k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJR7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsEEEvRT_DpOT0_:
 1001|   253k|{
 1002|   253k|    (::Unserialize(s, args), ...);
 1003|   253k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsEQ14UnserializableIT0_T_EEvRSE_OSD_:
  762|   253k|{
  763|   253k|    a.Unserialize(is);
  764|   253k|}
_ZN7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  483|   253k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN19CustomUintFormatterILi8ELb0EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE12ServiceFlagsEEvRT_RT0_:
  547|   253k|    {
  548|   253k|        using U = typename std::conditional<std::is_enum<I>::value, std::underlying_type<I>, std::common_type<I>>::type::type;
  549|   253k|        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
  550|   253k|        uint64_t raw = 0;
  551|   253k|        if (BigEndian) {
  ------------------
  |  Branch (551:13): [Folded - Ignored]
  ------------------
  552|      0|            s.read(AsWritableBytes(Span{&raw, 1}).last(Bytes));
  553|      0|            v = static_cast<I>(be64toh_internal(raw));
  554|   253k|        } else {
  555|   253k|            s.read(AsWritableBytes(Span{&raw, 1}).first(Bytes));
  556|   253k|            v = static_cast<I>(le64toh_internal(raw));
  557|   253k|        }
  558|   253k|    }
deserialize.cpp:_ZL5UsingI19CustomUintFormatterILi8ELb0EER12ServiceFlagsE7WrapperIT_RT0_EOS6_:
  497|   253k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI19CustomUintFormatterILi8ELb0EER12ServiceFlagsEC2ES3_:
  481|   253k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJ13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceEEEEvRT_DpOT0_:
 1033|   259k|    {
 1034|   259k|        ::UnserializeMany(s, args...);
 1035|   259k|    }
_Z15UnserializeManyI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEJR13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceEEEvRT_DpOT0_:
 1001|   259k|{
 1002|   259k|    (::Unserialize(s, args), ...);
 1003|   259k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceEQ14UnserializableIT0_T_EEvRSD_OSC_:
  762|   259k|{
  763|   259k|    a.Unserialize(is);
  764|   259k|}
_ZN13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
 1205|   259k|    {
 1206|   259k|        ParamsStream ss{s, m_params};
 1207|   259k|        ::Unserialize(ss, m_object);
 1208|   259k|    }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEC2ES5_RKS7_:
 1127|   259k|    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEER8CServiceQ14UnserializableIT0_T_EEvRSD_OSC_:
  762|   259k|{
  763|   259k|    a.Unserialize(is);
  764|   259k|}
_ZN8CService11UnserializeI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  228|   259k|    {                                                                                               \
  229|   259k|        static_assert(std::is_same<cls&, decltype(*this)>::value, "Unserialize type mismatch");     \
  230|   259k|        Unser(s, *this);                                                                            \
  231|   259k|    }
_ZN8CService5UnserI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_RS_:
  180|   259k|    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
_ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIRS1_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEJRS8_7WrapperI19CustomUintFormatterILi2ELb1EERtEEEEvRT_DpOT0_:
 1033|   259k|    {
 1034|   259k|        ::UnserializeMany(s, args...);
 1035|   259k|    }
_Z15UnserializeManyI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEJRS7_R7WrapperI19CustomUintFormatterILi2ELb1EERtEEEvRT_DpOT0_:
 1001|   259k|{
 1002|   259k|    (::Unserialize(s, args), ...);
 1003|   259k|}
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEERS7_Q14UnserializableIT0_T_EEvRSC_OSB_:
  762|   259k|{
  763|   259k|    a.Unserialize(is);
  764|   259k|}
_ZNK12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE9GetParamsIS7_EERKDav:
 1144|   259k|    {
 1145|   259k|        if constexpr (std::is_convertible_v<Params, P>) {
 1146|   259k|            return m_params;
 1147|       |        } else {
 1148|       |            return m_substream.template GetParams<P>();
 1149|       |        }
 1150|   259k|    }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEErsIRhEERS8_OT_:
 1134|  5.96k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEvRT_Rh:
  273|  5.96k|template<typename Stream> inline void Unserialize(Stream& s, uint8_t& a ) { a = ser_readdata8(s); }
_Z13ser_readdata8I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEhRT_:
   84|  11.9k|{
   85|  11.9k|    uint8_t obj;
   86|  11.9k|    s.read(AsWritableBytes(Span{&obj, 1}));
   87|  11.9k|    return obj;
   88|  11.9k|}
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE4readE4SpanISt4byteE:
 1136|   528k|    void read(Span<std::byte> dst) { GetStream().read(dst); }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE9GetStreamEv:
 1154|   531k|    {
 1155|   531k|        if constexpr (ContainsStream<SubStream>) {
 1156|   531k|            return m_substream.GetStream();
 1157|       |        } else {
 1158|       |            return m_substream;
 1159|       |        }
 1160|   531k|    }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEErsI7WrapperI20CompactSizeFormatterILb1EERmEEERS8_OT_:
 1134|  5.95k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEER7WrapperI20CompactSizeFormatterILb1EERmEQ14UnserializableIT0_T_EEvRSH_OSG_:
  762|  5.95k|{
  763|  5.95k|    a.Unserialize(is);
  764|  5.95k|}
_ZN7WrapperI20CompactSizeFormatterILb1EERmE11UnserializeI12ParamsStreamIRS5_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  483|  5.95k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN20CompactSizeFormatterILb1EE5UnserI12ParamsStreamIRS2_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEmEEvRT_RT0_:
  569|  5.95k|    {
  570|  5.95k|        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
  571|  5.95k|        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (571:13): [True: 147, False: 5.80k]
  |  Branch (571:50): [True: 0, False: 5.80k]
  ------------------
  572|      0|            throw std::ios_base::failure("CompactSize exceeds limit of type");
  573|      0|        }
  574|  5.95k|        v = n;
  575|  5.95k|    }
_Z15ReadCompactSizeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEmRT_b:
  340|  5.95k|{
  341|  5.95k|    uint8_t chSize = ser_readdata8(is);
  342|  5.95k|    uint64_t nSizeRet = 0;
  343|  5.95k|    if (chSize < 253)
  ------------------
  |  Branch (343:9): [True: 5.76k, False: 191]
  ------------------
  344|  5.76k|    {
  345|  5.76k|        nSizeRet = chSize;
  346|  5.76k|    }
  347|    191|    else if (chSize == 253)
  ------------------
  |  Branch (347:14): [True: 33, False: 158]
  ------------------
  348|     33|    {
  349|     33|        nSizeRet = ser_readdata16(is);
  350|     33|        if (nSizeRet < 253)
  ------------------
  |  Branch (350:13): [True: 6, False: 27]
  ------------------
  351|      6|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  352|     33|    }
  353|    158|    else if (chSize == 254)
  ------------------
  |  Branch (353:14): [True: 51, False: 107]
  ------------------
  354|     51|    {
  355|     51|        nSizeRet = ser_readdata32(is);
  356|     51|        if (nSizeRet < 0x10000u)
  ------------------
  |  Branch (356:13): [True: 8, False: 43]
  ------------------
  357|      8|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  358|     51|    }
  359|    107|    else
  360|    107|    {
  361|    107|        nSizeRet = ser_readdata64(is);
  362|    107|        if (nSizeRet < 0x100000000ULL)
  ------------------
  |  Branch (362:13): [True: 11, False: 96]
  ------------------
  363|     11|            throw std::ios_base::failure("non-canonical ReadCompactSize()");
  364|    107|    }
  365|  5.92k|    if (range_check && nSizeRet > MAX_SIZE) {
  ------------------
  |  Branch (365:9): [True: 5.91k, False: 11]
  |  Branch (365:24): [True: 111, False: 5.80k]
  ------------------
  366|    111|        throw std::ios_base::failure("ReadCompactSize(): size too large");
  367|    111|    }
  368|  5.81k|    return nSizeRet;
  369|  5.92k|}
_Z14ser_readdata16I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEtRT_:
   90|     33|{
   91|     33|    uint16_t obj;
   92|     33|    s.read(AsWritableBytes(Span{&obj, 1}));
   93|     33|    return le16toh_internal(obj);
   94|     33|}
_Z14ser_readdata32I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEjRT_:
  102|     51|{
  103|     51|    uint32_t obj;
  104|     51|    s.read(AsWritableBytes(Span{&obj, 1}));
  105|     51|    return le32toh_internal(obj);
  106|     51|}
_Z14ser_readdata64I12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEmRT_:
  114|    103|{
  115|    103|    uint64_t obj;
  116|    103|    s.read(AsWritableBytes(Span{&obj, 1}));
  117|    103|    return le64toh_internal(obj);
  118|    103|}
deserialize.cpp:_ZL5UsingI20CompactSizeFormatterILb1EERmE7WrapperIT_RT0_EOS5_:
  497|   308k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI20CompactSizeFormatterILb1EERmEC2ES2_:
  481|   308k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEErsI4SpanIhEEERS8_OT_:
 1134|  3.69k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEETk9BasicBytehEvRT_4SpanIT0_E:
  283|  3.69k|template <typename Stream, BasicByte B> void Unserialize(Stream& s, Span<B> span) { s.read(AsWritableBytes(span)); }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEE6ignoreEm:
 1137|  2.06k|    void ignore(size_t num) { GetStream().ignore(num); }
_ZN12ParamsStreamIRS_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEErsIRA16_hEERS8_OT_:
 1134|   253k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEETk9BasicBytehLi16EEvRT_RAT1__T0_:
  280|   253k|template <typename Stream, BasicByte B, int N> void Unserialize(Stream& s, B (&a)[N]) { s.read(MakeWritableByteSpan(a)); }
_Z11UnserializeI12ParamsStreamIRS0_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEER7WrapperI19CustomUintFormatterILi2ELb1EERtEQ14UnserializableIT0_T_EEvRSH_OSG_:
  762|   259k|{
  763|   259k|    a.Unserialize(is);
  764|   259k|}
_ZN7WrapperI19CustomUintFormatterILi2ELb1EERtE11UnserializeI12ParamsStreamIRS5_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEEEvRT_:
  483|   259k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN19CustomUintFormatterILi2ELb1EE5UnserI12ParamsStreamIRS2_IR10DataStreamN8CAddress9SerParamsEEN8CNetAddr9SerParamsEEtEEvRT_RT0_:
  547|   259k|    {
  548|   259k|        using U = typename std::conditional<std::is_enum<I>::value, std::underlying_type<I>, std::common_type<I>>::type::type;
  549|   259k|        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
  550|   259k|        uint64_t raw = 0;
  551|   259k|        if (BigEndian) {
  ------------------
  |  Branch (551:13): [Folded - Ignored]
  ------------------
  552|   259k|            s.read(AsWritableBytes(Span{&raw, 1}).last(Bytes));
  553|   259k|            v = static_cast<I>(be64toh_internal(raw));
  554|   259k|        } else {
  555|      0|            s.read(AsWritableBytes(Span{&raw, 1}).first(Bytes));
  556|      0|            v = static_cast<I>(le64toh_internal(raw));
  557|      0|        }
  558|   259k|    }
_Z6AsBaseI8CNetAddr8CServiceERT_RT0_:
  145|   259k|{
  146|   259k|    static_assert(std::is_base_of_v<Out, In>);
  147|   259k|    return x;
  148|   259k|}
deserialize.cpp:_ZL5UsingI19CustomUintFormatterILi2ELb1EERtE7WrapperIT_RT0_EOS5_:
  497|   259k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI19CustomUintFormatterILi2ELb1EERtEC2ES2_:
  481|   259k|    explicit Wrapper(T obj) : m_object(obj) {}
_ZNK8CNetAddr9SerParamsclIR8CServiceEEDaOT_:
 1228|   259k|    {                                                                                    \
 1229|   259k|        return ParamsWrapper{*this, t};                                                  \
 1230|   259k|    }
_ZN13ParamsWrapperIN8CNetAddr9SerParamsE8CServiceEC2ERKS1_RS2_:
 1195|   259k|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_Z6AsBaseI8CService8CAddressERT_RT0_:
  145|   259k|{
  146|   259k|    static_assert(std::is_base_of_v<Out, In>);
  147|   259k|    return x;
  148|   259k|}
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER8CNetAddrQ14UnserializableIT0_T_EEvRS9_OS8_:
  762|   352k|{
  763|   352k|    a.Unserialize(is);
  764|   352k|}
_ZNK12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE9GetParamsIN8CNetAddr9SerParamsEEERKDav:
 1144|   352k|    {
 1145|   352k|        if constexpr (std::is_convertible_v<Params, P>) {
 1146|   352k|            return m_params;
 1147|       |        } else {
 1148|       |            return m_substream.template GetParams<P>();
 1149|       |        }
 1150|   352k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRhEERS4_OT_:
 1134|   305k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_Rh:
  273|   305k|template<typename Stream> inline void Unserialize(Stream& s, uint8_t& a ) { a = ser_readdata8(s); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsI7WrapperI20CompactSizeFormatterILb1EERmEEERS4_OT_:
 1134|   302k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI20CompactSizeFormatterILb1EERmEQ14UnserializableIT0_T_EEvRSD_OSC_:
  762|   302k|{
  763|   302k|    a.Unserialize(is);
  764|   302k|}
_ZN7WrapperI20CompactSizeFormatterILb1EERmE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  483|   302k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN20CompactSizeFormatterILb1EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEmEEvRT_RT0_:
  569|   302k|    {
  570|   302k|        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
  571|   302k|        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
  ------------------
  |  Branch (571:13): [True: 121, False: 302k]
  |  Branch (571:50): [True: 0, False: 302k]
  ------------------
  572|      0|            throw std::ios_base::failure("CompactSize exceeds limit of type");
  573|      0|        }
  574|   302k|        v = n;
  575|   302k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsI4SpanIhEEERS4_OT_:
 1134|  93.0k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEETk9BasicBytehEvRT_4SpanIT0_E:
  283|  93.0k|template <typename Stream, BasicByte B> void Unserialize(Stream& s, Span<B> span) { s.read(AsWritableBytes(span)); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEE6ignoreEm:
 1137|   209k|    void ignore(size_t num) { GetStream().ignore(num); }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRA16_hEERS4_OT_:
 1134|  49.8k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEETk9BasicBytehLi16EEvRT_RAT1__T0_:
  280|  49.8k|template <typename Stream, BasicByte B, int N> void Unserialize(Stream& s, B (&a)[N]) { s.read(MakeWritableByteSpan(a)); }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNSA_8durationIxNS9_5ratioILl1ELl1EEEEEEEEQ14UnserializableIT0_T_EEvRSM_OSL_:
  762|   259k|{
  763|   259k|    a.Unserialize(is);
  764|   259k|}
_ZN7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEEvRT_:
  483|   259k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN15ChronoFormatterIlLb0EE5UnserI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEENSt3__16chrono10time_pointI9NodeClockNS9_8durationIxNS8_5ratioILl1ELl1EEEEEEEEEvRT_RT0_:
  591|   259k|    {
  592|   259k|        U u;
  593|   259k|        s >> u;
  594|       |        // Lossy deserialization does not make sense, so force Wnarrowing
  595|   259k|        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
  596|   259k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRlEERS4_OT_:
 1134|   259k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_Rl:
  278|   259k|template<typename Stream> inline void Unserialize(Stream& s, int64_t& a ) { a = ser_readdata64(s); }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEEEvRT_Ri:
  276|   756k|template<typename Stream> inline void Unserialize(Stream& s, int32_t& a ) { a = ser_readdata32(s); }
_Z6AsBaseI8CAddress8AddrInfoERT_RT0_:
  145|   260k|{
  146|   260k|    static_assert(std::is_base_of_v<Out, In>);
  147|   260k|    return x;
  148|   260k|}
_ZN7WrapperI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEEC2ESB_:
  481|   260k|    explicit Wrapper(T obj) : m_object(obj) {}
_Z15ser_writedata32I12VectorWriterEvRT_j:
   69|  41.0k|{
   70|  41.0k|    obj = htole32_internal(obj);
   71|  41.0k|    s.write(AsBytes(Span{&obj, 1}));
   72|  41.0k|}
_Z9SerializeI12VectorWriterTk9BasicBytehLi4EEvRT_RAT1__KT0_:
  265|  41.0k|template <typename Stream, BasicByte B, int N> void Serialize(Stream& s, const B (&a)[N]) { s.write(MakeByteSpan(a)); }
_Z9SerializeI12VectorWriterEvRT_j:
  262|  41.0k|template<typename Stream> inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); }
_Z15ser_writedata32I10HashWriterEvRT_j:
   69|   115k|{
   70|   115k|    obj = htole32_internal(obj);
   71|   115k|    s.write(AsBytes(Span{&obj, 1}));
   72|   115k|}
_ZNK8CAddress9SerParamsclIR8CNetAddrEEDaOT_:
 1228|  92.7k|    {                                                                                    \
 1229|  92.7k|        return ParamsWrapper{*this, t};                                                  \
 1230|  92.7k|    }
_ZN13ParamsWrapperIN8CAddress9SerParamsE8CNetAddrEC2ERKS1_RS2_:
 1195|  92.7k|    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
_Z11UnserializeI10DataStreamR13ParamsWrapperIN8CAddress9SerParamsE8CNetAddrEQ14UnserializableIT0_T_EEvRS8_OS7_:
  762|  92.7k|{
  763|  92.7k|    a.Unserialize(is);
  764|  92.7k|}
_ZN13ParamsWrapperIN8CAddress9SerParamsE8CNetAddrE11UnserializeI10DataStreamEEvRT_:
 1205|  92.7k|    {
 1206|  92.7k|        ParamsStream ss{s, m_params};
 1207|  92.7k|        ::Unserialize(ss, m_object);
 1208|  92.7k|    }
_Z16WriteCompactSizeI10HashWriterEvRT_m:
  309|   310k|{
  310|   310k|    if (nSize < 253)
  ------------------
  |  Branch (310:9): [True: 310k, False: 59]
  ------------------
  311|   310k|    {
  312|   310k|        ser_writedata8(os, nSize);
  313|   310k|    }
  314|     59|    else if (nSize <= std::numeric_limits<uint16_t>::max())
  ------------------
  |  Branch (314:14): [True: 59, False: 0]
  ------------------
  315|     59|    {
  316|     59|        ser_writedata8(os, 253);
  317|     59|        ser_writedata16(os, nSize);
  318|     59|    }
  319|      0|    else if (nSize <= std::numeric_limits<unsigned int>::max())
  ------------------
  |  Branch (319:14): [True: 0, False: 0]
  ------------------
  320|      0|    {
  321|      0|        ser_writedata8(os, 254);
  322|      0|        ser_writedata32(os, nSize);
  323|      0|    }
  324|      0|    else
  325|      0|    {
  326|      0|        ser_writedata8(os, 255);
  327|      0|        ser_writedata64(os, nSize);
  328|      0|    }
  329|   310k|    return;
  330|   310k|}
_Z14ser_writedata8I10HashWriterEvRT_h:
   55|   474k|{
   56|   474k|    s.write(AsBytes(Span{&obj, 1}));
   57|   474k|}
_Z15ser_writedata16I10HashWriterEvRT_t:
   59|     59|{
   60|     59|    obj = htole16_internal(obj);
   61|     59|    s.write(AsBytes(Span{&obj, 1}));
   62|     59|}
_Z15ser_writedata64I10HashWriterEvRT_m:
   79|  79.4k|{
   80|  79.4k|    obj = htole64_internal(obj);
   81|  79.4k|    s.write(AsBytes(Span{&obj, 1}));
   82|  79.4k|}
_Z9SerializeI10HashWriterhNSt3__19allocatorIhEEEvRT_RKNS1_6vectorIT0_T1_EE:
  846|   309k|{
  847|   309k|    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|   309k|        WriteCompactSize(os, v.size());
  849|   309k|        if (!v.empty()) os.write(MakeByteSpan(v));
  ------------------
  |  Branch (849:13): [True: 309k, False: 0]
  ------------------
  850|       |    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|       |        WriteCompactSize(os, v.size());
  855|       |        for (bool elem : v) {
  856|       |            ::Serialize(os, elem);
  857|       |        }
  858|       |    } else {
  859|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|       |    }
  861|   309k|}
_Z9SerializeI10HashWriter7uint256Q12SerializableIT0_T_EEvRS3_RKS2_:
  753|   274k|{
  754|   274k|    a.Serialize(os);
  755|   274k|}
_Z9SerializeI10HashWriterTk9BasicByteKhEvRT_4SpanIT0_E:
  268|   274k|template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
_Z9SerializeI10HashWriterEvRT_m:
  264|  79.4k|template<typename Stream> inline void Serialize(Stream& s, uint64_t a) { ser_writedata64(s, a); }
_Z9SerializeI10HashWriterEvRT_h:
  258|   115k|template<typename Stream> inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); }
_Z9SerializeI10HashWriterEvRT_i:
  261|   115k|template<typename Stream> inline void Serialize(Stream& s, int32_t a ) { ser_writedata32(s, a); }
addrman.cpp:_ZL5UsingI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEE7WrapperIT_RT0_EOS7_:
  497|  3.77k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_ZN7WrapperI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEEC2ES4_:
  481|  3.77k|    explicit Wrapper(T obj) : m_object(obj) {}
addrman.cpp:_ZL5UsingI15ChronoFormatterIlLb0EERNSt3__16chrono10time_pointI9NodeClockNS3_8durationIxNS2_5ratioILl1ELl1EEEEEEEE7WrapperIT_RT0_EOSE_:
  497|   260k|static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
_Z11UnserializeI10DataStreamR7WrapperI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEEQ14UnserializableIT0_T_EEvRSA_OS9_:
  762|  3.77k|{
  763|  3.77k|    a.Unserialize(is);
  764|  3.77k|}
_ZN7WrapperI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEE11UnserializeI10DataStreamEEvRT_:
  483|  3.77k|    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
_ZN19CustomUintFormatterILi1ELb0EE5UnserI10DataStreamN11AddrManImpl6FormatEEEvRT_RT0_:
  547|  3.77k|    {
  548|  3.77k|        using U = typename std::conditional<std::is_enum<I>::value, std::underlying_type<I>, std::common_type<I>>::type::type;
  549|  3.77k|        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
  550|  3.77k|        uint64_t raw = 0;
  551|  3.77k|        if (BigEndian) {
  ------------------
  |  Branch (551:13): [Folded - Ignored]
  ------------------
  552|      0|            s.read(AsWritableBytes(Span{&raw, 1}).last(Bytes));
  553|      0|            v = static_cast<I>(be64toh_internal(raw));
  554|  3.77k|        } else {
  555|  3.77k|            s.read(AsWritableBytes(Span{&raw, 1}).first(Bytes));
  556|  3.77k|            v = static_cast<I>(le64toh_internal(raw));
  557|  3.77k|        }
  558|  3.77k|    }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIR7uint256EERS4_OT_:
 1134|  3.32k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z11UnserializeI12ParamsStreamIR10DataStreamN8CAddress9SerParamsEER7uint256Q14UnserializableIT0_T_EEvRS9_OS8_:
  762|  3.32k|{
  763|  3.32k|    a.Unserialize(is);
  764|  3.32k|}
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIRiEERS4_OT_:
 1134|   497k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_ZN12ParamsStreamIR10DataStreamN8CAddress9SerParamsEErsIR8AddrInfoEERS4_OT_:
 1134|   260k|    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
_Z9SerializeI10HashWriterbNSt3__19allocatorIbEEEvRT_RKNS1_6vectorIT0_T1_EE:
  846|    440|{
  847|       |    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
  848|       |        WriteCompactSize(os, v.size());
  849|       |        if (!v.empty()) os.write(MakeByteSpan(v));
  850|    440|    } else if constexpr (std::is_same_v<T, bool>) {
  851|       |        // A special case for std::vector<bool>, as dereferencing
  852|       |        // std::vector<bool>::const_iterator does not result in a const bool&
  853|       |        // due to std::vector's special casing for bool arguments.
  854|    440|        WriteCompactSize(os, v.size());
  855|  48.7k|        for (bool elem : v) {
  ------------------
  |  Branch (855:24): [True: 48.7k, False: 440]
  ------------------
  856|  48.7k|            ::Serialize(os, elem);
  857|  48.7k|        }
  858|       |    } else {
  859|       |        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
  860|       |    }
  861|    440|}
_Z9SerializeI10HashWriterEvRT_b:
  285|  48.7k|template <typename Stream> inline void Serialize(Stream& s, bool a) { uint8_t f = a; ser_writedata8(s, f); }
_Z13SerializeManyI12VectorWriterJ14CMessageHeaderEEvRT_DpRKT0_:
  995|  41.0k|{
  996|  41.0k|    (::Serialize(s, args), ...);
  997|  41.0k|}
_Z9SerializeI12VectorWriter14CMessageHeaderQ12SerializableIT0_T_EEvRS3_RKS2_:
  753|  41.0k|{
  754|  41.0k|    a.Serialize(os);
  755|  41.0k|}
_ZNK14CMessageHeader9SerializeI12VectorWriterEEvRT_:
  222|  41.0k|    {                                                                                               \
  223|  41.0k|        static_assert(std::is_same<const cls&, decltype(*this)>::value, "Serialize type mismatch"); \
  224|  41.0k|        Ser(s, *this);                                                                              \
  225|  41.0k|    }                                                                                               \
_ZN14CMessageHeader3SerI12VectorWriterEEvRT_RKS_:
  178|  41.0k|    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
_ZN15ActionSerialize16SerReadWriteManyI12VectorWriterJNSt3__15arrayIhLm4EEEA12_cjA4_hEEEvRT_DpRKT0_:
 1013|  41.0k|    {
 1014|  41.0k|        ::SerializeMany(s, args...);
 1015|  41.0k|    }
_Z13SerializeManyI12VectorWriterJNSt3__15arrayIhLm4EEEA12_cjA4_hEEvRT_DpRKT0_:
  995|  41.0k|{
  996|  41.0k|    (::Serialize(s, args), ...);
  997|  41.0k|}
_Z9SerializeI12VectorWriterTk9BasicBytehLm4EEvRT_RKNSt3__15arrayIT0_XT1_EEE:
  266|  41.0k|template <typename Stream, BasicByte B, std::size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
_Z9SerializeI12VectorWriterTk9BasicBytecLi12EEvRT_RAT1__KT0_:
  265|  41.0k|template <typename Stream, BasicByte B, int N> void Serialize(Stream& s, const B (&a)[N]) { s.write(MakeByteSpan(a)); }

_Z9UCharCastPKh:
  285|  41.0k|inline const unsigned char* UCharCast(const unsigned char* c) { return c; }
_Z9UCharCastPKSt4byte:
  287|  1.58M|inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast<const unsigned char*>(c); }
_ZNK4SpanISt4byteE4lastEm:
  211|   259k|    {
  212|   259k|         ASSERT_IF_DEBUG(size() >= count);
  213|   259k|         return Span<C>(m_data + m_size - count, count);
  214|   259k|    }
_ZNK4SpanISt4byteE5firstEm:
  206|   257k|    {
  207|   257k|        ASSERT_IF_DEBUG(size() >= count);
  208|   257k|        return Span<C>(m_data, count);
  209|   257k|    }
_ZNK4SpanIKSt4byteE4sizeEv:
  187|  1.98M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKcE4dataEv:
  174|  41.0k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKSt4byteE4dataEv:
  174|  2.13M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4sizeEv:
  187|  7.45M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKhE5beginEv:
  175|  1.30M|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKhE3endEv:
  176|   348k|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanIhE4sizeEv:
  187|  65.3k|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIhE4dataEv:
  174|  1.80M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE4dataEv:
  174|   963k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE5firstEm:
  206|  3.85k|    {
  207|  3.85k|        ASSERT_IF_DEBUG(size() >= count);
  208|  3.85k|        return Span<C>(m_data, count);
  209|  3.85k|    }
_ZNK4SpanIKhE7subspanEmm:
  201|    394|    {
  202|    394|        ASSERT_IF_DEBUG(size() >= offset + count);
  203|    394|        return Span<C>(m_data + offset, count);
  204|    394|    }
_ZNK4SpanISt4byteE4sizeEv:
  187|  9.75M|    constexpr std::size_t size() const noexcept { return m_size; }
_ZNK4SpanIKhE5emptyEv:
  189|   404k|    constexpr bool empty() const noexcept { return size() == 0; }
_ZNK4SpanISt4byteE4dataEv:
  174|  3.12M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIKhE7subspanEm:
  196|  5.38M|    {
  197|  5.38M|        ASSERT_IF_DEBUG(size() >= offset);
  198|  5.38M|        return Span<C>(m_data + offset, m_size - offset);
  199|  5.38M|    }
_ZNK4SpanIKSt4byteE5beginEv:
  175|   278k|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKSt4byteE3endEv:
  176|   278k|    constexpr C* end() const noexcept { return m_data + m_size; }
_ZNK4SpanISt4byteE7subspanEm:
  196|  59.4k|    {
  197|  59.4k|        ASSERT_IF_DEBUG(size() >= offset);
  198|  59.4k|        return Span<C>(m_data + offset, m_size - offset);
  199|  59.4k|    }
_Z13UCharSpanCastIKhE4SpanINSt3__114remove_pointerIDTcl9UCharCastcldtfp_4dataEEEE4typeEES1_IT_E:
  293|  41.0k|template <typename T> constexpr auto UCharSpanCast(Span<T> s) -> Span<typename std::remove_pointer<decltype(UCharCast(s.data()))>::type> { return {UCharCast(s.data()), s.size()}; }
_ZNK4SpanIKhE10size_bytesEv:
  188|   780k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIKhE4SpanIKSt4byteES1_IT_E:
  259|   780k|{
  260|   780k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|   780k|}
_Z12MakeByteSpanIRKNSt3__16vectorIhNS0_9allocatorIhEEEEE4SpanIKSt4byteEOT_:
  270|   402k|{
  271|   402k|    return AsBytes(Span{std::forward<V>(v)});
  272|   402k|}
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalISA_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISA_EE4sizeEEmEE5valueEDnE4typeE:
  172|   656k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m:
  119|  1.73M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE:
  165|  5.46k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanISt4byteEC2INSt3__15arrayIS0_Lm8EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  165|  77.3k|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIjE4dataEv:
  174|  1.43M|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanIjE10size_bytesEv:
  188|  1.43M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIjE4SpanIKSt4byteES0_IT_E:
  259|   156k|{
  260|   156k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|   156k|}
_ZNK4SpanIhE10size_bytesEv:
  188|  1.73M|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesIhE4SpanIKSt4byteES0_IT_E:
  259|   680k|{
  260|   680k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|   680k|}
_ZNK4SpanItE4dataEv:
  174|    155|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanItE10size_bytesEv:
  188|    155|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesItE4SpanIKSt4byteES0_IT_E:
  259|     59|{
  260|     59|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|     59|}
_ZNK4SpanImE4dataEv:
  174|   855k|    constexpr C* data() const noexcept { return m_data; }
_ZNK4SpanImE10size_bytesEv:
  188|   855k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_Z7AsBytesImE4SpanIKSt4byteES0_IT_E:
  259|  79.4k|{
  260|  79.4k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  79.4k|}
_ZN4SpanIKhEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  5.44M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  3.68M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E:
  264|  1.05M|{
  265|  1.05M|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  1.05M|}
_ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m:
  119|  1.30M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesItE4SpanISt4byteES0_IT_E:
  264|     96|{
  265|     96|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|     96|}
_ZN4SpanItEC2ItTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_tEE5valueEiE4typeELi0EEEPS4_m:
  119|    155|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesIjE4SpanISt4byteES0_IT_E:
  264|  1.27M|{
  265|  1.27M|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|  1.27M|}
_ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m:
  119|  1.43M|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z15AsWritableBytesImE4SpanISt4byteES0_IT_E:
  264|   776k|{
  265|   776k|    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
  266|   776k|}
_ZN4SpanImEC2ImTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_mEE5valueEiE4typeELi0EEEPS4_m:
  119|   855k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_Z7AsBytesIKcE4SpanIKSt4byteES1_IT_E:
  259|  41.0k|{
  260|  41.0k|    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
  261|  41.0k|}
_ZNK4SpanIKcE10size_bytesEv:
  188|  41.0k|    constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; }
_ZN4SpanIKSt4byteEC2INSt3__15arrayIS0_Lm32EEEEERKT_NS4_9enable_ifIXaaaantsr7is_SpanIS7_EE5valuesr3std14is_convertibleIPA_NS4_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S1_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE:
  172|  30.2k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2INSt3__15arrayIhLm32EEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE:
  172|   274k|        : m_data(other.data()), m_size(other.size()){}
_Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEE4SpanISt4byteEOT_:
  275|  3.32k|{
  276|  3.32k|    return AsWritableBytes(Span{std::forward<V>(v)});
  277|  3.32k|}
_ZN4SpanIhEC2INSt3__15arrayIhLm32EEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  165|  3.32k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIKhEC2I7uint256EERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS7_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  172|  17.1k|        : m_data(other.data()), m_size(other.size()){}
_Z13MakeUCharSpanIRKNSt3__16vectorIhNS0_9allocatorIhEEEEEDTcl13UCharSpanCasttl4Spanclsr3stdE7forwardIT_Efp_EEEEOS8_:
  296|  41.0k|template <typename V> constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(Span{std::forward<V>(v)})) { return UCharSpanCast(Span{std::forward<V>(v)}); }
_ZN4SpanIhEC2I7uint256EERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS3_EE5valuesr3std14is_convertibleIPA_NS5_14remove_pointerIDTcldtclsr3stdE7declvalIS4_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS4_EE4sizeEEmEE5valueEDnE4typeE:
  165|  81.9k|        : m_data(other.data()), m_size(other.size()){}
_ZN4SpanIhEC2I9prevectorILj16EhjiEEERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS4_EE5valuesr3std14is_convertibleIPA_NS6_14remove_pointerIDTcldtclsr3stdE7declvalIS5_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS5_EE4sizeEEmEE5valueEDnE4typeE:
  165|  96.7k|        : m_data(other.data()), m_size(other.size()){}
_Z20MakeWritableByteSpanIRA16_hE4SpanISt4byteEOT_:
  275|   303k|{
  276|   303k|    return AsWritableBytes(Span{std::forward<V>(v)});
  277|   303k|}
_ZN4SpanIhEC2ILi16EEERAT__h:
  151|   303k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZN4SpanIKhEC2ILi16EEERAT__S0_:
  151|   307k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_Z12MakeByteSpanIRA4_KhE4SpanIKSt4byteEOT_:
  270|  41.0k|{
  271|  41.0k|    return AsBytes(Span{std::forward<V>(v)});
  272|  41.0k|}
_ZN4SpanIKhEC2ILi4EEERAT__S0_:
  151|  41.0k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZN4SpanIKhEC2I9prevectorILj16EhjiEEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS8_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  172|   327k|        : m_data(other.data()), m_size(other.size()){}
_Z12MakeByteSpanIRKNSt3__15arrayIhLm4EEEE4SpanIKSt4byteEOT_:
  270|  41.0k|{
  271|  41.0k|    return AsBytes(Span{std::forward<V>(v)});
  272|  41.0k|}
_ZN4SpanIKhEC2INSt3__15arrayIhLm4EEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE:
  172|  41.0k|        : m_data(other.data()), m_size(other.size()){}
_Z12MakeByteSpanIRA12_KcE4SpanIKSt4byteEOT_:
  270|  41.0k|{
  271|  41.0k|    return AsBytes(Span{std::forward<V>(v)});
  272|  41.0k|}
_ZN4SpanIKcEC2ILi12EEERAT__S0_:
  151|  41.0k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZN4SpanIKhEC2ILi32EEERAT__S0_:
  151|  7.29k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZN4SpanIhEC2ILi32EEERAT__h:
  151|  3.85k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZNK4SpanISt4byteE5beginEv:
  175|  97.8k|    constexpr C* begin() const noexcept { return m_data; }
_ZNK4SpanIKhEixEm:
  191|  42.2k|    {
  192|  42.2k|        ASSERT_IF_DEBUG(size() > pos);
  193|  42.2k|        return m_data[pos];
  194|  42.2k|    }
_ZN4SpanIKhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m:
  119|  10.8k|    constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
_ZN4SpanIKhEC2ILi1EEERAT__S0_:
  151|  3.85k|    constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
_ZN4SpanIKhEC2I9prevectorILj35EhjiEEERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS7_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE:
  165|    623|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIKhE4lastEm:
  211|  3.72k|    {
  212|  3.72k|         ASSERT_IF_DEBUG(size() >= count);
  213|  3.72k|         return Span<C>(m_data + m_size - count, count);
  214|  3.72k|    }
_Z12MakeByteSpanIRK7uint256E4SpanIKSt4byteEOT_:
  270|  17.1k|{
  271|  17.1k|    return AsBytes(Span{std::forward<V>(v)});
  272|  17.1k|}
_Z12MakeByteSpanIR7uint256E4SpanIKSt4byteEOT_:
  270|  20.4k|{
  271|  20.4k|    return AsBytes(Span{std::forward<V>(v)});
  272|  20.4k|}
_ZNK4SpanISt4byteE5emptyEv:
  189|   195k|    constexpr bool empty() const noexcept { return size() == 0; }
_ZN4SpanISt4byteEC2INSt3__15arrayIS0_Lm64EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE:
  165|  38.4k|        : m_data(other.data()), m_size(other.size()){}
_ZNK4SpanIKhE5frontEv:
  178|  5.16M|    {
  179|  5.16M|        ASSERT_IF_DEBUG(size() > 0);
  180|  5.16M|        return m_data[0];
  181|  5.16M|    }

_ZN12VectorWriterC2ERNSt3__16vectorIhNS0_9allocatorIhEEEEm:
   60|  41.0k|    VectorWriter(std::vector<unsigned char>& vchDataIn, size_t nPosIn) : vchData{vchDataIn}, nPos{nPosIn}
   61|  41.0k|    {
   62|  41.0k|        if(nPos > vchData.size())
  ------------------
  |  Branch (62:12): [True: 0, False: 41.0k]
  ------------------
   63|      0|            vchData.resize(nPos);
   64|  41.0k|    }
_ZN12VectorWriter5writeE4SpanIKSt4byteE:
   75|   164k|    {
   76|   164k|        assert(nPos <= vchData.size());
   77|   164k|        size_t nOverwrite = std::min(src.size(), vchData.size() - nPos);
   78|   164k|        if (nOverwrite) {
  ------------------
  |  Branch (78:13): [True: 0, False: 164k]
  ------------------
   79|      0|            memcpy(vchData.data() + nPos, src.data(), nOverwrite);
   80|      0|        }
   81|   164k|        if (nOverwrite < src.size()) {
  ------------------
  |  Branch (81:13): [True: 164k, False: 0]
  ------------------
   82|   164k|            vchData.insert(vchData.end(), UCharCast(src.data()) + nOverwrite, UCharCast(src.data() + src.size()));
   83|   164k|        }
   84|   164k|        nPos += src.size();
   85|   164k|    }
_ZN10DataStreamC2E4SpanIKhE:
  165|  3.77k|    explicit DataStream(Span<const uint8_t> sp) : DataStream{AsBytes(sp)} {}
_ZN10DataStreamC2E4SpanIKSt4byteE:
  166|  3.77k|    explicit DataStream(Span<const value_type> sp) : vch(sp.data(), sp.data() + sp.size()) {}
_ZN10DataStream6resizeEmSt4byte:
  183|  25.1k|    void resize(size_type n, value_type c = value_type{}) { vch.resize(n + m_read_pos, c); }
_ZN10DataStream5clearEv:
  187|  50.3k|    void clear()                                     { vch.clear(); m_read_pos = 0; }
_ZN10DataStream4readE4SpanISt4byteE:
  219|  3.08M|    {
  220|  3.08M|        if (dst.size() == 0) return;
  ------------------
  |  Branch (220:13): [True: 0, False: 3.08M]
  ------------------
  221|       |
  222|       |        // Read from the beginning of the buffer
  223|  3.08M|        auto next_read_pos{CheckedAdd(m_read_pos, dst.size())};
  224|  3.08M|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (224:13): [True: 0, False: 3.08M]
  |  Branch (224:43): [True: 977, False: 3.08M]
  ------------------
  225|    977|            throw std::ios_base::failure("DataStream::read(): end of data");
  226|    977|        }
  227|  3.08M|        memcpy(dst.data(), &vch[m_read_pos], dst.size());
  228|  3.08M|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (228:13): [True: 93.6k, False: 2.98M]
  ------------------
  229|  93.6k|            m_read_pos = 0;
  230|  93.6k|            vch.clear();
  231|  93.6k|            return;
  232|  93.6k|        }
  233|  2.98M|        m_read_pos = next_read_pos.value();
  234|  2.98M|    }
_ZN10DataStream6ignoreEm:
  237|   211k|    {
  238|       |        // Ignore from the beginning of the buffer
  239|   211k|        auto next_read_pos{CheckedAdd(m_read_pos, num_ignore)};
  240|   211k|        if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) {
  ------------------
  |  Branch (240:13): [True: 0, False: 211k]
  |  Branch (240:43): [True: 88, False: 211k]
  ------------------
  241|     88|            throw std::ios_base::failure("DataStream::ignore(): end of data");
  242|     88|        }
  243|   211k|        if (next_read_pos.value() == vch.size()) {
  ------------------
  |  Branch (243:13): [True: 11, False: 210k]
  ------------------
  244|     11|            m_read_pos = 0;
  245|     11|            vch.clear();
  246|     11|            return;
  247|     11|        }
  248|   210k|        m_read_pos = next_read_pos.value();
  249|   210k|    }
_ZN10DataStream5writeE4SpanIKSt4byteE:
  252|   278k|    {
  253|       |        // Write to the end of the buffer
  254|   278k|        vch.insert(vch.end(), src.begin(), src.end());
  255|   278k|    }
_ZN10DataStreamC2Ev:
  164|   143k|    explicit DataStream() = default;
_ZN10DataStreamrsIR20AddrManDeterministicEERS_OT_:
  266|  3.77k|    {
  267|  3.77k|        ::Unserialize(*this, obj);
  268|  3.77k|        return (*this);
  269|  3.77k|    }
_ZN10DataStreamlsIhEERS_RKT_:
  259|  92.7k|    {
  260|  92.7k|        ::Serialize(*this, obj);
  261|  92.7k|        return (*this);
  262|  92.7k|    }
_ZN10DataStreamlsINSt3__16vectorIhNS1_9allocatorIhEEEEEERS_RKT_:
  259|  92.7k|    {
  260|  92.7k|        ::Serialize(*this, obj);
  261|  92.7k|        return (*this);
  262|  92.7k|    }
_ZN10DataStreamrsI13ParamsWrapperIN8CAddress9SerParamsE8CNetAddrEEERS_OT_:
  266|  92.7k|    {
  267|  92.7k|        ::Unserialize(*this, obj);
  268|  92.7k|        return (*this);
  269|  92.7k|    }
_ZN10DataStreamrsI7WrapperI19CustomUintFormatterILi1ELb0EERN11AddrManImpl6FormatEEEERS_OT_:
  266|  3.77k|    {
  267|  3.77k|        ::Unserialize(*this, obj);
  268|  3.77k|        return (*this);
  269|  3.77k|    }
_ZN12VectorWriterC2IJR14CMessageHeaderEEERNSt3__16vectorIhNS3_9allocatorIhEEEEmDpOT_:
   70|  41.0k|    VectorWriter(std::vector<unsigned char>& vchDataIn, size_t nPosIn, Args&&... args) : VectorWriter{vchDataIn, nPosIn}
   71|  41.0k|    {
   72|  41.0k|        ::SerializeMany(*this, std::forward<Args>(args)...);
   73|  41.0k|    }

_ZN12PoolResourceILm144ELm8EED2Ev:
  201|      2|    {
  202|      2|        for (std::byte* chunk : m_allocated_chunks) {
  ------------------
  |  Branch (202:31): [True: 2, False: 2]
  ------------------
  203|      2|            std::destroy(chunk, chunk + m_chunk_size_bytes);
  204|      2|            ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES});
  205|      2|        }
  206|      2|    }

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

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

_Z17MaybeCheckNotHeldR14AnnotatedMixinINSt3__15mutexEE:
  247|  1.14M|inline Mutex& MaybeCheckNotHeld(Mutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; }
_ZZN20AddrManDeterministicC1ERK15NetGroupManagerR18FuzzedDataProvideriENKUlvE_clEv:
  301|  9.84k|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
  ------------------
  |  |  257|  9.84k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  9.84k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  9.84k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  9.84k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEEC2ERS3_PKcS7_ib:
  177|  1.13M|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  178|  1.13M|    {
  179|  1.13M|        if (fTry)
  ------------------
  |  Branch (179:13): [True: 0, False: 1.13M]
  ------------------
  180|      0|            TryEnter(pszName, pszFile, nLine);
  181|  1.13M|        else
  182|  1.13M|            Enter(pszName, pszFile, nLine);
  183|  1.13M|    }
_Z13EnterCriticalINSt3__15mutexEEvPKcS3_iPT_b:
   75|  1.13M|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_Z13LeaveCriticalv:
   76|  1.38M|inline void LeaveCritical() {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEE5EnterEPKcS6_i:
  157|  1.13M|    {
  158|  1.13M|        EnterCritical(pszName, pszFile, nLine, Base::mutex());
  159|       |#ifdef DEBUG_LOCKCONTENTION
  160|       |        if (Base::try_lock()) return;
  161|       |        LOG_TIME_MICROS_WITH_CATEGORY(strprintf("lock contention %s, %s:%d", pszName, pszFile, nLine), BCLog::LOCK);
  162|       |#endif
  163|  1.13M|        Base::lock();
  164|  1.13M|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEED2Ev:
  197|  1.13M|    {
  198|  1.13M|        if (Base::owns_lock())
  ------------------
  |  Branch (198:13): [True: 1.13M, False: 0]
  ------------------
  199|  1.13M|            LeaveCritical();
  200|  1.13M|    }
_Z10DeleteLockPv:
   82|   269k|inline void DeleteLock(void* cs) {}
_Z23AssertLockNotHeldInlinePKcS0_iP14AnnotatedMixinINSt3__15mutexEE:
  144|   663k|inline void AssertLockNotHeldInline(const char* name, const char* file, int line, Mutex* cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) { AssertLockNotHeldInternal(name, file, line, cs); }
_ZN15CSemaphoreGrant7ReleaseEv:
  369|  25.1k|    {
  370|  25.1k|        if (!fHaveGrant) {
  ------------------
  |  Branch (370:13): [True: 25.1k, False: 0]
  ------------------
  371|  25.1k|            return;
  372|  25.1k|        }
  373|      0|        sem->post();
  374|      0|        fHaveGrant = false;
  375|      0|    }
_ZN15CSemaphoreGrantC2Ev:
  408|  25.1k|    CSemaphoreGrant() noexcept : sem(nullptr), fHaveGrant(false) {}
_ZN15CSemaphoreGrantD2Ev:
  420|  25.1k|    {
  421|  25.1k|        Release();
  422|  25.1k|    }
_Z25AssertLockNotHeldInternalI14AnnotatedMixinINSt3__15mutexEEEvPKcS5_iPT_:
   81|   663k|void AssertLockNotHeldInternal(const char* pszName, const char* pszFile, int nLine, MutexType* cs) LOCKS_EXCLUDED(cs) {}
_Z17MaybeCheckNotHeldI14AnnotatedMixinINSt3__115recursive_mutexEEERT_S5_:
  253|   257k|inline MutexType& MaybeCheckNotHeld(MutexType& m) LOCKS_EXCLUDED(m) LOCK_RETURNED(m) { return m; }
_Z13EnterCriticalINSt3__115recursive_mutexEEvPKcS3_iPT_b:
   75|   249k|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEE5EnterEPKcS6_i:
  157|   249k|    {
  158|   249k|        EnterCritical(pszName, pszFile, nLine, Base::mutex());
  159|       |#ifdef DEBUG_LOCKCONTENTION
  160|       |        if (Base::try_lock()) return;
  161|       |        LOG_TIME_MICROS_WITH_CATEGORY(strprintf("lock contention %s, %s:%d", pszName, pszFile, nLine), BCLog::LOCK);
  162|       |#endif
  163|   249k|        Base::lock();
  164|   249k|    }
_Z22AssertLockHeldInternalI14AnnotatedMixinINSt3__15mutexEEEvPKcS5_iPT_:
   79|  1.33M|inline void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, MutexType* cs) EXCLUSIVE_LOCKS_REQUIRED(cs) {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEEC2ERS3_PKcS7_ib:
  177|   249k|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  178|   249k|    {
  179|   249k|        if (fTry)
  ------------------
  |  Branch (179:13): [True: 0, False: 249k]
  ------------------
  180|      0|            TryEnter(pszName, pszFile, nLine);
  181|   249k|        else
  182|   249k|            Enter(pszName, pszFile, nLine);
  183|   249k|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEED2Ev:
  197|   249k|    {
  198|   249k|        if (Base::owns_lock())
  ------------------
  |  Branch (198:13): [True: 249k, False: 0]
  ------------------
  199|   249k|            LeaveCritical();
  200|   249k|    }
_ZN14AnnotatedMixinINSt3__15mutexEED2Ev:
   94|   262k|    ~AnnotatedMixin() {
   95|   262k|        DeleteLock((void*)this);
   96|   262k|    }
_ZN14AnnotatedMixinINSt3__115recursive_mutexEED2Ev:
   94|  7.30k|    ~AnnotatedMixin() {
   95|  7.30k|        DeleteLock((void*)this);
   96|  7.30k|    }
_ZZN10CScheduler4stopEvENKUlvE_clEv:
  301|      2|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
  ------------------
  |  |  257|      2|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
net.cpp:_ZZN8CConnman9StopNodesEvENK3$_0clEv:
  301|  7.29k|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
  ------------------
  |  |  257|  7.29k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.29k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.29k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.29k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
_ZZN11CCheckQueueI12CScriptCheckNSt3__14pairI13ScriptError_tNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEED1EvENKUlvE_clEv:
  301|      2|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
  ------------------
  |  |  257|      2|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------

_ZN18FuzzedDataProviderC2EPKhm:
   37|  7.29k|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider15ConsumeIntegralIlEET_v:
  195|  19.3k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  19.3k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  19.3k|                                std::numeric_limits<T>::max());
  198|  19.3k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIlEET_S1_S1_:
  205|  52.4k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  52.4k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  52.4k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  52.4k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 52.4k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  52.4k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  52.4k|  uint64_t result = 0;
  215|  52.4k|  size_t offset = 0;
  216|       |
  217|   410k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 369k, False: 40.9k]
  |  Branch (217:43): [True: 361k, False: 7.61k]
  ------------------
  218|   410k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 357k, False: 3.86k]
  ------------------
  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|   357k|    --remaining_bytes_;
  226|   357k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|   357k|    offset += CHAR_BIT;
  228|   357k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  52.4k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 33.0k, False: 19.3k]
  ------------------
  232|  33.0k|    result = result % (range + 1);
  233|       |
  234|  52.4k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  52.4k|}
_ZN18FuzzedDataProvider15ConsumeIntegralImEET_v:
  195|   159k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|   159k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|   159k|                                std::numeric_limits<T>::max());
  198|   159k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_:
  205|   948k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|   948k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|   948k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|   948k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 948k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|   948k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|   948k|  uint64_t result = 0;
  215|   948k|  size_t offset = 0;
  216|       |
  217|  2.78M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 2.65M, False: 132k]
  |  Branch (217:43): [True: 1.87M, False: 776k]
  ------------------
  218|  2.78M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 1.84M, False: 39.4k]
  ------------------
  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|  1.84M|    --remaining_bytes_;
  226|  1.84M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  1.84M|    offset += CHAR_BIT;
  228|  1.84M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|   948k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 789k, False: 159k]
  ------------------
  232|   789k|    result = result % (range + 1);
  233|       |
  234|   948k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|   948k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIjEET_v:
  195|  58.4k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  58.4k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  58.4k|                                std::numeric_limits<T>::max());
  198|  58.4k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_:
  205|  83.5k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  83.5k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  83.5k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  83.5k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 83.5k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  83.5k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  83.5k|  uint64_t result = 0;
  215|  83.5k|  size_t offset = 0;
  216|       |
  217|   288k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 243k, False: 45.9k]
  |  Branch (217:43): [True: 221k, False: 21.6k]
  ------------------
  218|   288k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 205k, False: 16.0k]
  ------------------
  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|   205k|    --remaining_bytes_;
  226|   205k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|   205k|    offset += CHAR_BIT;
  228|   205k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  83.5k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 83.5k, False: 0]
  ------------------
  232|  83.5k|    result = result % (range + 1);
  233|       |
  234|  83.5k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  83.5k|}
_ZN18FuzzedDataProvider15ConsumeIntegralItEET_v:
  195|  50.3k|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  50.3k|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  50.3k|                                std::numeric_limits<T>::max());
  198|  50.3k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeItEET_S1_S1_:
  205|  50.3k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  50.3k|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  50.3k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  50.3k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 50.3k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  50.3k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  50.3k|  uint64_t result = 0;
  215|  50.3k|  size_t offset = 0;
  216|       |
  217|   134k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 92.6k, False: 42.2k]
  |  Branch (217:43): [True: 92.6k, False: 0]
  ------------------
  218|   134k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 84.5k, False: 8.08k]
  ------------------
  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|  84.5k|    --remaining_bytes_;
  226|  84.5k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  84.5k|    offset += CHAR_BIT;
  228|  84.5k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  50.3k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 50.3k, False: 0]
  ------------------
  232|  50.3k|    result = result % (range + 1);
  233|       |
  234|  50.3k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  50.3k|}
_ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v:
  195|  1.05M|template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
  196|  1.05M|  return ConsumeIntegralInRange(std::numeric_limits<T>::min(),
  197|  1.05M|                                std::numeric_limits<T>::max());
  198|  1.05M|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_:
  205|  1.05M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.05M|  static_assert(std::is_integral<T>::value, "An integral type is required.");
  207|  1.05M|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.05M|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.05M]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.05M|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.05M|  uint64_t result = 0;
  215|  1.05M|  size_t offset = 0;
  216|       |
  217|  2.06M|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 1.05M, False: 1.01M]
  |  Branch (217:43): [True: 1.05M, False: 0]
  ------------------
  218|  2.06M|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 1.01M, False: 41.1k]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  1.01M|    --remaining_bytes_;
  226|  1.01M|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  1.01M|    offset += CHAR_BIT;
  228|  1.01M|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.05M|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 1.05M, False: 0]
  ------------------
  232|  1.05M|    result = result % (range + 1);
  233|       |
  234|  1.05M|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.05M|}
_ZN18FuzzedDataProvider20ConsumeBytesAsStringEm:
  137|  3.45k|inline std::string FuzzedDataProvider::ConsumeBytesAsString(size_t num_bytes) {
  138|  3.45k|  static_assert(sizeof(std::string::value_type) == sizeof(uint8_t),
  139|  3.45k|                "ConsumeBytesAsString cannot convert the data to a string.");
  140|       |
  141|  3.45k|  num_bytes = std::min(num_bytes, remaining_bytes_);
  142|  3.45k|  std::string result(
  143|  3.45k|      reinterpret_cast<const std::string::value_type *>(data_ptr_), num_bytes);
  144|  3.45k|  Advance(num_bytes);
  145|  3.45k|  return result;
  146|  3.45k|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm:
  153|   212k|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|   212k|  std::string result;
  161|       |
  162|       |  // Reserve the anticipated capacity to prevent several reallocations.
  163|   212k|  result.reserve(std::min(max_length, remaining_bytes_));
  164|  51.8M|  for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) {
  ------------------
  |  Branch (164:22): [True: 51.8M, False: 26.1k]
  |  Branch (164:40): [True: 51.8M, False: 4.47k]
  ------------------
  165|  51.8M|    char next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  166|  51.8M|    Advance(1);
  167|  51.8M|    if (next == '\\' && remaining_bytes_ != 0) {
  ------------------
  |  Branch (167:9): [True: 184k, False: 51.6M]
  |  Branch (167:25): [True: 184k, False: 19]
  ------------------
  168|   184k|      next = ConvertUnsignedToSigned<char>(data_ptr_[0]);
  169|   184k|      Advance(1);
  170|   184k|      if (next != '\\')
  ------------------
  |  Branch (170:11): [True: 182k, False: 2.38k]
  ------------------
  171|   182k|        break;
  172|   184k|    }
  173|  51.6M|    result += next;
  174|  51.6M|  }
  175|       |
  176|   212k|  result.shrink_to_fit();
  177|   212k|  return result;
  178|   212k|}
_ZN18FuzzedDataProvider25ConsumeRandomLengthStringEv:
  181|  91.0k|inline std::string FuzzedDataProvider::ConsumeRandomLengthString() {
  182|  91.0k|  return ConsumeRandomLengthString(remaining_bytes_);
  183|  91.0k|}
_ZN18FuzzedDataProvider11ConsumeBoolEv:
  289|  1.01M|inline bool FuzzedDataProvider::ConsumeBool() {
  290|  1.01M|  return 1 & ConsumeIntegral<uint8_t>();
  291|  1.01M|}
_ZN18FuzzedDataProvider14CopyAndAdvanceEPvm:
  339|  92.4k|                                               size_t num_bytes) {
  340|  92.4k|  std::memcpy(destination, data_ptr_, num_bytes);
  341|  92.4k|  Advance(num_bytes);
  342|  92.4k|}
_ZN18FuzzedDataProvider7AdvanceEm:
  344|  52.1M|inline void FuzzedDataProvider::Advance(size_t num_bytes) {
  345|  52.1M|  if (num_bytes > remaining_bytes_)
  ------------------
  |  Branch (345:7): [True: 0, False: 52.1M]
  ------------------
  346|      0|    abort();
  347|       |
  348|  52.1M|  data_ptr_ += num_bytes;
  349|  52.1M|  remaining_bytes_ -= num_bytes;
  350|  52.1M|}
_ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_:
  379|  52.0M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) {
  380|  52.0M|  static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types.");
  381|  52.0M|  static_assert(!std::numeric_limits<TU>::is_signed,
  382|  52.0M|                "Source type must be unsigned.");
  383|       |
  384|       |  // TODO(Dor1s): change to `if constexpr` once C++17 becomes mainstream.
  385|  52.0M|  if (std::numeric_limits<TS>::is_modulo)
  ------------------
  |  Branch (385:7): [Folded - Ignored]
  ------------------
  386|      0|    return static_cast<TS>(value);
  387|       |
  388|       |  // Avoid using implementation-defined unsigned to signed conversions.
  389|       |  // To learn more, see https://stackoverflow.com/questions/13150449.
  390|  52.0M|  if (value <= std::numeric_limits<TS>::max()) {
  ------------------
  |  Branch (390:7): [True: 40.4M, False: 11.6M]
  ------------------
  391|  40.4M|    return static_cast<TS>(value);
  392|  40.4M|  } else {
  393|  11.6M|    constexpr auto TS_min = std::numeric_limits<TS>::min();
  394|  11.6M|    return TS_min + static_cast<TS>(value - TS_min);
  395|  11.6M|  }
  396|  52.0M|}
_ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEm:
  109|   102k|std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t num_bytes) {
  110|   102k|  num_bytes = std::min(num_bytes, remaining_bytes_);
  111|   102k|  return ConsumeBytes<T>(num_bytes, num_bytes);
  112|   102k|}
_ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEmm:
  353|   102k|std::vector<T> FuzzedDataProvider::ConsumeBytes(size_t size, size_t num_bytes) {
  354|   102k|  static_assert(sizeof(T) == sizeof(uint8_t), "Incompatible data type.");
  355|       |
  356|       |  // The point of using the size-based constructor below is to increase the
  357|       |  // odds of having a vector object with capacity being equal to the length.
  358|       |  // That part is always implementation specific, but at least both libc++ and
  359|       |  // libstdc++ allocate the requested number of bytes in that constructor,
  360|       |  // which seems to be a natural choice for other implementations as well.
  361|       |  // To increase the odds even more, we also call |shrink_to_fit| below.
  362|   102k|  std::vector<T> result(size);
  363|   102k|  if (size == 0) {
  ------------------
  |  Branch (363:7): [True: 10.1k, False: 92.4k]
  ------------------
  364|  10.1k|    if (num_bytes != 0)
  ------------------
  |  Branch (364:9): [True: 0, False: 10.1k]
  ------------------
  365|      0|      abort();
  366|  10.1k|    return result;
  367|  10.1k|  }
  368|       |
  369|  92.4k|  CopyAndAdvance(result.data(), num_bytes);
  370|       |
  371|       |  // Even though |shrink_to_fit| is also implementation specific, we expect it
  372|       |  // to provide an additional assurance in case vector's constructor allocated
  373|       |  // a buffer which is larger than the actual amount of data we put inside it.
  374|  92.4k|  result.shrink_to_fit();
  375|  92.4k|  return result;
  376|   102k|}
_ZN18FuzzedDataProvider16PickValueInArrayI12ServiceFlagsLm7EEET_RAT0__KS2_:
  304|  36.8k|T FuzzedDataProvider::PickValueInArray(const T (&array)[size]) {
  305|  36.8k|  static_assert(size > 0, "The array must be non empty.");
  306|  36.8k|  return array[ConsumeIntegralInRange<size_t>(0, size - 1)];
  307|  36.8k|}
_ZN18FuzzedDataProvider16PickValueInArrayI14ConnectionTypeLm6EEET_RAT0__KS2_:
  304|  25.1k|T FuzzedDataProvider::PickValueInArray(const T (&array)[size]) {
  305|  25.1k|  static_assert(size > 0, "The array must be non empty.");
  306|  25.1k|  return array[ConsumeIntegralInRange<size_t>(0, size - 1)];
  307|  25.1k|}
_ZN18FuzzedDataProvider16PickValueInArrayI18NetPermissionFlagsLm10EEET_RAT0__KS2_:
  304|  17.1k|T FuzzedDataProvider::PickValueInArray(const T (&array)[size]) {
  305|  17.1k|  static_assert(size > 0, "The array must be non empty.");
  306|  17.1k|  return array[ConsumeIntegralInRange<size_t>(0, size - 1)];
  307|  17.1k|}
_ZN18FuzzedDataProvider16PickValueInArrayI19ConnectionDirectionEET_St16initializer_listIKS2_E:
  316|  2.08k|T FuzzedDataProvider::PickValueInArray(std::initializer_list<const T> list) {
  317|       |  // TODO(Dor1s): switch to static_assert once C++14 is allowed.
  318|  2.08k|  if (!list.size())
  ------------------
  |  Branch (318:7): [True: 0, False: 2.08k]
  ------------------
  319|      0|    abort();
  320|       |
  321|  2.08k|  return *(list.begin() + ConsumeIntegralInRange<size_t>(0, list.size() - 1));
  322|  2.08k|}
_ZN18FuzzedDataProvider16PickValueInArrayIiLm18EEET_RKNSt3__15arrayIS1_XT0_EEE:
  310|    236|T FuzzedDataProvider::PickValueInArray(const std::array<T, size> &array) {
  311|    236|  static_assert(size > 0, "The array must be non empty.");
  312|    236|  return array[ConsumeIntegralInRange<size_t>(0, size - 1)];
  313|    236|}

_Z19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
   38|  7.29k|{
   39|  7.29k|    SeedRandomStateForTest(SeedRand::ZEROS);
   40|  7.29k|    FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
   41|  7.29k|    SetMockTime(ConsumeTime(fuzzed_data_provider));
   42|  7.29k|    auto netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
   43|  7.29k|    auto addr_man_ptr{std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio())};
   44|  7.29k|    if (fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (44:9): [True: 3.77k, False: 3.52k]
  ------------------
   45|  3.77k|        const std::vector<uint8_t> serialized_data{ConsumeRandomLengthByteVector(fuzzed_data_provider)};
   46|  3.77k|        DataStream ds{serialized_data};
   47|  3.77k|        try {
   48|  3.77k|            ds >> *addr_man_ptr;
   49|  3.77k|        } catch (const std::ios_base::failure&) {
   50|  2.54k|            addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio());
   51|  2.54k|        }
   52|  3.77k|    }
   53|  7.29k|    AddrManDeterministic& addr_man{*addr_man_ptr};
   54|  7.29k|    ConnmanTestMsg connman{fuzzed_data_provider.ConsumeIntegral<uint64_t>(),
   55|  7.29k|                     fuzzed_data_provider.ConsumeIntegral<uint64_t>(),
   56|  7.29k|                     addr_man,
   57|  7.29k|                     netgroupman,
   58|  7.29k|                     Params(),
   59|  7.29k|                     fuzzed_data_provider.ConsumeBool()};
   60|       |
   61|  7.29k|    const uint64_t max_outbound_limit{fuzzed_data_provider.ConsumeIntegral<uint64_t>()};
   62|  7.29k|    CConnman::Options options;
   63|  7.29k|    options.nMaxOutboundLimit = max_outbound_limit;
   64|  7.29k|    connman.Init(options);
   65|       |
   66|  7.29k|    CNetAddr random_netaddr;
   67|  7.29k|    CNode random_node = ConsumeNode(fuzzed_data_provider);
   68|  7.29k|    CSubNet random_subnet;
   69|  7.29k|    std::string random_string;
   70|       |
   71|  17.8k|    LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 100) {
  ------------------
  |  |   23|  25.1k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 17.9k, False: 7.27k]
  |  |  |  Branch (23:49): [True: 17.8k, False: 26]
  |  |  ------------------
  ------------------
   72|  17.8k|        CNode& p2p_node{*ConsumeNodeAsUniquePtr(fuzzed_data_provider).release()};
   73|  17.8k|        connman.AddTestNode(p2p_node);
   74|  17.8k|    }
   75|       |
   76|   541k|    LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
  ------------------
  |  |   23|   548k|    for (unsigned _count{limit}; (condition) && _count; --_count)
  |  |  ------------------
  |  |  |  Branch (23:34): [True: 541k, False: 7.29k]
  |  |  |  Branch (23:49): [True: 541k, False: 0]
  |  |  ------------------
  ------------------
   77|   541k|        CallOneOf(
   78|   541k|            fuzzed_data_provider,
   79|   541k|            [&] {
   80|   541k|                random_netaddr = ConsumeNetAddr(fuzzed_data_provider);
   81|   541k|            },
   82|   541k|            [&] {
   83|   541k|                random_subnet = ConsumeSubNet(fuzzed_data_provider);
   84|   541k|            },
   85|   541k|            [&] {
   86|   541k|                random_string = fuzzed_data_provider.ConsumeRandomLengthString(64);
   87|   541k|            },
   88|   541k|            [&] {
   89|   541k|                connman.AddNode({random_string, fuzzed_data_provider.ConsumeBool()});
   90|   541k|            },
   91|   541k|            [&] {
   92|   541k|                connman.CheckIncomingNonce(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
   93|   541k|            },
   94|   541k|            [&] {
   95|   541k|                connman.DisconnectNode(fuzzed_data_provider.ConsumeIntegral<NodeId>());
   96|   541k|            },
   97|   541k|            [&] {
   98|   541k|                connman.DisconnectNode(random_netaddr);
   99|   541k|            },
  100|   541k|            [&] {
  101|   541k|                connman.DisconnectNode(random_string);
  102|   541k|            },
  103|   541k|            [&] {
  104|   541k|                connman.DisconnectNode(random_subnet);
  105|   541k|            },
  106|   541k|            [&] {
  107|   541k|                connman.ForEachNode([](auto) {});
  108|   541k|            },
  109|   541k|            [&] {
  110|   541k|                (void)connman.ForNode(fuzzed_data_provider.ConsumeIntegral<NodeId>(), [&](auto) { return fuzzed_data_provider.ConsumeBool(); });
  111|   541k|            },
  112|   541k|            [&] {
  113|   541k|                auto max_addresses = fuzzed_data_provider.ConsumeIntegral<size_t>();
  114|   541k|                auto max_pct = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 100);
  115|   541k|                auto filtered = fuzzed_data_provider.ConsumeBool();
  116|   541k|                (void)connman.GetAddresses(max_addresses, max_pct, /*network=*/std::nullopt, filtered);
  117|   541k|            },
  118|   541k|            [&] {
  119|   541k|                auto max_addresses = fuzzed_data_provider.ConsumeIntegral<size_t>();
  120|   541k|                auto max_pct = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 100);
  121|   541k|                (void)connman.GetAddresses(/*requestor=*/random_node, max_addresses, max_pct);
  122|   541k|            },
  123|   541k|            [&] {
  124|   541k|                (void)connman.GetDeterministicRandomizer(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
  125|   541k|            },
  126|   541k|            [&] {
  127|   541k|                (void)connman.GetNodeCount(fuzzed_data_provider.PickValueInArray({ConnectionDirection::None, ConnectionDirection::In, ConnectionDirection::Out, ConnectionDirection::Both}));
  128|   541k|            },
  129|   541k|            [&] {
  130|   541k|                (void)connman.OutboundTargetReached(fuzzed_data_provider.ConsumeBool());
  131|   541k|            },
  132|   541k|            [&] {
  133|   541k|                CSerializedNetMsg serialized_net_msg;
  134|   541k|                serialized_net_msg.m_type = fuzzed_data_provider.ConsumeRandomLengthString(CMessageHeader::MESSAGE_TYPE_SIZE);
  135|   541k|                serialized_net_msg.data = ConsumeRandomLengthByteVector(fuzzed_data_provider);
  136|   541k|                connman.PushMessage(&random_node, std::move(serialized_net_msg));
  137|   541k|            },
  138|   541k|            [&] {
  139|   541k|                connman.RemoveAddedNode(random_string);
  140|   541k|            },
  141|   541k|            [&] {
  142|   541k|                connman.SetNetworkActive(fuzzed_data_provider.ConsumeBool());
  143|   541k|            },
  144|   541k|            [&] {
  145|   541k|                connman.SetTryNewOutboundPeer(fuzzed_data_provider.ConsumeBool());
  146|   541k|            });
  147|   541k|    }
  148|  7.29k|    (void)connman.GetAddedNodeInfo(fuzzed_data_provider.ConsumeBool());
  149|  7.29k|    (void)connman.GetExtraFullOutboundCount();
  150|  7.29k|    (void)connman.GetLocalServices();
  151|  7.29k|    assert(connman.GetMaxOutboundTarget() == max_outbound_limit);
  152|  7.29k|    (void)connman.GetMaxOutboundTimeframe();
  153|  7.29k|    (void)connman.GetMaxOutboundTimeLeftInCycle();
  154|  7.29k|    (void)connman.GetNetworkActive();
  155|  7.29k|    std::vector<CNodeStats> stats;
  156|  7.29k|    connman.GetNodeStats(stats);
  157|  7.29k|    (void)connman.GetOutboundTargetBytesLeft();
  158|  7.29k|    (void)connman.GetTotalBytesRecv();
  159|  7.29k|    (void)connman.GetTotalBytesSent();
  160|  7.29k|    (void)connman.GetTryNewOutboundPeer();
  161|  7.29k|    (void)connman.GetUseAddrmanOutgoing();
  162|  7.29k|    (void)connman.ASMapHealthCheck();
  163|       |
  164|  7.29k|    connman.ClearTestNodes();
  165|  7.29k|}
connman.cpp:_ZN12_GLOBAL__N_113GetCheckRatioEv:
   25|  9.84k|{
   26|  9.84k|    return std::clamp<int32_t>(g_setup->m_node.args->GetIntArg("-checkaddrman", 0), 0, 1000000);
   27|  9.84k|}
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_2clEv:
   79|  2.51k|            [&] {
   80|  2.51k|                random_netaddr = ConsumeNetAddr(fuzzed_data_provider);
   81|  2.51k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_3clEv:
   82|  43.3k|            [&] {
   83|  43.3k|                random_subnet = ConsumeSubNet(fuzzed_data_provider);
   84|  43.3k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_4clEv:
   85|  16.7k|            [&] {
   86|  16.7k|                random_string = fuzzed_data_provider.ConsumeRandomLengthString(64);
   87|  16.7k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_5clEv:
   88|  78.9k|            [&] {
   89|  78.9k|                connman.AddNode({random_string, fuzzed_data_provider.ConsumeBool()});
   90|  78.9k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_6clEv:
   91|  1.48k|            [&] {
   92|  1.48k|                connman.CheckIncomingNonce(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
   93|  1.48k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_7clEv:
   94|  17.1k|            [&] {
   95|  17.1k|                connman.DisconnectNode(fuzzed_data_provider.ConsumeIntegral<NodeId>());
   96|  17.1k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_8clEv:
   97|  17.7k|            [&] {
   98|  17.7k|                connman.DisconnectNode(random_netaddr);
   99|  17.7k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_9clEv:
  100|  10.8k|            [&] {
  101|  10.8k|                connman.DisconnectNode(random_string);
  102|  10.8k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_10clEv:
  103|  3.82k|            [&] {
  104|  3.82k|                connman.DisconnectNode(random_subnet);
  105|  3.82k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv:
  106|  39.4k|            [&] {
  107|  39.4k|                connman.ForEachNode([](auto) {});
  108|  39.4k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_1clEv:
  109|  2.23k|            [&] {
  110|  2.23k|                (void)connman.ForNode(fuzzed_data_provider.ConsumeIntegral<NodeId>(), [&](auto) { return fuzzed_data_provider.ConsumeBool(); });
  111|  2.23k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_11clEv:
  112|  64.5k|            [&] {
  113|  64.5k|                auto max_addresses = fuzzed_data_provider.ConsumeIntegral<size_t>();
  114|  64.5k|                auto max_pct = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 100);
  115|  64.5k|                auto filtered = fuzzed_data_provider.ConsumeBool();
  116|  64.5k|                (void)connman.GetAddresses(max_addresses, max_pct, /*network=*/std::nullopt, filtered);
  117|  64.5k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_12clEv:
  118|  5.46k|            [&] {
  119|  5.46k|                auto max_addresses = fuzzed_data_provider.ConsumeIntegral<size_t>();
  120|  5.46k|                auto max_pct = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 100);
  121|  5.46k|                (void)connman.GetAddresses(/*requestor=*/random_node, max_addresses, max_pct);
  122|  5.46k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_13clEv:
  123|  2.15k|            [&] {
  124|  2.15k|                (void)connman.GetDeterministicRandomizer(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
  125|  2.15k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_14clEv:
  126|  2.08k|            [&] {
  127|  2.08k|                (void)connman.GetNodeCount(fuzzed_data_provider.PickValueInArray({ConnectionDirection::None, ConnectionDirection::In, ConnectionDirection::Out, ConnectionDirection::Both}));
  128|  2.08k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_15clEv:
  129|  35.7k|            [&] {
  130|  35.7k|                (void)connman.OutboundTargetReached(fuzzed_data_provider.ConsumeBool());
  131|  35.7k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_16clEv:
  132|  79.9k|            [&] {
  133|  79.9k|                CSerializedNetMsg serialized_net_msg;
  134|  79.9k|                serialized_net_msg.m_type = fuzzed_data_provider.ConsumeRandomLengthString(CMessageHeader::MESSAGE_TYPE_SIZE);
  135|  79.9k|                serialized_net_msg.data = ConsumeRandomLengthByteVector(fuzzed_data_provider);
  136|  79.9k|                connman.PushMessage(&random_node, std::move(serialized_net_msg));
  137|  79.9k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_17clEv:
  138|  70.6k|            [&] {
  139|  70.6k|                connman.RemoveAddedNode(random_string);
  140|  70.6k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_18clEv:
  141|  4.38k|            [&] {
  142|  4.38k|                connman.SetNetworkActive(fuzzed_data_provider.ConsumeBool());
  143|  4.38k|            },
connman.cpp:_ZZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_19clEv:
  144|  42.1k|            [&] {
  145|  42.1k|                connman.SetTryNewOutboundPeer(fuzzed_data_provider.ConsumeBool());
  146|  42.1k|            });

LLVMFuzzerTestOneInput:
  222|  7.29k|{
  223|  7.29k|    test_one_input({data, size});
  224|  7.29k|    return 0;
  225|  7.29k|}
fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE:
   83|  7.29k|{
   84|  7.29k|    CheckGlobals check{};
   85|  7.29k|    (*Assert(g_test_one_input))(buffer);
  ------------------
  |  |   85|  7.29k|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
   86|  7.29k|}
fuzz.cpp:_ZZL10initializevENK3$_1clERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEb:
  127|   169k|    g_dns_lookup = [](const std::string& name, bool allow_lookup) {
  128|   169k|        if (allow_lookup) {
  ------------------
  |  Branch (128:13): [True: 0, False: 169k]
  ------------------
  129|      0|            std::terminate();
  130|      0|        }
  131|   169k|        return WrappedGetAddrInfo(name, false);
  132|   169k|    };

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

_Z28ConsumeRandomLengthBitVectorR18FuzzedDataProviderRKNSt3__18optionalImEE:
   69|  7.29k|{
   70|  7.29k|    return BytesToBits(ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length));
   71|  7.29k|}
_Z14ConsumeUInt256R18FuzzedDataProvider:
  172|  9.84k|{
  173|  9.84k|    const std::vector<uint8_t> v256 = fuzzed_data_provider.ConsumeBytes<uint8_t>(256 / 8);
  174|  9.84k|    if (v256.size() != 256 / 8) {
  ------------------
  |  Branch (174:9): [True: 2.27k, False: 7.56k]
  ------------------
  175|  2.27k|        return {};
  176|  2.27k|    }
  177|  7.56k|    return uint256{v256};
  178|  9.84k|}
_Z29ConsumeRandomLengthByteVectorIhENSt3__16vectorIT_NS0_9allocatorIS2_EEEER18FuzzedDataProviderRKNS0_8optionalImEE:
   58|  91.0k|{
   59|  91.0k|    static_assert(sizeof(B) == 1);
   60|  91.0k|    const std::string s = max_length ?
  ------------------
  |  Branch (60:27): [True: 0, False: 91.0k]
  ------------------
   61|      0|                              fuzzed_data_provider.ConsumeRandomLengthString(*max_length) :
   62|  91.0k|                              fuzzed_data_provider.ConsumeRandomLengthString();
   63|  91.0k|    std::vector<B> ret(s.size());
   64|  91.0k|    std::copy(s.begin(), s.end(), reinterpret_cast<char*>(ret.data()));
   65|  91.0k|    return ret;
   66|  91.0k|}
_Z15ConsumeWeakEnumI12ServiceFlagsLm7EET_R18FuzzedDataProviderRAT0__KS1_:
  134|  50.3k|{
  135|  50.3k|    return fuzzed_data_provider.ConsumeBool() ?
  ------------------
  |  Branch (135:12): [True: 36.8k, False: 13.5k]
  ------------------
  136|  36.8k|               fuzzed_data_provider.PickValueInArray<WeakEnumType>(all_types) :
  137|  50.3k|               WeakEnumType(fuzzed_data_provider.ConsumeIntegral<typename std::underlying_type<WeakEnumType>::type>());
  138|  50.3k|}
_Z15ConsumeWeakEnumI18NetPermissionFlagsLm10EET_R18FuzzedDataProviderRAT0__KS1_:
  134|  25.1k|{
  135|  25.1k|    return fuzzed_data_provider.ConsumeBool() ?
  ------------------
  |  Branch (135:12): [True: 17.1k, False: 8.04k]
  ------------------
  136|  17.1k|               fuzzed_data_provider.PickValueInArray<WeakEnumType>(all_types) :
  137|  25.1k|               WeakEnumType(fuzzed_data_provider.ConsumeIntegral<typename std::underlying_type<WeakEnumType>::type>());
  138|  25.1k|}
connman.cpp:_Z9CallOneOfIJZ19connman_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEE3$_2Z19connman_fuzz_targetS3_E3$_3Z19connman_fuzz_targetS3_E3$_4Z19connman_fuzz_targetS3_E3$_5Z19connman_fuzz_targetS3_E3$_6Z19connman_fuzz_targetS3_E3$_7Z19connman_fuzz_targetS3_E3$_8Z19connman_fuzz_targetS3_E3$_9Z19connman_fuzz_targetS3_E4$_10Z19connman_fuzz_targetS3_E3$_0Z19connman_fuzz_targetS3_E3$_1Z19connman_fuzz_targetS3_E4$_11Z19connman_fuzz_targetS3_E4$_12Z19connman_fuzz_targetS3_E4$_13Z19connman_fuzz_targetS3_E4$_14Z19connman_fuzz_targetS3_E4$_15Z19connman_fuzz_targetS3_E4$_16Z19connman_fuzz_targetS3_E4$_17Z19connman_fuzz_targetS3_E4$_18Z19connman_fuzz_targetS3_E4$_19EEmR18FuzzedDataProviderDpT_:
   36|   541k|{
   37|   541k|    constexpr size_t call_size{sizeof...(callables)};
   38|   541k|    static_assert(call_size >= 1);
   39|   541k|    const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
   40|       |
   41|   541k|    size_t i{0};
   42|  10.8M|    ((i++ == call_index ? callables() : void()), ...);
  ------------------
  |  Branch (42:7): [True: 2.51k, False: 539k]
  |  Branch (42:7): [True: 43.3k, False: 498k]
  |  Branch (42:7): [True: 16.7k, False: 524k]
  |  Branch (42:7): [True: 78.9k, False: 462k]
  |  Branch (42:7): [True: 1.48k, False: 540k]
  |  Branch (42:7): [True: 17.1k, False: 524k]
  |  Branch (42:7): [True: 17.7k, False: 523k]
  |  Branch (42:7): [True: 10.8k, False: 530k]
  |  Branch (42:7): [True: 3.82k, False: 537k]
  |  Branch (42:7): [True: 39.4k, False: 502k]
  |  Branch (42:7): [True: 2.23k, False: 539k]
  |  Branch (42:7): [True: 64.5k, False: 477k]
  |  Branch (42:7): [True: 5.46k, False: 536k]
  |  Branch (42:7): [True: 2.15k, False: 539k]
  |  Branch (42:7): [True: 2.08k, False: 539k]
  |  Branch (42:7): [True: 35.7k, False: 505k]
  |  Branch (42:7): [True: 79.9k, False: 461k]
  |  Branch (42:7): [True: 70.6k, False: 470k]
  |  Branch (42:7): [True: 4.38k, False: 537k]
  |  Branch (42:7): [True: 42.1k, False: 499k]
  ------------------
   43|   541k|    return call_size;
   44|   541k|}
_Z14SetFuzzedErrNoIiLm18EEvR18FuzzedDataProviderRKNSt3__15arrayIT_XT0_EEE:
  237|    236|{
  238|    236|    errno = fuzzed_data_provider.PickValueInArray(errnos);
  239|    236|}

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

_Z14ConsumeNetAddrR18FuzzedDataProviderP17FastRandomContext:
   29|  96.2k|{
   30|  96.2k|    struct NetAux {
   31|  96.2k|        Network net;
   32|  96.2k|        CNetAddr::BIP155Network bip155;
   33|  96.2k|        size_t len;
   34|  96.2k|    };
   35|       |
   36|  96.2k|    static constexpr std::array<NetAux, 6> nets{
   37|  96.2k|        NetAux{.net = Network::NET_IPV4, .bip155 = CNetAddr::BIP155Network::IPV4, .len = ADDR_IPV4_SIZE},
   38|  96.2k|        NetAux{.net = Network::NET_IPV6, .bip155 = CNetAddr::BIP155Network::IPV6, .len = ADDR_IPV6_SIZE},
   39|  96.2k|        NetAux{.net = Network::NET_ONION, .bip155 = CNetAddr::BIP155Network::TORV3, .len = ADDR_TORV3_SIZE},
   40|  96.2k|        NetAux{.net = Network::NET_I2P, .bip155 = CNetAddr::BIP155Network::I2P, .len = ADDR_I2P_SIZE},
   41|  96.2k|        NetAux{.net = Network::NET_CJDNS, .bip155 = CNetAddr::BIP155Network::CJDNS, .len = ADDR_CJDNS_SIZE},
   42|  96.2k|        NetAux{.net = Network::NET_INTERNAL, .bip155 = CNetAddr::BIP155Network{0}, .len = 0},
   43|  96.2k|    };
   44|       |
   45|  96.2k|    const size_t nets_index{rand == nullptr
  ------------------
  |  Branch (45:29): [True: 96.2k, False: 0]
  ------------------
   46|  96.2k|        ? fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, nets.size() - 1)
   47|  96.2k|        : static_cast<size_t>(rand->randrange(nets.size()))};
   48|       |
   49|  96.2k|    const auto& aux = nets[nets_index];
   50|       |
   51|  96.2k|    CNetAddr addr;
   52|       |
   53|  96.2k|    if (aux.net == Network::NET_INTERNAL) {
  ------------------
  |  Branch (53:9): [True: 3.45k, False: 92.7k]
  ------------------
   54|  3.45k|        if (rand == nullptr) {
  ------------------
  |  Branch (54:13): [True: 3.45k, False: 0]
  ------------------
   55|  3.45k|            addr.SetInternal(fuzzed_data_provider.ConsumeBytesAsString(32));
   56|  3.45k|        } else {
   57|      0|            const auto v = rand->randbytes(32);
   58|      0|            addr.SetInternal(std::string{v.begin(), v.end()});
   59|      0|        }
   60|  3.45k|        return addr;
   61|  3.45k|    }
   62|       |
   63|  92.7k|    DataStream s;
   64|       |
   65|  92.7k|    s << static_cast<uint8_t>(aux.bip155);
   66|       |
   67|  92.7k|    std::vector<uint8_t> addr_bytes;
   68|  92.7k|    if (rand == nullptr) {
  ------------------
  |  Branch (68:9): [True: 92.7k, False: 0]
  ------------------
   69|  92.7k|        addr_bytes = fuzzed_data_provider.ConsumeBytes<uint8_t>(aux.len);
   70|  92.7k|        addr_bytes.resize(aux.len);
   71|  92.7k|    } else {
   72|      0|        addr_bytes = rand->randbytes(aux.len);
   73|      0|    }
   74|  92.7k|    if (aux.net == NET_IPV6 && addr_bytes[0] == CJDNS_PREFIX) { // Avoid generating IPv6 addresses that look like CJDNS.
  ------------------
  |  Branch (74:9): [True: 33.2k, False: 59.4k]
  |  Branch (74:32): [True: 230, False: 33.0k]
  ------------------
   75|    230|        addr_bytes[0] = 0x55; // Just an arbitrary number, anything != CJDNS_PREFIX would do.
   76|    230|    }
   77|  92.7k|    if (aux.net == NET_CJDNS) { // Avoid generating CJDNS addresses that don't start with CJDNS_PREFIX because those are !IsValid().
  ------------------
  |  Branch (77:9): [True: 6.30k, False: 86.4k]
  ------------------
   78|  6.30k|        addr_bytes[0] = CJDNS_PREFIX;
   79|  6.30k|    }
   80|  92.7k|    s << addr_bytes;
   81|       |
   82|  92.7k|    s >> CAddress::V2_NETWORK(addr);
   83|       |
   84|  92.7k|    return addr;
   85|  96.2k|}
_Z14ConsumeAddressR18FuzzedDataProvider:
   88|  50.3k|{
   89|  50.3k|    return {ConsumeService(fuzzed_data_provider), ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS), NodeSeconds{std::chrono::seconds{fuzzed_data_provider.ConsumeIntegral<uint32_t>()}}};
   90|  50.3k|}
_ZN10FuzzedSockC2ER18FuzzedDataProvider:
  114|  25.1k|    : Sock{fuzzed_data_provider.ConsumeIntegralInRange<SOCKET>(INVALID_SOCKET - 1, INVALID_SOCKET)},
  ------------------
  |  |   56|  25.1k|#define INVALID_SOCKET      (SOCKET)(~0)
  ------------------
                  : Sock{fuzzed_data_provider.ConsumeIntegralInRange<SOCKET>(INVALID_SOCKET - 1, INVALID_SOCKET)},
  ------------------
  |  |   56|  25.1k|#define INVALID_SOCKET      (SOCKET)(~0)
  ------------------
  115|  25.1k|      m_fuzzed_data_provider{fuzzed_data_provider},
  116|  25.1k|      m_selectable{fuzzed_data_provider.ConsumeBool()}
  117|  25.1k|{
  118|  25.1k|}
_ZN10FuzzedSockD2Ev:
  121|  25.1k|{
  122|       |    // Sock::~Sock() will be called after FuzzedSock::~FuzzedSock() and it will call
  123|       |    // close(m_socket) if m_socket is not INVALID_SOCKET.
  124|       |    // Avoid closing an arbitrary file descriptor (m_socket is just a random very high number which
  125|       |    // theoretically may concide with a real opened file descriptor).
  126|  25.1k|    m_socket = INVALID_SOCKET;
  ------------------
  |  |   56|  25.1k|#define INVALID_SOCKET      (SOCKET)(~0)
  ------------------
  127|  25.1k|}
_ZNK10FuzzedSock4SendEPKvmi:
  136|  81.1k|{
  137|  81.1k|    constexpr std::array send_errnos{
  138|  81.1k|        EACCES,
  139|  81.1k|        EAGAIN,
  140|  81.1k|        EALREADY,
  141|  81.1k|        EBADF,
  142|  81.1k|        ECONNRESET,
  143|  81.1k|        EDESTADDRREQ,
  144|  81.1k|        EFAULT,
  145|  81.1k|        EINTR,
  146|  81.1k|        EINVAL,
  147|  81.1k|        EISCONN,
  148|  81.1k|        EMSGSIZE,
  149|  81.1k|        ENOBUFS,
  150|  81.1k|        ENOMEM,
  151|  81.1k|        ENOTCONN,
  152|  81.1k|        ENOTSOCK,
  153|  81.1k|        EOPNOTSUPP,
  154|  81.1k|        EPIPE,
  155|  81.1k|        EWOULDBLOCK,
  156|  81.1k|    };
  157|  81.1k|    if (m_fuzzed_data_provider.ConsumeBool()) {
  ------------------
  |  Branch (157:9): [True: 80.6k, False: 537]
  ------------------
  158|  80.6k|        return len;
  159|  80.6k|    }
  160|    537|    const ssize_t r = m_fuzzed_data_provider.ConsumeIntegralInRange<ssize_t>(-1, len);
  161|    537|    if (r == -1) {
  ------------------
  |  Branch (161:9): [True: 236, False: 301]
  ------------------
  162|    236|        SetFuzzedErrNo(m_fuzzed_data_provider, send_errnos);
  163|    236|    }
  164|    537|    return r;
  165|  81.1k|}

_Z22ConsumeNetGroupManagerR18FuzzedDataProvider:
  202|  7.29k|{
  203|  7.29k|    std::vector<bool> asmap = ConsumeRandomLengthBitVector(fuzzed_data_provider);
  204|  7.29k|    if (!SanityCheckASMap(asmap, 128)) asmap.clear();
  ------------------
  |  Branch (204:9): [True: 6.42k, False: 872]
  ------------------
  205|  7.29k|    return NetGroupManager(asmap);
  206|  7.29k|}
_ZN20AddrManDeterministicC2ERK15NetGroupManagerR18FuzzedDataProvideri:
   44|  9.84k|        : AddrMan(netgroupman, /*deterministic=*/true, check_ratio)
   45|  9.84k|    {
   46|  9.84k|        WITH_LOCK(m_impl->cs, m_impl->insecure_rand.Reseed(ConsumeUInt256(fuzzed_data_provider)));
  ------------------
  |  |  301|  9.84k|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }())
  ------------------
   47|  9.84k|    }
_Z14ConsumeServiceR18FuzzedDataProvider:
  214|  50.3k|{
  215|  50.3k|    return {ConsumeNetAddr(fuzzed_data_provider), fuzzed_data_provider.ConsumeIntegral<uint16_t>()};
  216|  50.3k|}
_Z13ConsumeSubNetR18FuzzedDataProvider:
  209|  43.3k|{
  210|  43.3k|    return {ConsumeNetAddr(fuzzed_data_provider), fuzzed_data_provider.ConsumeIntegral<uint8_t>()};
  211|  43.3k|}
_Z11ConsumeNodeILb1EEDaR18FuzzedDataProviderRKNSt3__18optionalIlEE:
  222|  17.8k|{
  223|  17.8k|    const NodeId node_id = node_id_in.value_or(fuzzed_data_provider.ConsumeIntegralInRange<NodeId>(0, std::numeric_limits<NodeId>::max()));
  224|  17.8k|    const auto sock = std::make_shared<FuzzedSock>(fuzzed_data_provider);
  225|  17.8k|    const CAddress address = ConsumeAddress(fuzzed_data_provider);
  226|  17.8k|    const uint64_t keyed_net_group = fuzzed_data_provider.ConsumeIntegral<uint64_t>();
  227|  17.8k|    const uint64_t local_host_nonce = fuzzed_data_provider.ConsumeIntegral<uint64_t>();
  228|  17.8k|    const CAddress addr_bind = ConsumeAddress(fuzzed_data_provider);
  229|  17.8k|    const std::string addr_name = fuzzed_data_provider.ConsumeRandomLengthString(64);
  230|  17.8k|    const ConnectionType conn_type = fuzzed_data_provider.PickValueInArray(ALL_CONNECTION_TYPES);
  231|  17.8k|    const bool inbound_onion{conn_type == ConnectionType::INBOUND ? fuzzed_data_provider.ConsumeBool() : false};
  ------------------
  |  Branch (231:30): [True: 2.09k, False: 15.7k]
  ------------------
  232|  17.8k|    NetPermissionFlags permission_flags = ConsumeWeakEnum(fuzzed_data_provider, ALL_NET_PERMISSION_FLAGS);
  233|  17.8k|    if constexpr (ReturnUniquePtr) {
  234|  17.8k|        return std::make_unique<CNode>(node_id,
  235|  17.8k|                                       sock,
  236|  17.8k|                                       address,
  237|  17.8k|                                       keyed_net_group,
  238|  17.8k|                                       local_host_nonce,
  239|  17.8k|                                       addr_bind,
  240|  17.8k|                                       addr_name,
  241|  17.8k|                                       conn_type,
  242|  17.8k|                                       inbound_onion,
  243|  17.8k|                                       CNodeOptions{ .permission_flags = permission_flags });
  244|       |    } else {
  245|       |        return CNode{node_id,
  246|       |                     sock,
  247|       |                     address,
  248|       |                     keyed_net_group,
  249|       |                     local_host_nonce,
  250|       |                     addr_bind,
  251|       |                     addr_name,
  252|       |                     conn_type,
  253|       |                     inbound_onion,
  254|       |                     CNodeOptions{ .permission_flags = permission_flags }};
  255|       |    }
  256|  17.8k|}
_Z22ConsumeNodeAsUniquePtrR18FuzzedDataProviderRKNSt3__18optionalIlEE:
  257|  17.8k|inline std::unique_ptr<CNode> ConsumeNodeAsUniquePtr(FuzzedDataProvider& fdp, const std::optional<NodeId>& node_id_in = std::nullopt) { return ConsumeNode<true>(fdp, node_id_in); }
_Z11ConsumeNodeILb0EEDaR18FuzzedDataProviderRKNSt3__18optionalIlEE:
  222|  7.29k|{
  223|  7.29k|    const NodeId node_id = node_id_in.value_or(fuzzed_data_provider.ConsumeIntegralInRange<NodeId>(0, std::numeric_limits<NodeId>::max()));
  224|  7.29k|    const auto sock = std::make_shared<FuzzedSock>(fuzzed_data_provider);
  225|  7.29k|    const CAddress address = ConsumeAddress(fuzzed_data_provider);
  226|  7.29k|    const uint64_t keyed_net_group = fuzzed_data_provider.ConsumeIntegral<uint64_t>();
  227|  7.29k|    const uint64_t local_host_nonce = fuzzed_data_provider.ConsumeIntegral<uint64_t>();
  228|  7.29k|    const CAddress addr_bind = ConsumeAddress(fuzzed_data_provider);
  229|  7.29k|    const std::string addr_name = fuzzed_data_provider.ConsumeRandomLengthString(64);
  230|  7.29k|    const ConnectionType conn_type = fuzzed_data_provider.PickValueInArray(ALL_CONNECTION_TYPES);
  231|  7.29k|    const bool inbound_onion{conn_type == ConnectionType::INBOUND ? fuzzed_data_provider.ConsumeBool() : false};
  ------------------
  |  Branch (231:30): [True: 4.33k, False: 2.96k]
  ------------------
  232|  7.29k|    NetPermissionFlags permission_flags = ConsumeWeakEnum(fuzzed_data_provider, ALL_NET_PERMISSION_FLAGS);
  233|       |    if constexpr (ReturnUniquePtr) {
  234|       |        return std::make_unique<CNode>(node_id,
  235|       |                                       sock,
  236|       |                                       address,
  237|       |                                       keyed_net_group,
  238|       |                                       local_host_nonce,
  239|       |                                       addr_bind,
  240|       |                                       addr_name,
  241|       |                                       conn_type,
  242|       |                                       inbound_onion,
  243|       |                                       CNodeOptions{ .permission_flags = permission_flags });
  244|  7.29k|    } else {
  245|  7.29k|        return CNode{node_id,
  246|  7.29k|                     sock,
  247|  7.29k|                     address,
  248|  7.29k|                     keyed_net_group,
  249|  7.29k|                     local_host_nonce,
  250|  7.29k|                     addr_bind,
  251|  7.29k|                     addr_name,
  252|  7.29k|                     conn_type,
  253|  7.29k|                     inbound_onion,
  254|  7.29k|                     CNodeOptions{ .permission_flags = permission_flags }};
  255|  7.29k|    }
  256|  7.29k|}

_ZN14ConnmanTestMsg11AddTestNodeER5CNode:
   55|  17.8k|    {
   56|  17.8k|        LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  17.8k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  17.8k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  17.8k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  17.8k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   57|  17.8k|        m_nodes.push_back(&node);
   58|       |
   59|  17.8k|        if (node.IsManualOrFullOutboundConn()) ++m_network_conn_counts[node.addr.GetNetwork()];
  ------------------
  |  Branch (59:13): [True: 6.38k, False: 11.4k]
  ------------------
   60|  17.8k|    }
_ZN14ConnmanTestMsg14ClearTestNodesEv:
   63|  7.29k|    {
   64|  7.29k|        LOCK(m_nodes_mutex);
  ------------------
  |  |  257|  7.29k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  7.29k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  7.29k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  7.29k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   65|  17.8k|        for (CNode* node : m_nodes) {
  ------------------
  |  Branch (65:26): [True: 17.8k, False: 7.29k]
  ------------------
   66|  17.8k|            delete node;
   67|  17.8k|        }
   68|  7.29k|        m_nodes.clear();
   69|  7.29k|    }

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

_ZN17BasicTestingSetupD2Ev:
  199|      2|{
  200|      2|    m_node.ecc_context.reset();
  201|      2|    m_node.kernel.reset();
  202|       |    if constexpr (!G_FUZZING) {
  203|       |        SetMockTime(0s); // Reset mocktime for following tests
  204|       |    }
  205|      2|    LogInstance().DisconnectTestLogger();
  206|      2|    if (m_has_custom_datadir) {
  ------------------
  |  Branch (206:9): [True: 0, False: 2]
  ------------------
  207|       |        // Only remove the lock file, preserve the data directory.
  208|      0|        UnlockDirectory(m_path_lock, ".lock");
  209|      0|        fs::remove(m_path_lock / ".lock");
  210|      2|    } else {
  211|      2|        fs::remove_all(m_path_root);
  212|      2|    }
  213|      2|    gArgs.ClearArgs();
  214|      2|}
_ZN17ChainTestingSetupD2Ev:
  267|      2|{
  268|      2|    if (m_node.scheduler) m_node.scheduler->stop();
  ------------------
  |  Branch (268:9): [True: 2, False: 0]
  ------------------
  269|      2|    if (m_node.validation_signals) m_node.validation_signals->FlushBackgroundCallbacks();
  ------------------
  |  Branch (269:9): [True: 2, False: 0]
  ------------------
  270|      2|    m_node.connman.reset();
  271|      2|    m_node.banman.reset();
  272|      2|    m_node.addrman.reset();
  273|      2|    m_node.netgroupman.reset();
  274|      2|    m_node.args = nullptr;
  275|      2|    m_node.mempool.reset();
  276|      2|    Assert(!m_node.fee_estimator); // Each test must create a local object, if they wish to use the fee_estimator
  ------------------
  |  |   85|      2|#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
  ------------------
  277|      2|    m_node.chainman.reset();
  278|      2|    m_node.validation_signals.reset();
  279|      2|    m_node.scheduler.reset();
  280|      2|}

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

_ZNK10tinyformat6detail9FormatArg6formatERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_i:
  541|  77.2k|        {
  542|  77.2k|            TINYFORMAT_ASSERT(m_value);
  ------------------
  |  |  153|  77.2k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  543|  77.2k|            TINYFORMAT_ASSERT(m_formatImpl);
  ------------------
  |  |  153|  77.2k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  544|  77.2k|            m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
  545|  77.2k|        }
_ZN10tinyformat10FormatListC2EPNS_6detail9FormatArgEi:
  966|  35.7k|            : m_args(args), m_N(N) { }
_ZN10tinyformat11formatValueERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcS7_ih:
  385|  30.2k|                        const char* fmtEnd, int /**/, charType value) \
  386|  30.2k|{                                                                     \
  387|  30.2k|    switch (*(fmtEnd-1)) {                                            \
  388|  30.2k|        case 'u': case 'd': case 'i': case 'o': case 'X': case 'x':   \
  ------------------
  |  Branch (388:9): [True: 30.2k, False: 0]
  |  Branch (388:19): [True: 0, False: 30.2k]
  |  Branch (388:29): [True: 0, False: 30.2k]
  |  Branch (388:39): [True: 0, False: 30.2k]
  |  Branch (388:49): [True: 0, False: 30.2k]
  |  Branch (388:59): [True: 0, False: 30.2k]
  ------------------
  389|  30.2k|            out << static_cast<int>(value); break;                    \
  390|  30.2k|        default:                                                      \
  ------------------
  |  Branch (390:9): [True: 0, False: 30.2k]
  ------------------
  391|      0|            out << value;                   break;                    \
  392|  30.2k|    }                                                                 \
  393|  30.2k|}
_ZN10tinyformat6detail18parseIntAndAdvanceERPKc:
  578|  1.47k|{
  579|  1.47k|    int i = 0;
  580|  2.95k|    for (;*c >= '0' && *c <= '9'; ++c)
  ------------------
  |  Branch (580:11): [True: 2.95k, False: 0]
  |  Branch (580:24): [True: 1.47k, False: 1.47k]
  ------------------
  581|  1.47k|        i = 10*i + (*c - '0');
  582|  1.47k|    return i;
  583|  1.47k|}
_ZN10tinyformat6detail21parseWidthOrPrecisionERiRPKcbPKNS0_9FormatArgES1_i:
  593|  78.7k|{
  594|  78.7k|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (594:9): [True: 77.2k, False: 1.47k]
  |  Branch (594:22): [True: 1.47k, False: 75.8k]
  ------------------
  595|  1.47k|        n = parseIntAndAdvance(c);
  596|  1.47k|    }
  597|  77.2k|    else if (*c == '*') {
  ------------------
  |  Branch (597:14): [True: 0, False: 77.2k]
  ------------------
  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|  77.2k|    else {
  618|  77.2k|        return false;
  619|  77.2k|    }
  620|  1.47k|    return true;
  621|  78.7k|}
_ZN10tinyformat6detail24printFormatStringLiteralERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKc:
  629|   113k|{
  630|   113k|    const char* c = fmt;
  631|   273k|    for (;; ++c) {
  632|   273k|        if (*c == '\0') {
  ------------------
  |  Branch (632:13): [True: 35.7k, False: 238k]
  ------------------
  633|  35.7k|            out.write(fmt, c - fmt);
  634|  35.7k|            return c;
  635|  35.7k|        }
  636|   238k|        else if (*c == '%') {
  ------------------
  |  Branch (636:18): [True: 77.2k, False: 160k]
  ------------------
  637|  77.2k|            out.write(fmt, c - fmt);
  638|  77.2k|            if (*(c+1) != '%')
  ------------------
  |  Branch (638:17): [True: 77.2k, False: 0]
  ------------------
  639|  77.2k|                return c;
  640|       |            // for "%%", tack trailing % onto next literal section.
  641|      0|            fmt = ++c;
  642|      0|        }
  643|   273k|    }
  644|   113k|}
_ZN10tinyformat6detail21streamStateFromFormatERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERbS7_RiPKcPKNS0_9FormatArgES8_i:
  685|  77.2k|{
  686|  77.2k|    TINYFORMAT_ASSERT(*fmtStart == '%');
  ------------------
  |  |  153|  77.2k|#   define TINYFORMAT_ASSERT(cond) assert(cond)
  ------------------
  687|       |    // Reset stream state to defaults.
  688|  77.2k|    out.width(0);
  689|  77.2k|    out.precision(6);
  690|  77.2k|    out.fill(' ');
  691|       |    // Reset most flags; ignore irrelevant unitbuf & skipws.
  692|  77.2k|    out.unsetf(std::ios::adjustfield | std::ios::basefield |
  693|  77.2k|               std::ios::floatfield | std::ios::showbase | std::ios::boolalpha |
  694|  77.2k|               std::ios::showpoint | std::ios::showpos | std::ios::uppercase);
  695|  77.2k|    bool precisionSet = false;
  696|  77.2k|    bool widthSet = false;
  697|  77.2k|    int widthExtra = 0;
  698|  77.2k|    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|  77.2k|    if (*c >= '0' && *c <= '9') {
  ------------------
  |  Branch (702:9): [True: 75.8k, False: 1.47k]
  |  Branch (702:22): [True: 0, False: 75.8k]
  ------------------
  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|  77.2k|    else if (positionalMode) {
  ------------------
  |  Branch (731:14): [True: 0, False: 77.2k]
  ------------------
  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|  77.2k|    if (!widthSet) {
  ------------------
  |  Branch (735:9): [True: 77.2k, False: 0]
  ------------------
  736|       |        // Parse flags
  737|  77.2k|        for (;; ++c) {
  738|  77.2k|            switch (*c) {
  739|      0|                case '#':
  ------------------
  |  Branch (739:17): [True: 0, False: 77.2k]
  ------------------
  740|      0|                    out.setf(std::ios::showpoint | std::ios::showbase);
  741|      0|                    continue;
  742|      0|                case '0':
  ------------------
  |  Branch (742:17): [True: 0, False: 77.2k]
  ------------------
  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: 77.2k]
  ------------------
  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: 77.2k]
  ------------------
  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: 77.2k]
  ------------------
  761|      0|                    out.setf(std::ios::showpos);
  762|      0|                    spacePadPositive = false;
  763|      0|                    widthExtra = 1;
  764|      0|                    continue;
  765|  77.2k|                default:
  ------------------
  |  Branch (765:17): [True: 77.2k, False: 0]
  ------------------
  766|  77.2k|                    break;
  767|  77.2k|            }
  768|  77.2k|            break;
  769|  77.2k|        }
  770|       |        // Parse width
  771|  77.2k|        int width = 0;
  772|  77.2k|        widthSet = parseWidthOrPrecision(width, c, positionalMode,
  773|  77.2k|                                         args, argIndex, numArgs);
  774|  77.2k|        if (widthSet) {
  ------------------
  |  Branch (774:13): [True: 0, False: 77.2k]
  ------------------
  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|  77.2k|    }
  784|       |    // 3) Parse precision
  785|  77.2k|    if (*c == '.') {
  ------------------
  |  Branch (785:9): [True: 1.47k, False: 75.8k]
  ------------------
  786|  1.47k|        ++c;
  787|  1.47k|        int precision = 0;
  788|  1.47k|        parseWidthOrPrecision(precision, c, positionalMode,
  789|  1.47k|                              args, argIndex, numArgs);
  790|       |        // Presence of `.` indicates precision set, unless the inferred value
  791|       |        // was negative in which case the default is used.
  792|  1.47k|        precisionSet = precision >= 0;
  793|  1.47k|        if (precisionSet)
  ------------------
  |  Branch (793:13): [True: 1.47k, False: 0]
  ------------------
  794|  1.47k|            out.precision(precision);
  795|  1.47k|    }
  796|       |    // 4) Ignore any C99 length modifier
  797|  77.2k|    while (*c == 'l' || *c == 'h' || *c == 'L' ||
  ------------------
  |  Branch (797:12): [True: 0, False: 77.2k]
  |  Branch (797:25): [True: 0, False: 77.2k]
  |  Branch (797:38): [True: 0, False: 77.2k]
  ------------------
  798|  77.2k|           *c == 'j' || *c == 'z' || *c == 't') {
  ------------------
  |  Branch (798:12): [True: 0, False: 77.2k]
  |  Branch (798:25): [True: 0, False: 77.2k]
  |  Branch (798:38): [True: 0, False: 77.2k]
  ------------------
  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|  77.2k|    bool intConversion = false;
  805|  77.2k|    switch (*c) {
  806|  45.6k|        case 'u': case 'd': case 'i':
  ------------------
  |  Branch (806:9): [True: 42.5k, False: 34.7k]
  |  Branch (806:19): [True: 230, False: 77.0k]
  |  Branch (806:29): [True: 2.95k, False: 74.3k]
  ------------------
  807|  45.6k|            out.setf(std::ios::dec, std::ios::basefield);
  808|  45.6k|            intConversion = true;
  809|  45.6k|            break;
  810|      0|        case 'o':
  ------------------
  |  Branch (810:9): [True: 0, False: 77.2k]
  ------------------
  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: 77.2k]
  ------------------
  815|      0|            out.setf(std::ios::uppercase);
  816|      0|            [[fallthrough]];
  817|  11.0k|        case 'x': case 'p':
  ------------------
  |  Branch (817:9): [True: 11.0k, False: 66.2k]
  |  Branch (817:19): [True: 0, False: 77.2k]
  ------------------
  818|  11.0k|            out.setf(std::ios::hex, std::ios::basefield);
  819|  11.0k|            intConversion = true;
  820|  11.0k|            break;
  821|      0|        case 'E':
  ------------------
  |  Branch (821:9): [True: 0, False: 77.2k]
  ------------------
  822|      0|            out.setf(std::ios::uppercase);
  823|      0|            [[fallthrough]];
  824|      0|        case 'e':
  ------------------
  |  Branch (824:9): [True: 0, False: 77.2k]
  ------------------
  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: 77.2k]
  ------------------
  829|      0|            out.setf(std::ios::uppercase);
  830|      0|            [[fallthrough]];
  831|  1.47k|        case 'f':
  ------------------
  |  Branch (831:9): [True: 1.47k, False: 75.8k]
  ------------------
  832|  1.47k|            out.setf(std::ios::fixed, std::ios::floatfield);
  833|  1.47k|            break;
  834|      0|        case 'A':
  ------------------
  |  Branch (834:9): [True: 0, False: 77.2k]
  ------------------
  835|      0|            out.setf(std::ios::uppercase);
  836|      0|            [[fallthrough]];
  837|      0|        case 'a':
  ------------------
  |  Branch (837:9): [True: 0, False: 77.2k]
  ------------------
  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: 77.2k]
  ------------------
  847|      0|            out.setf(std::ios::uppercase);
  848|      0|            [[fallthrough]];
  849|      0|        case 'g':
  ------------------
  |  Branch (849:9): [True: 0, False: 77.2k]
  ------------------
  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: 77.2k]
  ------------------
  855|       |            // Handled as special case inside formatValue()
  856|      0|            break;
  857|  19.0k|        case 's':
  ------------------
  |  Branch (857:9): [True: 19.0k, False: 58.2k]
  ------------------
  858|  19.0k|            if (precisionSet)
  ------------------
  |  Branch (858:17): [True: 0, False: 19.0k]
  ------------------
  859|      0|                ntrunc = static_cast<int>(out.precision());
  860|       |            // Make %s print Booleans as "true" and "false"
  861|  19.0k|            out.setf(std::ios::boolalpha);
  862|  19.0k|            break;
  863|      0|        case 'n':
  ------------------
  |  Branch (863:9): [True: 0, False: 77.2k]
  ------------------
  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: 77.2k]
  ------------------
  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: 77.2k]
  ------------------
  872|      0|            break;
  873|  77.2k|    }
  874|  77.2k|    if (intConversion && precisionSet && !widthSet) {
  ------------------
  |  Branch (874:9): [True: 56.7k, False: 20.5k]
  |  Branch (874:26): [True: 0, False: 56.7k]
  |  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|  77.2k|    return c+1;
  884|  77.2k|}
_ZN10tinyformat6detail10formatImplERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcPKNS0_9FormatArgEi:
  891|  35.7k|{
  892|       |    // Saved stream state
  893|  35.7k|    std::streamsize origWidth = out.width();
  894|  35.7k|    std::streamsize origPrecision = out.precision();
  895|  35.7k|    std::ios::fmtflags origFlags = out.flags();
  896|  35.7k|    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|  35.7k|    bool positionalMode = false;
  901|  35.7k|    int argIndex = 0;
  902|   113k|    while (true) {
  ------------------
  |  Branch (902:12): [Folded - Ignored]
  ------------------
  903|   113k|        fmt = printFormatStringLiteral(out, fmt);
  904|   113k|        if (*fmt == '\0') {
  ------------------
  |  Branch (904:13): [True: 35.7k, False: 77.2k]
  ------------------
  905|  35.7k|            if (!positionalMode && argIndex < numArgs) {
  ------------------
  |  Branch (905:17): [True: 35.7k, False: 0]
  |  Branch (905:36): [True: 0, False: 35.7k]
  ------------------
  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|  35.7k|            break;
  909|  35.7k|        }
  910|  77.2k|        bool spacePadPositive = false;
  911|  77.2k|        int ntrunc = -1;
  912|  77.2k|        const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt,
  913|  77.2k|                                                   args, argIndex, numArgs);
  914|       |        // NB: argIndex may be incremented by reading variable width/precision
  915|       |        // in `streamStateFromFormat`, so do the bounds check here.
  916|  77.2k|        if (argIndex >= numArgs) {
  ------------------
  |  Branch (916:13): [True: 0, False: 77.2k]
  ------------------
  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|  77.2k|        const FormatArg& arg = args[argIndex];
  921|       |        // Format the arg into the stream.
  922|  77.2k|        if (!spacePadPositive) {
  ------------------
  |  Branch (922:13): [True: 77.2k, False: 0]
  ------------------
  923|  77.2k|            arg.format(out, fmt, fmtEnd, ntrunc);
  924|  77.2k|        }
  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|  77.2k|        if (!positionalMode)
  ------------------
  |  Branch (941:13): [True: 77.2k, False: 0]
  ------------------
  942|  77.2k|            ++argIndex;
  943|  77.2k|        fmt = fmtEnd;
  944|  77.2k|    }
  945|       |
  946|       |    // Restore stream state
  947|  35.7k|    out.width(origWidth);
  948|  35.7k|    out.precision(origPrecision);
  949|  35.7k|    out.flags(origFlags);
  950|  35.7k|    out.fill(origFill);
  951|  35.7k|}
_ZN10tinyformat7vformatERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcRKNS_10FormatListE:
 1070|  35.7k|{
 1071|  35.7k|    detail::formatImpl(out, fmt, list.m_args, list.m_N);
 1072|  35.7k|}
_ZN10tinyformat6formatIJiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    254|{
 1089|    254|    std::ostringstream oss;
 1090|    254|    format(oss, fmt, args...);
 1091|    254|    return oss.str();
 1092|    254|}
_ZN10tinyformat6formatIJiEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    254|{
 1081|    254|    vformat(out, fmt, makeFormatList(args...));
 1082|    254|}
_ZN10tinyformat17FormatStringCheckILj1EEcvPKcEv:
  197|  12.2k|    operator const char*() { return fmt; }
_ZN10tinyformat14makeFormatListIJiEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    254|{
 1045|    254|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    254|}
_ZN10tinyformat6detail11FormatListNILi1EEC2IJiEEEDpRKT_:
  990|    254|            : FormatList(&m_formatterStore[0], N),
  991|    254|            m_formatterStore { FormatArg(args)... }
  992|    254|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2IiEERKT_:
  534|  3.43k|            : m_value(static_cast<const void*>(&value)),
  535|  3.43k|            m_formatImpl(&formatImpl<T>),
  536|  3.43k|            m_toIntImpl(&toIntImpl<T>)
  537|  3.43k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIiEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  3.43k|        {
  559|  3.43k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  3.43k|        }
_ZN10tinyformat11formatValueIiEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|  3.43k|{
  352|  3.43k|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
  353|       |    // Since we don't support printing of wchar_t using "%ls", make it fail at
  354|       |    // compile time in preference to printing as a void* at runtime.
  355|  3.43k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  3.43k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  3.43k|#endif
  358|       |    // The mess here is to support the %c and %p conversions: if these
  359|       |    // conversions are active we try to convert the type to a char or const
  360|       |    // void* respectively and format that instead of the value itself.  For the
  361|       |    // %p conversion it's important to avoid dereferencing the pointer, which
  362|       |    // could otherwise lead to a crash when printing a dangling (const char*).
  363|  3.43k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  3.43k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  3.43k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 3.43k]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  3.43k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  3.43k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 3.43k]
  ------------------
  373|       |        // Take care not to overread C strings in truncating conversions like
  374|       |        // "%.4s" where at most 4 characters may be read.
  375|      0|        detail::formatTruncated(out, value, ntrunc);
  376|      0|    }
  377|  3.43k|    else
  378|  3.43k|        out << value;
  379|  3.43k|}
_ZN10tinyformat6formatIJmmEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    107|{
 1089|    107|    std::ostringstream oss;
 1090|    107|    format(oss, fmt, args...);
 1091|    107|    return oss.str();
 1092|    107|}
_ZN10tinyformat6formatIJmmEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    107|{
 1081|    107|    vformat(out, fmt, makeFormatList(args...));
 1082|    107|}
_ZN10tinyformat17FormatStringCheckILj2EEcvPKcEv:
  197|  12.9k|    operator const char*() { return fmt; }
_ZN10tinyformat14makeFormatListIJmmEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    107|{
 1045|    107|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    107|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJmmEEEDpRKT_:
  990|    107|            : FormatList(&m_formatterStore[0], N),
  991|    107|            m_formatterStore { FormatArg(args)... }
  992|    107|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2ImEERKT_:
  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|        { }
_ZN10tinyformat6detail9FormatArg10formatImplImEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  1.69k|        {
  559|  1.69k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  1.69k|        }
_ZN10tinyformat11formatValueImEEvRNSt3__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): [Folded - Ignored]
  |  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 - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  1.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|}
_ZN10tinyformat6formatIJtEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  10.5k|{
 1089|  10.5k|    std::ostringstream oss;
 1090|  10.5k|    format(oss, fmt, args...);
 1091|  10.5k|    return oss.str();
 1092|  10.5k|}
_ZN10tinyformat6formatIJtEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  10.5k|{
 1081|  10.5k|    vformat(out, fmt, makeFormatList(args...));
 1082|  10.5k|}
_ZN10tinyformat14makeFormatListIJtEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  10.5k|{
 1045|  10.5k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  10.5k|}
_ZN10tinyformat6detail11FormatListNILi1EEC2IJtEEEDpRKT_:
  990|  10.5k|            : FormatList(&m_formatterStore[0], N),
  991|  10.5k|            m_formatterStore { FormatArg(args)... }
  992|  10.5k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2ItEERKT_:
  534|  21.6k|            : m_value(static_cast<const void*>(&value)),
  535|  21.6k|            m_formatImpl(&formatImpl<T>),
  536|  21.6k|            m_toIntImpl(&toIntImpl<T>)
  537|  21.6k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplItEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  21.6k|        {
  559|  21.6k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  21.6k|        }
_ZN10tinyformat11formatValueItEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|  21.6k|{
  352|  21.6k|#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|  21.6k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  21.6k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  21.6k|#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|  21.6k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  21.6k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  21.6k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 21.6k]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  21.6k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  21.6k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 21.6k]
  ------------------
  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|  21.6k|    else
  378|  21.6k|        out << value;
  379|  21.6k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  1.47k|{
 1089|  1.47k|    std::ostringstream oss;
 1090|  1.47k|    format(oss, fmt, args...);
 1091|  1.47k|    return oss.str();
 1092|  1.47k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  1.47k|{
 1081|  1.47k|    vformat(out, fmt, makeFormatList(args...));
 1082|  1.47k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_EEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  1.47k|{
 1045|  1.47k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  1.47k|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEESA_EEEDpRKT_:
  990|  1.47k|            : FormatList(&m_formatterStore[0], N),
  991|  1.47k|            m_formatterStore { FormatArg(args)... }
  992|  1.47k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_:
  534|  7.38k|            : m_value(static_cast<const void*>(&value)),
  535|  7.38k|            m_formatImpl(&formatImpl<T>),
  536|  7.38k|            m_toIntImpl(&toIntImpl<T>)
  537|  7.38k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRNS3_13basic_ostreamIcS6_EEPKcSE_iPKv:
  558|  7.38k|        {
  559|  7.38k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  7.38k|        }
_ZN10tinyformat11formatValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRNS1_13basic_ostreamIcS4_EEPKcSC_iRKT_:
  351|  7.38k|{
  352|  7.38k|#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.38k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  7.38k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  7.38k|#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.38k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  7.38k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  7.38k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  7.38k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  7.38k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 7.38k]
  ------------------
  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.38k|    else
  378|  7.38k|        out << value;
  379|  7.38k|}
_ZN10tinyformat6detail9FormatArgC2IdEERKT_:
  534|  1.47k|            : m_value(static_cast<const void*>(&value)),
  535|  1.47k|            m_formatImpl(&formatImpl<T>),
  536|  1.47k|            m_toIntImpl(&toIntImpl<T>)
  537|  1.47k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIdEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  1.47k|        {
  559|  1.47k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  1.47k|        }
_ZN10tinyformat11formatValueIdEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_:
  351|  1.47k|{
  352|  1.47k|#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.47k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  1.47k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  1.47k|#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.47k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  1.47k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  1.47k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 1.47k]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  1.47k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 0]
  ------------------
  368|      0|        detail::formatValueAsType<T, const void*>::invoke(out, value);
  369|       |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
  370|       |    else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
  371|       |#endif
  372|  1.47k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 1.47k]
  ------------------
  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.47k|    else
  378|  1.47k|        out << value;
  379|  1.47k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  1.47k|{
 1089|  1.47k|    std::ostringstream oss;
 1090|  1.47k|    format(oss, fmt, args...);
 1091|  1.47k|    return oss.str();
 1092|  1.47k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  1.47k|{
 1081|  1.47k|    vformat(out, fmt, makeFormatList(args...));
 1082|  1.47k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  1.47k|{
 1045|  1.47k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  1.47k|}
_ZN10tinyformat6detail11FormatListNILi1EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEDpRKT_:
  990|  1.47k|            : FormatList(&m_formatterStore[0], N),
  991|  1.47k|            m_formatterStore { FormatArg(args)... }
  992|  1.47k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6detail9FormatArgC2IPKcEERKT_:
  534|  11.0k|            : m_value(static_cast<const void*>(&value)),
  535|  11.0k|            m_formatImpl(&formatImpl<T>),
  536|  11.0k|            m_toIntImpl(&toIntImpl<T>)
  537|  11.0k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIPKcEEvRNSt3__113basic_ostreamIcNS5_11char_traitsIcEEEES4_S4_iPKv:
  558|  11.0k|        {
  559|  11.0k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  11.0k|        }
_ZN10tinyformat11formatValueIPKcEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEES2_S2_iRKT_:
  351|  11.0k|{
  352|  11.0k|#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|  11.0k|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|  11.0k|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|  11.0k|#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|  11.0k|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|  11.0k|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|  11.0k|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|  11.0k|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 11.0k]
  ------------------
  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|  11.0k|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 11.0k]
  ------------------
  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|  11.0k|    else
  378|  11.0k|        out << value;
  379|  11.0k|}
_ZN10tinyformat6detail9FormatArgC2IhEERKT_:
  534|  30.2k|            : m_value(static_cast<const void*>(&value)),
  535|  30.2k|            m_formatImpl(&formatImpl<T>),
  536|  30.2k|            m_toIntImpl(&toIntImpl<T>)
  537|  30.2k|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIhEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv:
  558|  30.2k|        {
  559|  30.2k|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|  30.2k|        }
_ZN10tinyformat17FormatStringCheckILj3EEcvPKcEv:
  197|  2.95k|    operator const char*() { return fmt; }
_ZN10tinyformat17FormatStringCheckILj4EEcvPKcEv:
  197|  7.58k|    operator const char*() { return fmt; }
_ZN10tinyformat6detail9FormatArgC2IA13_cEERKT_:
  534|    379|            : m_value(static_cast<const void*>(&value)),
  535|    379|            m_formatImpl(&formatImpl<T>),
  536|    379|            m_toIntImpl(&toIntImpl<T>)
  537|    379|        { }
_ZN10tinyformat6detail9FormatArg10formatImplIA13_cEEvRNSt3__113basic_ostreamIcNS4_11char_traitsIcEEEEPKcSB_iPKv:
  558|    379|        {
  559|    379|            formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast<const T*>(value));
  560|    379|        }
_ZN10tinyformat11formatValueIA13_cEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_iRKT_:
  351|    379|{
  352|    379|#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|    379|    typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
  356|    379|    (void) DummyType(); // avoid unused type warning with gcc-4.8
  357|    379|#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|    379|    const bool canConvertToChar = detail::is_convertible<T,char>::value;
  364|    379|    const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
  365|    379|    if (canConvertToChar && *(fmtEnd-1) == 'c')
  ------------------
  |  Branch (365:9): [Folded - Ignored]
  |  Branch (365:29): [True: 0, False: 0]
  ------------------
  366|      0|        detail::formatValueAsType<T, char>::invoke(out, value);
  367|    379|    else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
  ------------------
  |  Branch (367:14): [Folded - Ignored]
  |  Branch (367:37): [True: 0, False: 379]
  ------------------
  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|    379|    else if (ntrunc >= 0) {
  ------------------
  |  Branch (372:14): [True: 0, False: 379]
  ------------------
  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|    379|    else
  378|    379|        out << value;
  379|    379|}
_ZN10tinyformat6formatIJhhhhEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  7.20k|{
 1089|  7.20k|    std::ostringstream oss;
 1090|  7.20k|    format(oss, fmt, args...);
 1091|  7.20k|    return oss.str();
 1092|  7.20k|}
_ZN10tinyformat6formatIJhhhhEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  7.20k|{
 1081|  7.20k|    vformat(out, fmt, makeFormatList(args...));
 1082|  7.20k|}
_ZN10tinyformat14makeFormatListIJhhhhEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  7.20k|{
 1045|  7.20k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  7.20k|}
_ZN10tinyformat6detail11FormatListNILi4EEC2IJhhhhEEEDpRKT_:
  990|  7.20k|            : FormatList(&m_formatterStore[0], N),
  991|  7.20k|            m_formatterStore { FormatArg(args)... }
  992|  7.20k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJPKctEEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  11.0k|{
 1089|  11.0k|    std::ostringstream oss;
 1090|  11.0k|    format(oss, fmt, args...);
 1091|  11.0k|    return oss.str();
 1092|  11.0k|}
_ZN10tinyformat6formatIJPKctEEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  11.0k|{
 1081|  11.0k|    vformat(out, fmt, makeFormatList(args...));
 1082|  11.0k|}
_ZN10tinyformat14makeFormatListIJPKctEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  11.0k|{
 1045|  11.0k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  11.0k|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJPKctEEEDpRKT_:
  990|  11.0k|            : FormatList(&m_formatterStore[0], N),
  991|  11.0k|            m_formatterStore { FormatArg(args)... }
  992|  11.0k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJiiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    115|{
 1089|    115|    std::ostringstream oss;
 1090|    115|    format(oss, fmt, args...);
 1091|    115|    return oss.str();
 1092|    115|}
_ZN10tinyformat6formatIJiiEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    115|{
 1081|    115|    vformat(out, fmt, makeFormatList(args...));
 1082|    115|}
_ZN10tinyformat14makeFormatListIJiiEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    115|{
 1045|    115|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    115|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJiiEEEDpRKT_:
  990|    115|            : FormatList(&m_formatterStore[0], N),
  991|    115|            m_formatterStore { FormatArg(args)... }
  992|    115|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_dEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  1.47k|{
 1089|  1.47k|    std::ostringstream oss;
 1090|  1.47k|    format(oss, fmt, args...);
 1091|  1.47k|    return oss.str();
 1092|  1.47k|}
_ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_dEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  1.47k|{
 1081|  1.47k|    vformat(out, fmt, makeFormatList(args...));
 1082|  1.47k|}
_ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES7_dEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  1.47k|{
 1045|  1.47k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  1.47k|}
_ZN10tinyformat6detail11FormatListNILi3EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEESA_dEEEDpRKT_:
  990|  1.47k|            : FormatList(&m_formatterStore[0], N),
  991|  1.47k|            m_formatterStore { FormatArg(args)... }
  992|  1.47k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJiimEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|  1.47k|{
 1089|  1.47k|    std::ostringstream oss;
 1090|  1.47k|    format(oss, fmt, args...);
 1091|  1.47k|    return oss.str();
 1092|  1.47k|}
_ZN10tinyformat6formatIJiimEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|  1.47k|{
 1081|  1.47k|    vformat(out, fmt, makeFormatList(args...));
 1082|  1.47k|}
_ZN10tinyformat14makeFormatListIJiimEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|  1.47k|{
 1045|  1.47k|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|  1.47k|}
_ZN10tinyformat6detail11FormatListNILi3EEC2IJiimEEEDpRKT_:
  990|  1.47k|            : FormatList(&m_formatterStore[0], N),
  991|  1.47k|            m_formatterStore { FormatArg(args)... }
  992|  1.47k|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJhhEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    162|{
 1089|    162|    std::ostringstream oss;
 1090|    162|    format(oss, fmt, args...);
 1091|    162|    return oss.str();
 1092|    162|}
_ZN10tinyformat6formatIJhhEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    162|{
 1081|    162|    vformat(out, fmt, makeFormatList(args...));
 1082|    162|}
_ZN10tinyformat14makeFormatListIJhhEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    162|{
 1045|    162|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    162|}
_ZN10tinyformat6detail11FormatListNILi2EEC2IJhhEEEDpRKT_:
  990|    162|            : FormatList(&m_formatterStore[0], N),
  991|    162|            m_formatterStore { FormatArg(args)... }
  992|    162|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }
_ZN10tinyformat6formatIJhhA13_chEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1088|    379|{
 1089|    379|    std::ostringstream oss;
 1090|    379|    format(oss, fmt, args...);
 1091|    379|    return oss.str();
 1092|    379|}
_ZN10tinyformat6formatIJhhA13_chEEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_:
 1080|    379|{
 1081|    379|    vformat(out, fmt, makeFormatList(args...));
 1082|    379|}
_ZN10tinyformat14makeFormatListIJhhA13_chEEENS_6detail11FormatListNIXsZT_EEEDpRKT_:
 1044|    379|{
 1045|    379|    return detail::FormatListN<sizeof...(args)>(args...);
 1046|    379|}
_ZN10tinyformat6detail11FormatListNILi4EEC2IJhhA13_chEEEDpRKT_:
  990|    379|            : FormatList(&m_formatterStore[0], N),
  991|    379|            m_formatterStore { FormatArg(args)... }
  992|    379|        { static_assert(sizeof...(args) == N, "Number of args must be N"); }

_ZN16TxRequestTrackerD2Ev:
  725|      2|TxRequestTracker::~TxRequestTracker() = default;

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

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

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

_Z9InterpretRKNSt3__16vectorIbNS_9allocatorIbEEEES5_:
   89|  16.5k|{
   90|  16.5k|    std::vector<bool>::const_iterator pos = asmap.begin();
   91|  16.5k|    const std::vector<bool>::const_iterator endpos = asmap.end();
   92|  16.5k|    uint8_t bits = ip.size();
   93|  16.5k|    uint32_t default_asn = 0;
   94|  16.5k|    uint32_t jump, match, matchlen;
   95|  16.5k|    Instruction opcode;
   96|  59.4k|    while (pos != endpos) {
  ------------------
  |  Branch (96:12): [True: 59.4k, False: 0]
  ------------------
   97|  59.4k|        opcode = DecodeType(pos, endpos);
   98|  59.4k|        if (opcode == Instruction::RETURN) {
  ------------------
  |  Branch (98:13): [True: 12.3k, False: 47.1k]
  ------------------
   99|  12.3k|            default_asn = DecodeASN(pos, endpos);
  100|  12.3k|            if (default_asn == INVALID) break; // ASN straddles EOF
  ------------------
  |  Branch (100:17): [True: 0, False: 12.3k]
  ------------------
  101|  12.3k|            return default_asn;
  102|  47.1k|        } else if (opcode == Instruction::JUMP) {
  ------------------
  |  Branch (102:20): [True: 14.8k, False: 32.2k]
  ------------------
  103|  14.8k|            jump = DecodeJump(pos, endpos);
  104|  14.8k|            if (jump == INVALID) break; // Jump offset straddles EOF
  ------------------
  |  Branch (104:17): [True: 0, False: 14.8k]
  ------------------
  105|  14.8k|            if (bits == 0) break; // No input bits left
  ------------------
  |  Branch (105:17): [True: 0, False: 14.8k]
  ------------------
  106|  14.8k|            if (int64_t{jump} >= int64_t{endpos - pos}) break; // Jumping past EOF
  ------------------
  |  Branch (106:17): [True: 0, False: 14.8k]
  ------------------
  107|  14.8k|            if (ip[ip.size() - bits]) {
  ------------------
  |  Branch (107:17): [True: 3.38k, False: 11.4k]
  ------------------
  108|  3.38k|                pos += jump;
  109|  3.38k|            }
  110|  14.8k|            bits--;
  111|  32.2k|        } else if (opcode == Instruction::MATCH) {
  ------------------
  |  Branch (111:20): [True: 17.1k, False: 15.0k]
  ------------------
  112|  17.1k|            match = DecodeMatch(pos, endpos);
  113|  17.1k|            if (match == INVALID) break; // Match bits straddle EOF
  ------------------
  |  Branch (113:17): [True: 0, False: 17.1k]
  ------------------
  114|  17.1k|            matchlen = std::bit_width(match) - 1;
  115|  17.1k|            if (bits < matchlen) break; // Not enough input bits
  ------------------
  |  Branch (115:17): [True: 0, False: 17.1k]
  ------------------
  116|  33.9k|            for (uint32_t bit = 0; bit < matchlen; bit++) {
  ------------------
  |  Branch (116:36): [True: 20.9k, False: 13.0k]
  ------------------
  117|  20.9k|                if ((ip[ip.size() - bits]) != ((match >> (matchlen - 1 - bit)) & 1)) {
  ------------------
  |  Branch (117:21): [True: 4.18k, False: 16.7k]
  ------------------
  118|  4.18k|                    return default_asn;
  119|  4.18k|                }
  120|  16.7k|                bits--;
  121|  16.7k|            }
  122|  17.1k|        } else if (opcode == Instruction::DEFAULT) {
  ------------------
  |  Branch (122:20): [True: 15.0k, False: 0]
  ------------------
  123|  15.0k|            default_asn = DecodeASN(pos, endpos);
  124|  15.0k|            if (default_asn == INVALID) break; // ASN straddles EOF
  ------------------
  |  Branch (124:17): [True: 0, False: 15.0k]
  ------------------
  125|  15.0k|        } else {
  126|      0|            break; // Instruction straddles EOF
  127|      0|        }
  128|  59.4k|    }
  129|      0|    assert(false); // Reached EOF without RETURN, or aborted (see any of the breaks above) - should have been caught by SanityCheckASMap below
  130|      0|    return 0; // 0 is not a valid ASN
  131|      0|}
_Z16SanityCheckASMapRKNSt3__16vectorIbNS_9allocatorIbEEEEi:
  134|  7.29k|{
  135|  7.29k|    const std::vector<bool>::const_iterator begin = asmap.begin(), endpos = asmap.end();
  136|  7.29k|    std::vector<bool>::const_iterator pos = begin;
  137|  7.29k|    std::vector<std::pair<uint32_t, int>> jumps; // All future positions we may jump to (bit offset in asmap -> bits to consume left)
  138|  7.29k|    jumps.reserve(bits);
  139|  7.29k|    Instruction prevopcode = Instruction::JUMP;
  140|  7.29k|    bool had_incomplete_match = false;
  141|  22.3k|    while (pos != endpos) {
  ------------------
  |  Branch (141:12): [True: 19.8k, False: 2.45k]
  ------------------
  142|  19.8k|        uint32_t offset = pos - begin;
  143|  19.8k|        if (!jumps.empty() && offset >= jumps.back().first) return false; // There was a jump into the middle of the previous instruction
  ------------------
  |  Branch (143:13): [True: 5.32k, False: 14.5k]
  |  Branch (143:31): [True: 29, False: 5.29k]
  ------------------
  144|  19.8k|        Instruction opcode = DecodeType(pos, endpos);
  145|  19.8k|        if (opcode == Instruction::RETURN) {
  ------------------
  |  Branch (145:13): [True: 7.66k, False: 12.1k]
  ------------------
  146|  7.66k|            if (prevopcode == Instruction::DEFAULT) return false; // There should not be any RETURN immediately after a DEFAULT (could be combined into just RETURN)
  ------------------
  |  Branch (146:17): [True: 238, False: 7.43k]
  ------------------
  147|  7.43k|            uint32_t asn = DecodeASN(pos, endpos);
  148|  7.43k|            if (asn == INVALID) return false; // ASN straddles EOF
  ------------------
  |  Branch (148:17): [True: 663, False: 6.76k]
  ------------------
  149|  6.76k|            if (jumps.empty()) {
  ------------------
  |  Branch (149:17): [True: 2.61k, False: 4.15k]
  ------------------
  150|       |                // Nothing to execute anymore
  151|  2.61k|                if (endpos - pos > 7) return false; // Excessive padding
  ------------------
  |  Branch (151:21): [True: 1.67k, False: 947]
  ------------------
  152|  2.90k|                while (pos != endpos) {
  ------------------
  |  Branch (152:24): [True: 2.03k, False: 872]
  ------------------
  153|  2.03k|                    if (*pos) return false; // Nonzero padding bit
  ------------------
  |  Branch (153:25): [True: 75, False: 1.95k]
  ------------------
  154|  1.95k|                    ++pos;
  155|  1.95k|                }
  156|    872|                return true; // Sanely reached EOF
  157|  4.15k|            } else {
  158|       |                // Continue by pretending we jumped to the next instruction
  159|  4.15k|                offset = pos - begin;
  160|  4.15k|                if (offset != jumps.back().first) return false; // Unreachable code
  ------------------
  |  Branch (160:21): [True: 120, False: 4.03k]
  ------------------
  161|  4.03k|                bits = jumps.back().second; // Restore the number of bits we would have had left after this jump
  162|  4.03k|                jumps.pop_back();
  163|  4.03k|                prevopcode = Instruction::JUMP;
  164|  4.03k|            }
  165|  12.1k|        } else if (opcode == Instruction::JUMP) {
  ------------------
  |  Branch (165:20): [True: 4.89k, False: 7.30k]
  ------------------
  166|  4.89k|            uint32_t jump = DecodeJump(pos, endpos);
  167|  4.89k|            if (jump == INVALID) return false; // Jump offset straddles EOF
  ------------------
  |  Branch (167:17): [True: 190, False: 4.70k]
  ------------------
  168|  4.70k|            if (int64_t{jump} > int64_t{endpos - pos}) return false; // Jump out of range
  ------------------
  |  Branch (168:17): [True: 329, False: 4.38k]
  ------------------
  169|  4.38k|            if (bits == 0) return false; // Consuming bits past the end of the input
  ------------------
  |  Branch (169:17): [True: 2, False: 4.37k]
  ------------------
  170|  4.37k|            --bits;
  171|  4.37k|            uint32_t jump_offset = pos - begin + jump;
  172|  4.37k|            if (!jumps.empty() && jump_offset >= jumps.back().first) return false; // Intersecting jumps
  ------------------
  |  Branch (172:17): [True: 774, False: 3.60k]
  |  Branch (172:35): [True: 51, False: 723]
  ------------------
  173|  4.32k|            jumps.emplace_back(jump_offset, bits);
  174|  4.32k|            prevopcode = Instruction::JUMP;
  175|  7.30k|        } else if (opcode == Instruction::MATCH) {
  ------------------
  |  Branch (175:20): [True: 3.84k, False: 3.46k]
  ------------------
  176|  3.84k|            uint32_t match = DecodeMatch(pos, endpos);
  177|  3.84k|            if (match == INVALID) return false; // Match bits straddle EOF
  ------------------
  |  Branch (177:17): [True: 130, False: 3.71k]
  ------------------
  178|  3.71k|            int matchlen = std::bit_width(match) - 1;
  179|  3.71k|            if (prevopcode != Instruction::MATCH) had_incomplete_match = false;
  ------------------
  |  Branch (179:17): [True: 3.16k, False: 542]
  ------------------
  180|  3.71k|            if (matchlen < 8 && had_incomplete_match) return false; // Within a sequence of matches only at most one should be incomplete
  ------------------
  |  Branch (180:17): [True: 3.32k, False: 390]
  |  Branch (180:33): [True: 42, False: 3.27k]
  ------------------
  181|  3.66k|            had_incomplete_match = (matchlen < 8);
  182|  3.66k|            if (bits < matchlen) return false; // Consuming bits past the end of the input
  ------------------
  |  Branch (182:17): [True: 7, False: 3.66k]
  ------------------
  183|  3.66k|            bits -= matchlen;
  184|  3.66k|            prevopcode = Instruction::MATCH;
  185|  3.66k|        } else if (opcode == Instruction::DEFAULT) {
  ------------------
  |  Branch (185:20): [True: 3.44k, False: 16]
  ------------------
  186|  3.44k|            if (prevopcode == Instruction::DEFAULT) return false; // There should not be two successive DEFAULTs (they could be combined into one)
  ------------------
  |  Branch (186:17): [True: 92, False: 3.35k]
  ------------------
  187|  3.35k|            uint32_t asn = DecodeASN(pos, endpos);
  188|  3.35k|            if (asn == INVALID) return false; // ASN straddles EOF
  ------------------
  |  Branch (188:17): [True: 314, False: 3.03k]
  ------------------
  189|  3.03k|            prevopcode = Instruction::DEFAULT;
  190|  3.03k|        } else {
  191|     16|            return false; // Instruction straddles EOF
  192|     16|        }
  193|  19.8k|    }
  194|  2.45k|    return false; // Reached EOF without RETURN instruction
  195|  7.29k|}
asmap.cpp:_ZN12_GLOBAL__N_110DecodeTypeERNSt3__114__bit_iteratorINS0_6vectorIbNS0_9allocatorIbEEEELb1ELm0EEERKS6_:
   62|  79.3k|{
   63|  79.3k|    return Instruction(DecodeBits(bitpos, endpos, 0, TYPE_BIT_SIZES));
   64|  79.3k|}
asmap.cpp:_ZN12_GLOBAL__N_110DecodeBitsERNSt3__114__bit_iteratorINS0_6vectorIbNS0_9allocatorIbEEEELb1ELm0EEERKS6_hRKNS2_IhNS3_IhEEEE:
   25|   158k|{
   26|   158k|    uint32_t val = minval;
   27|   158k|    bool bit;
   28|   158k|    for (std::vector<uint8_t>::const_iterator bit_sizes_it = bit_sizes.begin();
   29|   320k|        bit_sizes_it != bit_sizes.end(); ++bit_sizes_it) {
  ------------------
  |  Branch (29:9): [True: 320k, False: 0]
  ------------------
   30|   320k|        if (bit_sizes_it + 1 != bit_sizes.end()) {
  ------------------
  |  Branch (30:13): [True: 278k, False: 42.1k]
  ------------------
   31|   278k|            if (bitpos == endpos) break;
  ------------------
  |  Branch (31:17): [True: 289, False: 277k]
  ------------------
   32|   277k|            bit = *bitpos;
   33|   277k|            bitpos++;
   34|   277k|        } else {
   35|  42.1k|            bit = 0;
   36|  42.1k|        }
   37|   319k|        if (bit) {
  ------------------
  |  Branch (37:13): [True: 161k, False: 158k]
  ------------------
   38|   161k|            val += (1 << *bit_sizes_it);
   39|   161k|        } else {
   40|   941k|            for (int b = 0; b < *bit_sizes_it; b++) {
  ------------------
  |  Branch (40:29): [True: 784k, False: 157k]
  ------------------
   41|   784k|                if (bitpos == endpos) return INVALID; // Reached EOF in mantissa
  ------------------
  |  Branch (41:21): [True: 1.02k, False: 783k]
  ------------------
   42|   783k|                bit = *bitpos;
   43|   783k|                bitpos++;
   44|   783k|                val += bit << (*bit_sizes_it - 1 - b);
   45|   783k|            }
   46|   157k|            return val;
   47|   158k|        }
   48|   319k|    }
   49|    289|    return INVALID; // Reached EOF in exponent
   50|   158k|}
asmap.cpp:_ZN12_GLOBAL__N_19DecodeASNERNSt3__114__bit_iteratorINS0_6vectorIbNS0_9allocatorIbEEEELb1ELm0EEERKS6_:
   68|  38.2k|{
   69|  38.2k|    return DecodeBits(bitpos, endpos, 1, ASN_BIT_SIZES);
   70|  38.2k|}
asmap.cpp:_ZN12_GLOBAL__N_110DecodeJumpERNSt3__114__bit_iteratorINS0_6vectorIbNS0_9allocatorIbEEEELb1ELm0EEERKS6_:
   82|  19.7k|{
   83|  19.7k|    return DecodeBits(bitpos, endpos, 17, JUMP_BIT_SIZES);
   84|  19.7k|}
asmap.cpp:_ZN12_GLOBAL__N_111DecodeMatchERNSt3__114__bit_iteratorINS0_6vectorIbNS0_9allocatorIbEEEELb1ELm0EEERKS6_:
   75|  21.0k|{
   76|  21.0k|    return DecodeBits(bitpos, endpos, 2, MATCH_BIT_SIZES);
   77|  21.0k|}

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

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

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

_ZN4SockC2Ej:
   27|  25.1k|Sock::Sock(SOCKET s) : m_socket(s) {}
_ZN4SockD2Ev:
   35|  25.1k|Sock::~Sock() { Close(); }
_ZN4Sock5CloseEv:
  402|  25.1k|{
  403|  25.1k|    if (m_socket == INVALID_SOCKET) {
  ------------------
  |  |   56|  25.1k|#define INVALID_SOCKET      (SOCKET)(~0)
  ------------------
  |  Branch (403:9): [True: 25.1k, False: 0]
  ------------------
  404|  25.1k|        return;
  405|  25.1k|    }
  406|       |#ifdef WIN32
  407|       |    int ret = closesocket(m_socket);
  408|       |#else
  409|      0|    int ret = close(m_socket);
  410|      0|#endif
  411|      0|    if (ret) {
  ------------------
  |  Branch (411:9): [True: 0, False: 0]
  ------------------
  412|      0|        LogPrintf("Error closing socket %d: %s\n", m_socket, NetworkErrorString(WSAGetLastError()));
  ------------------
  |  |  266|      0|#define LogPrintf(...) LogInfo(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |  261|      0|#define LogInfo(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |  255|      0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  413|      0|    }
  414|      0|    m_socket = INVALID_SOCKET;
  ------------------
  |  |   56|      0|#define INVALID_SOCKET      (SOCKET)(~0)
  ------------------
  415|      0|}

_Z13SplitHostPortNSt3__117basic_string_viewIcNS_11char_traitsIcEEEERtRNS_12basic_stringIcS2_NS_9allocatorIcEEEE:
   73|   174k|{
   74|   174k|    bool valid = false;
   75|   174k|    size_t colon = in.find_last_of(':');
   76|       |    // if a : is found, and it either follows a [...], or no other : is in the string, treat it as port separator
   77|   174k|    bool fHaveColon = colon != in.npos;
   78|   174k|    bool fBracketed = fHaveColon && (in[0] == '[' && in[colon - 1] == ']'); // if there is a colon, and in[0]=='[', colon is not 0, so in[colon-1] is safe
  ------------------
  |  Branch (78:23): [True: 64.8k, False: 109k]
  |  Branch (78:38): [True: 3.48k, False: 61.3k]
  |  Branch (78:54): [True: 990, False: 2.49k]
  ------------------
   79|   174k|    bool fMultiColon{fHaveColon && colon != 0 && (in.find_last_of(':', colon - 1) != in.npos)};
  ------------------
  |  Branch (79:22): [True: 64.8k, False: 109k]
  |  Branch (79:36): [True: 61.1k, False: 3.64k]
  |  Branch (79:50): [True: 19.2k, False: 41.8k]
  ------------------
   80|   174k|    if (fHaveColon && (colon == 0 || fBracketed || !fMultiColon)) {
  ------------------
  |  Branch (80:9): [True: 64.8k, False: 109k]
  |  Branch (80:24): [True: 3.64k, False: 61.1k]
  |  Branch (80:38): [True: 990, False: 60.1k]
  |  Branch (80:52): [True: 41.4k, False: 18.7k]
  ------------------
   81|  46.0k|        uint16_t n;
   82|  46.0k|        if (ParseUInt16(in.substr(colon + 1), &n)) {
  ------------------
  |  Branch (82:13): [True: 21.9k, False: 24.1k]
  ------------------
   83|  21.9k|            in = in.substr(0, colon);
   84|  21.9k|            portOut = n;
   85|  21.9k|            valid = (portOut != 0);
   86|  21.9k|        }
   87|   128k|    } else {
   88|   128k|        valid = true;
   89|   128k|    }
   90|   174k|    if (in.size() > 0 && in[0] == '[' && in[in.size() - 1] == ']') {
  ------------------
  |  Branch (90:9): [True: 173k, False: 1.07k]
  |  Branch (90:26): [True: 5.54k, False: 167k]
  |  Branch (90:42): [True: 1.21k, False: 4.33k]
  ------------------
   91|  1.21k|        hostOut = in.substr(1, in.size() - 2);
   92|   173k|    } else {
   93|   173k|        hostOut = in;
   94|   173k|    }
   95|       |
   96|   174k|    return valid;
   97|   174k|}
_Z12EncodeBase324SpanIKhEb:
  146|  1.67k|{
  147|  1.67k|    static const char *pbase32 = "abcdefghijklmnopqrstuvwxyz234567";
  148|       |
  149|  1.67k|    std::string str;
  150|  1.67k|    str.reserve(((input.size() + 4) / 5) * 8);
  151|  1.67k|    ConvertBits<8, 5, true>([&](int v) { str += pbase32[v]; }, input.begin(), input.end());
  152|  1.67k|    if (pad) {
  ------------------
  |  Branch (152:9): [True: 1.04k, False: 631]
  ------------------
  153|  1.04k|        while (str.size() % 8) {
  ------------------
  |  Branch (153:16): [True: 0, False: 1.04k]
  ------------------
  154|      0|            str += '=';
  155|      0|        }
  156|  1.04k|    }
  157|  1.67k|    return str;
  158|  1.67k|}
_Z12DecodeBase32NSt3__117basic_string_viewIcNS_11char_traitsIcEEEE:
  166|  13.8k|{
  167|  13.8k|    static const int8_t decode32_table[256]{
  168|  13.8k|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  169|  13.8k|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  170|  13.8k|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, -1, -1, -1, -1,
  171|  13.8k|        -1, -1, -1, -1, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
  172|  13.8k|        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1,  0,  1,  2,
  173|  13.8k|         3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
  174|  13.8k|        23, 24, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  175|  13.8k|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  176|  13.8k|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  177|  13.8k|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  178|  13.8k|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  179|  13.8k|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  180|  13.8k|        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
  181|  13.8k|    };
  182|       |
  183|  13.8k|    if (str.size() % 8 != 0) return {};
  ------------------
  |  Branch (183:9): [True: 1.31k, False: 12.5k]
  ------------------
  184|       |    /* 1, 3, 4, or 6 padding '=' suffix characters are permitted. */
  185|  12.5k|    if (str.size() >= 1 && str.back() == '=') str.remove_suffix(1);
  ------------------
  |  Branch (185:9): [True: 12.5k, False: 0]
  |  Branch (185:28): [True: 8.17k, False: 4.38k]
  ------------------
  186|  12.5k|    if (str.size() >= 2 && str.substr(str.size() - 2) == "==") str.remove_suffix(2);
  ------------------
  |  Branch (186:9): [True: 12.5k, False: 0]
  |  Branch (186:28): [True: 7.76k, False: 4.79k]
  ------------------
  187|  12.5k|    if (str.size() >= 1 && str.back() == '=') str.remove_suffix(1);
  ------------------
  |  Branch (187:9): [True: 12.5k, False: 0]
  |  Branch (187:28): [True: 8.06k, False: 4.48k]
  ------------------
  188|  12.5k|    if (str.size() >= 2 && str.substr(str.size() - 2) == "==") str.remove_suffix(2);
  ------------------
  |  Branch (188:9): [True: 12.5k, False: 0]
  |  Branch (188:28): [True: 261, False: 12.2k]
  ------------------
  189|       |
  190|  12.5k|    std::vector<unsigned char> ret;
  191|  12.5k|    ret.reserve((str.size() * 5) / 8);
  192|  12.5k|    bool valid = ConvertBits<5, 8, false>(
  193|  12.5k|        [&](unsigned char c) { ret.push_back(c); },
  194|  12.5k|        str.begin(), str.end(),
  195|  12.5k|        [](char c) { return decode32_table[uint8_t(c)]; }
  196|  12.5k|    );
  197|       |
  198|  12.5k|    if (!valid) return {};
  ------------------
  |  Branch (198:9): [True: 3.02k, False: 9.52k]
  ------------------
  199|       |
  200|  9.52k|    return ret;
  201|  12.5k|}
_Z11ParseUInt16NSt3__117basic_string_viewIcNS_11char_traitsIcEEEEPt:
  240|  46.0k|{
  241|  46.0k|    return ParseIntegral<uint16_t>(str, out);
  242|  46.0k|}
_Z7ToLowerNSt3__117basic_string_viewIcNS_11char_traitsIcEEEE:
  416|  9.66k|{
  417|  9.66k|    std::string r;
  418|  9.66k|    r.reserve(str.size());
  419|  77.2k|    for (auto ch : str) r += ToLower(ch);
  ------------------
  |  Branch (419:18): [True: 77.2k, False: 9.66k]
  ------------------
  420|  9.66k|    return r;
  421|  9.66k|}
strencodings.cpp:_ZZ12EncodeBase324SpanIKhEbENK3$_0clEi:
  151|  74.4k|    ConvertBits<8, 5, true>([&](int v) { str += pbase32[v]; }, input.begin(), input.end());
strencodings.cpp:_ZZ12DecodeBase32NSt3__117basic_string_viewIcNS_11char_traitsIcEEEEENK3$_1clEc:
  195|   544k|        [](char c) { return decode32_table[uint8_t(c)]; }
strencodings.cpp:_ZZ12DecodeBase32NSt3__117basic_string_viewIcNS_11char_traitsIcEEEEENK3$_0clEh:
  193|   334k|        [&](unsigned char c) { ret.push_back(c); },
strencodings.cpp:_ZN12_GLOBAL__N_113ParseIntegralItEEbNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPT_:
  206|  46.0k|{
  207|  46.0k|    static_assert(std::is_integral<T>::value);
  208|       |    // Replicate the exact behavior of strtol/strtoll/strtoul/strtoull when
  209|       |    // handling leading +/- for backwards compatibility.
  210|  46.0k|    if (str.length() >= 2 && str[0] == '+' && str[1] == '-') {
  ------------------
  |  Branch (210:9): [True: 30.4k, False: 15.5k]
  |  Branch (210:30): [True: 2.02k, False: 28.4k]
  |  Branch (210:47): [True: 1.77k, False: 247]
  ------------------
  211|  1.77k|        return false;
  212|  1.77k|    }
  213|  44.2k|    const std::optional<T> opt_int = ToIntegral<T>((!str.empty() && str[0] == '+') ? str.substr(1) : str);
  ------------------
  |  Branch (213:53): [True: 39.8k, False: 4.47k]
  |  Branch (213:69): [True: 579, False: 39.2k]
  ------------------
  214|  44.2k|    if (!opt_int) {
  ------------------
  |  Branch (214:9): [True: 22.3k, False: 21.9k]
  ------------------
  215|  22.3k|        return false;
  216|  22.3k|    }
  217|  21.9k|    if (out != nullptr) {
  ------------------
  |  Branch (217:9): [True: 21.9k, False: 0]
  ------------------
  218|  21.9k|        *out = *opt_int;
  219|  21.9k|    }
  220|  21.9k|    return true;
  221|  44.2k|}

_Z7ToLowerc:
  305|  77.2k|{
  306|  77.2k|    return (c >= 'A' && c <= 'Z' ? (c - 'A') + 'a' : c);
  ------------------
  |  Branch (306:13): [True: 27.6k, False: 49.6k]
  |  Branch (306:25): [True: 216, False: 27.4k]
  ------------------
  307|  77.2k|}
strencodings.cpp:_ZNK12_GLOBAL__N_111IntIdentityclEi:
  263|  46.1k|    [[maybe_unused]] int operator()(int x) const { return x; }
strencodings.cpp:_Z11ConvertBitsILi8ELi5ELb1EZ12EncodeBase324SpanIKhEbE3$_0PS1_N12_GLOBAL__N_111IntIdentityEEbT2_T3_S8_T4_:
  270|  1.67k|bool ConvertBits(O outfn, It it, It end, I infn = {}) {
  271|  1.67k|    size_t acc = 0;
  272|  1.67k|    size_t bits = 0;
  273|  1.67k|    constexpr size_t maxv = (1 << tobits) - 1;
  274|  1.67k|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  275|  47.8k|    while (it != end) {
  ------------------
  |  Branch (275:12): [True: 46.1k, False: 1.67k]
  ------------------
  276|  46.1k|        int v = infn(*it);
  277|  46.1k|        if (v < 0) return false;
  ------------------
  |  Branch (277:13): [True: 0, False: 46.1k]
  ------------------
  278|  46.1k|        acc = ((acc << frombits) | v) & max_acc;
  279|  46.1k|        bits += frombits;
  280|   119k|        while (bits >= tobits) {
  ------------------
  |  Branch (280:16): [True: 73.7k, False: 46.1k]
  ------------------
  281|  73.7k|            bits -= tobits;
  282|  73.7k|            outfn((acc >> bits) & maxv);
  283|  73.7k|        }
  284|  46.1k|        ++it;
  285|  46.1k|    }
  286|  1.67k|    if (pad) {
  ------------------
  |  Branch (286:9): [Folded - Ignored]
  ------------------
  287|  1.67k|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (287:13): [True: 631, False: 1.04k]
  ------------------
  288|  1.67k|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (288:16): [True: 0, False: 0]
  |  Branch (288:36): [True: 0, False: 0]
  ------------------
  289|      0|        return false;
  290|      0|    }
  291|  1.67k|    return true;
  292|  1.67k|}
strencodings.cpp:_Z11ConvertBitsILi5ELi8ELb0EZ12DecodeBase32NSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEE3$_0PKcZ12DecodeBase32S4_E3$_1EbT2_T3_SA_T4_:
  270|  12.5k|bool ConvertBits(O outfn, It it, It end, I infn = {}) {
  271|  12.5k|    size_t acc = 0;
  272|  12.5k|    size_t bits = 0;
  273|  12.5k|    constexpr size_t maxv = (1 << tobits) - 1;
  274|  12.5k|    constexpr size_t max_acc = (1 << (frombits + tobits - 1)) - 1;
  275|   554k|    while (it != end) {
  ------------------
  |  Branch (275:12): [True: 544k, False: 9.99k]
  ------------------
  276|   544k|        int v = infn(*it);
  277|   544k|        if (v < 0) return false;
  ------------------
  |  Branch (277:13): [True: 2.55k, False: 541k]
  ------------------
  278|   541k|        acc = ((acc << frombits) | v) & max_acc;
  279|   541k|        bits += frombits;
  280|   876k|        while (bits >= tobits) {
  ------------------
  |  Branch (280:16): [True: 334k, False: 541k]
  ------------------
  281|   334k|            bits -= tobits;
  282|   334k|            outfn((acc >> bits) & maxv);
  283|   334k|        }
  284|   541k|        ++it;
  285|   541k|    }
  286|  9.99k|    if (pad) {
  ------------------
  |  Branch (286:9): [Folded - Ignored]
  ------------------
  287|      0|        if (bits) outfn((acc << (tobits - bits)) & maxv);
  ------------------
  |  Branch (287:13): [True: 0, False: 0]
  ------------------
  288|  9.99k|    } else if (bits >= frombits || ((acc << (tobits - bits)) & maxv)) {
  ------------------
  |  Branch (288:16): [True: 264, False: 9.73k]
  |  Branch (288:36): [True: 207, False: 9.52k]
  ------------------
  289|    471|        return false;
  290|    471|    }
  291|  9.52k|    return true;
  292|  9.99k|}
_Z10ToIntegralIhENSt3__18optionalIT_EENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE:
  180|     10|{
  181|     10|    static_assert(std::is_integral<T>::value);
  182|     10|    T result;
  183|     10|    const auto [first_nonmatching, error_condition] = std::from_chars(str.data(), str.data() + str.size(), result);
  184|     10|    if (first_nonmatching != str.data() + str.size() || error_condition != std::errc{}) {
  ------------------
  |  Branch (184:9): [True: 0, False: 10]
  |  Branch (184:57): [True: 0, False: 10]
  ------------------
  185|      0|        return std::nullopt;
  186|      0|    }
  187|     10|    return result;
  188|     10|}
_Z10ToIntegralItENSt3__18optionalIT_EENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE:
  180|  44.2k|{
  181|  44.2k|    static_assert(std::is_integral<T>::value);
  182|  44.2k|    T result;
  183|  44.2k|    const auto [first_nonmatching, error_condition] = std::from_chars(str.data(), str.data() + str.size(), result);
  184|  44.2k|    if (first_nonmatching != str.data() + str.size() || error_condition != std::errc{}) {
  ------------------
  |  Branch (184:9): [True: 16.0k, False: 28.2k]
  |  Branch (184:57): [True: 6.28k, False: 21.9k]
  ------------------
  185|  22.3k|        return std::nullopt;
  186|  22.3k|    }
  187|  21.9k|    return result;
  188|  44.2k|}

_ZN4util13ContainsNoNULENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  222|   980k|{
  223|  36.9M|    for (auto c : str) {
  ------------------
  |  Branch (223:17): [True: 36.9M, False: 910k]
  ------------------
  224|  36.9M|        if (c == 0) return false;
  ------------------
  |  Branch (224:13): [True: 70.9k, False: 36.8M]
  ------------------
  225|  36.9M|    }
  226|   910k|    return true;
  227|   980k|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm6EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|  67.2k|{
  248|  67.2k|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 67.2k, False: 0]
  ------------------
  249|  67.2k|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 645, False: 66.5k]
  ------------------
  250|  67.2k|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm12EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|   573k|{
  248|   573k|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 573k, False: 0]
  ------------------
  249|   573k|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 8.14k, False: 565k]
  ------------------
  250|   573k|}
_ZN4util9HasPrefixI4SpanIKhELm12EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|   314k|{
  248|   314k|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 314k, False: 0]
  ------------------
  249|   314k|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 3.46k, False: 311k]
  ------------------
  250|   314k|}
_ZN4util9HasPrefixI4SpanIKhELm6EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|   622k|{
  248|   622k|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 622k, False: 0]
  ------------------
  249|   622k|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 174, False: 622k]
  ------------------
  250|   622k|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm2EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|   299k|{
  248|   299k|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 299k, False: 0]
  ------------------
  249|   299k|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 2.05k, False: 297k]
  ------------------
  250|   299k|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm3EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|  1.20M|{
  248|  1.20M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 1.20M, False: 0]
  ------------------
  249|  1.20M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 14.1k, False: 1.18M]
  ------------------
  250|  1.20M|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm4EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|  1.03M|{
  248|  1.03M|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 1.03M, False: 0]
  ------------------
  249|  1.03M|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 4.87k, False: 1.02M]
  ------------------
  250|  1.03M|}
_ZN4util9HasPrefixI9prevectorILj16EhjiELm8EEEbRKT_RKNSt3__15arrayIhXT0_EEE:
  247|   552k|{
  248|   552k|    return obj.size() >= PREFIX_LEN &&
  ------------------
  |  Branch (248:12): [True: 552k, False: 0]
  ------------------
  249|   552k|           std::equal(std::begin(prefix), std::end(prefix), std::begin(obj));
  ------------------
  |  Branch (249:12): [True: 837, False: 551k]
  ------------------
  250|   552k|}

_ZN4util19TaskRunnerInterfaceD2Ev:
   22|      2|    virtual ~TaskRunnerInterface() = default;

_ZN16CThreadInterruptC2Ev:
   10|  7.29k|CThreadInterrupt::CThreadInterrupt() : flag(false) {}
_ZN16CThreadInterruptclEv:
   23|  14.5k|{
   24|  14.5k|    {
   25|  14.5k|        LOCK(mut);
  ------------------
  |  |  257|  14.5k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|  14.5k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|  14.5k|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|  14.5k|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   26|  14.5k|        flag.store(true, std::memory_order_release);
   27|  14.5k|    }
   28|  14.5k|    cond.notify_all();
   29|  14.5k|}

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

_Z15TicksSinceEpochINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEENS1_10time_pointI9NodeClockS5_EEEDaT0_:
   78|  25.6k|{
   79|  25.6k|    return Ticks<Duration>(t.time_since_epoch());
   80|  25.6k|}
_Z5TicksINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEES5_EDaT0_:
   73|  25.6k|{
   74|  25.6k|    return std::chrono::duration_cast<Dur1>(d).count();
   75|  25.6k|}
_Z3NowINSt3__16chrono10time_pointI9NodeClockNS1_8durationIxNS0_5ratioILl1ELl1EEEEEEEET_v:
  119|   238k|{
  120|   238k|    return std::chrono::time_point_cast<typename T::duration>(T::clock::now());
  121|   238k|}
_Z5TicksINSt3__16chrono8durationIdNS0_5ratioILl1ELl1000EEEEENS2_IxNS3_ILl1ELl1000000000EEEEEEDaT0_:
   73|  1.47k|{
   74|  1.47k|    return std::chrono::duration_cast<Dur1>(d).count();
   75|  1.47k|}
_Z15TicksSinceEpochINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEENS1_10time_pointINS1_12system_clockES5_EEEDaT0_:
   78|      2|{
   79|      2|    return Ticks<Duration>(t.time_since_epoch());
   80|      2|}
_Z7GetTimeINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEEET_v:
  125|   158k|{
  126|   158k|    return Now<std::chrono::time_point<NodeClock, T>>().time_since_epoch();
  127|   158k|}
_Z7GetTimeINSt3__16chrono8durationIxNS0_5ratioILl1ELl1000000EEEEEET_v:
  125|  5.46k|{
  126|  5.46k|    return Now<std::chrono::time_point<NodeClock, T>>().time_since_epoch();
  127|  5.46k|}
_Z3NowINSt3__16chrono10time_pointI9NodeClockNS1_8durationIxNS0_5ratioILl1ELl1000000EEEEEEEET_v:
  119|  5.46k|{
  120|  5.46k|    return std::chrono::time_point_cast<typename T::duration>(T::clock::now());
  121|  5.46k|}

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

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

_ZN17ChainstateManagerD2Ev:
 6319|      2|{
 6320|      2|    LOCK(::cs_main);
  ------------------
  |  |  257|      2|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 6321|       |
 6322|      2|    m_versionbitscache.Clear();
 6323|      2|}

_ZN17ValidationSignalsD2Ev:
   97|      2|ValidationSignals::~ValidationSignals() = default;
_ZN17ValidationSignals24FlushBackgroundCallbacksEv:
  100|      2|{
  101|      2|    m_internals->m_task_runner->flush();
  102|      2|}

_ZN16VersionBitsCache5ClearEv:
  242|      2|{
  243|      2|    LOCK(m_mutex);
  ------------------
  |  |  257|      2|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__)
  |  |  ------------------
  |  |  |  |   11|      2|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__)
  |  |  |  |  ------------------
  |  |  |  |  |  |    9|      2|#define PASTE2(x, y) PASTE(x, y)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |    8|      2|#define PASTE(x, y) x ## y
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  244|      6|    for (unsigned int d = 0; d < Consensus::MAX_VERSION_BITS_DEPLOYMENTS; d++) {
  ------------------
  |  Branch (244:30): [True: 4, False: 2]
  ------------------
  245|      4|        m_caches[d].clear();
  246|      4|    }
  247|      2|}