_ZN9base_uintILj6144EEmLERKS0_:
   62|  2.03k|{
   63|  2.03k|    base_uint<BITS> a;
   64|   392k|    for (int j = 0; j < WIDTH; j++) {
  ------------------
  |  Branch (64:21): [True: 390k, False: 2.03k]
  ------------------
   65|   390k|        uint64_t carry = 0;
   66|  38.0M|        for (int i = 0; i + j < WIDTH; i++) {
  ------------------
  |  Branch (66:25): [True: 37.6M, False: 390k]
  ------------------
   67|  37.6M|            uint64_t n = carry + a.pn[i + j] + (uint64_t)pn[j] * b.pn[i];
   68|  37.6M|            a.pn[i + j] = n & 0xffffffff;
   69|  37.6M|            carry = n >> 32;
   70|  37.6M|        }
   71|   390k|    }
   72|  2.03k|    *this = a;
   73|  2.03k|    return *this;
   74|  2.03k|}
_ZN9base_uintILj6144EEdVERKS0_:
   78|  1.01k|{
   79|  1.01k|    base_uint<BITS> div = b;     // make a copy, so we can shift.
   80|  1.01k|    base_uint<BITS> num = *this; // make a copy, so we can subtract.
   81|  1.01k|    *this = 0;                   // the quotient.
   82|  1.01k|    int num_bits = num.bits();
   83|  1.01k|    int div_bits = div.bits();
   84|  1.01k|    if (div_bits == 0)
  ------------------
  |  Branch (84:9): [True: 0, False: 1.01k]
  ------------------
   85|      0|        throw uint_error("Division by zero");
   86|  1.01k|    if (div_bits > num_bits) // the result is certainly 0.
  ------------------
  |  Branch (86:9): [True: 532, False: 484]
  ------------------
   87|    532|        return *this;
   88|    484|    int shift = num_bits - div_bits;
   89|    484|    div <<= shift; // shift so that div and num align.
   90|  98.6k|    while (shift >= 0) {
  ------------------
  |  Branch (90:12): [True: 98.1k, False: 484]
  ------------------
   91|  98.1k|        if (num >= div) {
  ------------------
  |  Branch (91:13): [True: 51.8k, False: 46.3k]
  ------------------
   92|  51.8k|            num -= div;
   93|  51.8k|            pn[shift / 32] |= (1U << (shift & 31)); // set a bit of the result.
   94|  51.8k|        }
   95|  98.1k|        div >>= 1; // shift back.
   96|  98.1k|        shift--;
   97|  98.1k|    }
   98|       |    // num now contains the remainder of the division.
   99|    484|    return *this;
  100|  1.01k|}
_ZNK9base_uintILj6144EE4bitsEv:
  158|  2.03k|{
  159|   235k|    for (int pos = WIDTH - 1; pos >= 0; pos--) {
  ------------------
  |  Branch (159:31): [True: 235k, False: 44]
  ------------------
  160|   235k|        if (pn[pos]) {
  ------------------
  |  Branch (160:13): [True: 1.98k, False: 233k]
  ------------------
  161|  15.6k|            for (int nbits = 31; nbits > 0; nbits--) {
  ------------------
  |  Branch (161:34): [True: 15.6k, False: 30]
  ------------------
  162|  15.6k|                if (pn[pos] & 1U << nbits)
  ------------------
  |  Branch (162:21): [True: 1.95k, False: 13.6k]
  ------------------
  163|  1.95k|                    return 32 * pos + nbits + 1;
  164|  15.6k|            }
  165|     30|            return 32 * pos + 1;
  166|  1.98k|        }
  167|   235k|    }
  168|     44|    return 0;
  169|  2.03k|}
_ZN9base_uintILj6144EElSEj:
   16|    484|{
   17|    484|    base_uint<BITS> a(*this);
   18|  93.4k|    for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (18:21): [True: 92.9k, False: 484]
  ------------------
   19|  92.9k|        pn[i] = 0;
   20|    484|    int k = shift / 32;
   21|    484|    shift = shift % 32;
   22|  93.4k|    for (int i = 0; i < WIDTH; i++) {
  ------------------
  |  Branch (22:21): [True: 92.9k, False: 484]
  ------------------
   23|  92.9k|        if (i + k + 1 < WIDTH && shift != 0)
  ------------------
  |  Branch (23:13): [True: 89.5k, False: 3.33k]
  |  Branch (23:34): [True: 75.9k, False: 13.6k]
  ------------------
   24|  75.9k|            pn[i + k + 1] |= (a.pn[i] >> (32 - shift));
   25|  92.9k|        if (i + k < WIDTH)
  ------------------
  |  Branch (25:13): [True: 90.0k, False: 2.85k]
  ------------------
   26|  90.0k|            pn[i + k] |= (a.pn[i] << shift);
   27|  92.9k|    }
   28|    484|    return *this;
   29|    484|}
_ZNK9base_uintILj6144EE9CompareToERKS0_:
  104|  98.1k|{
  105|  6.83M|    for (int i = WIDTH - 1; i >= 0; i--) {
  ------------------
  |  Branch (105:29): [True: 6.83M, False: 1]
  ------------------
  106|  6.83M|        if (pn[i] < b.pn[i])
  ------------------
  |  Branch (106:13): [True: 46.3k, False: 6.79M]
  ------------------
  107|  46.3k|            return -1;
  108|  6.79M|        if (pn[i] > b.pn[i])
  ------------------
  |  Branch (108:13): [True: 51.8k, False: 6.74M]
  ------------------
  109|  51.8k|            return 1;
  110|  6.79M|    }
  111|      1|    return 0;
  112|  98.1k|}
_ZN9base_uintILj6144EErSEj:
   33|  98.1k|{
   34|  98.1k|    base_uint<BITS> a(*this);
   35|  18.9M|    for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (35:21): [True: 18.8M, False: 98.1k]
  ------------------
   36|  18.8M|        pn[i] = 0;
   37|  98.1k|    int k = shift / 32;
   38|  98.1k|    shift = shift % 32;
   39|  18.9M|    for (int i = 0; i < WIDTH; i++) {
  ------------------
  |  Branch (39:21): [True: 18.8M, False: 98.1k]
  ------------------
   40|  18.8M|        if (i - k - 1 >= 0 && shift != 0)
  ------------------
  |  Branch (40:13): [True: 18.7M, False: 98.1k]
  |  Branch (40:31): [True: 18.7M, False: 0]
  ------------------
   41|  18.7M|            pn[i - k - 1] |= (a.pn[i] << (32 - shift));
   42|  18.8M|        if (i - k >= 0)
  ------------------
  |  Branch (42:13): [True: 18.8M, False: 0]
  ------------------
   43|  18.8M|            pn[i - k] |= (a.pn[i] >> shift);
   44|  18.8M|    }
   45|  98.1k|    return *this;
   46|  98.1k|}

_ZN9base_uintILj6144EEC2Ev:
   35|  56.8k|    {
   36|  10.9M|        for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (36:25): [True: 10.9M, False: 56.8k]
  ------------------
   37|  10.9M|            pn[i] = 0;
   38|  56.8k|    }
_ZN9base_uintILj6144EEaSEm:
   71|  1.01k|    {
   72|  1.01k|        pn[0] = (unsigned int)b;
   73|  1.01k|        pn[1] = (unsigned int)(b >> 32);
   74|   194k|        for (int i = 2; i < WIDTH; i++)
  ------------------
  |  Branch (74:25): [True: 193k, False: 1.01k]
  ------------------
   75|   193k|            pn[i] = 0;
   76|  1.01k|        return *this;
   77|  1.01k|    }
_ZssRK9base_uintILj6144EES2_:
  204|  98.1k|    friend inline std::strong_ordering operator<=>(const base_uint& a, const base_uint& b) { return a.CompareTo(b) <=> 0; }
_ZN9base_uintILj6144EEmIERKS0_:
  130|  52.8k|    {
  131|  52.8k|        *this += -b;
  132|  52.8k|        return *this;
  133|  52.8k|    }
_ZNK9base_uintILj6144EEngEv:
   60|  52.8k|    {
   61|  52.8k|        base_uint ret;
   62|  10.1M|        for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (62:25): [True: 10.1M, False: 52.8k]
  ------------------
   63|  10.1M|            ret.pn[i] = ~pn[i];
   64|  52.8k|        ++ret;
   65|  52.8k|        return ret;
   66|  52.8k|    }
_ZN9base_uintILj6144EEppEv:
  156|  52.8k|    {
  157|       |        // prefix operator
  158|  52.8k|        int i = 0;
  159|  1.53M|        while (i < WIDTH && ++pn[i] == 0)
  ------------------
  |  Branch (159:16): [True: 1.53M, False: 560]
  |  Branch (159:29): [True: 1.48M, False: 52.2k]
  ------------------
  160|  1.48M|            i++;
  161|  52.8k|        return *this;
  162|  52.8k|    }
_ZN9base_uintILj6144EEpLERKS0_:
  118|  52.8k|    {
  119|  52.8k|        uint64_t carry = 0;
  120|  10.1M|        for (int i = 0; i < WIDTH; i++)
  ------------------
  |  Branch (120:25): [True: 10.1M, False: 52.8k]
  ------------------
  121|  10.1M|        {
  122|  10.1M|            uint64_t n = carry + pn[i] + b.pn[i];
  123|  10.1M|            pn[i] = n & 0xffffffff;
  124|  10.1M|            carry = n >> 32;
  125|  10.1M|        }
  126|  52.8k|        return *this;
  127|  52.8k|    }

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

_Z16htole64_internalm:
   59|  48.7k|{
   60|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(host_64bits);
   61|  48.7k|        else return host_64bits;
   62|  48.7k|}
_Z16le64toh_internalm:
   69|  97.5k|{
   70|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits);
   71|  97.5k|        else return little_endian_64bits;
   72|  97.5k|}
_Z16htole32_internalj:
   39|  97.5k|{
   40|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits);
   41|  97.5k|        else return host_32bits;
   42|  97.5k|}
_Z16le32toh_internalj:
   49|   195k|{
   50|       |    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits);
   51|   195k|        else return little_endian_32bits;
   52|   195k|}

_ZN15ChaCha20AlignedD2Ev:
   42|      4|{
   43|      4|    memory_cleanse(input, sizeof(input));
   44|      4|}
_ZN8ChaCha20D2Ev:
  332|      4|{
  333|      4|    memory_cleanse(m_buffer.data(), m_buffer.size());
  334|      4|}

_Z8ReadLE64ITk8ByteTypehEmPKT_:
   36|  97.5k|{
   37|  97.5k|    uint64_t x;
   38|  97.5k|    memcpy(&x, ptr, 8);
   39|  97.5k|    return le64toh_internal(x);
   40|  97.5k|}
_Z8ReadLE32ITk8ByteTypehEjPKT_:
   28|   195k|{
   29|   195k|    uint32_t x;
   30|   195k|    memcpy(&x, ptr, 4);
   31|   195k|    return le32toh_internal(x);
   32|   195k|}
_Z9WriteLE32ITk8ByteTypehEvPT_j:
   51|  97.5k|{
   52|  97.5k|    uint32_t v = htole32_internal(x);
   53|  97.5k|    memcpy(ptr, &v, 4);
   54|  97.5k|}
_Z9WriteLE64ITk8ByteTypehEvPT_m:
   58|  48.7k|{
   59|  48.7k|    uint64_t v = htole64_internal(x);
   60|  48.7k|    memcpy(ptr, &v, 8);
   61|  48.7k|}

_ZNK7Num307210IsOverflowEv:
  117|  1.01k|{
  118|  1.01k|    if (this->limbs[0] <= std::numeric_limits<limb_t>::max() - MAX_PRIME_DIFF) return false;
  ------------------
  |  Branch (118:9): [True: 812, False: 204]
  ------------------
  119|  1.34k|    for (int i = 1; i < LIMBS; ++i) {
  ------------------
  |  Branch (119:21): [True: 1.33k, False: 17]
  ------------------
  120|  1.33k|        if (this->limbs[i] != std::numeric_limits<limb_t>::max()) return false;
  ------------------
  |  Branch (120:13): [True: 187, False: 1.14k]
  ------------------
  121|  1.33k|    }
  122|     17|    return true;
  123|    204|}
_ZN7Num307210FullReduceEv:
  126|     82|{
  127|     82|    limb_t c0 = MAX_PRIME_DIFF;
  128|     82|    limb_t c1 = 0;
  129|  4.01k|    for (int i = 0; i < LIMBS; ++i) {
  ------------------
  |  Branch (129:21): [True: 3.93k, False: 82]
  ------------------
  130|  3.93k|        addnextract2(c0, c1, this->limbs[i], this->limbs[i]);
  131|  3.93k|    }
  132|     82|}
_ZN7Num30728MultiplyERKS_:
  457|  1.01k|{
  458|  1.01k|    limb_t c0 = 0, c1 = 0, c2 = 0;
  459|  1.01k|    Num3072 tmp;
  460|       |
  461|       |    /* Compute limbs 0..N-2 of this*a into tmp, including one reduction. */
  462|  48.7k|    for (int j = 0; j < LIMBS - 1; ++j) {
  ------------------
  |  Branch (462:21): [True: 47.7k, False: 1.01k]
  ------------------
  463|  47.7k|        limb_t d0 = 0, d1 = 0, d2 = 0;
  464|  47.7k|        mul(d0, d1, this->limbs[1 + j], a.limbs[LIMBS + j - (1 + j)]);
  465|  1.14M|        for (int i = 2 + j; i < LIMBS; ++i) muladd3(d0, d1, d2, this->limbs[i], a.limbs[LIMBS + j - i]);
  ------------------
  |  Branch (465:29): [True: 1.09M, False: 47.7k]
  ------------------
  466|  47.7k|        mulnadd3(c0, c1, c2, d0, d1, d2, MAX_PRIME_DIFF);
  467|  1.19M|        for (int i = 0; i < j + 1; ++i) muladd3(c0, c1, c2, this->limbs[i], a.limbs[j - i]);
  ------------------
  |  Branch (467:25): [True: 1.14M, False: 47.7k]
  ------------------
  468|  47.7k|        extract3(c0, c1, c2, tmp.limbs[j]);
  469|  47.7k|    }
  470|       |
  471|       |    /* Compute limb N-1 of a*b into tmp. */
  472|  1.01k|    assert(c2 == 0);
  ------------------
  |  Branch (472:5): [True: 1.01k, False: 0]
  ------------------
  473|  49.7k|    for (int i = 0; i < LIMBS; ++i) muladd3(c0, c1, c2, this->limbs[i], a.limbs[LIMBS - 1 - i]);
  ------------------
  |  Branch (473:21): [True: 48.7k, False: 1.01k]
  ------------------
  474|  1.01k|    extract3(c0, c1, c2, tmp.limbs[LIMBS - 1]);
  475|       |
  476|       |    /* Perform a second reduction. */
  477|  1.01k|    muln2(c0, c1, MAX_PRIME_DIFF);
  478|  49.7k|    for (int j = 0; j < LIMBS; ++j) {
  ------------------
  |  Branch (478:21): [True: 48.7k, False: 1.01k]
  ------------------
  479|  48.7k|        addnextract2(c0, c1, tmp.limbs[j], this->limbs[j]);
  480|  48.7k|    }
  481|       |
  482|  1.01k|    assert(c1 == 0);
  ------------------
  |  Branch (482:5): [True: 1.01k, False: 0]
  ------------------
  483|  1.01k|    assert(c0 == 0 || c0 == 1);
  ------------------
  |  Branch (483:5): [True: 951, False: 65]
  |  Branch (483:5): [True: 65, False: 0]
  |  Branch (483:5): [True: 1.01k, False: 0]
  ------------------
  484|       |
  485|       |    /* Perform up to two more reductions if the internal state has already
  486|       |     * overflown the MAX of Num3072 or if it is larger than the modulus or
  487|       |     * if both are the case.
  488|       |     * */
  489|  1.01k|    if (this->IsOverflow()) this->FullReduce();
  ------------------
  |  Branch (489:9): [True: 17, False: 999]
  ------------------
  490|  1.01k|    if (c0) this->FullReduce();
  ------------------
  |  Branch (490:9): [True: 65, False: 951]
  ------------------
  491|  1.01k|}
_ZN7Num30728SetToOneEv:
  494|  1.01k|{
  495|  1.01k|    this->limbs[0] = 1;
  496|  48.7k|    for (int i = 1; i < LIMBS; ++i) this->limbs[i] = 0;
  ------------------
  |  Branch (496:21): [True: 47.7k, False: 1.01k]
  ------------------
  497|  1.01k|}
_ZN7Num3072C2ERA384_Kh:
  516|  2.03k|Num3072::Num3072(const unsigned char (&data)[BYTE_SIZE]) {
  517|  99.5k|    for (int i = 0; i < LIMBS; ++i) {
  ------------------
  |  Branch (517:21): [True: 97.5k, False: 2.03k]
  ------------------
  518|  97.5k|        if (sizeof(limb_t) == 4) {
  ------------------
  |  Branch (518:13): [Folded, False: 97.5k]
  ------------------
  519|      0|            this->limbs[i] = ReadLE32(data + 4 * i);
  520|  97.5k|        } else if (sizeof(limb_t) == 8) {
  ------------------
  |  Branch (520:20): [True: 97.5k, Folded]
  ------------------
  521|  97.5k|            this->limbs[i] = ReadLE64(data + 8 * i);
  522|  97.5k|        }
  523|  97.5k|    }
  524|  2.03k|}
_ZN7Num30727ToBytesERA384_h:
  526|  1.01k|void Num3072::ToBytes(unsigned char (&out)[BYTE_SIZE]) {
  527|  49.7k|    for (int i = 0; i < LIMBS; ++i) {
  ------------------
  |  Branch (527:21): [True: 48.7k, False: 1.01k]
  ------------------
  528|  48.7k|        if (sizeof(limb_t) == 4) {
  ------------------
  |  Branch (528:13): [Folded, False: 48.7k]
  ------------------
  529|      0|            WriteLE32(out + i * 4, this->limbs[i]);
  530|  48.7k|        } else if (sizeof(limb_t) == 8) {
  ------------------
  |  Branch (530:20): [True: 48.7k, Folded]
  ------------------
  531|  48.7k|            WriteLE64(out + i * 8, this->limbs[i]);
  532|  48.7k|        }
  533|  48.7k|    }
  534|  1.01k|}
muhash.cpp:_ZN12_GLOBAL__N_112addnextract2ERmS0_RKmS0_:
   95|  52.7k|{
   96|  52.7k|    limb_t c2 = 0;
   97|       |
   98|       |    // add
   99|  52.7k|    c0 += a;
  100|  52.7k|    if (c0 < a) {
  ------------------
  |  Branch (100:9): [True: 5.06k, False: 47.6k]
  ------------------
  101|  5.06k|        c1 += 1;
  102|       |
  103|       |        // Handle case when c1 has overflown
  104|  5.06k|        if (c1 == 0) c2 = 1;
  ------------------
  |  Branch (104:13): [True: 0, False: 5.06k]
  ------------------
  105|  5.06k|    }
  106|       |
  107|       |    // extract
  108|  52.7k|    n = c0;
  109|  52.7k|    c0 = c1;
  110|  52.7k|    c1 = c2;
  111|  52.7k|}
muhash.cpp:_ZN12_GLOBAL__N_13mulERmS0_RKmS2_:
   49|  47.7k|{
   50|  47.7k|    double_limb_t t = (double_limb_t)a * b;
   51|  47.7k|    c1 = t >> LIMB_SIZE;
   52|  47.7k|    c0 = t;
   53|  47.7k|}
muhash.cpp:_ZN12_GLOBAL__N_17muladd3ERmS0_S0_RKmS2_:
   79|  2.29M|{
   80|  2.29M|    double_limb_t t = (double_limb_t)a * b;
   81|  2.29M|    limb_t th = t >> LIMB_SIZE;
   82|  2.29M|    limb_t tl = t;
   83|       |
   84|  2.29M|    c0 += tl;
   85|  2.29M|    th += (c0 < tl) ? 1 : 0;
  ------------------
  |  Branch (85:11): [True: 70.1k, False: 2.22M]
  ------------------
   86|  2.29M|    c1 += th;
   87|  2.29M|    c2 += (c1 < th) ? 1 : 0;
  ------------------
  |  Branch (87:11): [True: 86.1k, False: 2.20M]
  ------------------
   88|  2.29M|}
muhash.cpp:_ZN12_GLOBAL__N_18mulnadd3ERmS0_S0_S0_S0_S0_RKm:
   57|  47.7k|{
   58|  47.7k|    double_limb_t t = (double_limb_t)d0 * n + c0;
   59|  47.7k|    c0 = t;
   60|  47.7k|    t >>= LIMB_SIZE;
   61|  47.7k|    t += (double_limb_t)d1 * n + c1;
   62|  47.7k|    c1 = t;
   63|  47.7k|    t >>= LIMB_SIZE;
   64|  47.7k|    c2 = t + d2 * n;
   65|  47.7k|}
muhash.cpp:_ZN12_GLOBAL__N_18extract3ERmS0_S0_S0_:
   40|  48.7k|{
   41|  48.7k|    n = c0;
   42|  48.7k|    c0 = c1;
   43|  48.7k|    c1 = c2;
   44|  48.7k|    c2 = 0;
   45|  48.7k|}
muhash.cpp:_ZN12_GLOBAL__N_15muln2ERmS0_RKm:
   69|  1.01k|{
   70|  1.01k|    double_limb_t t = (double_limb_t)c0 * n;
   71|  1.01k|    c0 = t;
   72|  1.01k|    t >>= LIMB_SIZE;
   73|  1.01k|    t += (double_limb_t)c1 * n;
   74|  1.01k|    c1 = t;
   75|  1.01k|}

_ZN7Num3072C2Ev:
   62|  1.01k|    Num3072() { this->SetToOne(); };

_ZN9ChainCodeD2Ev:
   28|      2|    ~ChainCode() { memory_cleanse(data(), size()); }

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

_ZNK9prevectorILj16EhjiE9is_directEv:
  126|     16|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj16EhjiED2Ev:
  422|     16|    ~prevector() {
  423|     16|        if (!is_direct()) {
  ------------------
  |  Branch (423:13): [True: 0, False: 16]
  ------------------
  424|      0|            free(_union.indirect_contents.indirect);
  425|      0|            _union.indirect_contents.indirect = nullptr;
  426|      0|        }
  427|     16|    }
_ZNK9prevectorILj36EhjiE9is_directEv:
  126|     14|    bool is_direct() const { return _size <= N; }
_ZN9prevectorILj36EhjiED2Ev:
  422|     14|    ~prevector() {
  423|     14|        if (!is_direct()) {
  ------------------
  |  Branch (423:13): [True: 0, False: 14]
  ------------------
  424|      0|            free(_union.indirect_contents.indirect);
  425|      0|            _union.indirect_contents.indirect = nullptr;
  426|      0|        }
  427|     14|    }

random.cpp:_ZN12_GLOBAL__N_18RNGStateD2Ev:
  367|      2|    ~RNGState() = default;

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

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

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

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

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

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

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

_ZN14AnnotatedMixinINSt3__115recursive_mutexEED2Ev:
   96|      2|    ~AnnotatedMixin() {
   97|      2|        DeleteLock((void*)this);
   98|      2|    }
_ZN14AnnotatedMixinINSt3__15mutexEED2Ev:
   96|     64|    ~AnnotatedMixin() {
   97|     64|        DeleteLock((void*)this);
   98|     64|    }
_Z10DeleteLockPv:
   74|     66|inline void DeleteLock(void* cs) {}
_Z17MaybeCheckNotHeldR14AnnotatedMixinINSt3__15mutexEE:
  258|     30|inline Mutex& MaybeCheckNotHeld(Mutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEEC2ERS3_PKcS7_ib:
  181|     30|    UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock)
  182|     30|    {
  183|     30|        if (fTry)
  ------------------
  |  Branch (183:13): [True: 0, False: 30]
  ------------------
  184|      0|            TryEnter(pszName, pszFile, nLine);
  185|     30|        else
  186|     30|            Enter(pszName, pszFile, nLine);
  187|     30|    }
_Z13EnterCriticalINSt3__15mutexEEvPKcS3_iPT_b:
   67|     30|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {}
_Z13LeaveCriticalv:
   68|     30|inline void LeaveCritical() {}
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEE5EnterEPKcS6_i:
  159|     30|    {
  160|     30|        EnterCritical(pszName, pszFile, nLine, Base::mutex());
  161|       |#ifdef DEBUG_LOCKCONTENTION
  162|       |        if (!Base::try_lock()) {
  163|       |            ContendedLock(pszName, pszFile, nLine, static_cast<Base&>(*this));
  164|       |        }
  165|       |#else
  166|     30|        Base::lock();
  167|     30|#endif
  168|     30|    }
_ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEED2Ev:
  201|     30|    {
  202|     30|        if (Base::owns_lock())
  ------------------
  |  Branch (202:13): [True: 30, False: 0]
  ------------------
  203|     30|            LeaveCritical();
  204|     30|    }

_ZN18FuzzedDataProvider11ConsumeDataEPvm:
  330|  2.03k|                                              size_t num_bytes) {
  331|  2.03k|  num_bytes = std::min(num_bytes, remaining_bytes_);
  332|  2.03k|  CopyAndAdvance(destination, num_bytes);
  333|  2.03k|  return num_bytes;
  334|  2.03k|}
_ZN18FuzzedDataProviderC2EPKhm:
   37|  1.01k|      : data_ptr_(data), remaining_bytes_(size) {}
_ZN18FuzzedDataProvider14CopyAndAdvanceEPvm:
  338|  2.03k|                                               size_t num_bytes) {
  339|  2.03k|  std::memcpy(destination, data_ptr_, num_bytes);
  340|  2.03k|  Advance(num_bytes);
  341|  2.03k|}
_ZN18FuzzedDataProvider7AdvanceEm:
  343|  2.03k|inline void FuzzedDataProvider::Advance(size_t num_bytes) {
  344|  2.03k|  if (num_bytes > remaining_bytes_)
  ------------------
  |  Branch (344:7): [True: 0, False: 2.03k]
  ------------------
  345|      0|    abort();
  346|       |
  347|  2.03k|  data_ptr_ += num_bytes;
  348|  2.03k|  remaining_bytes_ -= num_bytes;
  349|  2.03k|}
_ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_:
  205|  1.01k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
  206|  1.01k|  static_assert(std::is_integral_v<T>, "An integral type is required.");
  207|  1.01k|  static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
  208|       |
  209|  1.01k|  if (min > max)
  ------------------
  |  Branch (209:7): [True: 0, False: 1.01k]
  ------------------
  210|      0|    abort();
  211|       |
  212|       |  // Use the biggest type possible to hold the range and the result.
  213|  1.01k|  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  214|  1.01k|  uint64_t result = 0;
  215|  1.01k|  size_t offset = 0;
  216|       |
  217|  3.04k|  while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
  ------------------
  |  Branch (217:10): [True: 3.04k, False: 0]
  |  Branch (217:43): [True: 2.03k, False: 1.00k]
  ------------------
  218|  2.03k|         remaining_bytes_ != 0) {
  ------------------
  |  Branch (218:10): [True: 2.02k, False: 8]
  ------------------
  219|       |    // Pull bytes off the end of the seed data. Experimentally, this seems to
  220|       |    // allow the fuzzer to more easily explore the input space. This makes
  221|       |    // sense, since it works by modifying inputs that caused new code to run,
  222|       |    // and this data is often used to encode length of data read by
  223|       |    // |ConsumeBytes|. Separating out read lengths makes it easier modify the
  224|       |    // contents of the data that is actually read.
  225|  2.02k|    --remaining_bytes_;
  226|  2.02k|    result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
  227|  2.02k|    offset += CHAR_BIT;
  228|  2.02k|  }
  229|       |
  230|       |  // Avoid division by 0, in case |range + 1| results in overflow.
  231|  1.01k|  if (range != std::numeric_limits<decltype(range)>::max())
  ------------------
  |  Branch (231:7): [True: 1.01k, False: 0]
  ------------------
  232|  1.01k|    result = result % (range + 1);
  233|       |
  234|  1.01k|  return static_cast<T>(static_cast<uint64_t>(min) + result);
  235|  1.01k|}

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

_Z23num3072_mul_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE:
  107|  1.01k|{
  108|       |    // Test multiplication
  109|  1.01k|    FuzzedDataProvider provider{buffer.data(), buffer.size()};
  110|       |
  111|       |    // Read two 3072-bit numbers from fuzz input, and construct arith_uint6144
  112|       |    // and Num3072 objects with the read values.
  113|  1.01k|    uint16_t data_a_len = provider.ConsumeIntegralInRange(0, 384);
  114|  1.01k|    uint8_t data_a[384] = {0};
  115|  1.01k|    provider.ConsumeData(data_a, data_a_len);
  116|  1.01k|    arith_uint6144 a_uint{data_a};
  117|  1.01k|    Num3072 a_num{data_a};
  118|       |
  119|  1.01k|    uint8_t data_b[384] = {0};
  120|  1.01k|    provider.ConsumeData(data_b, 384);
  121|  1.01k|    arith_uint6144 b_uint{data_b};
  122|  1.01k|    Num3072 b_num{data_b};
  123|       |
  124|       |    // Multiply the first number with the second, in both representations.
  125|  1.01k|    a_num.Multiply(b_num);
  126|  1.01k|    a_uint *= b_uint;
  127|  1.01k|    Reduce(a_uint);
  128|       |
  129|       |    // Serialize both to bytes and compare.
  130|  1.01k|    uint8_t buf_num[384], buf_uint[384];
  131|  1.01k|    a_num.ToBytes(buf_num);
  132|  1.01k|    a_uint.Serialize(buf_uint);
  133|       |    assert(std::ranges::equal(buf_num, buf_uint));
  ------------------
  |  Branch (133:5): [True: 1.01k, False: 0]
  ------------------
  134|  1.01k|}
muhash.cpp:_ZN12_GLOBAL__N_114arith_uint6144C2ENSt3__14spanIKhLm18446744073709551615EEE:
   28|  2.03k|    arith_uint6144(std::span<const uint8_t> bytes) : base_uint{}
   29|  2.03k|    {
   30|  2.03k|        assert(bytes.size() % 4 == 0);
  ------------------
  |  Branch (30:9): [True: 2.03k, False: 0]
  ------------------
   31|  2.03k|        assert(bytes.size() <= 768);
  ------------------
  |  Branch (31:9): [True: 2.03k, False: 0]
  ------------------
   32|   197k|        for (unsigned i = 0; i * 4 < bytes.size(); ++i) {
  ------------------
  |  Branch (32:30): [True: 195k, False: 2.03k]
  ------------------
   33|   195k|            pn[i] = ReadLE32(bytes.data() + 4 * i);
   34|   195k|        }
   35|  2.03k|    }
muhash.cpp:_ZN12_GLOBAL__N_16ReduceERNS_14arith_uint6144E:
   97|  1.01k|{
   98|  1.01k|    arith_uint6144 tmp = value;
   99|  1.01k|    tmp /= MODULUS;
  100|  1.01k|    tmp *= MODULUS;
  101|  1.01k|    value -= tmp;
  102|  1.01k|}
muhash.cpp:_ZN12_GLOBAL__N_114arith_uint61449SerializeENSt3__14spanIhLm18446744073709551615EEE:
   39|  1.01k|    void Serialize(std::span<uint8_t> bytes) {
   40|  1.01k|        assert(bytes.size() % 4 == 0);
  ------------------
  |  Branch (40:9): [True: 1.01k, False: 0]
  ------------------
   41|  1.01k|        assert(bytes.size() <= 768);
  ------------------
  |  Branch (41:9): [True: 1.01k, False: 0]
  ------------------
   42|  98.5k|        for (unsigned i = 0; i * 4 < bytes.size(); ++i) {
  ------------------
  |  Branch (42:30): [True: 97.5k, False: 1.01k]
  ------------------
   43|  97.5k|            WriteLE32(bytes.data() + 4 * i, pn[i]);
   44|  97.5k|        }
   45|  98.5k|        for (unsigned i = bytes.size() / 4; i * 4 < 768; ++i) {
  ------------------
  |  Branch (45:45): [True: 97.5k, False: 1.01k]
  ------------------
   46|       |            assert(pn[i] == 0);
  ------------------
  |  Branch (46:13): [True: 97.5k, False: 0]
  ------------------
   47|  97.5k|        }
   48|  1.01k|    };

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

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

_ZN9base_blobILj256EE4dataEv:
   99|      2|    constexpr unsigned char* data() { return m_data.data(); }
_ZN9base_blobILj256EE4sizeEv:
  107|      2|    static constexpr unsigned int size() { return WIDTH; }

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

_Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_RKNS0_15source_locationENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE:
   90|  1.01k|{
   91|  1.01k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 1.01k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  1.01k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 1.01k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  1.01k|    }
   96|  1.01k|    return std::forward<T>(val);
   97|  1.01k|}
_Z22inline_assertion_checkILb1EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   90|  1.01k|{
   91|  1.01k|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [True: 1.01k, Folded]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|  1.01k|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 1.01k]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|  1.01k|    }
   96|  1.01k|    return std::forward<T>(val);
   97|  1.01k|}
_Z22inline_assertion_checkILb0EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE:
   90|     10|{
   91|     10|    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
  ------------------
  |  Branch (91:9): [Folded, False: 0]
  |  Branch (91:22): [Folded, False: 0]
  |  Branch (91:54): [True: 0, Folded]
  ------------------
   92|     10|        if (!val) {
  ------------------
  |  Branch (92:13): [True: 0, False: 10]
  ------------------
   93|      0|            assertion_fail(loc, assertion);
   94|      0|        }
   95|     10|    }
   96|     10|    return std::forward<T>(val);
   97|     10|}

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

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

_Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE:
   54|  1.01k|{
   55|  1.01k|    Assert(mock_time_in >= 0s);
  ------------------
  |  |  116|  1.01k|#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
  ------------------
   56|  1.01k|    g_mock_time.store(mock_time_in, std::memory_order_relaxed);
   57|  1.01k|}
_ZN19MockableSteadyClock13ClearMockTimeEv:
   84|  1.01k|{
   85|  1.01k|    g_mock_steady_time.store(0ms, std::memory_order_relaxed);
   86|  1.01k|}

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